2. Insight JS code

(() => {
// Minimal utilities
const qs = (sel, root=document) => root.querySelector(sel);
const esc = (s) => String((s === null || s === undefined) ? ” : s)
.replaceAll(‘&’,’&’).replaceAll(‘<','<') .replaceAll('>‘,’>’).replaceAll(‘”‘,’"’)
.replaceAll(“‘”,”'”);

/**
* Allow ONLY basic inline formatting tags that you expect in Formidable content.
* Everything else remains escaped (so no scripts, no arbitrary HTML).
*/
function safeBasicHtml(raw) {
let h = esc(raw);

// allow a small whitelist of tags
h = h.replace(/<(\/?)(strong|em|b|i)>/gi, ‘<$1$2>‘);
h = h.replace(/<br\s*\/?>/gi, ‘
‘);

// preserve newlines as line breaks
h = h.replace(/\r\n|\r|\n/g, ‘
‘);

return h;
}

// Match GTKY behaviour: allow ?lang=en-GB, default en-GB
function getParam(name, fallback = ”) {
const p = new URLSearchParams(window.location.search);
const v = p.get(name);
return String(v == null ? fallback : v).trim();
}
const langVariant = (getParam(‘lang’, ”) || ‘en-GB’).trim() || ‘en-GB’;

// GTKY-equivalent spellcheck, but via your MU proxy (cpVars.insightPage.aiUrl)
async function spellcheckLocale(text) {
try {
const original = String(text || ”).trim();
if (!original) return text;

// Do not spellcheck very short replies like “no”, “yes”, “maybe”, etc.
if (original.length <= 3) return original; const v = (window.cpVars && window.cpVars.insightPage) ? window.cpVars.insightPage : {}; if (!v.aiUrl) return original; const headers = { 'Content-Type': 'application/json' }; if (v.token) headers['X-CP-Token'] = v.token; else if (v.restNonce) headers['X-WP-Nonce'] = v.restNonce; const payload = { model: 'gpt-4o', temperature: 0, messages: [{ role: 'user', content: `Correct ${langVariant} spelling and grammar only. ` + `Do not change meaning, do not answer the user, do not explain anything, and do not add content. ` + `If the text is already fine, return it unchanged. ` + `Return only the corrected text.\n\n` + original }] }; const res = await fetch(v.aiUrl, { method: 'POST', headers, body: JSON.stringify(payload) }); const j = await res.json(); let corrected = ''; if (j && typeof j.text === 'string') corrected = j.text.trim(); else { const alt = j && j.choices && j.choices[0] && j.choices[0].message && j.choices[0].message.content; if (typeof alt === 'string') corrected = alt.trim(); } if (!corrected) return original; // Reject obvious meta/apology replies from the model if ( /i need the text you want corrected/i.test(corrected) || /please provide the text/i.test(corrected) || /i'm sorry/i.test(corrected) ) { return original; } // Reject wildly longer outputs; spellcheck should not rewrite a tiny answer into a sentence if (corrected.length > original.length + 20) {
return original;
}

return corrected;
} catch (e) {
return text;
}
}

// Thread state
// Thread state
const thread = [];

// Keep a stable session id (GTKY style)
const SID_KEY = ‘cp_sid’;
let sessionId = getParam(‘sid’, ”) || sessionStorage.getItem(SID_KEY) || ”;
if (!sessionId) {
sessionId = (crypto?.randomUUID ? crypto.randomUUID() : String(Date.now()));
sessionStorage.setItem(SID_KEY, sessionId);
}
// Ensure URL carries sid
if (!getParam(‘sid’,”)) {
const u = new URL(location.href);
u.searchParams.set(‘sid’, sessionId);
history.replaceState(null, ”, u);
}

// Per-Insight stable response_id (so each Insight keeps its own 320/329/338 chain)
function respKeyForThisInsight() {
const v = (window.cpVars && window.cpVars.insightPage) ? window.cpVars.insightPage : {};
const base = (getParam(‘insight’,”) || v.insightSequence || ‘generic’).trim();
return ‘cp_resp_id_’ + base;
}

// Prevent duplicate 329/338 emits for the same accepted user turn
let metaCommitted = false;

function pushMsg(role, content) {
const safeContent = String(content ?? ”);

thread.push({ role, content: safeContent });

// Each new user turn re-opens the ability to emit 329/338 once.
if (role === ‘user’) metaCommitted = false;

renderThread();

window.cpVars = window.cpVars || {};
window.cpVars.conversationHistory = window.cpVars.conversationHistory || [];

window.cpVars.conversationHistory.push({
role,
content: safeContent
});

// keep last 20 only
if (window.cpVars.conversationHistory.length > 20) {
window.cpVars.conversationHistory.shift();
}
}
function renderThread() {
const box = qs(‘#cp-ai-thread’);
if (!box) return;

box.innerHTML = ”;

// Match GTKY: nickname via ?nname=…, fallback “You”
const USER_NAME = getParam(‘nname’, ”) || ‘You’;
const COACH_NAME = ‘AI Coach’;

for (const m of thread) {
const isUser = (m.role === ‘user’);

const bubble = document.createElement(‘div’);
bubble.className = ‘cp-bubble ‘ + (isUser ? ‘cp-user’ : ‘cp-assistant’);

const head = document.createElement(‘div’);
head.className = ‘cp-msg-head ‘ + (isUser ? ‘cp-user-head’ : ‘cp-ai-head’);
head.innerHTML = isUser
? `👤 ${esc(USER_NAME)}`
: `⚡ ${esc(COACH_NAME)}`;
bubble.appendChild(head);

const body = document.createElement(‘div’);
body.className = ‘cp-msg-text’;
body.textContent = String(m.content ?? ”);
bubble.appendChild(body);

box.appendChild(bubble);
}

box.scrollTop = box.scrollHeight;
}

function hasUserText() {
return thread.some(m => m.role === ‘user’ && (m.content || ”).trim().length > 0);
}

function cpBaseMeta() {
const v = (window.cpVars && window.cpVars.insightPage) ? window.cpVars.insightPage : {};
return {
userpass: String(v.userpass || getParam(‘userpass’,”) || ”).trim(),
session: sessionId,
user_id: String(window.currentWpUserId || ”),
edition: String(v.edition || getParam(‘edition’,”) || ”),
kind: ‘insight’,
insight_id: String(getParam(‘insight’,”) || v.insightSequence || ”),
linked_insight_key: String(getParam(‘insight’,”) || v.insightSequence || ”)
};
}

async function postSaveMemory(payload) {
const v = (window.cpVars && window.cpVars.insightPage) ? window.cpVars.insightPage : {};
if (!v.saveUrl || (!v.token && !v.restNonce)) return;

const headers = { ‘Content-Type’: ‘application/json’ };
if (v.token) headers[‘X-CP-Token’] = v.token;
else if (v.restNonce) headers[‘X-WP-Nonce’] = v.restNonce;

return fetch(v.saveUrl, {
method: ‘POST’,
headers,
body: JSON.stringify(payload),
keepalive: true
});
}

// —- 320 (Responses) saver (same purpose as your old saveNow) —-
async function saveNow(payload = {}) {
const v = (window.cpVars && window.cpVars.insightPage) ? window.cpVars.insightPage : {};
if (!v.saveUrl || (!v.token && !v.restNonce)) return;
if (!hasUserText()) return;

const RESP_KEY = respKeyForThisInsight();
let responseId = sessionStorage.getItem(RESP_KEY);
if (!responseId) {
responseId = (crypto?.randomUUID ? crypto.randomUUID() : String(Date.now()));
sessionStorage.setItem(RESP_KEY, responseId);
}

// derive last user / last AI
let lastUser = ”, lastAI = ”;
for (let i = thread.length – 1; i >= 0; i–) {
const m = thread[i];
if (!m || !m.content) continue;
if (!lastUser && m.role === ‘user’) lastUser = m.content.trim();
if (!lastAI && m.role === ‘assistant’) lastAI = m.content.trim();
if (lastUser && lastAI) break;
}

const body = Object.assign({}, cpBaseMeta(), {
response_id: responseId,
dialogue: buildTranscript(),
response_sequence: thread.filter(m => m.role === ‘user’).length,
status: ‘Live’,
insight_sequence: v.insightSequence || getParam(‘insight’,”) || ”,
tone: v.tone || getParam(‘tone’,’direct’) || ‘direct’,
}, payload);

if (!(‘user_input’ in body) && lastUser) body.user_input = lastUser;
if (!(‘ai_reply’ in body) && lastAI) body.ai_reply = lastAI;

// strip empties
[‘ai_reply’,’summary’,’dialogue’,’user_input’].forEach(k => {
if (k in body && String(body[k]).trim() === ”) delete body[k];
});

await postSaveMemory(body);
}

// —- Summary generator (used to feed 329/338 + stored on 320) —-
async function summariseThread() {
const v = (window.cpVars && window.cpVars.insightPage) ? window.cpVars.insightPage : {};
if (!v.aiUrl) return ”;

// Use only the recent tail to keep it cheap + focused
const transcript = buildTranscript(2500);

const headers = { ‘Content-Type’: ‘application/json’ };
if (v.token) headers[‘X-CP-Token’] = v.token;
else if (v.restNonce) headers[‘X-WP-Nonce’] = v.restNonce;

const payload = {
model: ‘gpt-4o’,
temperature: 0.2,
messages: [{
role: ‘user’,
content:
`Write a concise, Insight-specific coach summary of the conversation so far.\n` +
`- 2–5 sentences.\n` +
`- Focus on what the user revealed, tensions, values, motivations.\n` +
`- No generic productivity advice.\n\n` +
`TRANSCRIPT:\n${transcript}`
}]
};

const res = await fetch(v.aiUrl, { method: ‘POST’, headers, body: JSON.stringify(payload) });
const j = await res.json();
const text = (j && (j.text || j.reply || j.content)) ? String(j.text || j.reply || j.content) : ”;
return text.trim();
}

// —- 329 trait scorer (LLM JSON) —-
async function scoreTraitsWithLLM({ questionText, answerText, miniSummary }) {
const v = (window.cpVars && window.cpVars.insightPage) ? window.cpVars.insightPage : {};
if (!v.aiUrl) return { traits: [] };

const headers = { ‘Content-Type’: ‘application/json’ };
if (v.token) headers[‘X-CP-Token’] = v.token;
else if (v.restNonce) headers[‘X-WP-Nonce’] = v.restNonce;

const system =
`You are scoring Change Pathway trait signals from ONE user answer.\n` +
`Traits: Awareness, Balance, Commitment, Drive, Engagement, Flexibility, Groundedness, Heart.\n` +
`Return ONLY valid JSON of the form:\n` +
`{“traits”:[{“trait”:”Awareness”,”quality”:”Positive|Neutral|Negative|Caution”,”confidence”:1-10,”rationale”:”…”,”quote”:”…”}]}\n` +
`Rules:\n` +
`- Max 3 traits.\n` +
`- Be conservative; if weak evidence, return []\n` +
`- quote must be exact user words (a short phrase).\n`;

const user =
`INSIGHT QUESTION:\n${questionText}\n\n` +
`USER ANSWER:\n${answerText}\n\n` +
`MINI SUMMARY:\n${miniSummary}\n`;

const payload = {
model: ‘gpt-4o’,
temperature: 0,
messages: [
{ role: ‘system’, content: system },
{ role: ‘user’, content: user }
]
};

const res = await fetch(v.aiUrl, { method: ‘POST’, headers, body: JSON.stringify(payload) });
const j = await res.json();
const raw = (j && (j.text || j.reply || j.content)) ? String(j.text || j.reply || j.content) : ”;

try {
const parsed = JSON.parse(raw);
if (parsed && Array.isArray(parsed.traits)) return parsed;
} catch {}
return { traits: [] };
}

// —- Chapter map + classifier (338) —-
async function ensureChapterMapLoaded() {
try {
if (window.cpChapterMap && Object.keys(window.cpChapterMap).length) return window.cpChapterMap;

const v = (window.cpVars && window.cpVars.insightPage) ? window.cpVars.insightPage : {};
const headers = {};
if (v.token) headers[‘X-CP-Token’] = v.token;
else if (v.restNonce) headers[‘X-WP-Nonce’] = v.restNonce;

async function classifyChapterForAnswer({ questionText, answerText, summary }) {
const v = (window.cpVars && window.cpVars.insightPage) ? window.cpVars.insightPage : {};
if (!v.aiUrl) return null;

const ans = (answerText || ”).trim();
if (!ans) return null;

const map = await ensureChapterMapLoaded();
if (!map || !Object.keys(map).length) return null;

const catalogue = buildChapterCatalogue(map);

const headers = { ‘Content-Type’: ‘application/json’ };
if (v.token) headers[‘X-CP-Token’] = v.token;
else if (v.restNonce) headers[‘X-WP-Nonce’] = v.restNonce;

const trimmedLastUser = (lastUser || ”).trim();
const trimmedSummary = (summary || ”).trim();
if (!trimmedLastUser && !trimmedSummary) return;

const dialogueTail = (() => {
const txt = buildTranscript(1200);
return txt.length > 800 ? txt.slice(-800) : txt;
})();

const base = Object.freeze(Object.assign({}, cpBaseMeta(), {
response_sequence: thread.filter(m => m.role === ‘user’).length,
response_id: responseId,
user_input: lastUser || ”,
}));

// Use Insight question as the “prompt text”
const questionText = String(v.coachFields?.insightQuestion || v.insight?.question || ”).trim();

// (1) 329 traits (append-only)
const traitSignals = await scoreTraitsWithLLM({
questionText,
answerText: lastUser,
miniSummary: trimmedSummary || ”
});

const traits = Array.isArray(traitSignals?.traits) ? traitSignals.traits : [];
for (const t of traits) {
if (!t || !t.trait) continue;

// normalise confidence to 1–10 number
let conf = Number(t.confidence);
if (!Number.isFinite(conf)) conf = 7;
conf = Math.max(1, Math.min(10, Math.round(conf)));

const allowedQual = [‘Positive’,’Neutral’,’Negative’,’Caution’];
const q = String(t.quality || ‘Neutral’).trim();
const qNorm = q ? (q[0].toUpperCase() + q.slice(1).toLowerCase()) : ‘Neutral’;
const quality = allowedQual.includes(qNorm) ? qNorm : ‘Neutral’;

const traitPayload = Object.freeze({
…base,
append_only: true,
framework: ‘Change Pathway’,
trait: String(t.trait || ”).trim(),
quality,
confidence: conf,
rationale: String(t.rationale || ”).trim().slice(0, 300) || trimmedLastUser.slice(0, 300),
quote: String(t.quote || ”).trim() || trimmedLastUser,
dialogue_tail: dialogueTail
});

try { await postSaveMemory(traitPayload); } catch {}
}

// (2) 338 chapter (append-only, 0 or 1)
const chapterDecision = await classifyChapterForAnswer({
questionText,
answerText: lastUser,
summary: trimmedSummary || ”
});

if (chapterDecision) {
const selectedQuotes = (() => {
const s = (lastUser || ”).split(/(?<=[.!?])\s+/).map(x => x.trim()).filter(Boolean);
return s.slice(0, 3);
})();

const chapterPayload = Object.freeze({
…base,
append_only: true,
chapter_key: chapterDecision.chapter_key,
matched_terms: chapterDecision.matched_terms || [],
quality: chapterDecision.quality || ‘Neutral’,
confidence: Math.max(1, Math.min(10, Math.round(Number(chapterDecision.confidence) || 8))),
rationale: trimmedSummary
? trimmedSummary.replace(/^\s*[\u2022\-\*]+\s*/gm, ”).slice(0, 900)
: trimmedLastUser.slice(0, 300),
chapter_quote: selectedQuotes.join(‘ | ‘),
quotes: selectedQuotes,
dialogue_tail: dialogueTail
});

try { await postSaveMemory(chapterPayload); } catch {}
}

metaCommitted = true;
} catch {
// swallow: we never want meta emit failures to break the UI
}
}

const vStep = (window.cpVars && window.cpVars.insightPage) ? window.cpVars.insightPage : {};
const STEP_KEY = ‘cp_step_’ + ((vStep.insightSequence || getParam(‘insight’,”) || ‘generic’).trim());

const cf = vStep.coachFields || {};

const steps = String(cf.aiCoachFrameworkSteps || ”)
.split(‘\n’)
.map(s => s.trim())
.filter(Boolean);

const completionCriteria = cf.step_completion_criteria || ”;
const fallbackRoutes = cf.fallback_routes || ”;
const allowedMoves = cf.allowed_moves || ”;
const disallowedMoves = cf.disallowed_moves || ”;
const closureRule = cf.closure_rule || ”;

console.log(‘AI COACH STEPS RAW:’, vStep.coachFields?.aiCoachFrameworkSteps);
console.log(‘AI COACH STEPS PARSED:’, steps);

let currentStep = Number(sessionStorage.getItem(STEP_KEY) || 0);

async function evaluateTurn(userText) {
const v = (window.cpVars && window.cpVars.insightPage) ? window.cpVars.insightPage : {};

if (!v.aiUrl) {
return { advance:false, fallback:false, close:false };
}

const headers = { ‘Content-Type’: ‘application/json’ };
if (v.token) headers[‘X-CP-Token’] = v.token;
else if (v.restNonce) headers[‘X-WP-Nonce’] = v.restNonce;

const payload = {
model: ‘gpt-4o’,
temperature: 0,
messages: [
{
role: ‘system’,
content:
`You are evaluating a coaching response.

Return ONLY JSON:
{
“advance”: true|false,
“fallback”: true|false,
“close”: true|false
}

Use these rules:

ADVANCE:
– User meaningfully answered the question
– Provided a concrete example OR clear personal reaction

FALLBACK:
– Vague, abstract, avoids answering
– Says “don’t know”, “not sure”, etc.

CLOSE:
– Strong reflection + pattern + meaning already explored
– No further depth emerging

Be conservative. If unsure, do NOT advance.`
},
{
role: ‘user’,
content: String(userText || ”)
}
]
};

try {
const res = await fetch(v.aiUrl, {
method:’POST’,
headers,
body: JSON.stringify(payload)
});

const j = await res.json();
const raw = j.text || j.reply || j.content || ”;

return JSON.parse(raw);
} catch {
return { advance:false, fallback:false, close:false };
}
}
if (!Number.isFinite(currentStep) || currentStep < 0) currentStep = 0; async function classifyTurnWithAI(userText) { const v = (window.cpVars && window.cpVars.insightPage) ? window.cpVars.insightPage : {}; if (!v.aiUrl) { return { turnType: 'partial', needsReflection: false }; } const headers = { 'Content-Type': 'application/json' }; if (v.token) headers['X-CP-Token'] = v.token; else if (v.restNonce) headers['X-WP-Nonce'] = v.restNonce; const transcript = buildTranscript(1800); const previousCoachQuestion = (() => {
for (let i = thread.length – 1; i >= 0; i–) {
const m = thread[i];
if (m && m.role === ‘assistant’ && String(m.content || ”).trim()) {
return String(m.content || ”).trim();
}
}
return ”;
})();

const system =
`You are classifying the user’s latest coaching reply.\n` +
`Return ONLY valid JSON in this exact form:\n` +
`{“turnType”:”insight|example|preference|repeat|disengaged|partial”,”reflectionMode”:”none|light|full”,”focus”:”cause|belief|fear|tradeoff|implication”}\n` +
`\n` +
`Definitions:\n` +
`- insight: the user expresses genuine self-understanding, e.g. a cause, belief, fear, assumption, conflict, or pattern in themselves\n` +
`- example: the user gives a concrete instance or past event\n` +
`- preference: the user states what they tend to choose, value, or prioritise\n` +
`- repeat: the user mainly repeats an earlier point without meaningful new information\n` +
`- disengaged: the user avoids, refuses, shrugs off, or gives very low-engagement input\n` +
`- partial: the user gives some relevant content but not enough to count as insight/example/preference/repeat/disengaged\n` +
`\n` +
`Reflection rule:\n` +
`- reflectionMode = “none” when the user is:\n` +
` – stating a preference or general position\n` +
` – describing behaviour or giving an example\n` +
` – repeating a point\n` +
`\n` +
`- reflectionMode = “light” when the user shows some personal meaning but no clear explanation\n` +
` (e.g. “I’ve always thought…”, “I tend to…”, “I usually…”)\n` +
`\n` +
`- reflectionMode = “full” ONLY when the user expresses clear internal meaning:\n` +
` – a cause (“because…”, “that’s why…”)\n` +
` – a self-explanation (“I think I…”, “I realise…”)\n` +
` – an association (“I associate X with Y”)\n` +
`\n` +
`- The first response is usually “none” unless there is explicit causal explanation.\n` +
`\n` +
`Focus rule:\n` +
`- focus = “cause” when the user is describing behaviour\n` +
`- focus = “belief” when they express a viewpoint or assumption\n` +
`- focus = “fear” when risk, avoidance, or concern is present\n` +
`- focus = “tradeoff” when tension between two things appears\n` +
`- focus = “implication” when they have already explained a cause\n`;

const user =
`PREVIOUS AI COACH QUESTION:\n${previousCoachQuestion}\n\n` +
`USER REPLY:\n${String(userText || ”).trim()}\n\n` +
`RECENT TRANSCRIPT:\n${transcript}\n`;

const payload = {
model: ‘gpt-4o’,
temperature: 0,
messages: [
{ role: ‘system’, content: system },
{ role: ‘user’, content: user }
]
};

try {
const res = await fetch(v.aiUrl, {
method: ‘POST’,
headers,
body: JSON.stringify(payload)
});

const j = await res.json();
const raw = (j && (j.text || j.reply || j.content)) ? String(j.text || j.reply || j.content) : ”;

console.log(‘TURN CLASSIFICATION RAW:’, raw);

const parsed = JSON.parse(raw);

const allowedTypes = [‘insight’, ‘example’, ‘preference’, ‘repeat’, ‘disengaged’, ‘partial’];
const allowedReflectionModes = [‘none’, ‘light’, ‘full’];
const allowedFocus = [’cause’, ‘belief’, ‘fear’, ‘tradeoff’, ‘implication’];

const turnType = allowedTypes.includes(parsed.turnType) ? parsed.turnType : ‘partial’;
const reflectionMode = allowedReflectionModes.includes(parsed.reflectionMode) ? parsed.reflectionMode : ‘none’;
const focus = allowedFocus.includes(parsed.focus) ? parsed.focus : ’cause’;

console.log(‘TURN CLASSIFICATION PARSED:’, { turnType, reflectionMode, focus });

return { turnType, reflectionMode, focus };
} catch (err) {
console.log(‘TURN CLASSIFICATION ERROR:’, err);
return { turnType: ‘partial’, reflectionMode: ‘none’, focus: ’cause’ };
}
}

async function callAI(userText, evalResult, replyDecision) {
const v = (window.cpVars && window.cpVars.insightPage) ? window.cpVars.insightPage : {};
const headers = { ‘Content-Type’: ‘application/json’ };
if (v.token) headers[‘X-CP-Token’] = v.token;
else if (v.restNonce) headers[‘X-WP-Nonce’] = v.restNonce;

// Compose prompt context: Insight + mode + trait modulation + coach tone
const payload = {
kind: ‘insight’,
userpass: v.userpass,
edition: v.edition,
insight_sequence: v.insightSequence,
tone: v.tone || ‘direct’,

mode: v.mode || null,
insight: v.insight || null,
videos: v.videos || [],

// Dialogue so far
messages: [
{
role: ‘system’,
content: (() => {
const cf = v.coachFields || {};
const tone = v.tone || ‘direct’;

return (
`GLOBAL BEHAVIOURAL RULES (MANDATORY):\n` +
`Your job is to move the conversation forward.\n` +
`Follow the RESPONSE RULE to decide whether to include an acknowledgement before the question.\n` +
`\n` +

`CLASSIFICATION RESULT:\n` +
`- turnType = ${replyDecision.turnType}\n` +
`- reflectionMode = ${replyDecision.reflectionMode}\n` +
`- focus = ${replyDecision.focus}\n` +
`\n` +

`RESPONSE RULE (STRICT):\n` +
`- If reflectionMode = “none”:\n` +
` – Ask ONE question only.\n` +
`\n` +
`- If reflectionMode = “light”:\n` +
` – Ask ONE question only.\n` +
`\n` +
`- If reflectionMode = “full”:\n` +
` – You MUST include ONE acknowledgement sentence.\n` +
` – Then ask ONE question.\n` +
`\n` +
`- Never include more than one acknowledgement.\n` +
`- Never include more than one question.\n` +

`ACKNOWLEDGEMENT RULE (STRICT):\n` +
`- The acknowledgement must stay grounded in the user’s actual words and meaning.\n` +
`- Do NOT simply restate the user’s words; add precision by naming the tension, choice, or constraint.\n` +
`- Only name a tension, choice, or constraint if it is explicitly evidenced in the user’s words.\n` +
`- Do NOT introduce new traits, motives, or interpretations.\n` +
`- Do NOT praise, evaluate, or judge the user’s response.\n` +
`- Do NOT use phrases such as “that’s interesting”, “that’s insightful”, “that’s important”, or “that’s a strong value”.\n` +
`- Do NOT comment on the quality of the user’s thinking.\n` +
`- Do NOT hedge (no “it sounds like”, “you seem”, “it appears”).\n` +
`- Do NOT use generic templates (e.g. “this shows”, “this reveals”, “this indicates”).\n` +
`- Do NOT reframe the user’s example into a generalised statement.\n` +
`- Focus only on:\n` +
` – the choice being made\n` +
` – the trade-off involved\n` +
` – the constraint or pattern in behaviour\n` +
`- Keep it concrete and specific.\n` +
`\n` +

`DIRECTION:\n` +
`- Follow the most recent meaningful thread.\n` +
`- Stay with the same idea and deepen it.\n` +
`- Do not switch topics unless the user does.\n` +
`\n` +

`PROGRESSION:\n` +
`- If the user gives an example, move to cause, belief, or implication.\n` +
`- If the user repeats a point, move deeper rather than restating it.\n` +
`\n` +

`GENERAL:\n` +
`- Ask ONE clear question.\n` +
`- Do not analyse, label, or diagnose.\n` +
`- Keep language direct and specific.\n` +
`- Use focus to guide the question:\n` +
` – cause → “what was driving…”\n` +
` – belief → “what do you believe…”\n` +
` – fear → “what are you concerned might happen…”\n` +
` – tradeoff → “how do you weigh…”\n` +
` – implication → “what does that mean for…”\n` +
`\n` +

`LANGUAGE RULE:\n` +
`- Use UK English spelling (e.g. prioritise, organise, behaviour, centre).\n` +
`\n` +

`STEP EXECUTION RULE (CRITICAL):\n` +
`You are operating a structured coaching sequence.\n` +
`\n` +
`Current step index: ${steps.length ? (currentStep + 1) : 0} of ${steps.length}\n` +
`\n` +
`Current step instruction:\n` +
`${steps[currentStep] || ‘No step defined’}\n` +
`\n` +

`STEP COMPLETION CRITERIA:\n` +
`${completionCriteria}\n` +
`\n` +

`FALLBACK ROUTES:\n` +
`${fallbackRoutes}\n` +
`\n` +

`ALLOWED MOVES:\n` +
`${allowedMoves}\n` +
`\n` +

`DISALLOWED MOVES:\n` +
`${disallowedMoves}\n` +
`\n` +

`CLOSURE RULE:\n` +
`${closureRule}\n` +
`\n` +

`EVALUATION RESULT:\n` +
`${JSON.stringify(evalResult)}\n` +
`\n` +

`Rules:\n` +
`- Follow the current step exactly.\n` +
`- Ask ONE question that executes this step.\n` +
`- Do NOT skip ahead.\n` +
`- Do NOT combine steps.\n` +
`\n` +

`ENDING RULES:\n` +
`- Continue while new depth is emerging.\n` +
`- If no new depth, offer to move on.\n`
);
})()
},

…thread,
{ role:’user’, content: userText }
]
};

const res = await fetch(v.aiUrl, { method:’POST’, headers, body: JSON.stringify(payload) });
if (!res.ok) throw new Error(`AI error ${res.status}`);
const data = await res.json();

const replyText = data.text || data.reply || data.content || ”;

return replyText;
}

function renderQuoteBlocks(insight) {
const raw = (insight && insight.quote_html && String(insight.quote_html).trim() !== ”)
? String(insight.quote_html)
: (insight && insight.quote ? String(insight.quote) : ”);

if (!raw.trim()) return ”;

// normalise newlines to
so we can split consistently
const normalised = raw
.replace(/\r\n/g, ‘\n’)
.replace(/\n/g, ‘
‘);

// Split into multiple quotes on blank line / double
const parts = normalised
.split(/(?:
\s*){2,}/i)
.map(s => s.trim())
.filter(Boolean);

const blocks = parts.map(part => {
// Split the part into lines using
const lines = part
.split(//i)
.map(s => s.trim())
.filter(Boolean);

// Expect: [quoteHtml, name, role…]
const quoteHtmlRaw = lines[0] || ”;
const nameRaw = lines[1] || ”;
const roleRaw = lines.slice(2).join(‘
‘) || ”;

// Remove literal quote characters inside the first …
const quoteClean = quoteHtmlRaw
.replace(/(\s*)[“”‘]+/i, ‘$1’)
.replace(/[””‘]+(\s*<\/strong>)/i, ‘$1’);

// Allow only basic inline tags, convert any stray newlines to
const quoteHtml = safeBasicHtml(quoteClean);
const nameHtml = safeBasicHtml(nameRaw);
const roleHtml = safeBasicHtml(roleRaw);

return `

${quoteHtml}

${nameRaw ? `

${nameHtml}

` : “}
${roleRaw ? `

${roleHtml}

` : “}

`;
}).join(”);

return `

${blocks}

`;
}

function buildInsightBodyHtml(insight) {
// Prefer text_html if present (Formidable may already provide basic HTML)
const rawHtml = (insight.text_html && String(insight.text_html).trim() !== ”)
? String(insight.text_html).trim()
: ”;

const rawText = (!rawHtml && insight.text) ? String(insight.text || ”).trim() : ”;

// Convert plain text into

paragraphs (split on blank lines)
function textToParagraphs(t) {
const paras = t
.replace(/\r\n/g, ‘\n’)
.split(/\n\s*\n+/)
.map(s => s.trim())
.filter(Boolean);

return paras.map(p => `

${esc(p).replace(/\n/g, ‘
‘)}

`).join(”);
}

// If HTML already contains

, keep it; otherwise wrap into

function normaliseHtmlToParagraphs(h) {
const hasP = /<\s*p[\s>]/i.test(h);
if (hasP) return h;

// If it’s HTML but not paragraphised, treat line breaks as paragraphs
const tmp = h
.replace(/\r\n/g, ‘\n’)
.replace(//gi, ‘\n’)
.split(/\n\s*\n+/)
.map(s => s.trim())
.filter(Boolean);

return tmp.map(p => `

${p}

`).join(”);
}

let bodyHtml = rawHtml ? normaliseHtmlToParagraphs(rawHtml) : (rawText ? textToParagraphs(rawText) : ”);
if (!bodyHtml) return ”;

// One restrained pull-quote (auto inserted after first paragraph).
// Prefer a dedicated field if you add one later; otherwise extract from this Insight’s own text.
function firstGoodSentenceFromText(t) {
const s = String(t || ”)
.replace(/\s+/g, ‘ ‘)
.trim();

if (!s) return ”;

// Split into sentences conservatively.
const parts = s.split(/(?<=[.!?])\s+/).map(x => x.trim()).filter(Boolean);

// Pick the first “good” sentence: not tiny, not massive, not a generic opener.
for (const p of parts) {
const clean = p.replace(/^[““”]+|[““”]+$/g, ”).trim();
if (clean.length < 35) continue; if (clean.length > 140) continue;
return clean;
}

// Fallback: take a clean slice.
return s.slice(0, 120).replace(/^[““”]+|[““”]+$/g, ”).trim();
}

const pullQuoteField =
insight?.pull_quote ??
insight?.pullQuote ??
insight?.[‘Pull quote’] ??
insight?.[‘Pull Quote’] ??
”;

// Use text_html stripped-ish fallback via rawText when available; if HTML-only, we still try via plain text.
const sourceTextForQuote = rawText || String(insight?.text || ”).trim();

const pullQuote = String(pullQuoteField || ”).trim() || firstGoodSentenceFromText(sourceTextForQuote);

if (pullQuote && /<\/p>/i.test(bodyHtml)) {
bodyHtml = bodyHtml.replace(
/<\/p>/i,
`

“

${esc(pullQuote)}

`
);
}

return bodyHtml;
}

function renderInsight(ctx) {
const root = qs(‘#cp-insight-root’);
if (!root) return;

const page = (window.cpVars && window.cpVars.insightPage) ? window.cpVars.insightPage : {};
const insight = ctx.insight || {};
const videos = ctx.videos || [];

const banner = ctx.active?.entry_id
? `

You have an active conversation open. Finish it before starting another Insight.

`
: ”;

const videoHtml = videos.map((v, idx) => {
const start = v.clip_start ? parseInt(v.clip_start, 10) : null;
const end = v.clip_end ? parseInt(v.clip_end, 10) : null;

const src = youtubeEmbedUrl(v.address, start, end);
if (!src) return ”;

const title = (v.clip_title || ”).trim();
const speaker = (v.heading || ”).trim();

// Use curated Tab invite text from Form 303 field [7205] when present
const tabInvite =
String(
v.tab_invite_text ??
v[‘Tab invite text’] ??
v[‘7205’] ??
”
).trim();

// Fallback to prior auto-text if the curated field is missing/blank
const affordance = tabInvite ||
((speaker && title) ? `Watch ${speaker} speak about “${title}”`
: (speaker) ? `Watch ${speaker} speak`
: (title) ? `Watch video about “${title}”`
: `Watch video`);

const detId = `cp-video-${idx}`;

return `

${esc(affordance)}

<br />

${title ? `

${esc(title)}

` : ”}

`;
}).join(”);

const tailoredHtml = ctx.tailored_html || ”;

// AI Coach heading/subheading: allow future per-user / per-insight overrides from the context API
// AI Coach heading/subheading: allow future per-user / per-insight overrides from the context API
const coachHeading = String(
ctx.coach_heading ||
ctx.coachHeading ||
ctx.tailored_coach_heading ||
ctx.tailoredCoachHeading ||
‘Your Turn.’
).trim() || ‘Your Turn.’;

// Show the default “Share your thoughts…” hint only once per browser session
const DEFAULT_COACH_SUB = ‘Share your thoughts here and I (your AI Coach) will talk them through with you.’;
const introKey = ‘cp_insight_intro_shown’;
const showIntroHint = !sessionStorage.getItem(introKey);
if (showIntroHint) sessionStorage.setItem(introKey, ‘1’);

// If the context API provides a coach subheading, always show it.
// Otherwise, show the default hint only once.
const coachSubFromCtx = String(
ctx.coach_sub ||
ctx.coachSub ||
ctx.tailored_coach_sub ||
ctx.tailoredCoachSub ||
”
).trim();

const coachSub = coachSubFromCtx || (showIntroHint ? DEFAULT_COACH_SUB : ”);
const coachSubIsIntro = (!coachSubFromCtx && showIntroHint);

root.innerHTML = `

${banner}

${(() => {
const t =
ctx?.chapterMeta?.title ||
ctx?.chapter_meta?.title ||
ctx?.insight?.chapterMeta?.title ||
ctx?.insight?.chapter_meta?.title ||
ctx?.insight?.chapter_title ||
ctx?.insight?.chapterTitle ||
”;

// Prefer the explicit chapter number if present; otherwise derive from Insight sequence “1.1” → “1”
const n =
ctx?.chapterMeta?.chapter_number ||
ctx?.chapter_meta?.chapter_number ||
ctx?.insight?.chapterMeta?.chapter_number ||
ctx?.insight?.chapter_meta?.chapter_number ||
ctx?.insight?.chapter_number ||
”;

const title = String(t || ”).trim();
let num = String(n || ”).trim();

if (!num) {
const seq = String(page.insightSequenceNumber || ”).trim();
if (seq && seq.includes(‘.’)) num = seq.split(‘.’)[0].trim();
}

if (!title && !num) return ”;

return `

${num ? `Chapter ${esc(num)}${title ? `: ${esc(title)}` : “}` : `${esc(title)}`}

`;
})()}

${(() => {
const seq = String(page.insightSequenceNumber || ”).trim(); // e.g. “1.1”
const ttl = String(insight.title || ”).trim();
const full = (seq ? `${seq} ` : ”) + ttl; // “1.1 Follow Your Passion?”
return `

${esc(full)}

`;
})()}

${renderQuoteBlocks(insight)}

${tailoredHtml ? `

${tailoredHtml}

` : ”}
${videoHtml ? `

${videoHtml}

` : ”}

${buildInsightBodyHtml(insight)}

${esc(coachHeading)}

${esc(coachSub)}

Awaiting your response…

`;

// Video: only load iframe when opened; unload when closed (prevents “audio keeps playing”)
const videoDetails = root.querySelectorAll(‘.cp-video-details’);
videoDetails.forEach(det => {
const iframe = det.querySelector(‘iframe.cp-video’);
if (!iframe) return;

const load = () => {
if (!iframe.src) iframe.src = iframe.getAttribute(‘data-src’) || ”;
};
const unload = () => {
iframe.src = ”;
};

// If it starts open for any reason, load it
if (det.open) load();

det.addEventListener(‘toggle’, () => {
if (det.open) load();
else unload();
});
});

// Safety: if user navigates away mid-play, blank all iframes
window.addEventListener(‘beforeunload’, () => {
root.querySelectorAll(‘iframe.cp-video’).forEach(f => { f.src = ”; });
});

// — Wire collapsible videos (arrow state handled by CSS; this handles loading + stopping audio) —
(function wireVideos(){
const detailsEls = root.querySelectorAll(‘details.cp-video-details’);
if (!detailsEls || !detailsEls.length) return;

function closeAllIframes() {
detailsEls.forEach(d => {
const iframe = d.querySelector(‘iframe.cp-video’);
if (!iframe) return;
// remember src if it was ever set
if (!iframe.dataset.src && iframe.getAttribute(‘src’)) {
iframe.dataset.src = iframe.getAttribute(‘src’);
}
iframe.setAttribute(‘src’, ”);
});
}

detailsEls.forEach(d => {
const iframe = d.querySelector(‘iframe.cp-video’);
if (!iframe) return;

// If someone saved older HTML with src set, normalise into data-src
const existingSrc = iframe.getAttribute(‘src’);
if (existingSrc && existingSrc.trim() && (!iframe.dataset.src || !iframe.dataset.src.trim())) {
iframe.dataset.src = existingSrc.trim();
iframe.setAttribute(‘src’, ”);
}

// If it starts open, load immediately
if (d.open && iframe.dataset.src) {
iframe.setAttribute(‘src’, iframe.dataset.src);
}

d.addEventListener(‘toggle’, () => {
if (d.open) {
// opening: load this one
if (iframe.dataset.src && !iframe.getAttribute(‘src’)) {
iframe.setAttribute(‘src’, iframe.dataset.src);
}
} else {
// closing: stop audio by unloading
iframe.setAttribute(‘src’, ”);
}
});
});

// If the user navigates away / closes the tab, kill any running audio.
window.addEventListener(‘pagehide’, closeAllIframes);
window.addEventListener(‘beforeunload’, closeAllIframes);
})();

window.addEventListener(‘scroll’, () => {
// only try to schedule if we’re in “awaiting response” state
if (!String(coachState?.draft || ”).trim()) scheduleNudge();
}, { passive: true });

// Wire input (REPLACEMENT BLOCK)
const sendBtn = qs(‘#cp-ai-send’);
const nextBtn = qs(‘#cp-ai-next’);
const ta = qs(‘#cp-ai-input’);
const ctaText = qs(‘#cp-ai-cta-status’);

const nudgeBtn = qs(‘#cp-ai-nudge’);
const nudgeBox = qs(‘#cp-ai-nudge-options’);

let nudgeTimer = null;
let nudgeShown = false;
let nudgeOpen = false;

function clearNudge() {
if (nudgeTimer) clearTimeout(nudgeTimer);
nudgeTimer = null;

nudgeOpen = false;

if (nudgeBtn) nudgeBtn.style.display = ‘none’;
if (nudgeBox) nudgeBox.style.display = ‘none’;
}

function scheduleNudge() {
// If the options are currently visible, do not hide them on scroll.
if (nudgeOpen) return;

// Clear timer only (do not clear UI)
if (nudgeTimer) clearTimeout(nudgeTimer);
nudgeTimer = null;

if (!nudgeBtn) return;

// only if the user hasn’t started typing
if (String(coachState?.draft || ”).trim()) return;

// Only start the timer once the input area is visible on screen
const inputWrap = ta ? ta.closest(‘.cp-input’) : null;
if (!inputWrap) return;

const rect = inputWrap.getBoundingClientRect();
const inView = rect.top < (window.innerHeight * 0.85) && rect.bottom > 0;
if (!inView) return;

nudgeTimer = setTimeout(() => {
// still empty?
if (String(ta?.value || ”).trim()) return;

// still in view?
const r = inputWrap.getBoundingClientRect();
const stillInView = r.top < (window.innerHeight * 0.85) && r.bottom > 0;
if (!stillInView) return;

nudgeBtn.style.display = ”;
}, 15000);
}

if (!sendBtn || !nextBtn || !ta || !ctaText) return;

// Next is always visible from the start (your new decision)
nextBtn.style.display = ”;
nextBtn.disabled = false;

// Minimal draft state (no sufficiency/length gating)
let coachState = { draft: ” };

// When Next is clicked and the AI says “not really covered”, we require confirmation.
// This flag means “user already confirmed they want to move on anyway”.
let nextConfirmedOverride = false;

function renderCTA() {
const locked = !!(window.cpVars && window.cpVars.insightPage && window.cpVars.insightPage.active && window.cpVars.insightPage.active.entry_id);

if (locked) {
ctaText.textContent = ‘Finish your active conversation before starting another Insight.’;
sendBtn.disabled = true;
nextBtn.disabled = true;
return;
}

const hasDraft = !!String(coachState.draft || ”).trim();

if (!hasDraft) {
// Awaiting response: Next enabled, Send disabled
ctaText.textContent = ‘Awaiting your response…’;
sendBtn.disabled = true;
nextBtn.disabled = false;
scheduleNudge();
} else {
// Listening: Send enabled, Next disabled
ctaText.textContent = ‘Listening…’;
sendBtn.disabled = false;
nextBtn.disabled = true;
clearNudge();
}
}

ta.addEventListener(‘input’, () => {
// Keep draft in sync (no meaning checks, no word/char counting)
coachState.draft = String(ta.value || ”);
renderCTA();
});

// —- AI check used ONLY when the user clicks Next —-
async function assessInsightCoveredForNextClick() {
const v = (window.cpVars && window.cpVars.insightPage) ? window.cpVars.insightPage : {};
if (!v.aiUrl) return { covered: true, message: ” }; // fail-open: never block Next if AI is unavailable

const headers = { ‘Content-Type’: ‘application/json’ };
if (v.token) headers[‘X-CP-Token’] = v.token;
else if (v.restNonce) headers[‘X-WP-Nonce’] = v.restNonce;

const cf = v.coachFields || {};
const transcript = buildTranscript(3500);
// Provide the last two user turns explicitly to the monitor model
const lastTwoUser = thread
.filter(m => m.role === ‘user’)
.slice(-2)
.map(m => String(m.content || ”).trim());

const system =
`You are checking whether this Insight has been sufficiently covered to move on.\n` +
`Be conservative.\n` +
`Return ONLY valid JSON:\n` +
`{“covered”:true|false,”message”:”…”}\n` +
`- If covered=true: message may be empty.\n` +
`- If covered=false: message must briefly say what may still be worth exploring, and ask the user to confirm if they still want to move on.\n`;

const user =
`INSIGHT QUESTION:\n${cf.insightQuestion || String(v.insight?.question || ”).trim()}\n\n` +
`INSIGHT SUMMARY:\n${cf.insightSummary || ”}\n\n` +
`TRANSCRIPT:\n${transcript}\n`;

const payload = {
model: ‘gpt-4o’,
temperature: 0,
messages: [
{ role: ‘system’, content: system },
{ role: ‘user’, content: user }
]
};

const res = await fetch(v.aiUrl, { method: ‘POST’, headers, body: JSON.stringify(payload) });
const j = await res.json();
const raw = (j && (j.text || j.reply || j.content)) ? String(j.text || j.reply || j.content) : ”;

try {
const parsed = JSON.parse(raw);
if (typeof parsed.covered === ‘boolean’) {
return { covered: !!parsed.covered, message: String(parsed.message || ”).trim() };
}
} catch {}

// If the model returns anything unexpected, do not block Next
return { covered: true, message: ” };
}

// —- AI check used on SEND (before generating a reply) —-
// Goal: detect stalled / non-productive exchange and offer the SAME confirm as [Next].
// Rule: only act on TWO successive flagged user turns.
// Once offered and user declines, do NOT offer again for this Insight/session.

function showExampleNudges() {
if (!nudgeBox) return;
nudgeOpen = true;
if (nudgeTimer) { clearTimeout(nudgeTimer); nudgeTimer = null; }
const examples = [
“It feels inspiring, but also slightly unrealistic.”,
“I like the idea, but I’m not sure what my passion actually is.”,
“It sounds idealistic — life feels more complicated than that.”
];

nudgeBox.innerHTML = examples.map(e =>
`

${esc(e)}

`
).join(”);

nudgeBox.style.display = ‘flex’;

nudgeBox.querySelectorAll(‘.cp-nudge-option’).forEach(el => {
el.addEventListener(‘click’, () => {
ta.value = el.textContent;
coachState.draft = el.textContent;
clearNudge();
renderCTA();
});
});
}

if (nudgeBtn) {
nudgeBtn.addEventListener(‘click’, showExampleNudges);
}

// Try to hand off to whatever navigation is already wired.
// (We do not assume a specific navigation implementation in this file.)
function triggerNextNavigation() {
// 1) Let any outer script hook it
try {
window.dispatchEvent(new CustomEvent(‘cp_ai_next’, { detail: { source: ‘cp-ai-next’ } }));
} catch {}

// 2) If we know the next Insight KEY (field 6897), construct the next URL
try {
const page = (window.cpVars && window.cpVars.insightPage) ? window.cpVars.insightPage : {};
const nextKey = String(page.nextInsightKey || ”).trim();
if (nextKey) {
const cur = new URL(window.location.href);

const u = new URL(‘/insight/’, window.location.origin);
const sp = new URLSearchParams(cur.search || ”);

// Keep existing params, but force the next Insight key
sp.set(‘userpass’, String(page.userpass || getParam(‘userpass’,”) || ”));
sp.set(‘edition’, String(page.edition || getParam(‘edition’,”) || ”));
sp.set(‘insight’, nextKey);

// Preserve these if present
const tone = String(page.tone || getParam(‘tone’,”) || ”);
const reset = String(getParam(‘reset’,”) || ”);
const sid = String(getParam(‘sid’,”) || ”);

if (tone) sp.set(‘tone’, tone);
if (reset !== ”) sp.set(‘reset’, reset);
if (sid) sp.set(‘sid’, sid);

u.search = sp.toString();
window.location.assign(u.toString());
return;
}
} catch {}

// 3) If we already know the next Insight URL, go there
try {
const page = (window.cpVars && window.cpVars.insightPage) ? window.cpVars.insightPage : {};
const nextUrl = String(page.nextInsightUrl || page.nextUrl || ”).trim();
if (nextUrl) {
window.location.assign(nextUrl);
return;
}
} catch {}

// 4) Try common “rel=next” hooks (anchor or link)
try {
const a = document.querySelector(‘a[rel=”next”][href]’);
if (a && a.href) { window.location.assign(a.href); return; }
} catch {}

try {
const l = document.querySelector(‘link[rel=”next”][href]’);
if (l && l.href) { window.location.assign(l.href); return; }
} catch {}

// 5) If we get here, we have no safe navigation target
try { window.alert(‘Next Insight link not found on this page.’); } catch {}
}

// Next handler
nextBtn.addEventListener(‘click’, async (e) => {
// Prevent accidental double-binding loops if any external handler re-triggers click.
// If you remove this and your external wiring is clean, fine — but this prevents recursion.
if (e && e.isTrusted === false) return;

if (nextBtn.disabled) return;

// If user already confirmed override, move on immediately (no second AI call)
if (nextConfirmedOverride) {
triggerNextNavigation();
return;
}

// Lock UI (AI working)
sendBtn.disabled = true;
nextBtn.disabled = true;
ctaText.textContent = ‘Checking whether it’s a good point to move on…’;

try {
const verdict = await assessInsightCoveredForNextClick();

if (verdict.covered) {
nextConfirmedOverride = false;
triggerNextNavigation();
return;
}

// Not covered: ask confirmation WITHOUT adding a new coach message to the thread
const ok = window.confirm(
“Are you sure you’re ready to move on [OK], or would you like to continue exploring this Insight [Cancel]?”
);
if (ok) {
nextConfirmedOverride = true;
triggerNextNavigation();
} else {
nextConfirmedOverride = false;
return; // explicit: no further action
}

} catch {
// fail-open on errors
triggerNextNavigation();
} finally {
sendBtn.disabled = false;
nextBtn.disabled = false;
renderCTA();
}
});

// Send handler (adds a pre-reply stall/non-response check)
sendBtn.addEventListener(‘click’, async () => {
if (sendBtn.disabled) return;

let text = (ta.value || ”).trim();
if (!text) return;

// Lock UI (AI working)
sendBtn.disabled = true;
nextBtn.disabled = true;
ctaText.textContent = ‘AI Coach is updating your notes’;

// Spellcheck before submit (GTKY behaviour)
text = await spellcheckLocale(text);

// Clear input + commit user message to the thread
ta.value = ”;
coachState.draft = ”;
nextConfirmedOverride = false; // any new user turn resets the override
pushMsg(‘user’, text);

try {
const evalResult = await evaluateTurn(text);

if (evalResult.advance && currentStep < steps.length - 1) { currentStep++; sessionStorage.setItem(STEP_KEY, String(currentStep)); } const replyDecision = await classifyTurnWithAI(text); const reply = await callAI(text, evalResult, replyDecision); const cleanReply = String(reply || '').trim(); pushMsg('assistant', cleanReply); // 1) mini summary const summary = await summariseThread(); // 2) append-only emits to 329 + 338 (once per user turn) await saveConversationSummary({ summary }); // 3) store to 320 Responses (no advance gating) const coachDecision = { next_model: 'next_click_ai_check' }; await saveNow({ status: 'Live', summary, '7206': JSON.stringify(coachDecision), 'coach decision': JSON.stringify(coachDecision) }); } catch (e) { pushMsg('assistant', `Sorry — something went wrong. ${String(e.message || e)}`); } finally { sendBtn.disabled = false; nextBtn.disabled = false; renderCTA(); } }); // Initial UI state sendBtn.textContent = 'Send'; nextBtn.style.display = ''; coachState.draft = String(ta.value || ''); renderCTA(); } async function init() { const page = (window.cpVars && window.cpVars.insightPage) ? window.cpVars.insightPage : {}; const userpass = getParam('userpass',''); const edition = (getParam('edition','workplace') || 'workplace').toLowerCase(); const insight = getParam('insight',''); const tone = (getParam('tone','direct') || 'direct').toLowerCase(); page.tone = tone; if (!userpass) { const root = qs('#cp-insight-root'); if (root) root.innerHTML = `
Missing userpass.

`;
return;
}

const headers = {};
if (page.token) headers[‘X-CP-Token’] = page.token;
else if (page.restNonce) headers[‘X-WP-Nonce’] = page.restNonce;

if (!page.contextUrl) {
const root = qs(‘#cp-insight-root’);
if (root) root.innerHTML = `

Missing cpVars.insightPage.contextUrl.

`;
return;
}

// Build context URL using ONLY the params the endpoint expects.
// (Do not forward arbitrary page params like “id” etc.)
const u = new URL(page.contextUrl, window.location.origin);
const sp = new URLSearchParams();

sp.set(‘userpass’, userpass);
sp.set(‘edition’, edition);
sp.set(‘insight’, insight || ”);
sp.set(‘tone’, tone || ‘direct’);

const reset = String(getParam(‘reset’, ”) || ”).trim();
const sid = String(getParam(‘sid’, ”) || ”).trim();

if (reset !== ”) sp.set(‘reset’, reset);
if (sid !== ”) sp.set(‘sid’, sid);

u.search = sp.toString();

const res = await fetch(u.toString(), { headers });
if (!res.ok) throw new Error(`Insight context error ${res.status}`);
const ctx = await res.json();

// store into cpVars for AI calls
page.userpass = userpass;
page.edition = edition;

// KEEP: entry-key (used for routing + saving)
page.insightSequence = insight;

// NEW: human-facing Insight Sequence number (Formidable field [6856])
// Prefer numeric key access because it’s the most reliable across payload variants.
const i = ctx?.insight || {};
const i2 = ctx?.insight_fields || ctx?.insightFields || ctx?.fields || {}; // defensive

// Helper: first non-empty value from a list of candidates
const pick = (…vals) => {
for (const v of vals) {
const s = (v === null || v === undefined) ? ” : String(v);
if (s.trim() !== ”) return s.trim();
}
return ”;
};

// NEW: sequence number from field [6856] (plus common named variants)
page.insightSequenceNumber = pick(
// numeric field key variants
i2?.[‘6856’], i?.[‘6856’],
i2?.[6856], i?.[6856],

// common human-name variants (depends how MU serialises the record)
i2?.[‘Insight Sequence’], i?.[‘Insight Sequence’],
i2?.[‘Insight Sequence field’], i?.[‘Insight Sequence field’],
i2?.insight_sequence, i?.insight_sequence,
i2?.insightSequence, i?.insightSequence
);

// Debug (only when missing): show which keys we actually got back
if (!page.insightSequenceNumber) {
console.log(‘[cp-insight] missing Insight Sequence [6856]’, {
insightKey: insight, // the entry-key from URL
insightKeys: Object.keys(i || {}).sort(),
altKeys: Object.keys(i2 || {}).sort(),
sample: {
i_6856: i?.[‘6856’] ?? i?.[6856],
i2_6856: i2?.[‘6856’] ?? i2?.[6856],
i_named: i?.[‘Insight Sequence’],
i2_named: i2?.[‘Insight Sequence’]
}
});
}

page.insight = ctx.insight;
page.videos = ctx.videos;
page.mode = ctx.mode;

// Prefer the MU-provided canonical field (ctx.insight.next).
page.nextInsightKey = pick(
i?.next,
i?.nextInsightKey,
i2?.[‘6897’], i?.[‘6897’],
i2?.[6897], i?.[6897]
);

// NEW: curated coaching rails (field names)
// (i, i2, pick already defined above)

const interventionScope =
i?.intervention_scope_v3 ??
i?.[‘Intervention Scope v3’] ??
i?.[‘7207’] ??
i?.[7207] ??
i2?.intervention_scope_v3 ??
i2?.[‘Intervention Scope v3’] ??
i2?.[‘7207’] ??
i2?.[7207] ??
”;

const aiInsightPromptV3 =
i?.ai_insight_prompt_v3 ??
i?.[‘AI Insight Prompt v3’] ??
i?.[‘7208’] ??
i?.[7208] ??
i2?.ai_insight_prompt_v3 ??
i2?.[‘AI Insight Prompt v3’] ??
i2?.[‘7208’] ??
i2?.[7208] ??
”;

const aiStepPromptV3 =
i?.ai_step_prompt_v3 ??
i?.[‘AI Step Prompt v3’] ??
i?.[‘7209’] ??
i?.[7209] ??
i2?.ai_step_prompt_v3 ??
i2?.[‘AI Step Prompt v3’] ??
i2?.[‘7209’] ??
i2?.[7209] ??
”;

// Debug (only when missing): shows what keys are actually coming back from the endpoint
// Debug (only when missing): shows what keys are actually coming back from the endpoint
if (!interventionScope || !aiInsightPromptV3 || !aiStepPromptV3) {
console.log(‘[cp-insight] missing coach rails (v3)’, {
interventionScopePresent: !!interventionScope,
aiInsightPromptV3Present: !!aiInsightPromptV3,
aiStepPromptV3Present: !!aiStepPromptV3,
insightKeys: Object.keys(i || {}).sort(),
altKeys: Object.keys(i2 || {}).sort()
});
}
const aiCoachFrameworkSteps =
i?.ai_coach_framework_steps ??
i?.[‘AI Coach Framework Steps’] ??
i?.[‘7202’] ??
i?.[7202] ??
i2?.ai_coach_framework_steps ??
i2?.[‘AI Coach Framework Steps’] ??
i2?.[‘7202’] ??
i2?.[7202] ??
”;

page.coachFields = {
// Core framing (must)
insightQuestion: pick(i[‘Insight Question’], i.question, i2[‘Insight Question’], i2.question),
insightSummary: pick(i[‘Insight Summary’], i2[‘Insight Summary’]),

// Primary coaching guidance (must)
coachGuidance: pick(
i[‘AI Coach – Generic advice, customised for Insight’],
i2[‘AI Coach – Generic advice, customised for Insight’]
),

// AI coaching rails (v3 only)
interventionScope: interventionScope,
aiInsightPrompt: aiInsightPromptV3,
aiStepPrompt: aiStepPromptV3,
aiCoachFrameworkSteps:
insight?.ai_coach_framework_steps ||
i?.ai_coach_framework_steps ||
i2?.ai_coach_framework_steps ||
”,

// Behaviour/process rails (must)
coachStyle: pick(i[‘Coach Style’], i2[‘Coach Style’]),
coachChunking: pick(i[‘Coach Chunking’], i2[‘Coach Chunking’]),
};

// NEW: capture Insight Guide (WE Insight Guide)
page.insightGuide = String(
ctx?.insight?.[‘WE Insight Guide’] || ”
).trim();

renderInsight(ctx);

// Seed first AI prompt with the Insight question
if (ctx?.insight?.question) {
pushMsg(‘assistant’, ctx.insight.question);
}

// Optional resume fetch (if you later wire the MU resume payload properly)
// const r = await fetch(`${v.resumeUrl}?userpass=${encodeURIComponent(userpass)}&insight=${encodeURIComponent(insight)}`, { headers });
// const rd = await r.json();
// if (rd?.resume?.dialogue) { /* parse transcript back into thread if you want */ }
}

if (document.readyState === ‘loading’) {
document.addEventListener(‘DOMContentLoaded’, init);
} else {
init();
}
})();

2. Insight JS code

Share This Story, Choose Your Platform!

About the Author: Coming Soon...