cp-insight.js

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

return `

`;
}).join(”);

return `

`;
}

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,
`

`
);
}

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
? `

`
: ”;

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 `

`;
}).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 = `

`;

// 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;
nextBtn.style.display = ”;
nextBtn.textContent = ‘End’;
return;
}

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

// Whenever the end report is not showing, the End button must be visible
if (!endReportShown) {
nextBtn.style.display = ”;
nextBtn.textContent = ‘End’;
}

if (!hasDraft) {
// Awaiting response: End enabled, Send disabled
ctaText.textContent = ‘Awaiting your response…’;
sendBtn.disabled = true;
nextBtn.disabled = false;
scheduleNudge();
} else {
// Listening: Send enabled, End 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 =>
`

`
).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() {
if (endReportShown) return;

// 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) => {
if (e && e.isTrusted === false) return;

if (nextBtn.disabled) return;
if (endReportShown) return;

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) {
triggerNextNavigation();
return;
}

// Hide the whole input area immediately
const inputWrap = qs(‘.cp-input’);
if (inputWrap) inputWrap.style.display = ‘none’;

// Hide the End button immediately
nextBtn.style.display = ‘none’;

await showEndOfInsightReport();
return;

} catch {
triggerNextNavigation();
} finally {
// Only restore the normal UI if we are NOT showing the end report
if (!endReportShown) {
sendBtn.disabled = false;
nextBtn.disabled = false;
renderCTA();
}
}
});

/**
* Return the most recent assistant message in the current thread.
*/
function getLastAssistantMessage() {
for (let i = thread.length – 1; i >= 0; i–) {
const message = thread[i];

if (message?.role === ‘assistant’) {
return message;
}
}

return null;
}

/**
* Find the coaching question which came before the continuation check.
*/
function getQuestionBeforeContinuationCheck() {
for (let i = thread.length – 1; i >= 0; i–) {
const message = thread[i];

if (message?.role !== ‘assistant’) {
continue;
}

if (
typeof message.content === ‘object’ &&
message.content?.control === ‘continuation_check’
) {
continue;
}

const question =
typeof message.content === ‘object’
? String(message.content?.question || ”).trim()
: String(message.content || ”).trim();

if (question) {
return question;
}
}

const v =
window.cpVars && window.cpVars.insightPage
? window.cpVars.insightPage
: {};

return String(
v.coachFields?.insightQuestion ||
v.insight?.question ||
”
).trim();
}

/**
* Handle the user’s answer to a coaching control question.
*
* Supported controls:
* – continuation_check
* – non_resonance_offer
*
* These replies are decisions about the coaching flow.
* They must never be passed to Layer A or Layer B as Insight evidence.
*/
async function handleContinuationCheckReply(userText, responseId) {
const lastAssistant = getLastAssistantMessage();

const control =
lastAssistant &&
typeof lastAssistant.content === ‘object’
? String(lastAssistant.content?.control || ”).trim()
: ”;

const isContinuationCheck =
control === ‘continuation_check’;

const isNonResonanceOffer =
control === ‘non_resonance_offer’;

if (!isContinuationCheck && !isNonResonanceOffer) {
return {
handled: false
};
}

const v =
window.cpVars && window.cpVars.insightPage
? window.cpVars.insightPage
: {};

/*
* NON-RESONANCE OFFER
*
* The user is choosing whether to leave the Insight or continue.
* This is not an Insight answer.
*/
if (isNonResonanceOffer) {
const aiResult = await window.cpAiService.callJson({
task: ‘non_resonance_offer_decision’,
responseId,
config: v,
payload: {
model: ‘gpt-4o’,
temperature: 0,
messages: [
{
role: ‘system’,
content:
`You classify the user’s answer to a coaching offer to leave or continue the current Insight.

Return ONLY valid JSON in this exact form:
{
“decision”: “continue|move_on|unclear”,
“reason”: “short reason”
}

Definitions:
– continue: the user clearly wants to continue exploring the current Insight.
– move_on: the user clearly wants to leave this Insight and move on.
– unclear: the user’s preference cannot be determined confidently.

Rules:
– This is a control decision, not an Insight answer.
– Do not analyse the user’s circumstances.
– Do not infer more than the user has said.
– “Continue”, “carry on”, “keep going”, “let’s continue” or similar means continue.
– “Move on”, “leave it”, “stop”, “that’s enough” or similar means move_on.`
},
{
role: ‘user’,
content:
`COACH OFFER:
${String(lastAssistant.content?.question || ”).trim()}

USER REPLY:
${String(userText || ”).trim()}`
}
]
}
});

const decision =
aiResult?.ok &&
[‘continue’, ‘move_on’, ‘unclear’].includes(
aiResult?.data?.decision
)
? aiResult.data.decision
: ‘unclear’;

/*
* User chooses to continue.
*
* The current line of enquiry has already reached non-resonance,
* so advance to the next framework step rather than restarting or
* repeating the current one.
*/
if (decision === ‘continue’) {
const stepCfg = getStepConfig();
const steps = stepCfg.steps || [];
const currentStepIndex = stepCfg.currentStep;

const hasNextStep =
steps.length > 0 &&
currentStepIndex < steps.length - 1; let targetStepIndex = currentStepIndex; if (hasNextStep) { targetStepIndex = currentStepIndex + 1; sessionStorage.removeItem( `${stepCfg.stepKey}_follow_up_${currentStepIndex}` ); sessionStorage.setItem( stepCfg.stepKey, String(targetStepIndex) ); } const rawTargetStep = String(steps[targetStepIndex] || '').trim(); const targetStepObjective = String( stepCfg.completionCriteriaByStep?.[ targetStepIndex + 1 ] || rawTargetStep || '' ).trim(); /* * Framework steps may contain internal labels such as * "Qualities:" and may also assume material that the user * never established, such as "that experience". * * After non-resonance, Continue means move forward through * the framework — but the next question must still be written * conversationally from what the user has actually established. */ let question = ''; if ( window.cpAiService && typeof window.cpAiService.callText === 'function' && v.aiUrl ) { try { const aiResult = await window.cpAiService.callText({ task: 'non_resonance_continue_writer', responseId, config: v, payload: { model: 'gpt-4o', temperature: 0.3, messages: [ { role: 'system', content: `You are writing the next AI Coach question after the user has chosen Continue following a non-resonance offer. The previous line of enquiry has been left behind. The coaching journey is now moving forward to the next framework step. Your job is to write ONE natural coaching question that pursues the purpose of the target framework step. Rules: - Treat the target framework step as the intended coaching purpose, not as wording that must be copied. - Do not expose framework labels, headings or configuration language such as "Qualities:", "Patterns:", "Experience:" or similar. - Never prefix the question with a framework label followed by a colon. - Use the conversation so far to understand what the user has actually established. - Never assume an experience, example, feeling, belief or other premise that the user has not established. - If the framework wording depends on missing information, reformulate it so the same step purpose can be explored from material the user has actually provided. - Do not return to the line of enquiry that has just reached non-resonance. - Do not try again to obtain an answer the user has repeatedly declined to provide. - Move the coaching forward. - Ask one question only. - Do not write a reflection. - Do not explain the framework or the transition. - Use UK English. - Return only the user-facing question.` }, { role: 'user', content: `TARGET FRAMEWORK STEP: ${rawTargetStep} TARGET STEP OBJECTIVE: ${targetStepObjective} RECENT CONVERSATION: ${buildTranscript(3000)} ACCEPTED USER EVIDENCE: ${JSON.stringify(acceptedEvidence || [], null, 2)}` } ] } }); if (aiResult?.ok) { question = String(aiResult.data || '').trim(); } } catch (err) { console.log( 'NON-RESONANCE CONTINUE WRITER ERROR:', err ); } } /* * Safe fallback: * remove an internal framework label if the AI writer * was unavailable. */ if (!question) { question = rawTargetStep .replace( /^[A-Za-z][A-Za-z\s/&-]{0,40}:\s*/, '' ) .trim(); } if (!question) { question = String( v.coachFields?.insightQuestion || v.insight?.question || '' ).trim(); } /* * Defensive clean-up in case a writer nevertheless returns * a framework-style label. */ question = String(question || '') .replace( /^[A-Za-z][A-Za-z\s/&-]{0,40}:\s*/, '' ) .trim(); await saveNow({ status: 'Live', gate_result: JSON.stringify({ status: 'non_resonance_continued', decision: 'continue' }), coach_decision: JSON.stringify({ next_model: 'next_framework_step', control: 'non_resonance_offer' }) }); pushMsg('assistant', { reflection: '', question, debug_trace: '', control: '' }); return { handled: true, decision: 'continue' }; } /* * User chooses to leave the Insight. * * Close the Insight properly: * - let Layer D decide whether there is anything useful to reflect; * - show that reflection only when there is meaningful material; * - tell the user we are moving to the next Insight; * - then navigate automatically. */ if (decision === 'move_on') { const layerD = await window.cpInsightLayerD.runLayerD({ config: v, responseId, thread, insightQuestion: String( v.coachFields?.insightQuestion || v.insight?.question || '' ).trim(), insightSummary: String( v.coachFields?.insightSummary || v.insight?.summary || v.insight?.text || '' ).trim(), reflectionHistory: v.coachMemory?.reflectionHistory || [], previousInsightReviews: v.coachMemory?.previousInsightReviews || [], relevantTraitHistory: v.coachMemory?.relevantTraitHistory || [], traitUpdates: [] }); const hasReview = layerD?.review_required === true && !!String(layerD.review || '').trim(); const review = hasReview ? String(layerD.review || '').trim() : ''; const closingDebugTrace = `AI DECISION TRACE Layered AI Coach Control Decision : non_resonance_offer Result : end Reason : The user chose to end the current Insight. Layer D Decision : ${layerD?.debug?.decision || 'D1'} Result : ${ hasReview ? 'full_review' : 'no_user_facing_review' } Reason : ${ layerD?.debug?.reason || layerD?.eligibility?.reason || 'Layer D assessed whether the conversation contained enough meaningful material for a closing reflection.' }`; await saveNow({ status: 'Ended', layer_d_result: JSON.stringify(layerD), gate_result: JSON.stringify({ status: 'non_resonance_confirmed', decision: 'end' }), coach_decision: JSON.stringify({ next_model: hasReview ? 'review_then_next_insight' : 'next_insight', control: 'non_resonance_offer', review_type: hasReview ? layerD?.review_type || 'full' : 'none' }) }); const inputWrap = qs('.cp-input'); if (inputWrap) { inputWrap.style.display = 'none'; } /* * If Layer D has nothing worthwhile to show the user, * there is no reason to hold them on this Insight. */ if (!hasReview) { endReportShown = false; triggerNextNavigation(); return { handled: true, decision: 'move_on', layerD }; } /* * Layer D has produced a worthwhile closing reflection. * Keep it visible until the user explicitly chooses Next Insight. */ pushMsg('assistant', { reflection: '', question: review, debug_trace: closingDebugTrace, control: '' }); endReportShown = true; const endReportBox = qs('#cp-end-report'); if (endReportBox) { endReportBox.innerHTML = `

`;

endReportBox.style.display = ‘block’;

const nextInsightBtn =
qs(‘#cp-non-resonance-next’, endReportBox);

if (nextInsightBtn) {
nextInsightBtn.addEventListener(‘click’, () => {
endReportShown = false;
triggerNextNavigation();
});
}
}

return {
handled: true,
decision: ‘move_on’,
layerD
};
}

/*
* The reply was ambiguous, so ask only for the choice again.
*/
const question =
‘Would you like to continue with this Insight, or leave it here and move on?’;

await saveNow({
status: ‘Live’,
gate_result: JSON.stringify({
status: ‘non_resonance_choice_unclear’,
decision: ‘unclear’
}),
coach_decision: JSON.stringify({
next_model: ‘non_resonance_offer’,
control: ‘non_resonance_offer’
})
});

pushMsg(‘assistant’, {
reflection: ”,
question,
debug_trace: ”,
control: ‘non_resonance_offer’
});

return {
handled: true,
decision: ‘unclear’
};
}

/*
* EXISTING A5 CONTINUATION CHECK
*/
const fallbackQuestion = getQuestionBeforeContinuationCheck();

const aiResult = await window.cpAiService.callJson({
task: ‘continuation_check_decision’,
responseId,
config: v,
payload: {
model: ‘gpt-4o’,
temperature: 0,
messages: [
{
role: ‘system’,
content:
`You classify the user’s answer to a coaching continuation check.

Return ONLY valid JSON in this exact form:
{
“decision”: “continue|pause|unclear”,
“reason”: “short reason”
}

Definitions:
– continue: the user clearly wants to continue the current Insight now.
– pause: the user clearly wants to stop for now, pause, or return later.
– unclear: the user’s preference cannot be determined confidently.

Rules:
– This is not an Insight answer.
– Do not analyse the user’s circumstances.
– Do not infer more than the user has said.
– A simple yes, carry on, continue, or similar means continue.
– A simple no, not now, later, pause, or similar means pause.`
},
{
role: ‘user’,
content:
`CONTINUATION QUESTION:
${String(lastAssistant.content?.question || ”).trim()}

USER REPLY:
${String(userText || ”).trim()}`
}
]
}
});

const decision =
aiResult?.ok &&
[‘continue’, ‘pause’, ‘unclear’].includes(
aiResult?.data?.decision
)
? aiResult.data.decision
: ‘unclear’;

if (decision === ‘continue’) {
const question =
fallbackQuestion ||
‘Let us return to the Insight. What were you noticing in response to the question?’;

await saveNow({
status: ‘Live’,
gate_result: JSON.stringify({
status: ‘continuation_resumed’,
decision: ‘continue’
}),
coach_decision: JSON.stringify({
next_model: ‘resume_insight’
})
});

pushMsg(‘assistant’, {
reflection: ”,
question,
debug_trace: ”,
control: ”
});

return {
handled: true,
decision: ‘continue’
};
}

if (decision === ‘pause’) {
const question =
‘Of course. We can pause here, and you can return to this Insight when the time feels right.’;

await saveNow({
status: ‘Live’,
gate_result: JSON.stringify({
status: ‘continuation_paused’,
decision: ‘pause’
}),
coach_decision: JSON.stringify({
next_model: ‘pause_insight’
})
});

pushMsg(‘assistant’, {
reflection: ”,
question,
debug_trace: ”,
control: ”
});

return {
handled: true,
decision: ‘pause’
};
}

const question =
‘Would you like to continue with this Insight now, or pause and return another time?’;

await saveNow({
status: ‘Live’,
gate_result: JSON.stringify({
status: ‘continuation_unclear’,
decision: ‘unclear’
}),
coach_decision: JSON.stringify({
next_model: ‘continuation_check’
})
});

pushMsg(‘assistant’, {
reflection: ”,
question,
debug_trace: ”,
control: ‘continuation_check’
});

return {
handled: true,
decision: ‘unclear’
};
}

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

if (
!window.cpAiService ||
typeof window.cpAiService.callJson !== ‘function’ ||
typeof window.cpAiService.callText !== ‘function’ ||
!window.cpInsightLayerA ||
!window.cpInsightLayerB ||
!window.cpInsightLayerC ||
!window.cpInsightLayerD ||
!window.cpInsightOrchestrator ||
typeof window.cpInsightOrchestrator.handleUserTurnLayered !== ‘function’
) {
throw new Error(‘Layered Insight architecture is not fully loaded.’);
}

const stepCfg = getStepConfig();

console.log(‘STEP CONFIG:’, stepCfg);

const steps = stepCfg.steps || [];
const currentStepIndex = stepCfg.currentStep;

const currentFrameworkStep =
steps[currentStepIndex] || ”;

const nextFrameworkStep =
steps[currentStepIndex + 1] || ”;

const isFinalFrameworkStep =
steps.length > 0 &&
currentStepIndex >= steps.length – 1;

const followUpKey =
`${stepCfg.stepKey}_follow_up_${currentStepIndex}`;

const followUpUsed =
sessionStorage.getItem(followUpKey) === ‘1’;

const responseId = getOrCreateResponseId();

/*
* cp-ai-service.js requires the current response record to exist
* before any AI request is made.
*/
await saveNow({
status: ‘Live’,
response_id: responseId,
user_input: userText
});

/*
* A reply to an A5 continuation check is a control decision,
* not evidence for the current Insight.
*/
const continuationResult =
await handleContinuationCheckReply(
userText,
responseId
);

if (continuationResult.handled) {
return {
stopped_at: ‘CONTINUATION_DECISION’,
continuation: continuationResult
};
}

const lastAssistantMessage = getLastAssistantMessage();

const lastCoachQuestion =
lastAssistantMessage?.role === ‘assistant’
? (
typeof lastAssistantMessage.content === ‘object’
? String(
lastAssistantMessage.content?.question || ”
).trim()
: String(lastAssistantMessage.content || ”).trim()
)
: ”;

console.log(‘LAYERED STEP CONTEXT:’, {
currentFrameworkStep,
currentStepObjective:
stepCfg.currentStepObjective || currentFrameworkStep || ”,
stepCompletionCriteria:
stepCfg.currentStepObjective ||
stepCfg.completionCriteria ||
currentFrameworkStep ||
”,
rawCompletionCriteria:
stepCfg.completionCriteria || ”,
completionCriteriaByStep:
stepCfg.completionCriteriaByStep || {}
});
const result =
await window.cpInsightOrchestrator.handleUserTurnLayered({
config: v,
responseId,
userText,
thread,

lastCoachQuestion,

insightQuestion: String(
v.coachFields?.insightQuestion ||
v.insight?.question ||
”
).trim(),

insightSummary: String(
v.coachFields?.insightSummary ||
v.insight?.summary ||
v.insight?.text ||
”
).trim(),

interventionScope: String(
v.coachFields?.interventionScope || ”
).trim(),

aiInsightPromptV3: String(
v.coachFields?.aiInsightPromptV3 || ”
).trim(),

currentFrameworkStep,

currentStepObjective: String(
stepCfg.currentStepObjective ||
currentFrameworkStep ||
”
).trim(),

nextFrameworkStep,

nextStepObjective: String(
stepCfg.nextStepObjective ||
nextFrameworkStep ||
”
).trim(),

stepCompletionCriteria: String(
stepCfg.currentStepObjective ||
stepCfg.completionCriteria ||
currentFrameworkStep ||
”
).trim(),

fallbackRoutes: String(
stepCfg.fallbackRoutes || ”
).trim(),

allowedMoves: String(
stepCfg.allowedMoves || ”
).trim(),

disallowedMoves: String(
stepCfg.disallowedMoves || ”
).trim(),

closureRule: String(
stepCfg.closureRule || ”
).trim(),

isFinalFrameworkStep,
followUpUsed,

aiStepPromptV3: String(
v.coachFields?.aiStepPromptV3 || ”
).trim(),

coachStyle: String(
v.coachFields?.coachStyle ||
v.tone ||
‘direct’
).trim(),

acceptedEvidence,

currentTraitStatus:
v.coachMemory?.currentTraitStatus || {},

futureChapterMap:
v.coachMemory?.futureChapterMap || {},

reflectionHistory:
v.coachMemory?.reflectionHistory || [],

previousInsightReviews:
v.coachMemory?.previousInsightReviews || [],

relevantTraitHistory:
v.coachMemory?.relevantTraitHistory || [],

pushAssistantMessage(message) {
pushMsg(‘assistant’, message);
},

async saveNow(payload) {
await saveNow(payload);
}
});

/*
* Retain only evidence that Layer B itself classified as:
* – new
* – materially_developed
*
* Repeated evidence is not added again.
* Unknown evidence is not treated as accepted.
*/
retainAcceptedEvidence(result?.layerB);

const strategy =
result?.layerB?.strategy?.response_strategy || ”;

if (strategy === ‘follow_up’) {
sessionStorage.setItem(followUpKey, ‘1’);
}

if (
strategy === ‘next_step’ &&
!isFinalFrameworkStep &&
steps.length
) {
sessionStorage.removeItem(followUpKey);

const nextStepIndex = Math.min(
currentStepIndex + 1,
steps.length – 1
);

sessionStorage.setItem(
stepCfg.stepKey,
String(nextStepIndex)
);
}

/*
* NON-RESONANCE OFFER
*
* C3 has NOT ended the Insight.
* Layer B has decided that the current exploration may no longer
* be useful, so give the user an explicit choice:
*
* – Continue → remain in this Insight and move beyond the
* stalled line of enquiry.
* – Next Insight → close this Insight properly through Layer D.
*
* Do not require the user to type this control decision.
*/
if (result?.stopped_at === ‘C3_NON_RESONANCE_OFFER’) {
const inputWrap = qs(‘.cp-input’);

if (inputWrap) {
inputWrap.style.display = ‘none’;
}

if (nextBtn) {
nextBtn.disabled = true;
nextBtn.style.display = ‘none’;
}

const choiceBox = qs(‘#cp-end-report’);

if (choiceBox) {
choiceBox.innerHTML = `

`;

choiceBox.style.display = ‘block’;

const continueBtn =
qs(‘#cp-non-resonance-continue’, choiceBox);

const moveOnBtn =
qs(‘#cp-non-resonance-move-on’, choiceBox);

/*
* Continue with this Insight.
*
* Feed the decision into the existing non_resonance_offer
* control route. That route already advances beyond the stalled
* framework line rather than asking the same question again.
*/
if (continueBtn) {
continueBtn.addEventListener(‘click’, async () => {
if (continueBtn.disabled) return;

continueBtn.disabled = true;
if (moveOnBtn) moveOnBtn.disabled = true;

choiceBox.innerHTML = ”;
choiceBox.style.display = ‘none’;

const continuationResult =
await handleContinuationCheckReply(
‘continue’,
responseId
);

if (
continuationResult?.handled &&
continuationResult?.decision === ‘continue’
) {
if (inputWrap) {
inputWrap.style.display = ”;
}

if (sendBtn) {
sendBtn.style.display = ”;
sendBtn.disabled = true;
}

if (nextBtn) {
nextBtn.style.display = ”;
nextBtn.hidden = false;
nextBtn.disabled = false;
nextBtn.removeAttribute(‘disabled’);
nextBtn.textContent = ‘End’;
}

if (ctaText) {
ctaText.textContent = ‘Awaiting your response…’;
}

clearNudge();
scheduleNudge();
}
});
}

/*
* Leave this Insight.
*
* Again use the existing control route. It already:
* – runs Layer D;
* – shows a closing reflection when warranted;
* – saves the Insight as Ended;
* – leaves the final Next Insight button visible.
*/
if (moveOnBtn) {
moveOnBtn.addEventListener(‘click’, async () => {
if (moveOnBtn.disabled) return;

moveOnBtn.disabled = true;
if (continueBtn) continueBtn.disabled = true;

choiceBox.innerHTML = ”;
choiceBox.style.display = ‘none’;

await handleContinuationCheckReply(
‘move on’,
responseId
);
});
}
}

return result;
}

/*
* ACTUAL END-OF-INSIGHT STATES
*
* Layer D has completed the closing process.
*/
if (
result?.stopped_at === ‘D_REVIEW’ ||
result?.stopped_at === ‘D_RELATIONSHIP_RESISTANCE’
) {
endReportShown = true;

const inputWrap = qs(‘.cp-input’);
if (inputWrap) inputWrap.style.display = ‘none’;

if (nextBtn) {
nextBtn.disabled = true;
nextBtn.style.display = ‘none’;
}

/*
* Resume is available only when framework steps genuinely remain
* and the user has not explicitly chosen to stop the conversation.
*/
const endReportBox = qs(‘#cp-end-report’);

const userExplicitlyStopped =
result?.stopped_at === ‘D_RELATIONSHIP_RESISTANCE’;

const canResume =
!userExplicitlyStopped &&
!isFinalFrameworkStep &&
steps.length > 0;

if (endReportBox) {
endReportBox.innerHTML = `

`;

endReportBox.style.display = ‘block’;

const resumeBtn = qs(‘#cp-end-report-resume’, endReportBox);
const nextInsightBtn = qs(‘#cp-end-report-next’, endReportBox);

if (resumeBtn) {
resumeBtn.addEventListener(‘click’, async () => {
endReportShown = false;
nextConfirmedOverride = false;

endReportBox.innerHTML = ”;
endReportBox.style.display = ‘none’;

const nextStepIndex = Math.min(
currentStepIndex + 1,
steps.length – 1
);

sessionStorage.removeItem(followUpKey);
sessionStorage.setItem(
stepCfg.stepKey,
String(nextStepIndex)
);

const nextQuestion =
String(steps[nextStepIndex] || ”).trim();

await saveNow({
status: ‘Live’,
coach_decision: JSON.stringify({
next_model: ‘next_framework_step’,
control: ‘resume_after_review’
})
});

if (nextQuestion) {
pushMsg(‘assistant’, {
reflection: ”,
question: nextQuestion,
debug_trace: ”,
control: ”
});
}

if (inputWrap) {
inputWrap.style.display = ”;
}

if (sendBtn) {
sendBtn.style.display = ”;
sendBtn.disabled = true;
}

if (nextBtn) {
nextBtn.style.display = ”;
nextBtn.hidden = false;
nextBtn.disabled = false;
nextBtn.removeAttribute(‘disabled’);
nextBtn.textContent = ‘End’;
}

if (ctaText) {
ctaText.textContent = ‘Awaiting your response…’;
}

clearNudge();
scheduleNudge();
});
}

if (nextInsightBtn) {
nextInsightBtn.addEventListener(‘click’, () => {
endReportShown = false;
triggerNextNavigation();
});
}
}
}

return result;
}

// Send handler
sendBtn.addEventListener(‘click’, async () => {
if (aiTurnInProgress) {
console.log(‘SEND BLOCKED: already processing’);
return;
}

if (sendBtn.disabled) return;

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

aiTurnInProgress = true;

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

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

// Clear input and commit the user message to the thread
ta.value = ”;
coachState.draft = ”;
nextConfirmedOverride = false;
endReportShown = false;
renderEndOfInsightReport(”, ”);
nextBtn.textContent = ‘End’;
nextBtn.style.display = ”;
pushMsg(‘user’, text);

try {
await runLayeredInsightTurn(text);
} catch (e) {
pushMsg(
‘assistant’,
`Sorry — something went wrong. ${String(e.message || e)}`
);
} finally {
aiTurnInProgress = false;
sendBtn.disabled = false;
nextBtn.disabled = false;
renderCTA();
}
});

// Initial UI state
sendBtn.textContent = ‘Send’;
nextBtn.textContent = ‘End’;
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 = `

`;
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 = `

`;
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;
page.coachMemory =
ctx && ctx.coachMemory && typeof ctx.coachMemory === ‘object’
? ctx.coachMemory
: {};

// 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()
});
}
console.log(‘Insight object keys:’, Object.keys(i || {}));
console.log(‘Alt insight object keys:’, Object.keys(i2 || {}));

const aiCoachFrameworkSteps = pick(
i?.[7202],
i?.[‘7202’],
i2?.[7202],
i2?.[‘7202’],
i?.ai_coach_framework_steps,
i2?.ai_coach_framework_steps,
i?.[‘AI Coach Framework Steps – KEY FIELD’],
i2?.[‘AI Coach Framework Steps – KEY FIELD’]
);

const stepCompletionCriteria = pick(
i?.[7217],
i?.[‘7217’],
i2?.[7217],
i2?.[‘7217’],
i?.step_completion_criteria,
i2?.step_completion_criteria,
i?.[‘step_completion_criteria’],
i2?.[‘step_completion_criteria’]
);

const fallbackRoutes = pick(
i?.[7218],
i?.[‘7218’],
i2?.[7218],
i2?.[‘7218’],
i?.fallback_routes,
i2?.fallback_routes,
i?.[‘fallback_routes’],
i2?.[‘fallback_routes’]
);

const allowedMoves = pick(
i?.[7219],
i?.[‘7219’],
i2?.[7219],
i2?.[‘7219’],
i?.allowed_moves,
i2?.allowed_moves,
i?.[‘allowed_moves’],
i2?.[‘allowed_moves’]
);

const disallowedMoves = pick(
i?.[7220],
i?.[‘7220’],
i2?.[7220],
i2?.[‘7220’],
i?.disallowed_moves,
i2?.disallowed_moves,
i?.[‘disallowed_moves’],
i2?.[‘disallowed_moves’]
);

const closureRule = pick(
i?.closure_rule,
i2?.closure_rule,
i?.[‘closure_rule’],
i2?.[‘closure_rule’],
i?.[‘Closure Rule’],
i2?.[‘Closure Rule’]
);

page.coachFields = {
insightQuestion: pick(
i?.[‘Insight Question’],
i?.question,
i2?.[‘Insight Question’],
i2?.question
),

insightSummary: pick(
i?.[‘Insight Summary’],
i2?.[‘Insight Summary’],
i?.insight_summary,
i2?.insight_summary
),

coachGuidance: pick(
i?.[‘AI Coach – Generic advice, customised for Insight’],
i2?.[‘AI Coach – Generic advice, customised for Insight’]
),

interventionScope,

aiInsightPromptV3,
aiStepPromptV3,

aiCoachFrameworkSteps,

step_completion_criteria: stepCompletionCriteria,
fallback_routes: fallbackRoutes,
allowed_moves: allowedMoves,
disallowed_moves: disallowedMoves,
closure_rule: closureRule,

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();
}
})();