Insight JS code

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`
).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);
}
function stallFlagKeyForThisInsight() {
const v = (window.cpVars && window.cpVars.insightPage) ? window.cpVars.insightPage : {};
const base = (getParam(‘insight’,”) || v.insightSequence || ‘generic’).trim();
return ‘cp_ai_stall_flag_’ + base;
}

function stallOfferShownKeyForThisInsight() {
const v = (window.cpVars && window.cpVars.insightPage) ? window.cpVars.insightPage : {};
const base = (getParam(‘insight’,”) || v.insightSequence || ‘generic’).trim();
return ‘cp_ai_stall_offer_shown_’ + base;
}

async function assessStallOrNonresponseBeforeReply() {
const v = (window.cpVars && window.cpVars.insightPage) ? window.cpVars.insightPage : {};
if (!v.aiUrl) return { flagged: false }; // fail-open

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

const lastTwoUser = thread
.filter(m => m.role === ‘user’)
.slice(-2)
.map(m => String(m.content || ”).trim());

const system =
`You are monitoring whether a guided Insight reflection should offer a “move on” confirmation.\n` +
`Return ONLY valid JSON:\n` +
`{“flagged”:true|false}\n` +
`\n` +
`Hard rule (must follow):\n` +
`- If BOTH of the last two user turns indicate they cannot think of anything to say (e.g. “nothing comes to mind”, “I don’t know”, “can’t think of anything”, “there’s nothing there”), you MUST return {“flagged”:true}.\n` +
`\n` +
`Otherwise, flag true only if one of these is clearly present across the most recent turns:\n` +
`A) The user is not engaged or is not responding properly to questions.\n` +
`B) The conversation is stalled/exhausted (looping, diminishing returns, no new depth).\n` +
`\n` +
`Do not include any other keys. Do not include commentary.\n`;

const user =
`INSIGHT QUESTION:\n${cf.insightQuestion || String(v.insight?.question || ”).trim()}\n\n` +
`INSIGHT SUMMARY:\n${cf.insightSummary || ”}\n\n` +
`LAST TWO USER TURNS:\n` +
`1) ${(lastTwoUser[0] || ”).slice(0, 500)}\n` +
`2) ${(lastTwoUser[1] || ”).slice(0, 500)}\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.flagged === ‘boolean’) return { flagged: !!parsed.flagged };
} catch {}

return { flagged: false }; // fail-open
}

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

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

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

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

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

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

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

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

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

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

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

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

if (nextBtn.disabled) return;

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

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

try {
const verdict = await assessInsightCoveredForNextClick();

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

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

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

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

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

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

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

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

// — NEW: pre-reply stall/non-response check —
try {
const flagKey = stallFlagKeyForThisInsight();
const offerKey = stallOfferShownKeyForThisInsight();

const offerAlreadyShown = (sessionStorage.getItem(offerKey) === ‘1’);
const wasFlagged = (sessionStorage.getItem(flagKey) === ‘1’);

const verdict = await assessStallOrNonresponseBeforeReply();
const nowFlagged = !!verdict.flagged;

if (offerAlreadyShown) {
// Never offer again this Insight/session
if (!nowFlagged) sessionStorage.removeItem(flagKey);
else sessionStorage.setItem(flagKey, ‘1’);
} else {
if (!nowFlagged) {
sessionStorage.removeItem(flagKey);
} else if (!wasFlagged) {
// First successive flag: arm for next turn
sessionStorage.setItem(flagKey, ‘1’);
} else {
// Second successive flag: show SAME confirm as Next
sessionStorage.removeItem(flagKey);

const ok = window.confirm(
“Are you sure you’re ready to move on [OK], or would you like to continue exploring this Insight [Cancel]?”
);

if (ok) {
nextConfirmedOverride = true;
triggerNextNavigation();
return; // do NOT generate a coach reply if moving on
}

// User declined: mark so we never offer again this Insight/session
sessionStorage.setItem(offerKey, ‘1’);
// proceed with normal coach reply
}
}
} catch {
// fail-open: continue
}

try {
const reply = await callAI(text);
const cleanReply = String(reply || ”).trim();
pushMsg(‘assistant’, cleanReply);

// 1) mini summary
const summary = await summariseThread();

// 2) append-only emits to 329 + 338 (once per user turn)
await saveConversationSummary({ summary });

// 3) store to 320 Responses (no advance gating)
const coachDecision = { next_model: ‘next_click_ai_check’ };

await saveNow({
status: ‘Live’,
summary,
‘7206’: JSON.stringify(coachDecision),
‘coach decision’: JSON.stringify(coachDecision)
});

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

// Initial UI state
sendBtn.textContent = ‘Send’;
nextBtn.style.display = ”;
coachState.draft = String(ta.value || ”);
renderCTA();
}

async function init() {
const page = (window.cpVars && window.cpVars.insightPage) ? window.cpVars.insightPage : {};
const userpass = getParam(‘userpass’,”);
const edition = (getParam(‘edition’,’workplace’) || ‘workplace’).toLowerCase();
const insight = getParam(‘insight’,”);
const tone = (getParam(‘tone’,’direct’) || ‘direct’).toLowerCase();
page.tone = tone;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

renderInsight(ctx);

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

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

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