insight-orchestrator

/**
* insight-orchestrator.js
*
* Architecture Orchestrator
* ————————-
* Coordinates Layers A, B, C and D.
*/

(function () {
‘use strict’;

function buildDecisionTrace(items) {
if (!items || !items.length) return ”;

const lines = [‘AI DECISION TRACE’, ‘Layered AI Coach’, ”];

items.forEach(item => {
lines.push(`Layer ${item.layer || ”}`);
lines.push(`Decision : ${item.decision || item.route || ”}`);
lines.push(`Result : ${item.value || ”}`);
lines.push(`Reason : ${item.reason || ”}`);

if (Array.isArray(item.details) && item.details.length) {
lines.push(”);

item.details.forEach(detail => {
lines.push(
`${detail.decision || detail.route || ”} ${detail.value || ”}${
detail.reason ? ` — ${detail.reason}` : ”
}`
);
});
}

lines.push(”);
});

return lines.join(‘\n’).trim();
}

async function handleUserTurnLayered(ctx) {
const debugMode =
new URLSearchParams(window.location.search).get(‘debug’) === ‘1’;

const debugTrace = [];

function addDebug(result) {
if (debugMode && result?.debug) {
debugTrace.push(result.debug);
}
}

function getDecisionTrace() {
if (!debugMode) return ”;

return buildDecisionTrace(debugTrace);
}

const gate = await window.cpInsightLayerA.evaluateGoodFaithAnswer(ctx);
ctx.gate = gate;

addDebug(gate);

if (gate.status === ‘clarification_required’) {
const question = await window.cpInsightLayerA.writeClarification(ctx, gate);

ctx.pushAssistantMessage({
reflection: ”,
question,
debug_trace: getDecisionTrace()
});

if (ctx.saveNow) {
await ctx.saveNow({
status: ‘Live’,
gate_result: JSON.stringify(gate),
coach_decision: JSON.stringify({ next_model: ‘clarification’ })
});
}

return { stopped_at: ‘A2’, gate };
}

if (gate.status === ‘redirect_required’) {
const question = await window.cpInsightLayerA.writeRedirect(ctx, gate);

ctx.pushAssistantMessage({
reflection: ”,
question,
debug_trace: getDecisionTrace()
});

if (ctx.saveNow) {
await ctx.saveNow({
status: ‘Live’,
gate_result: JSON.stringify(gate),
coach_decision: JSON.stringify({ next_model: ‘redirect’ })
});
}

return { stopped_at: ‘A3’, gate };
}

if (gate.status === ‘boundary_set’) {
const question = await window.cpInsightLayerA.writeBoundaryResponse(ctx, gate);

ctx.pushAssistantMessage({
reflection: ”,
question,
debug_trace: getDecisionTrace()
});

if (ctx.saveNow) {
await ctx.saveNow({
status: ‘Live’,
gate_result: JSON.stringify(gate),
coach_decision: JSON.stringify({ next_model: ‘boundary’ })
});
}

return { stopped_at: ‘A4’, gate };
}
const layerB = await window.cpInsightLayerB.runLayerB(ctx);

addDebug(layerB);

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

if (strategy === ‘non_resonance’) {
const layerC = await window.cpInsightLayerC.runLayerC(ctx, layerB);

ctx.pushAssistantMessage({
reflection: ”,
question: layerC.ending || ”,
debug_trace: getDecisionTrace()
});

if (ctx.saveNow) {
await ctx.saveNow({
status: ‘Ended’,
gate_result: JSON.stringify(gate),
layer_b_result: JSON.stringify(layerB),
layer_c_result: JSON.stringify(layerC),
coach_decision: JSON.stringify({
next_model: ‘non_resonance’,
response_strategy: strategy
})
});
}

return {
stopped_at: ‘C3_NON_RESONANCE’,
gate,
layerB,
layerC
};
}

const isFinalComplete =
strategy === ‘next_step’ && ctx.isFinalFrameworkStep === true;

if (isFinalComplete) {
const layerD = await window.cpInsightLayerD.runLayerD({
…ctx,
traitUpdates: layerB?.traits?.trait_updates || []
});

addDebug(layerD);

ctx.pushAssistantMessage({
reflection: ”,
question: layerD.review || ”,
debug_trace: getDecisionTrace()
});

if (ctx.saveNow) {
await ctx.saveNow({
status: ‘Ended’,
gate_result: JSON.stringify(gate),
layer_b_result: JSON.stringify(layerB),
layer_d_result: JSON.stringify(layerD),
coach_decision: JSON.stringify({
next_model: ‘review’,
response_strategy: strategy,
review_type: layerD.review_type
})
});
}

return {
stopped_at: ‘D_REVIEW’,
gate,
layerB,
layerD
};
}

const layerC = await window.cpInsightLayerC.runLayerC(ctx, layerB);

ctx.pushAssistantMessage({
reflection: layerC.reflection || ”,
question: layerC.question || ”,
debug_trace: getDecisionTrace()
});

if (ctx.saveNow) {
await ctx.saveNow({
status: ‘Live’,
gate_result: JSON.stringify(gate),
layer_b_result: JSON.stringify(layerB),
layer_c_result: JSON.stringify(layerC),
coach_decision: JSON.stringify({
next_model: ‘question’,
response_strategy: strategy
})
});
}

return {
stopped_at: ‘C_RESPONSE’,
gate,
layerB,
layerC
};
}

window.cpInsightOrchestrator = {
handleUserTurnLayered
};
})();