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

// Wire input
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’);

/*
* NUDGE FEATURE DISABLED
*
* Keep these harmless shims because existing resume, continuation and
* end-of-Insight flows still call clearNudge() / scheduleNudge().
*
* No timer is created, no nudge UI is shown and no nudge AI call can
* be reached through the normal interface.
*/
const nudgeBtn = null;
const nudgeBox = null;

function clearNudge() {}

function scheduleNudge() {}

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;

window.addEventListener(
‘cp_ai_progressive_status_changed’,
() => {
renderCTA();
}
);

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.
// Ellipsis appears only while progressive assessment is actively running.
ctaText.textContent =
responseSession.assessmentInFlight
? ‘Listening…’
: ‘Listening’;
sendBtn.disabled = false;
nextBtn.disabled = true;
clearNudge();
}
}

ta.addEventListener(‘input’, () => {
// Keep the existing draft/UI behaviour unchanged.
const currentText = String(ta.value || ”);
coachState.draft = currentText;

/*
* Response Session
*
* The first user input starts a temporary response session.
* From this point onwards, version identifies successive states of
* the developing response.
*
* IMPORTANT:
* currentText is only the latest textarea contents. Future progressive
* assessments will add meaning to heardEvidence separately, so deleting
* text here will not itself erase anything the Coach has already heard.
*/

if (!responseSession.active && currentText.length > 0) {
responseSession.active = true;

/*
* Start each user response with fresh progressive working state.
* Authoritative framework state lives separately.
*/
responseSession.heardEvidence = {};
responseSession.provisionalCoverage = {};
responseSession.provisionalStepContext = {};
responseSession.likelyNextStep = null;
responseSession.provisionalNextQuestion = ”;
responseSession.provisionalGate = null;
responseSession.provisionalLayerBEvidence = null;
responseSession.provisionalLayerBEvidenceCheckpointText = ”;
responseSession.handoverLayerBEvidence = null;
responseSession.handoverLayerBEvidenceCheckpointText = ”;
responseSession.provisionalLayerBNovelty = null;
responseSession.provisionalStrategy = null;
responseSession.evidenceAssessmentQueued = null;
responseSession.completedCheckpoint = null;
responseSession.destinationBatch = null;
responseSession.assessmentQueued = false;
responseSession.lastCheckpointText = ”;
responseSession.lastCompletedCheckpointText = ”;
}

if (
responseSession.active &&
currentText !== responseSession.currentText
) {
const trimmedCurrentText =
String(currentText || ”).trim();

const provisionalEvidenceCheckpointText =
String(
responseSession.provisionalLayerBEvidenceCheckpointText || ”
).trim();

/*
* Once the user starts a later sentence, the evidence from the preceding
* completed sentence becomes the fixed Send-handover evidence.
*/
if (
provisionalEvidenceCheckpointText &&
/[.!?]$/.test(provisionalEvidenceCheckpointText) &&
trimmedCurrentText.length >
provisionalEvidenceCheckpointText.length &&
trimmedCurrentText.startsWith(
provisionalEvidenceCheckpointText
)
) {
responseSession.handoverLayerBEvidence =
cloneProgressiveLayerBEvidence(
responseSession.provisionalLayerBEvidence
);

responseSession.handoverLayerBEvidenceCheckpointText =
provisionalEvidenceCheckpointText;
}

/*
* If earlier text is edited, evidence derived from that old prefix can no
* longer be handed to Send. Clear it rather than guessing.
*/
const handoverCheckpointText =
String(
responseSession.handoverLayerBEvidenceCheckpointText || ”
).trim();

if (
handoverCheckpointText &&
!trimmedCurrentText.startsWith(handoverCheckpointText)
) {
responseSession.handoverLayerBEvidence = null;
responseSession.handoverLayerBEvidenceCheckpointText = ”;
}

responseSession.version += 1;
responseSession.currentText = currentText;
}

/*
* Check whether the developing response has reached a useful
* progressive-assessment checkpoint.
*
* Assessment is silent and updates Response Session working memory
* only. It does not affect authoritative coverage or persistence.
*/
if (responseSessionCheckpointEligible()) {
const checkpointText =
String(responseSession.currentText || ”).trim();

const checkpointVersion =
responseSession.version;

/*
* Destination and evidence processing are deliberately independent.
* A slower progressive B1 call must never delay Layer A #1.
*/
void runProgressiveDestinationAssessment();

void runProgressiveEvidenceAssessment(
checkpointText,
checkpointVersion
);
}

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 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: v.aiModel,
messages: [
{ role: ‘system’, content: system },
{ role: ‘user’, content: user }
]
};

const aiResult = await window.cpAiService.callText({
task: ‘insight_next_coverage_check’,
responseId: getOrCreateResponseId(),
config: v,
payload
});

if (!aiResult || !aiResult.ok) {
return { covered: true, message: ” };
}

const raw = String(aiResult.data || ”);

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.

async function showExampleNudges() {
if (!nudgeBox) return;

nudgeOpen = true;

if (nudgeTimer) {
clearTimeout(nudgeTimer);
nudgeTimer = null;
}

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

const lastAssistant = getLastAssistantMessage();

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

let examples = [];

/*
* Generate nudges from the question the user is actually being asked,
* rather than using fixed examples tied to Step 1.
*/
if (
currentCoachQuestion &&
window.cpAiService &&
typeof window.cpAiService.callJson === ‘function’ &&
v.aiUrl
) {
try {
const aiResult = await window.cpAiService.callJson({
task: ‘insight_nudge_writer’,
responseId: getOrCreateResponseId(),
config: v,
payload: {
model: v.aiModel,
messages: [
{
role: ‘system’,
content:
`You are generating three short example responses to help a user answer the AI Coach’s CURRENT question.

Return ONLY valid JSON in this exact form:
{“examples”:[“…”,”…”,”…”]}

Rules:
– Each example must directly answer the CURRENT COACH QUESTION.
– Use the recent conversation so the examples fit what has actually been discussed.
– Do not return to an earlier framework step unless the current Coach question does so.
– Do not introduce facts, experiences, feelings or conclusions the user has not established.
– The examples are prompts the user may choose or adapt, not statements about what is true for them.
– Keep each example natural and conversational.
– Keep each example to one short sentence.
– Make the three examples meaningfully different.
– Use UK English.`
},
{
role: ‘user’,
content:
`CURRENT COACH QUESTION:
${currentCoachQuestion}

RECENT CONVERSATION:
${buildTranscript(2200)}`
}
]
}
});

if (
aiResult?.ok &&
Array.isArray(aiResult.data?.examples)
) {
examples = aiResult.data.examples
.map(example => String(example || ”).trim())
.filter(Boolean)
.slice(0, 3);
}
} catch (err) {
console.log(‘NUDGE WRITER ERROR:’, err);
}
}

/*
* Safe generic fallback if the nudge writer is unavailable.
* These do not assume any particular framework step.
*/
if (examples.length !== 3) {
examples = [
“One thing that comes to mind is…”,
“I’m not completely sure, but I think…”,
“I suppose part of it might be…”
];
}

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

// 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.textContent = ‘Send’;
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: v.aiModel,
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 forwardTarget =
findFirstForwardStep(
currentStepIndex,
steps,
stepCfg.completionCriteriaByStep || {}
);

const hasNextStep =
!!forwardTarget;

let targetStepIndex = currentStepIndex;

if (hasNextStep) {
targetStepIndex =
forwardTarget.index;

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: v.aiModel,
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: v.aiModel,
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,
submittedResponseSession = null
) {
const v =
window.cpVars && window.cpVars.insightPage
? window.cpVars.insightPage
: {};

/*
* Determine whether the coherent completed progressive checkpoint
* represents the complete response that the user actually submitted.
*
* Compare the pre-spellcheck submitted text with checkpointText from the
* completed checkpoint package. Spellcheck happens only after Send, so
* any later spelling correction must not make otherwise-current
* progressive work stale.
*
* This establishes checkpoint completeness only. It does not make any
* provisional judgement authoritative.
*/
const submittedResponseText =
String(
submittedResponseSession?.currentText || ”
).trim();

const progressiveCompletedCheckpointText =
String(
submittedResponseSession
?.completedCheckpoint
?.checkpointText || ”
).trim();

const progressiveResponseIsCurrent =
Boolean(
submittedResponseSession?.active &&
submittedResponseText &&
progressiveCompletedCheckpointText &&
submittedResponseText === progressiveCompletedCheckpointText
);

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

let result = null;

/*
* PARKED-MATERIAL RESPONSE
*
* C5 has already returned to every point the Coach explicitly promised
* to revisit. The user’s response now belongs to the completed Insight,
* but it must not reopen framework progression.
*
* The response is already present in the live thread, so Layer D can
* review the complete conversation directly.
*/
if (parkedMaterialResponsePending) {
parkedMaterialResponsePending = false;

/*
* Every explicit parking commitment has now been fulfilled.
* Clear the in-memory list so it cannot trigger another C5 return.
*/
parkedMaterial.length = 0;

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 || [],

/*
* The parked response is not a new framework turn, so no new
* Layer B trait assessment is run here.
*/
traitUpdates: []
});

await saveNow({
status: ‘Ended’,
summary: String(layerD?.review || ”).trim(),
layer_d_result: JSON.stringify(layerD),
coach_decision: JSON.stringify({
route: ‘layer_d’,
next_model: ‘review’,
control: ‘parked_material_response_complete’,
review_type: layerD?.review_type || ”
})
});

pushMsg(‘assistant’, {
reflection: ”,
question: layerD?.review || ”,
debug_trace: ”,
control: ”
});

result = {
stopped_at: ‘D_REVIEW’,
layerD
};
} else {
/*
* 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 || {}
});

result =
await window.cpInsightOrchestrator.handleUserTurnLayered({
config: v,
responseId,
userText,
thread,

/*
* Hand the completed progressive work to the authoritative orchestrator.
*
* progressiveResponseIsCurrent says only whether that work represents
* the complete pre-spellcheck response. The orchestrator remains
* responsible for deciding what can safely become authoritative.
*/
progressiveResponseIsCurrent,
submittedResponseSession,

/*
* Give the orchestrator access to the same Layer A #1 batch launcher
* used by typing-time background processing.
*
* This avoids creating a second implementation of destination selection.
*/
createFrameworkDestinationBatch(args) {
return startFrameworkDestinationBatch(args);
},

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(),

frameworkSteps: steps,
currentStepIndex,
completionCriteriaByStep:
stepCfg.completionCriteriaByStep || {},

stepCoverageMap,
stepCoverageContext,
parkedMaterial,

resolveNextFrameworkStep() {
return findFirstForwardStep(
currentStepIndex,
steps,
stepCfg.completionCriteriaByStep || {}
);
},

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 || [],

persistentCoachContext:
String(
v.coachMemory?.persistentCoachContext || ”
).trim(),

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

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

/*
* Layer A may identify context that should survive beyond this Insight.
*
* Persist it before continuing with the current-Insight evidence
* handling. The PHP endpoint owns lookup, deduplication and merging
* into Form 313 [7236].
*/
console.log(
‘PERSISTENT CONTEXT DEBUG:’,
result?.gate?.additional_context
);

try {
await savePersistentCoachContext(result?.gate);
} catch (err) {
console.log(
‘PERSISTENT COACH CONTEXT SAVE ERROR:’,
err
);
}

/*
* 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’ &&
Number.isInteger(result?.nextStepIndex)
) {
sessionStorage.removeItem(followUpKey);

sessionStorage.setItem(
stepCfg.stepKey,
String(result.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’;
}

/*
* Continue is meaningful only when a forward framework step
* remains that has not already been sufficiently addressed.
*/
const forwardTarget =
findFirstForwardStep(
currentStepIndex,
steps,
stepCfg.completionCriteriaByStep || {}
);

const canContinue =
!!forwardTarget;

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 advances to the first forward
* framework step that has not already been sufficiently addressed.
*/
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;
}
if (result?.stopped_at === ‘RELATIONSHIP_TERMINATED’) {
endReportShown = true;

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

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

clearNudge();

return result;
}
/*
* PARKED MATERIAL RETURN
*
* The framework is complete, but the Coach has explicitly promised
* to return to one or more significant points before the Insight review.
*
* C5 has now issued the single combined invitation. The next user
* response must go directly to Layer D rather than back through
* framework progression.
*/
if (
result?.stopped_at ===
‘C5_PARKED_MATERIAL_RETURN’
) {
parkedMaterialResponsePending = true;
endReportShown = false;

const inputWrap = qs(‘.cp-input’);

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

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

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

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

clearNudge();
scheduleNudge();

return result;
}

/*
* NORMAL END-OF-INSIGHT REVIEW
*
* Layer D has completed its review, but before closing the Insight
* give the user one final opportunity to say where the Insight has
* left them and whether their thinking has shifted.
*
* This is deliberately outside the framework step architecture.
*/
if (result?.stopped_at === ‘D_REVIEW’) {
finalInsightReflectionPending = true;
endReportShown = false;

const inputWrap = qs(‘.cp-input’);
const endReportBox = qs(‘#cp-end-report’);

if (endReportBox) {
endReportBox.innerHTML = ”;
endReportBox.style.display = ‘none’;
}

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

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

const insightFocus = String(
v.coachFields?.insightFocus || ”
).trim();

const finalInsightFocus =
insightFocus || ‘this Insight’;

pushMsg(‘assistant’, {
reflection: ”,
question:
`Having read that reflection, what are your final thoughts on ${finalInsightFocus}? ` +
`Has your thinking about it shifted or developed in any way through our conversation? ` +
`And if there’s anything you’d change or add to my reflection, please do. ` +
`Take as much space as you like.`,
debug_trace: ”,
control: ‘final_insight_reflection’
});

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

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

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

clearNudge();
scheduleNudge();

/*
* pushMsg() redraws the thread and normally leaves the newest
* message at the bottom.
*
* Here the user needs to start with the Layer D review, not the
* final-reflection question underneath it.
*
* scrollIntoView() handles both the conversation’s own scroll
* container and the surrounding browser page.
*/
requestAnimationFrame(() => {
const threadBox = qs(‘#cp-ai-thread’);
if (!threadBox) return;

const coachBubbles =
threadBox.querySelectorAll(‘.cp-bubble.cp-assistant’);

if (coachBubbles.length >= 2) {
const reviewBubble =
coachBubbles[coachBubbles.length – 2];

const y =
reviewBubble.getBoundingClientRect().top +
window.scrollY –
140;

window.scrollTo({
top: Math.max(0, y),
behavior: ‘auto’
});
}
});

return result;
}

/*
* RELATIONSHIP RESISTANCE END STATE
*
* This remains an immediate close. Do not ask for a final Insight
* reflection when the user has explicitly rejected the conversation.
*/
if (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’;
}

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

const userExplicitlyStopped = true;

const resumeTarget =
findFirstForwardStep(
currentStepIndex,
steps,
stepCfg.completionCriteriaByStep || {}
);

const canResume = false;

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 =
resumeTarget.index;

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

/*
* Persist the completed turn’s framework coverage.
* The earlier save creates the response record before the AI calls;
* this save records the coverage resulting from those calls.
*/
await saveNow({
status: ‘Live’,
response_id: responseId,
user_input: userText
});

return result;
}

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

if (!v.aiUrl) {
return ‘Thank you for reflecting on this Insight.’;
}

const insightTopic = String(
v.coachFields?.insightFocus || ”
).trim();

const payload = {
model: v.aiModel,
messages: [{
role: ‘user’,
content:
`Write the AI Coach’s brief closing acknowledgement after the user has given their final reflection on an Insight.\n\n` +

`Rules:\n` +
`- Acknowledge what the user actually said.\n` +
`- If their response contains a meaningful concluding thought, briefly recognise it.\n` +
`- If their response is minimal or contains no meaningful new thought, simply thank them for reflecting.\n` +
`- Do not ask a question.\n` +
`- Do not continue coaching.\n` +
`- Do not give advice.\n` +
`- Do not introduce a new interpretation or insight.\n` +
`- Do not overstate what the user has concluded.\n` +
`- Do not repeat their response back to them.\n` +
`- Use UK English.\n` +
`- Maximum 2 short sentences.\n` +
`- This is a natural closing acknowledgement immediately before the user moves to the next Insight.\n\n` +

`INSIGHT TOPIC:\n${insightTopic}\n\n` +
`USER’S FINAL REFLECTION:\n${String(userText || ”).trim()}`
}]
};

try {
const aiResult = await window.cpAiService.callText({
task: ‘insight_final_acknowledgement’,
responseId: getOrCreateResponseId(),
config: v,
payload
});

if (!aiResult || !aiResult.ok) {
return ‘Thank you for reflecting on this Insight.’;
}

const acknowledgement =
String(aiResult.data || ”).trim();

return acknowledgement ||
‘Thank you for reflecting on this Insight.’;
} catch (err) {
console.log(
‘FINAL INSIGHT ACKNOWLEDGEMENT ERROR:’,
err
);

return ‘Thank you for reflecting on this Insight.’;
}
}

// 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;

if (
window.cpAiService &&
typeof window.cpAiService.markTimingEvent === ‘function’
) {
window.cpAiService.markTimingEvent(
‘send_pressed’,
{
response_id: getOrCreateResponseId(),
response_session_version:
responseSession.version,
progressive_in_flight:
responseSession.assessmentInFlight,
progressive_queued:
responseSession.assessmentQueued,
completed_checkpoint_current:
Boolean(
responseSession.completedCheckpoint &&
String(
responseSession.completedCheckpoint
.checkpointText || ”
).trim() === text
)
}
);
}

/*
* Freeze the provisional Response Session at the moment Send is
* pressed.
*
* This is a snapshot only. Nothing here becomes authoritative merely
* because it was prepared while the user was typing.
*
* The completed-response path can now reconcile the submitted text
* against the exact progressive work that existed for this response,
* without later Response Session changes altering that evidence.
*/

/*
* SEND HANDOVER RULE
*
* Layer C may receive only B1 evidence represented by text that is
* strictly before the final submitted material.
*
* This protects against a user beginning another sentence, causing the
* preceding sentence to become handover evidence, and then deleting that
* later sentence before pressing Send.
*/
const submittedResponseTextForHandover =
String(responseSession.currentText || ”).trim();

const handoverCheckpointTextForSend =
String(
responseSession.handoverLayerBEvidenceCheckpointText || ”
).trim();

const safeHandoverLayerBEvidence =
handoverCheckpointTextForSend &&
submittedResponseTextForHandover.length >
handoverCheckpointTextForSend.length &&
submittedResponseTextForHandover.startsWith(
handoverCheckpointTextForSend
)
? cloneProgressiveLayerBEvidence(
responseSession.handoverLayerBEvidence
)
: { evidence: [] };

const submittedResponseSession = {

active: responseSession.active,
version: responseSession.version,
currentText: responseSession.currentText,

/*
* Preserve the exact destination batch by reference.
*
* Do not clone it: an exact-current batch may still contain the live
* decisionPromise that the Send path should adopt rather than restart.
*/
destinationBatch:
responseSession.destinationBatch || null,

heardEvidence: {
…responseSession.heardEvidence
},

provisionalCoverage: {
…responseSession.provisionalCoverage
},

provisionalStepContext: {
…responseSession.provisionalStepContext
},

likelyNextStep:
responseSession.likelyNextStep
? { …responseSession.likelyNextStep }
: null,

provisionalNextQuestion:
String(
responseSession.provisionalNextQuestion || ”
).trim(),

provisionalGate:
responseSession.provisionalGate || null,

/*
* Deliberately hand over only evidence from before the final sentence.
* Layer C receives the complete submitted response separately.
*/
provisionalLayerBEvidence:
safeHandoverLayerBEvidence,

provisionalLayerBNovelty:
responseSession.provisionalLayerBNovelty || null,

provisionalStrategy:
responseSession.provisionalStrategy || null,

completedCheckpoint:
responseSession.completedCheckpoint
? {
…responseSession.completedCheckpoint,

provisionalCoverage: {
…(
responseSession.completedCheckpoint
.provisionalCoverage || {}
)
},

provisionalStepContext: {
…(
responseSession.completedCheckpoint
.provisionalStepContext || {}
)
},

likelyNextStep:
responseSession.completedCheckpoint.likelyNextStep
? {
…responseSession.completedCheckpoint
.likelyNextStep
}
: null
}
: null,

lastCheckpointText:
String(
responseSession.lastCheckpointText || ”
),

lastCompletedCheckpointText:
String(
responseSession.lastCompletedCheckpointText || ”
)
};

/*
* Send now owns the complete response.
*
* Preserve everything captured in submittedResponseSession, but stop
* the live Response Session from launching or committing any further
* progressive work.
*
* Send never waits for unfinished progressive processing.
*/
responseSession.active = false;
responseSession.assessmentQueued = false;
responseSession.evidenceAssessmentQueued = null;

const inputWrap = qs(‘.cp-input’);

/*
* FINAL INSIGHT REFLECTION
*
* This is the user’s response to the completed Layer D review.
* It is their closing position on the Insight, not another framework
* answer, so do not send it through Layers A/B/C.
*/
if (finalInsightReflectionPending) {
aiTurnInProgress = true;

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

sendBtn.disabled = true;
nextBtn.disabled = true;
ctaText.textContent = ‘Saving your final reflection…’;

ta.value = ”;
coachState.draft = ”;

/*
* Display what the user submitted immediately, then quietly apply
* the normal spellcheck in place.
*/
pushMsg(‘user’, text);

const correctedText = await spellcheckLocale(text);

if (correctedText && correctedText !== text) {
const latestUserMessage =
[…thread]
.reverse()
.find(message => message?.role === ‘user’);

if (latestUserMessage) {
latestUserMessage.content = correctedText;
renderThread();
}

text = correctedText;
}

finalInsightReflectionPending = false;
endReportShown = true;

/*
* Generate a brief closing acknowledgement of the user’s
* final reflection before showing Next Insight.
*/
ctaText.textContent = ‘AI Coach is considering your final reflection…’;

showCoachThinkingIndicator();

const finalAcknowledgement =
await generateFinalInsightAcknowledgement(text);

removeCoachThinkingIndicator();

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

/*
* Save after adding the acknowledgement so the stored dialogue
* contains the complete closing exchange.
*/
await saveNow({
status: ‘Ended’,
user_input: text,
coach_decision: JSON.stringify({
next_model: ‘next_insight’,
control: ‘final_insight_reflection_complete’
})
});

await runEndOfChapterPersonalCoach();

const endReportBox = qs(‘#cp-end-report’);
if (endReportBox) {
endReportBox.innerHTML = `

`;

endReportBox.style.display = ‘block’;

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

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

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

clearNudge();

aiTurnInProgress = false;
ctaText.textContent = ”;

return;
}

aiTurnInProgress = true;

/*
* Once the user has submitted their response there is nothing
* further for them to type until the Coach has responded.
*
* Hide the whole response area while the turn is being processed.
*/
if (inputWrap) {
inputWrap.style.display = ‘none’;
}

// Lock remaining controls while AI Coach is working
sendBtn.disabled = true;
nextBtn.disabled = true;
ctaText.textContent = ‘AI Coach is considering your response…’;

/*
* Show the user’s submitted response immediately.
*
* Spellcheck happens straight afterwards and, if it makes a
* correction, the displayed user message is updated before the
* response is sent through the coaching architecture.
*/
ta.value = ”;
coachState.draft = ”;
nextConfirmedOverride = false;
endReportShown = false;
renderEndOfInsightReport(”, ”);
nextBtn.textContent = ‘End’;
nextBtn.style.display = ”;

/*
* Freeze the exact submitted wording for the coaching turn.
*
* Spellcheck now runs independently. It may improve the displayed
* wording, but the Insight Coach must not wait for it before beginning
* its question-critical processing.
*/
const submittedText = text;

/*
* Remember exactly which thread item belongs to this submission.
*
* Do not later search for “the latest user message”, because by the
* time an asynchronous spellcheck completes the conversation may
* already contain additional Coach content.
*/
const submittedUserMessageIndex = thread.length;

pushMsg(‘user’, submittedText);

/*
* Temporary visual acknowledgement that the response has
* been received and the Coach is now considering it.
*/
showCoachThinkingIndicator();

/*
* Start spellcheck, but deliberately DO NOT await it here.
*
* The coaching architecture begins immediately below.
*
* When spellcheck finishes:
* – update only the exact user message that was submitted;
* – never alter a later user message;
* – redraw the thread;
* – restore the thinking indicator only if the Coach has not yet
* produced a visible response.
*/
const spellcheckPromise =
spellcheckLocale(submittedText)
.then(correctedText => {
const corrected =
String(correctedText || ”).trim();

if (
!corrected ||
corrected === submittedText
) {
return submittedText;
}

const submittedUserMessage =
thread[submittedUserMessageIndex];

if (
!submittedUserMessage ||
submittedUserMessage.role !== ‘user’ ||
String(
submittedUserMessage.content || ”
).trim() !== submittedText
) {
return submittedText;
}

submittedUserMessage.content = corrected;

/*
* renderThread() removes temporary UI-only elements, including
* the thinking indicator. Restore it only when no Coach message
* has yet appeared after this submitted response.
*/
const coachHasResponded =
thread
.slice(submittedUserMessageIndex + 1)
.some(message =>
message?.role === ‘assistant’
);

renderThread();

if (
aiTurnInProgress &&
!coachHasResponded
) {
showCoachThinkingIndicator();
}

return corrected;
})
.catch(err => {
console.log(
‘NON-BLOCKING SPELLCHECK ERROR:’,
err
);

return submittedText;
});

let turnResult = null;

try {
turnResult = await runLayeredInsightTurn(
submittedText,
submittedResponseSession
);
} catch (e) {
removeCoachThinkingIndicator();

pushMsg(
‘assistant’,
`Sorry — something went wrong. ${String(e.message || e)}`
);
} finally {
aiTurnInProgress = false;

/*
* The real Coach response will normally have caused renderThread()
* to redraw the conversation. Remove the temporary indicator
* defensively in case the turn ended without a normal response.
*/
removeCoachThinkingIndicator();

const keepInputHidden =
endReportShown ||
turnResult?.stopped_at === ‘C3_NON_RESONANCE_OFFER’ ||
turnResult?.stopped_at === ‘RELATIONSHIP_TERMINATED’ ||
turnResult?.stopped_at === ‘D_REVIEW’ ||
turnResult?.stopped_at === ‘D_RELATIONSHIP_RESISTANCE’;

/*
* Restore the response area only when the Coach has produced
* another question that genuinely requires a user response.
*
* End states, Continue / End choices and relationship termination
* manage their own UI and therefore remain hidden.
*/
if (!keepInputHidden && inputWrap) {
inputWrap.style.display = ”;
}

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;

/*
* AI Coach entitlement from Form 313 field 7232.
*
* The server normalises this to:
* – insight
* – personal
*
* Default safely to Insight Coach only if the value is missing or invalid.
*/
page.aiCoachLevel =
String(ctx?.aiCoachLevel || ”).trim().toLowerCase() === ‘personal’
? ‘personal’
: ‘insight’;

page.coachMemory =
ctx && ctx.coachMemory && typeof ctx.coachMemory === ‘object’
? ctx.coachMemory
: {};

/*
* Restore accepted B1/B1a evidence for this Insight unless reset=1.
*
* This keeps novelty comparison and end-of-Chapter accumulation intact if the
* user reloads the page part-way through an Insight.
*/
acceptedEvidence.length = 0;

if (
getParam(‘reset’, ”) !== ‘1’ &&
Array.isArray(page.coachMemory?.currentAcceptedEvidence)
) {
const seenAcceptedEvidence = new Set();

page.coachMemory.currentAcceptedEvidence.forEach(item => {
if (!item || typeof item !== ‘object’) return;

const category =
String(item.category || ”).trim();

const statement =
String(item.statement || ”).trim();

const quote =
String(item.quote || ”).trim();

if (!category || !statement || !quote) return;

const duplicateKey = [
category.toLowerCase(),
statement.toLowerCase(),
quote.toLowerCase()
].join(‘|’);

if (seenAcceptedEvidence.has(duplicateKey)) return;
seenAcceptedEvidence.add(duplicateKey);

acceptedEvidence.push({
category,
statement,
quote,
novelty_status:
String(item.novelty_status || ”).trim() ===
‘materially_developed’
? ‘materially_developed’
: ‘new’
});
});
}

/*
* Restore cumulative AI usage for this Insight before any new
* Insight AI calls are made.
*
* reset=1 deliberately starts the Insight with zero usage because
* the corresponding Form 320 record has been deleted.
*/
if (
window.cpAiService &&
typeof window.cpAiService.initialiseUsage === ‘function’
) {
window.cpAiService.initialiseUsage(
getParam(‘reset’, ”) === ‘1’
? null
: page.coachMemory?.aiUsage
);
}

/*
* Restore cumulative framework coverage and semantic context
* unless reset=1.
*
* A reset deliberately starts with no restored Step Coverage Map
* or Step Coverage Context.
*/
Object.keys(stepCoverageMap).forEach(key => {
delete stepCoverageMap[key];
});

Object.keys(stepCoverageContext).forEach(key => {
delete stepCoverageContext[key];
});

if (getParam(‘reset’, ”) !== ‘1’) {
const restoredCoverage =
page.coachMemory?.stepCoverageMap;

if (
restoredCoverage &&
typeof restoredCoverage === ‘object’ &&
!Array.isArray(restoredCoverage)
) {
Object.entries(restoredCoverage).forEach(
([stepNumber, status]) => {
const cleanStatus =
String(status || ”).trim();

if (
[
‘not_addressed’,
‘partially_addressed’,
‘left_incomplete’,
‘sufficiently_addressed’
].includes(cleanStatus)
) {
stepCoverageMap[String(stepNumber)] =
cleanStatus;
}
}
);
}

const restoredContext =
page.coachMemory?.stepCoverageContext;

if (
restoredContext &&
typeof restoredContext === ‘object’ &&
!Array.isArray(restoredContext)
) {
Object.entries(restoredContext).forEach(
([stepNumber, semanticContext]) => {
const cleanStepNumber =
String(stepNumber || ”).trim();

const coverageStatus =
stepCoverageMap[cleanStepNumber];

if (
!/^\d+$/.test(cleanStepNumber) ||
(
coverageStatus !== ‘partially_addressed’ &&
coverageStatus !== ‘left_incomplete’
) ||
!semanticContext ||
typeof semanticContext !== ‘object’ ||
Array.isArray(semanticContext)
) {
return;
}

const established =
String(
semanticContext.established || ”
).trim();

const remainingGap =
String(
semanticContext.remaining_gap || ”
).trim();

if (!established && !remainingGap) return;

stepCoverageContext[cleanStepNumber] = {
established,
remaining_gap: remainingGap
};
}
);
}
}

// 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
),

insightFocus: pick(
i?.insight_focus,
i2?.insight_focus,
i?.[7235],
i?.[‘7235’],
i2?.[7235],
i2?.[‘7235’]
),

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

if (
String(ctx?.aiCoachingStatus || ”)
.trim()
.toLowerCase() === ‘terminated’
) {
const chat = qs(‘.cp-chat’);

if (chat) {
chat.innerHTML =
‘

‘;
}

return;
}

/*
* First AI Coach question
*
* A genuinely new Insight may use the opening pre-assessment.
*
* An existing saved Live Insight must NOT run that opening path again:
* its current-Insight progress already exists and must be resumed rather
* than recalculated from GTKY / previous Insight material.
*/
const currentInsightState =
page.coachMemory?.currentInsightState &&
typeof page.coachMemory.currentInsightState === ‘object’
? page.coachMemory.currentInsightState
: {};

const isExistingLiveInsight =
getParam(‘reset’, ”) !== ‘1’ &&
String(currentInsightState.status || ”).trim().toLowerCase() === ‘live’ &&
String(currentInsightState.dialogue || ”).trim() !== ”;

const initialStepConfig = getStepConfig();

if (isExistingLiveInsight) {
const dialogueRestored =
restoreThreadFromTranscript(
currentInsightState.dialogue
);

if (dialogueRestored) {
renderThread();
}

console.log(
‘RESUME LIVE INSIGHT:’,
dialogueRestored
? ‘saved dialogue restored; opening pre-assessment skipped’
: ‘saved dialogue could not be restored; opening pre-assessment skipped’
);

return;
}

/*
* NEW INSIGHT OPENING
*
* Do not show an incomplete “Your Turn” state while the opening
* pre-assessment and first Coach question are still being prepared.
*
* Existing Live Insights return above, so resume behaviour is unchanged.
*/
const openingCoachHeading =
qs(‘.cp-coach-h2-wrap’);

const openingCoachChat =
qs(‘.cp-chat’);

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

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

const frameworkSteps =
Array.isArray(initialStepConfig.steps)
? initialStepConfig.steps
: [];

const completionCriteriaByStep =
initialStepConfig.completionCriteriaByStep || {};

const gtkyDialogue =
String(
page.coachMemory?.gtkyDialogue || ”
).trim();

const previousInsightReviews =
Array.isArray(
page.coachMemory?.previousInsightReviews
)
? page.coachMemory.previousInsightReviews
: [];

const establishedMaterialParts = [];

if (gtkyDialogue) {
establishedMaterialParts.push(
`GTKY DIALOGUE:\n${gtkyDialogue}`
);
}

if (previousInsightReviews.length) {
establishedMaterialParts.push(
`COMPLETED EARLIER INSIGHT REVIEWS:\n${
JSON.stringify(
previousInsightReviews,
null,
2
)
}`
);
}

const establishedMaterial =
establishedMaterialParts.join(‘\n\n’).trim();

/*
* Only perform the opening pre-assessment when there is established
* material to assess.
*
* Failure is non-destructive: the existing opening behaviour remains
* available as the fallback.
*/
let openingContext = {
step_context: {},
overall_established: ”
};

if (
establishedMaterial &&
window.cpInsightLayerA &&
typeof window.cpInsightLayerA
.assessEstablishedFrameworkCoverage === ‘function’
) {
try {
const assessedCoverage =
await window.cpInsightLayerA
.assessEstablishedFrameworkCoverage({
config: page,
responseId: getOrCreateResponseId(),
frameworkSteps,
completionCriteriaByStep,
establishedMaterial
});

console.log(
‘INITIAL ESTABLISHED FRAMEWORK COVERAGE:’,
assessedCoverage
);

if (
assessedCoverage &&
typeof assessedCoverage === ‘object’ &&
!Array.isArray(assessedCoverage)
) {
if (
assessedCoverage.__opening_context &&
typeof assessedCoverage.__opening_context === ‘object’
) {
openingContext = {
step_context:
assessedCoverage.__opening_context.step_context &&
typeof assessedCoverage.__opening_context.step_context === ‘object’
? assessedCoverage.__opening_context.step_context
: {},

overall_established:
String(
assessedCoverage.__opening_context
.overall_established || ”
).trim()
};
}

Object.entries(assessedCoverage).forEach(
([stepNumber, status]) => {
const cleanStatus =
String(status || ”).trim();

if (
[
‘not_addressed’,
‘partially_addressed’,
‘sufficiently_addressed’
].includes(cleanStatus)
) {
stepCoverageMap[String(stepNumber)] =
cleanStatus;
}
}
);
}

} catch (err) {
console.log(
‘INITIAL FRAMEWORK COVERAGE ERROR:’,
err
);
}
}

/*
* Start at the first framework territory that is not already
* sufficiently addressed.
*/
const firstUnresolved =
findFirstForwardStep(
-1,
frameworkSteps,
completionCriteriaByStep
);

/*
* If every framework step is already sufficiently addressed,
* the opening should not fall back to Step 1.
*
* Use the final step only as a technical state anchor while Layer C
* writes a whole-Insight integration question instead of reopening
* any individual framework step.
*/
const allStepsSufficient =
!firstUnresolved &&
frameworkSteps.length > 0;

const openingStepIndex =
firstUnresolved
? firstUnresolved.index
: Math.max(frameworkSteps.length – 1, 0);

const openingFrameworkStep =
String(
frameworkSteps[openingStepIndex] || ”
)
.replace(
/^[A-Za-z][A-Za-z\s/&-]{0,40}:\s*/,
”
)
.trim();

const openingStepObjective =
String(
completionCriteriaByStep[
openingStepIndex + 1
] ||
openingFrameworkStep
).trim();

if (openingFrameworkStep) {

/*
* Keep the normal live-conversation step state aligned with the
* territory selected by the opening pre-assessment.
*/
if (initialStepConfig.stepKey) {
sessionStorage.setItem(
initialStepConfig.stepKey,
String(openingStepIndex)
);
}

let firstQuestion = openingFrameworkStep;

try {

if (
window.cpInsightLayerC &&
typeof window.cpInsightLayerC.writeQuestion === ‘function’
) {

firstQuestion =
await window.cpInsightLayerC.writeQuestion(
{
config: page,

responseId: getOrCreateResponseId(),

userText: ”,
thread: [],
lastCoachQuestion: ”,

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

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

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

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

currentFrameworkStep:
openingFrameworkStep,

currentStepObjective:
openingStepObjective,

nextFrameworkStep: ”,

nextStepObjective: ”,

frameworkSteps,

currentStepIndex:
openingStepIndex,

completionCriteriaByStep,

stepCoverageMap,

openingEstablished: String(
openingContext.step_context?.[
String(openingStepIndex + 1)
]?.established || ”
).trim(),

openingRemainingGap: String(
openingContext.step_context?.[
String(openingStepIndex + 1)
]?.remaining_gap || ”
).trim(),

openingOverallEstablished: String(
openingContext.overall_established || ”
).trim(),

layerBEvidence: [],
acceptedEvidence: [],

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

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

previousInsightReviews,

persistentCoachContext: String(
page.coachMemory?.persistentCoachContext || ”
).trim(),

gate: {
assessment: ”,
additional_context: {
present: false,
summary: ”,
coach_note: ”
}
}
},

{
strategy: {
response_strategy:
allStepsSufficient
? ‘initial_integration’
: ‘initial’,

reason:
allStepsSufficient
? ‘All framework territories are already sufficiently addressed. Write one whole-Insight integration question.’
: ‘Write the opening question for the first unresolved framework territory.’,

follow_up_gap:
!allStepsSufficient &&
firstUnresolved?.coverage_status ===
‘partially_addressed’
? String(
openingContext.step_context?.[
String(openingStepIndex + 1)
]?.remaining_gap || ”
).trim()
: ”
}
},

”
);
}

} catch (err) {
console.log(
‘INITIAL QUESTION WRITER ERROR:’,
err
);

firstQuestion = openingFrameworkStep;
}

if (firstQuestion) {
/*
* The first Coach question is now ready.
* Reveal the complete coaching area before rendering it.
*/
if (openingCoachHeading) {
openingCoachHeading.style.display = ”;
}

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

pushMsg(‘assistant’, firstQuestion);
}
}

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