sneakoscope 6.0.3 → 6.1.2

package/dist/core/hooks-runtime.js

@@ -16,9 +16,20 @@ import { appendMissionStatus } from './recallpulse.js';
 import { scanAgentTextForRecursion } from './agents/agent-recursion-guard.js';
 import { evaluateLoopContinuation } from './loops/loop-continuation-enforcer.js';
 import { diagnosticPromptAllowedDuringNoQuestions } from './routes/diagnostic-allowlist.js';
+import { closeWorkOrderLedgerForRouteResult } from './work-order-ledger.js';
 import { maybeReconcileProjectSkillsPreflight } from './hooks-runtime/skill-reconcile-preflight.js';
 import { codePackFreshnessNote } from './hooks-runtime/code-pack-freshness-preflight.js';
+import { claimHookInvocation } from './hooks-runtime/hook-invocation-dedupe.js';
 import { joinSystemMessages, teamLiveDigest } from './hooks-runtime/team-digest.js';
+import { armLightTurnStopBypass, clearLightTurnStopBypass, consumeLightTurnStopBypass, hasMatchingLightTurnStopBypass } from './hooks-runtime/light-turn.js';
+import { classifyTaskProfile } from './runtime/task-profile.js';
+import { resolveSubagentThreadBudget } from './subagents/thread-budget.js';
+import { readOfficialSubagentConfig } from './subagents/official-subagent-config.js';
+import { withFileLock } from './locks/file-lock.js';
+import { NARUTO_PARENT_EFFORT, NARUTO_PARENT_MODEL } from './subagents/model-policy.js';
+import { officialSubagentRolePlan } from './subagents/agent-catalog.js';
+import { recordOfficialSubagentParentOutcomesTelemetry, recordOfficialSubagentZellijTelemetry } from './zellij/zellij-official-subagent-telemetry.js';
+import { bindTrustworthySubagentParentSummaryToRun, normalizeSubagentParentSummary, persistOrReuseTrustworthySubagentParentSummary, readSubagentEvents, recordSubagentEvent, SUBAGENT_EVIDENCE_FILENAME, SUBAGENT_PARENT_SUMMARY_FILENAME, writeSubagentEvidence } from './subagents/subagent-evidence.js';
 const STOP_REPEAT_GUARD_ARTIFACT = 'stop-hook-repeat-guard.json';
 const LIGHT_ROUTE_STOP_ARTIFACT = 'light-route-stop.json';
 const CODEX_GIT_ACTION_STOP_ARTIFACT = 'codex-git-action-stop-bypass.json';
@@ -31,6 +42,8 @@ const UPDATE_CHECK_HOOK_INVOCATION_POLICY = 'function-only:no-runSksUpdateCheck-
 // by release readiness so ordinary Codex hook flow cannot grow a hidden update
 // prompt path.
 import { loadHookPayload, normalizeHookResult, visibleHookMessage } from './hooks-runtime/hook-io.js';
+import { codexGitActionMetadataSignal, codexGitActionMetadataText, compactAnswerContext, conversationId, explicitConversationId, extractCommand, extractLastMessage, extractUserPrompt, hookTurnId, looksLikeCodexGitAction, looksLikeCodexGitActionStopCompletion, looksLikeCodexUiSettingsEvent, looksLikeMadSksConfirmationPrompt, observedParentModel, observedParentModelMismatch, toolFailed } from './hooks-runtime/payload-signals.js';
+import { interruptedToolOutputRecoveryBlockReason, missingToolOutputCallId, missingToolOutputCallIdFromPayload, quarantineMissingToolOutput, readToolOutputQuarantine } from './hooks-runtime/tool-output-quarantine.js';
 export { loadHookPayload, normalizeHookResult };
 async function loadState(root, payload = {}) {
     return loadStateForSession(root, conversationId(payload));
@@ -39,142 +52,39 @@ function isNoQuestionRunning(state) {
     return (state.mode === 'RESEARCH' && state.phase === 'RESEARCH_RUNNING_NO_QUESTIONS')
         || (state.mode === 'QALOOP' && state.phase === 'QALOOP_RUNNING_NO_QUESTIONS');
 }
-function extractLastMessage(payload) {
-    return payload.last_assistant_message || payload.assistant_message || payload.message || payload.response || payload.raw || '';
-}
-function extractUserPrompt(payload) {
-    return payload.prompt
-        || payload.user_prompt
-        || payload.userPrompt
-        || payload.message
-        || payload.input?.prompt
-        || payload.input?.message
-        || payload.raw
-        || '';
-}
-function conversationId(payload) {
-    return String(payload.conversation_id || payload.thread_id || payload.session_id || payload.chat_id || payload.cwd || 'default');
-}
-function explicitConversationId(payload = {}) {
-    return payload.conversation_id || payload.thread_id || payload.session_id || payload.chat_id || null;
-}
-function extractCommand(payload) {
-    return payload.command || payload.tool_input?.command || payload.toolInput?.command || payload.input?.command || payload.tool?.input?.command || '';
+export async function hookMain(name) {
+    const payload = await loadHookPayload();
+    const root = await projectRoot(payload.cwd || process.cwd());
+    return evaluateHookPayloadOnce(name, payload, { root });
 }
-function codexGitActionMetadataText(payload = {}) {
-    const seen = new Set();
-    const out = [];
-    const interesting = new Set([
-        'action',
-        'intent',
-        'operation',
-        'permission',
-        'description',
-        'kind',
-        'type',
-        'feature',
-        'tool_name',
-        'toolName',
-        'name',
-        'label',
-        'title',
-        'source',
-        'event',
-        'hook',
-        'hook_name',
-        'hookName',
-        'hook_event_name',
-        'hookEventName',
-        'id',
-        'command'
-    ]);
-    const noisy = new Set([
-        'prompt',
-        'user_prompt',
-        'userPrompt',
-        'message',
-        'assistant_message',
-        'last_assistant_message',
-        'response',
-        'raw',
-        'stdout',
-        'stderr'
-    ]);
-    function walk(value, depth = 0, parentKey = '') {
-        if (!value || typeof value !== 'object' || depth > 5 || seen.has(value))
-            return;
-        seen.add(value);
-        for (const [key, candidate] of Object.entries(value)) {
-            if (noisy.has(key))
-                continue;
-            if (typeof candidate === 'string') {
-                if (interesting.has(key) || /\b(?:codex[_\s-]*app|git[_\s-]*actions?|codex_git_|gitCommit|gitPush|pull\s+request)\b/i.test(candidate)) {
-                    out.push(`${key}:${candidate}`);
-                }
-                continue;
-            }
-            if (candidate && typeof candidate === 'object') {
-                const allowedContainer = interesting.has(key)
-                    || /^(?:input|metadata|context|client|thread|session|request|payload|tool|tool_input|toolInput|permission_request|permissionRequest)$/i.test(key)
-                    || parentKey;
-                if (allowedContainer)
-                    walk(candidate, depth + 1, key);
-            }
-        }
+export async function evaluateHookPayloadOnce(name, payload = {}, opts = {}) {
+    const root = opts.root || await projectRoot(payload.cwd || process.cwd());
+    if (name === 'user-prompt-submit' && hookPayloadIsLightTurnCandidate(payload)) {
+        return evaluateHookPayload(name, payload, { root });
     }
-    walk(payload);
-    return out.join(' ');
+    const claim = await claimHookInvocation(root, name, payload).catch(() => ({ duplicate: false }));
+    if (claim.duplicate)
+        return { continue: true, suppressedDuplicate: true };
+    return evaluateHookPayload(name, payload, { root });
 }
-function codexGitActionMetadataSignal(text = '') {
-    const s = String(text || '');
-    if (!s)
+function hookPayloadIsLightTurnCandidate(payload = {}) {
+    const prompt = stripVisibleDecisionAnswerBlocks(extractUserPrompt(payload));
+    if (dollarCommand(prompt))
         return false;
-    const action = String(s)
-        .replace(/([a-z])([A-Z])/g, '$1 $2')
-        .replace(/[_-]+/g, ' ');
-    if (/\bcodex\s*app\b[\s\S]{0,120}\bgit\b[\s\S]{0,120}\b(?:action|actions|commit|push|pr|pull request)\b/i.test(action))
-        return true;
-    if (/\bgit\s*actions?\b[\s\S]{0,120}\b(?:commit|push|pr|pull request|commit\s*(?:and|&)\s*push)\b/i.test(action))
-        return true;
-    if (/\bcodex\s*git\s*(?:commit|push|pr|pull request|commit\s*(?:and|&)\s*push)\b/i.test(action))
-        return true;
-    if (/\b(?:git\s*)?(?:commit|push|commit\s*(?:and|&)\s*push|create\s+(?:a\s+)?pull\s+request|pull\s+request|pr)\b/i.test(action)) {
-        return /\b(?:action|intent|operation|permission|feature|tool\s*name|source|event|hook|name|label|title|type|kind|id)\s*:/i.test(action);
-    }
-    return false;
-}
-function toolFailed(payload = {}) {
-    const candidates = [
-        payload.exit_code,
-        payload.exitCode,
-        payload.tool_response?.exit_code,
-        payload.toolResponse?.exitCode,
-        payload.result?.exit_code,
-        payload.result?.exitCode
-    ];
-    for (const candidate of candidates) {
-        if (candidate === undefined || candidate === null || candidate === '')
-            continue;
-        const n = Number(candidate);
-        if (Number.isFinite(n))
-            return n !== 0;
-    }
-    if (payload.isError === true || payload.tool_response?.isError === true || payload.toolResponse?.isError === true || payload.result?.isError === true)
-        return true;
-    if (payload.success === false || payload.tool_response?.success === false || payload.toolResponse?.success === false || payload.result?.success === false)
-        return true;
-    if (payload.executed === false)
+    const profile = classifyTaskProfile(prompt);
+    if (profile === 'passthrough')
         return true;
-    return false;
-}
-export async function hookMain(name) {
-    const payload = await loadHookPayload();
-    return evaluateHookPayload(name, payload);
+    return routePrompt(prompt)?.id === 'Answer';
 }
 export async function evaluateHookPayload(name, payload = {}, opts = {}) {
     const root = opts.root || await projectRoot(payload.cwd || process.cwd());
     const sessionKey = conversationId(payload);
-    if (!explicitConversationId(payload)) {
+    const greetingFastPath = name === 'user-prompt-submit'
+        && !dollarCommand(stripVisibleDecisionAnswerBlocks(extractUserPrompt(payload)))
+        && classifyTaskProfile(stripVisibleDecisionAnswerBlocks(extractUserPrompt(payload))) === 'passthrough';
+    const matchingLightStop = name === 'stop'
+        && await hasMatchingLightTurnStopBypass(root, { sessionKey, turnId: hookTurnId(payload) }).catch(() => false);
+    if (!explicitConversationId(payload) && !greetingFastPath && !matchingLightStop) {
         await appendJsonl(path.join(root, '.sneakoscope', 'state', 'session-id-fallback-warning.jsonl'), {
             ts: nowIso(),
             warning: 'hook_payload_missing_explicit_session_id',
@@ -183,7 +93,11 @@ export async function evaluateHookPayload(name, payload = {}, opts = {}) {
             hook: name
         }).catch(() => null);
     }
-    const loadedState = opts.state || payload.state || await loadState(root, payload);
+    // Hook decisions use persisted session state. Codex hook payloads do not
+    // define a trusted `state` field; accepting a partial/spoofed value can hide
+    // an active mission or bypass route gates. Explicit opts.state remains for
+    // internal replay and focused tests.
+    const loadedState = opts.state || await loadState(root, payload);
     const state = { ...loadedState, _session_key: loadedState?._session_key || sessionKey };
     const noQuestion = isNoQuestionRunning(state);
     if (name === 'user-prompt-submit') {
@@ -198,46 +112,166 @@ export async function evaluateHookPayload(name, payload = {}, opts = {}) {
     if (name === 'stop')
         return hookStop(root, state, payload, noQuestion, sessionKey);
     if (name === 'subagent-start')
-        return hookSubagentStart(root, state, sessionKey);
+        return hookSubagentStart(root, state, payload, sessionKey);
+    if (name === 'subagent-stop')
+        return hookSubagentStop(root, state, payload, sessionKey);
     return { continue: true };
 }
-async function hookSubagentStart(root, state, sessionKey = null) {
-    void sessionKey;
-    const active = await activeRouteContext(root, state).catch(() => '');
+async function hookSubagentStart(root, state, payload = {}, sessionKey = null) {
+    const artifactDir = officialSubagentArtifactDir(root, state, sessionKey);
+    await recordAndRefreshSubagentEvidence(root, artifactDir, state, payload, 'SubagentStart').catch(() => null);
+    const config = await readOfficialSubagentConfig(root);
+    const budget = resolveSubagentThreadBudget({ configuredMaxThreads: config.maxThreads });
+    const active = subagentRouteContext(state);
     const resourceGuard = [
-        'SKS resource guard: keep at most 4 active subagents in this session.',
-        'Subagents must not spawn nested subagents or duplicate an already assigned audit lane.',
-        'Queue additional independent work instead of increasing active fan-out.'
+        `SKS subagent policy: Codex [agents].max_threads is ${budget.maxThreads}.`,
+        'Use max_depth=1. Subagents must not spawn subagents.',
+        'Do not duplicate an already assigned slice.',
+        'Parallel writes require disjoint paths; serialize overlapping paths.',
+        'Close completed agent threads when no longer needed.'
     ].join(' ');
     const additionalContext = [leanEngineeringCompactText(), resourceGuard, active].filter(Boolean).join('\n\n');
     return { continue: true, additionalContext };
 }
-function looksLikeCodexUiSettingsEvent(payload = {}) {
-    const prompt = stripVisibleDecisionAnswerBlocks(extractUserPrompt(payload));
-    const haystack = [
-        payload.action,
-        payload.intent,
-        payload.operation,
-        payload.permission,
-        payload.description,
-        payload.kind,
-        payload.type,
-        payload.feature,
-        payload.source,
-        payload.event,
-        payload.hook,
-        payload.hook_name,
-        payload.metadata?.action,
-        payload.metadata?.intent,
-        payload.metadata?.operation,
-        payload.metadata?.feature,
-        payload.metadata?.source,
-        payload.context?.surface,
-        payload.session?.surface
-    ].filter(Boolean).join(' ');
-    return !prompt && /\b(?:settings|preferences|profile|speed|fast[_\s-]*mode|reasoning|model[_\s-]*select|codex[_\s-]*app)\b/i.test(haystack);
+function subagentRouteContext(state = {}) {
+    if (!state?.route && !state?.mode)
+        return '';
+    const route = state.route_command || state.route || state.mode;
+    const mission = state.mission_id ? ` for mission ${state.mission_id}` : '';
+    const artifacts = state.mission_id
+        ? ` Read only the route artifacts relevant to your assigned slice under .sneakoscope/missions/${state.mission_id}/.`
+        : '';
+    const databaseBoundary = String(state.mode || state.route || '').toUpperCase() === 'DB'
+        ? ' Keep database inspection read-only unless the parent supplied a separately sealed mutation contract.'
+        : '';
+    return `You are a child thread on ${route}${mission}. Execute only the slice assigned by the parent.${artifacts} Do not spawn or delegate other agents, wait for sibling threads, integrate sibling results, close the parent route, or author the sks.subagent-parent-summary.v1 parent result. Return a concise slice result to the parent.${databaseBoundary}`;
+}
+async function hookSubagentStop(root, state, payload = {}, sessionKey = null) {
+    const artifactDir = officialSubagentArtifactDir(root, state, sessionKey);
+    await recordAndRefreshSubagentEvidence(root, artifactDir, state, payload, 'SubagentStop').catch(() => null);
+    // SubagentStop is evidence collection only. It must never reuse the parent
+    // Stop hook's route gate or block a child thread from returning its result.
+    return { continue: true, silent: true };
+}
+function officialSubagentArtifactDir(root, state = {}, sessionKey = null) {
+    if (state?.mission_id)
+        return missionDir(root, state.mission_id);
+    return path.join(root, '.sneakoscope', 'state', 'subagents', sha256(String(sessionKey || 'default')).slice(0, 32));
+}
+async function recordAndRefreshSubagentEvidence(root, artifactDir, state, payload, eventName) {
+    return withFileLock({
+        lockPath: path.join(artifactDir, '.subagent-evidence.lock'),
+        timeoutMs: 5_000,
+        staleMs: 60_000
+    }, async () => {
+        const plan = await readJson(path.join(artifactDir, 'subagent-plan.json'), {});
+        const workflowRunId = String(plan?.workflow_run_id || state?.official_subagent_run_id || '').trim();
+        const eventPayload = workflowRunId && payload && typeof payload === 'object' && !Array.isArray(payload)
+            ? { ...payload, workflow_run_id: workflowRunId }
+            : payload;
+        const event = await recordSubagentEvent(artifactDir, eventPayload, eventName);
+        if (!event)
+            return null;
+        const zellijTelemetry = await recordOfficialSubagentZellijTelemetry({
+            root,
+            routeMissionId: plan?.mission_id || state?.mission_id || null,
+            event,
+            payload: eventPayload,
+            plan
+        }).catch(async (error) => {
+            await appendJsonl(path.join(artifactDir, 'zellij-telemetry-warnings.jsonl'), {
+                ts: nowIso(),
+                warning: 'official_subagent_zellij_telemetry_failed',
+                event_name: eventName,
+                thread_id: event.thread_id,
+                error: String(error?.message || error)
+            }).catch(() => null);
+            return null;
+        });
+        if (zellijTelemetry?.blocker) {
+            await appendJsonl(path.join(artifactDir, 'zellij-telemetry-warnings.jsonl'), {
+                ts: nowIso(),
+                warning: 'official_subagent_zellij_telemetry_incomplete',
+                event_name: eventName,
+                thread_id: event.thread_id,
+                blocker: zellijTelemetry.blocker,
+                failed_mission_ids: 'failed_mission_ids' in zellijTelemetry ? zellijTelemetry.failed_mission_ids : []
+            }).catch(() => null);
+        }
+        const existing = await readJson(path.join(artifactDir, SUBAGENT_EVIDENCE_FILENAME), {});
+        const parentSummary = await readJson(path.join(artifactDir, SUBAGENT_PARENT_SUMMARY_FILENAME), null);
+        const requestedSubagents = Number(plan?.requested_subagents
+            || state?.requested_subagents
+            || existing?.requested_subagents
+            || 0);
+        if (!Number.isFinite(requestedSubagents) || requestedSubagents < 1)
+            return event;
+        await writeSubagentEvidence(artifactDir, {
+            requestedSubagents,
+            parentSummary,
+            parentSummaryPresent: parentSummary !== null,
+            workflowStatus: 'running',
+            preparationOnly: false,
+            runId: workflowRunId || null,
+            additionalBlockers: Array.isArray(plan?.config_blockers)
+                ? plan.config_blockers.map((item) => `official_subagent_config:${String(item)}`)
+                : []
+        });
+        return event;
+    });
 }
 async function hookUserPrompt(root, state, payload, noQuestion, sessionKey = null) {
+    // A receipt is scoped to exactly one submitted turn. Every later prompt,
+    // including Codex App git/settings events, invalidates it before returning.
+    await clearLightTurnStopBypass(root, { sessionKey }).catch(() => undefined);
+    const submittedPrompt = stripVisibleDecisionAnswerBlocks(extractUserPrompt(payload));
+    const explicitSession = explicitConversationId(payload);
+    const detectedMissingCallId = missingToolOutputCallId(submittedPrompt)
+        || missingToolOutputCallIdFromPayload(payload);
+    let toolOutputQuarantine = explicitSession
+        ? await readToolOutputQuarantine(root, sessionKey).catch(() => null)
+        : null;
+    if (detectedMissingCallId && explicitSession) {
+        toolOutputQuarantine = await quarantineMissingToolOutput({
+            root,
+            sessionKey,
+            callId: detectedMissingCallId,
+            missionId: state?.mission_id,
+            turnId: hookTurnId(payload)
+        }).catch(() => toolOutputQuarantine);
+    }
+    if (submittedPrompt && (detectedMissingCallId || toolOutputQuarantine)) {
+        return {
+            decision: 'block',
+            reason: interruptedToolOutputRecoveryBlockReason({
+                callId: detectedMissingCallId || toolOutputQuarantine?.call_id,
+                missionId: state?.mission_id || toolOutputQuarantine?.mission_id
+            })
+        };
+    }
+    const parentLaunchMissionId = process.env.SKS_NARUTO_PARENT_LAUNCH === '1'
+        ? String(process.env.SKS_NARUTO_PARENT_MISSION_ID || '').trim()
+        : '';
+    if (parentLaunchMissionId) {
+        const attachedState = {
+            ...state,
+            mission_id: parentLaunchMissionId,
+            mode: 'NARUTO',
+            route: 'Naruto',
+            route_command: '$Naruto',
+            route_closed: false,
+            subagents_required: true,
+            native_sessions_required: false
+        };
+        await setCurrent(root, attachedState, { sessionKey, replace: true });
+        const activeContext = await activeRouteContext(root, attachedState);
+        return {
+            continue: true,
+            additionalContext: activeContext,
+            systemMessage: visibleHookMessage('user-prompt-submit', activeContext),
+            attached_parent_mission_id: parentLaunchMissionId
+        };
+    }
     if (looksLikeCodexGitAction(payload)) {
         await armCodexGitActionStopBypass(root, payload).catch(() => null);
         return {
@@ -251,15 +285,63 @@ async function hookUserPrompt(root, state, payload, noQuestion, sessionKey = nul
             systemMessage: 'SKS: Codex App settings/profile event ignored; route gates unchanged.'
         };
     }
-    await maybeReconcileProjectSkillsPreflight(root).catch(() => null);
     if (!noQuestion) {
-        const prompt = stripVisibleDecisionAnswerBlocks(extractUserPrompt(payload));
-        const madSksConfirmation = await handleMadSksUserConfirmation(root, state, prompt);
+        const prompt = submittedPrompt;
+        const taskProfile = classifyTaskProfile(prompt);
+        const explicitCommand = Boolean(dollarCommand(prompt));
+        const lightRoute = explicitCommand ? null : routePrompt(prompt);
+        const clarificationPending = isBlockingClarificationAwaiting(state);
+        const madConfirmationPrompt = looksLikeMadSksConfirmationPrompt(prompt);
+        const activeContinuation = Boolean(state?.mission_id && state?.route_closed !== true && looksLikeActiveContinuationPrompt(prompt));
+        if (!explicitCommand && !clarificationPending && !madConfirmationPrompt && !activeContinuation && taskProfile === 'passthrough') {
+            const turnId = hookTurnId(payload);
+            if (turnId) {
+                await armLightTurnStopBypass(root, {
+                    sessionKey,
+                    turnId,
+                    prompt,
+                    profile: 'passthrough',
+                    ttlMs: 60_000
+                });
+            }
+            return { continue: true, silent: true, sksTaskProfile: taskProfile };
+        }
+        if (!explicitCommand && !clarificationPending && !madConfirmationPrompt && !activeContinuation && lightRoute?.id === 'Answer') {
+            const turnId = hookTurnId(payload);
+            if (turnId) {
+                await armLightTurnStopBypass(root, {
+                    sessionKey,
+                    turnId,
+                    prompt,
+                    profile: 'answer',
+                    ttlMs: 5 * 60_000
+                });
+            }
+            const additionalContext = compactAnswerContext(prompt);
+            return { continue: true, additionalContext, sksTaskProfile: 'answer' };
+        }
+        const madSksConfirmation = madConfirmationPrompt
+            ? await handleMadSksUserConfirmation(root, state, prompt)
+            : null;
         if (madSksConfirmation?.handled) {
             const teamDigest = await teamLiveDigest(root, state);
             const additionalContext = [madSksConfirmation.additionalContext, teamDigest?.context].filter(Boolean).join('\n\n');
             return { continue: true, additionalContext, systemMessage: joinSystemMessages(visibleHookMessage('user-prompt-submit', additionalContext), teamDigest?.system) };
         }
+        if (activeContinuation) {
+            const activeContext = await activeRouteContext(root, state);
+            const teamDigest = await teamLiveDigest(root, state);
+            const additionalContext = [
+                activeContext,
+                teamDigest?.context
+            ].filter(Boolean).join('\n\n');
+            return {
+                continue: true,
+                additionalContext,
+                systemMessage: joinSystemMessages(visibleHookMessage('user-prompt-submit', activeContext), teamDigest?.system)
+            };
+        }
+        await maybeReconcileProjectSkillsPreflight(root).catch(() => null);
         const updateContext = '';
         const command = dollarCommand(prompt);
         const route = routePrompt(prompt);
@@ -290,7 +372,10 @@ async function hookUserPrompt(root, state, payload, noQuestion, sessionKey = nul
         if (activeContext && shouldLoadActiveContext)
             contexts.push(routePipelineContext(prompt), activeContext);
         else
-            contexts.push((await prepareRoute(root, prompt, state, { sessionKey })).additionalContext);
+            contexts.push((await prepareRoute(root, prompt, state, {
+                sessionKey,
+                parentModel: observedParentModel(payload)
+            })).additionalContext);
         if (goalOverlay)
             contexts.push(goalOverlay);
         if (teamDigest?.context)
@@ -330,10 +415,13 @@ function shouldPrepareFreshRouteOnActivePrompt(prompt, route = null, opts = {})
     return routeRequiresSubagents(route, prompt);
 }
 function looksLikeActiveContinuationPrompt(prompt = '') {
-    const text = stripVisibleDecisionAnswerBlocks(String(prompt || '')).trim();
+    const text = stripVisibleDecisionAnswerBlocks(String(prompt || ''))
+        .trim()
+        .replace(/[.!?。！？…,:;]+$/u, '')
+        .trim();
     if (!text)
         return false;
-    return /^(?:keep\s+going|continue|resume|go\s+on|proceed|carry\s+on|계속|이어\s*서|이어서|진행|계속\s*해|마저\s*해|다음|next)$/i.test(text);
+    return /^(?:(?:please\s+)?(?:keep\s+going|continue|resume|go\s+on|proceed|carry\s+on)(?:\s+please)?|계속(?:\s*진행)?(?:\s*해\s*줘|\s*해주세요|\s*해)?|이어\s*서(?:\s*해\s*줘|\s*해주세요|\s*진행해)?|이어서(?:\s*해\s*줘|\s*해주세요|\s*진행해)?|진행(?:\s*해\s*줘|\s*해주세요|\s*해)?|마저\s*해(?:\s*줘|\s*주세요)?|다음|next)$/i.test(text);
 }
 function isClarificationAwaiting(state = {}) {
     const phase = String(state.phase || '');
@@ -613,6 +701,11 @@ function clarificationPauseBlockReason(state = {}) {
 }
 async function hookStop(root, state, payload, noQuestion, sessionKey = null) {
     const last = extractLastMessage(payload);
+    if (!noQuestion) {
+        const lightTurn = await consumeLightTurnStopBypass(root, { sessionKey, turnId: hookTurnId(payload) });
+        if (lightTurn.accepted)
+            return { continue: true, action: 'light_turn', silent: true };
+    }
     if (state?.mode === 'LOOP' || state?.route === 'Loop' || state?.route_command === '$Loop') {
         const missionId = state?.mission_id;
         if (missionId) {
@@ -643,6 +736,9 @@ async function hookStop(root, state, payload, noQuestion, sessionKey = null) {
             systemMessage: 'SKS: DFix ultralight finalization accepted; full-route Honest Mode loopback is not required.'
         };
     }
+    if (state?.subagents_required === true) {
+        await refreshOfficialSubagentCompletionArtifacts(root, state, last, sessionKey).catch(() => null);
+    }
     const routeDecision = await evaluateStop(root, state, payload, { noQuestion });
     if (routeDecision)
         return routeDecision;
@@ -680,6 +776,163 @@ async function hookStop(root, state, payload, noQuestion, sessionKey = null) {
         reason: 'SKS no-question run is not done. Continue autonomously, fix failing checks, update the active gate file, and do not ask the user.'
     };
 }
+async function refreshOfficialSubagentCompletionArtifacts(root, state = {}, parentSummary = '', sessionKey = null) {
+    const id = state?.mission_id;
+    if (!id)
+        return null;
+    const dir = missionDir(root, id);
+    const plan = await readJson(path.join(dir, 'subagent-plan.json'), null).catch(() => null);
+    if (plan?.workflow !== 'official_codex_subagent')
+        return null;
+    const requestedSubagents = Number(plan.requested_subagents || state.requested_subagents || 0);
+    const workflowRunId = String(plan.workflow_run_id || state.official_subagent_run_id || '').trim();
+    const events = await readSubagentEvents(dir);
+    const runBoundParentSummary = bindTrustworthySubagentParentSummaryToRun(parentSummary, workflowRunId);
+    const effectiveParentSummary = await persistOrReuseTrustworthySubagentParentSummary(dir, runBoundParentSummary, {
+        workflowStatus: 'parent_completed',
+        runId: workflowRunId || null
+    });
+    const structuredParentSummary = normalizeSubagentParentSummary(effectiveParentSummary);
+    const evidence = await writeSubagentEvidence(dir, {
+        requestedSubagents,
+        events,
+        parentSummary: effectiveParentSummary,
+        workflowStatus: 'parent_completed',
+        preparationOnly: false,
+        runId: workflowRunId || null,
+        additionalBlockers: Array.isArray(plan.config_blockers)
+            ? plan.config_blockers.map((item) => `official_subagent_config:${String(item)}`)
+            : []
+    });
+    if (structuredParentSummary.trustworthy) {
+        const parentTelemetry = await recordOfficialSubagentParentOutcomesTelemetry({
+            root,
+            routeMissionId: id,
+            parentSummary: structuredParentSummary.raw,
+            plan
+        }).catch(async (error) => {
+            await appendJsonl(path.join(dir, 'zellij-telemetry-warnings.jsonl'), {
+                ts: nowIso(),
+                warning: 'official_subagent_parent_outcome_telemetry_failed',
+                error: String(error?.message || error)
+            }).catch(() => null);
+            return null;
+        });
+        if (parentTelemetry?.blocker) {
+            await appendJsonl(path.join(dir, 'zellij-telemetry-warnings.jsonl'), {
+                ts: nowIso(),
+                warning: 'official_subagent_parent_outcome_telemetry_incomplete',
+                blocker: parentTelemetry.blocker,
+                failed_mission_ids: 'failed_mission_ids' in parentTelemetry ? parentTelemetry.failed_mission_ids : [],
+                skipped_thread_ids: 'skipped_thread_ids' in parentTelemetry ? parentTelemetry.skipped_thread_ids : []
+            }).catch(() => null);
+        }
+    }
+    const isNaruto = String(state?.mode || '').toUpperCase() === 'NARUTO'
+        || String(state?.route || state?.route_command || '').replace(/^\$/, '').toUpperCase() === 'NARUTO';
+    if (!isNaruto) {
+        await setCurrent(root, {
+            subagents_spawned: evidence.started_threads > 0,
+            subagents_reported: evidence.completed_threads > 0,
+            subagents_verified: evidence.ok,
+            subagent_evidence_file: SUBAGENT_EVIDENCE_FILENAME,
+            parent_summary_present: evidence.parent_summary_present
+        }, { sessionKey: sessionKey || state._session_key });
+        return evidence;
+    }
+    const previousGate = await readJson(path.join(dir, 'naruto-gate.json'), {}).catch(() => ({}));
+    const parentModel = plan.observed_parent_model || state.observed_parent_model || null;
+    const parentModelMismatch = previousGate.parent_model_match === false || observedParentModelMismatch(parentModel, NARUTO_PARENT_MODEL);
+    const blockers = [...new Set([
+            ...evidence.blockers,
+            ...(Array.isArray(previousGate.config_blockers) ? previousGate.config_blockers.map(String) : []),
+            ...(Array.isArray(plan.config_blockers) ? plan.config_blockers.map((item) => `official_subagent_config:${String(item)}`) : []),
+            ...(parentModelMismatch ? [`parent_model_mismatch:${String(parentModel || 'unknown')}`] : [])
+        ])];
+    const passed = evidence.ok === true && blockers.length === 0;
+    const updatedAt = nowIso();
+    const summary = {
+        schema: 'sks.naruto-subagent-workflow.v1',
+        ok: passed,
+        workflow: 'official_codex_subagent',
+        workflow_run_id: workflowRunId || null,
+        mission_id: id,
+        route: '$Naruto',
+        status: passed ? 'completed' : evidence.status,
+        parent: {
+            model: NARUTO_PARENT_MODEL,
+            model_reasoning_effort: NARUTO_PARENT_EFFORT,
+            observed_model: parentModel,
+            observed_model_match: parentModel ? !parentModelMismatch : null
+        },
+        requested_subagents: requestedSubagents,
+        max_threads: Number(plan.max_threads || state.subagent_max_threads || 0),
+        max_depth: 1,
+        started_subagents: evidence.started_threads,
+        completed_subagents: evidence.completed_threads,
+        failed_subagents: evidence.failed_threads,
+        agents: officialSubagentRolePlan(),
+        verification: {
+            budget: plan.verification?.budget || plan.verification_budget || 'affected',
+            checks: Array.isArray(plan.verification?.checks)
+                ? plan.verification.checks
+                : Array.isArray(plan.verification_checks)
+                    ? plan.verification_checks
+                    : []
+        },
+        legacy_process_swarm_used: false,
+        parent_summary_present: evidence.parent_summary_present,
+        parent_summary: structuredParentSummary.summary,
+        parent_thread_outcomes: structuredParentSummary.raw?.thread_outcomes || [],
+        subagent_evidence: SUBAGENT_EVIDENCE_FILENAME,
+        blockers,
+        updated_at: updatedAt
+    };
+    await writeJsonAtomic(path.join(dir, 'naruto-summary.json'), summary);
+    await writeJsonAtomic(path.join(dir, 'naruto-gate.json'), {
+        ...previousGate,
+        schema: 'sks.naruto-gate.v1',
+        workflow: 'official_codex_subagent',
+        workflow_run_id: workflowRunId || null,
+        mission_id: id,
+        status: passed ? 'passed' : 'blocked',
+        passed,
+        terminal: passed,
+        terminal_state: passed ? 'completed' : 'blocked',
+        subagent_plan_ready: true,
+        official_subagent_evidence: evidence.ok === true,
+        parent_summary_present: evidence.parent_summary_present,
+        session_cleanup: evidence.failed_threads === 0 && evidence.completed_threads >= requestedSubagents,
+        subagent_evidence_ready: evidence.ok === true,
+        requested_subagents: evidence.requested_subagents,
+        started_subagents: evidence.started_threads,
+        completed_subagents: evidence.completed_threads,
+        failed_subagents: evidence.failed_threads,
+        event_sources: evidence.event_sources,
+        evidence: {
+            ...(previousGate.evidence || {}),
+            official_subagent_evidence: SUBAGENT_EVIDENCE_FILENAME,
+            parent_summary: SUBAGENT_PARENT_SUMMARY_FILENAME,
+            requested_subagents: requestedSubagents,
+            started_threads: evidence.started_threads,
+            completed_threads: evidence.completed_threads,
+            failed_threads: evidence.failed_threads
+        },
+        blockers,
+        missing_fields: blockers,
+        updated_at: updatedAt
+    });
+    if (passed)
+        await closeWorkOrderLedgerForRouteResult(dir, { ok: true }).catch(() => null);
+    await setCurrent(root, {
+        subagents_spawned: evidence.started_threads > 0,
+        subagents_reported: evidence.completed_threads > 0,
+        subagents_verified: evidence.ok,
+        subagent_evidence_file: SUBAGENT_EVIDENCE_FILENAME,
+        parent_summary_present: evidence.parent_summary_present
+    }, { sessionKey: sessionKey || state._session_key });
+    return evidence;
+}
 async function consumeLightRouteStop(root, payload = {}) {
     const file = path.join(root, '.sneakoscope', 'state', LIGHT_ROUTE_STOP_ARTIFACT);
     const record = await readJson(file, null).catch(() => null);
@@ -713,91 +966,6 @@ function hasDfixLightCompletion(text) {
     const gap = /(미검증|남은|문제|gap|remaining|not verified|not run|blocker|차단|불가|없음|none)/i.test(s);
     return verification && gap;
 }
-function looksLikeCodexGitAction(payload = {}) {
-    const prompt = stripVisibleDecisionAnswerBlocks(extractUserPrompt(payload));
-    const metadataText = codexGitActionMetadataText(payload);
-    const haystack = [
-        metadataText,
-        payload.action,
-        payload.intent,
-        payload.operation,
-        payload.permission,
-        payload.description,
-        payload.kind,
-        payload.type,
-        payload.feature,
-        payload.tool_name,
-        payload.toolName,
-        payload.source,
-        payload.event,
-        payload.hook,
-        payload.hook_name,
-        payload.input?.action,
-        payload.input?.intent,
-        payload.input?.operation,
-        payload.input?.feature,
-        payload.input?.source,
-        payload.metadata?.action,
-        payload.metadata?.intent,
-        payload.metadata?.operation,
-        payload.metadata?.feature,
-        payload.metadata?.source
-    ].filter(Boolean).join(' ');
-    const codexAppGitSignal = /\bcodex[_\s-]*app\b[\s\S]{0,80}\bgit\b[\s\S]{0,80}\b(?:action|actions|commit|push|pr)\b/i.test(haystack);
-    const gitActionSignal = /\bgit[_\s-]*actions?\b[\s\S]{0,80}\b(?:commit|push|commit[\s_-]*(?:and|&)?[\s_-]*push)\b/i.test(haystack);
-    const appSignal = codexGitActionMetadataSignal(metadataText)
-        || codexAppGitSignal
-        || gitActionSignal
-        || /\b(?:codex[_\s-]*(?:app[_\s-]*)?)?(?:git[_\s-]*)?(?:commit[_\s-]*message|git[_\s-]*commit|git[_\s-]*push|git[_\s-]*pr|codex_git_commit|codex_git_push|codex_git_pr)\b/i.test(haystack)
-        || /커밋\s*메시지\s*생성/i.test(haystack);
-    const promptSignal = /\bgenerate(?:\s+a)?(?:\s+git)?\s+commit\s+message\b/i.test(prompt)
-        || /\bcommit\s+message\b[\s\S]{0,80}\b(?:staged|diff|changes?|git)\b/i.test(prompt)
-        || looksLikeStockCodexGitActionPrompt(prompt)
-        || /커밋\s*메시지\s*생성/i.test(prompt);
-    if (!appSignal && !promptSignal)
-        return false;
-    if (looksLikeStockCodexGitActionPrompt(prompt))
-        return true;
-    if (appSignal)
-        return true;
-    return !looksLikeUserImplementationRequest(prompt);
-}
-function looksLikeStockCodexGitActionPrompt(prompt = '') {
-    const text = String(prompt || '').trim();
-    if (!text || text.length > 120)
-        return false;
-    return /^(?:generate\s+(?:a\s+)?git\s+commit\s+message(?:\s+for\s+(?:the\s+)?(?:staged\s+)?diff)?|commit\s+changes|commit\s+and\s+push\s+changes|push\s+changes|create\s+(?:a\s+)?commit|create\s+(?:a\s+)?pull\s+request)\.?$/i.test(text);
-}
-function looksLikeCodexGitActionStopCompletion(last = '', payload = {}) {
-    const text = String(last || '').trim();
-    const metadataText = codexGitActionMetadataText(payload);
-    const haystack = [
-        metadataText,
-        payload.action,
-        payload.intent,
-        payload.operation,
-        payload.kind,
-        payload.type,
-        payload.feature,
-        payload.source,
-        payload.event,
-        payload.metadata?.action,
-        payload.metadata?.intent,
-        payload.metadata?.operation,
-        payload.metadata?.feature,
-        payload.metadata?.source
-    ].filter(Boolean).join(' ');
-    if (codexGitActionMetadataSignal(metadataText))
-        return true;
-    if (/\bcodex[_\s-]*app\b[\s\S]{0,80}\bgit\b[\s\S]{0,80}\b(?:action|commit|push|pr)\b/i.test(haystack))
-        return true;
-    if (!text || text.length > 180)
-        return false;
-    return /^(?:commit(?:ted)?(?:\s+and\s+pushed)?(?:\s+changes)?(?:\s+complete[.!]?)?|push(?:ed)?(?:\s+changes)?(?:\s+complete[.!]?)?|created\s+(?:a\s+)?pull\s+request[.!]?)$/i.test(text);
-}
-function looksLikeUserImplementationRequest(text = '') {
-    return /(fix|bug|broken|error|issue|implement|change|update|repair|수정|버그|오류|에러|문제|고쳐|고치|해결|변경|수리|패치|안생기|안\s*생기)/i.test(String(text || ''));
-}
 async function armCodexGitActionStopBypass(root, payload = {}) {
     const nowMs = Date.now();
     const record = {