sneakoscope 6.4.0 → 6.7.0

package/dist/core/commands/naruto-command.js

@@ -1,15 +1,21 @@
 import path from 'node:path';
 import { ui as cliUi } from '../../cli/cli-theme.js';
-import { createMission, findLatestMission, getOrCreateSessionMission, loadStateForSession, loadMission, sessionStateKey, setCurrent } from '../mission.js';
+import { createMission, findLatestMission, getOrCreateSessionMission, loadStateForSession, loadMission, sessionStateKey, setCurrent, updateCurrentIfMissionAndRun } from '../mission.js';
 import { closeWorkOrderLedgerForRouteResult, createAndWriteWorkOrderLedgerForPrompt } from '../work-order-ledger.js';
 import { appendJsonl, exists, nowIso, readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
 import { SUBAGENT_EVENT_LOG_FILENAME, SUBAGENT_PARENT_SUMMARY_FILENAME, bindTrustworthySubagentParentSummaryToRun, persistOrReuseTrustworthySubagentParentSummary, readSubagentEvents, writeSubagentEvidence } from '../subagents/subagent-evidence.js';
 import { buildNarutoHelpResult } from '../subagents/naruto-help-contract.js';
+import { buildNarutoProofProjection } from '../subagents/naruto-proof-projection.js';
 import { withFileLock } from '../locks/file-lock.js';
 import { codexAppSessionKey, detectCodexAppSession, runOfficialSubagentWorkflow } from '../subagents/official-subagent-runner.js';
-import { NARUTO_GATE_FILENAME, NARUTO_RESULT_SCHEMA, NARUTO_SUMMARY_FILENAME, SUBAGENT_PLAN_FILENAME, buildNarutoGateResult, buildNarutoSummary, prepareOfficialSubagentMission, writeNarutoGate } from '../subagents/official-subagent-preparation.js';
+import { NARUTO_GATE_FILENAME, NARUTO_RESULT_SCHEMA, NARUTO_SUMMARY_FILENAME, SUBAGENT_PLAN_FILENAME, buildNarutoGateResult, buildNarutoSummary, officialSubagentPreparationInProgress, prepareOfficialSubagentMission, withOfficialSubagentLifecycleLock, withNarutoMissionRunAdmission, writeNarutoGate } from '../subagents/official-subagent-preparation.js';
 import { recordOfficialSubagentParentOutcomesTelemetry } from '../zellij/zellij-official-subagent-telemetry.js';
+import { effectiveSubagentTarget, refreshSubagentWaveLifecycle } from '../subagents/wave-lifecycle.js';
 export { buildNarutoGateResult } from '../subagents/official-subagent-preparation.js';
+let nextNarutoPreparationFailureInjectionForTest = null;
+export function injectNextNarutoPreparationFailureForTest(value) {
+    nextNarutoPreparationFailureInjectionForTest = value;
+}
 export async function narutoCommand(commandOrArgs = 'naruto', maybeArgs = []) {
     const args = Array.isArray(commandOrArgs) ? commandOrArgs.map(String) : maybeArgs.map(String);
     if (args.some((arg) => arg === '--glm' || arg.startsWith('--glm=')))
@@ -43,21 +49,30 @@ async function narutoRun(parsed) {
             staleMs: 120_000
         }, () => narutoRunTransaction(parsed, root, appSession, sessionKey));
     }
-    return narutoRunTransaction(parsed, root, appSession, sessionKey);
-}
-async function narutoRunTransaction(parsed, root, appSession, sessionKey) {
+    if (appSession)
+        return narutoRunTransaction(parsed, root, true, null);
     const mission = await resolveRunMission(root, parsed, sessionKey);
-    if (!mission) {
-        return emit(parsed, {
-            schema: NARUTO_RESULT_SCHEMA,
-            ok: false,
-            status: 'blocked',
-            blockers: [`naruto_mission_not_found:${parsed.missionId}`]
-        }, () => console.error(`Naruto mission not found: ${parsed.missionId}`), true);
-    }
+    if (!mission)
+        return missingRunMission(parsed);
+    const admission = await withNarutoMissionRunAdmission({
+        missionId: mission.id,
+        missionDir: mission.dir,
+        prompt: parsed.prompt
+    }, (lease) => narutoRunTransaction(parsed, root, false, null, mission, lease));
+    if (admission.kind === 'executed')
+        return admission.value;
+    const response = admission.kind === 'reused'
+        ? { ...admission.response, artifacts: terminalNarutoArtifactLinks(admission.response) }
+        : admission.response;
+    return emit(parsed, response, () => renderRunResult(response), response.status === 'blocked');
+}
+async function narutoRunTransaction(parsed, root, appSession, sessionKey, resolvedMission, missionLease) {
+    const mission = resolvedMission || await resolveRunMission(root, parsed, sessionKey);
+    if (!mission)
+        return missingRunMission(parsed);
     const { id, dir } = mission;
     if (appSession && sessionKey) {
-        const pending = await readPendingAppNarutoRun(root, { id, dir }, sessionKey);
+        const pending = await readPendingAppNarutoRun(root, { id, dir }, sessionKey, parsed.prompt);
         if (pending)
             return emit(parsed, pending, () => renderRunResult(pending));
     }
@@ -66,11 +81,9 @@ async function narutoRunTransaction(parsed, root, appSession, sessionKey) {
         route: 'Naruto',
         prompt: parsed.prompt
     });
-    const preparation = await withFileLock({
-        lockPath: path.join(dir, '.naruto-preparation.lock'),
-        timeoutMs: 5_000,
-        staleMs: 60_000
-    }, () => prepareOfficialSubagentMission({
+    const preparationFailureInjection = nextNarutoPreparationFailureInjectionForTest;
+    nextNarutoPreparationFailureInjectionForTest = null;
+    const preparation = await prepareOfficialSubagentMission({
         root,
         dir,
         missionId: id,
@@ -82,31 +95,43 @@ async function narutoRunTransaction(parsed, root, appSession, sessionKey) {
         ...(parsed.maxThreads === undefined ? {} : { maxThreads: parsed.maxThreads }),
         mode: 'naruto',
         readOnly: parsed.readOnly,
-        preparationOnly: true
-    }));
+        preparationOnly: true,
+        ...(preparationFailureInjection ? { failureInjection: preparationFailureInjection } : {}),
+        statePatch: ({ budget: preparedBudget, workflowRunId: preparedRunId }) => ({
+            mission_id: id,
+            route: 'Naruto',
+            route_command: '$Naruto',
+            mode: 'NARUTO',
+            phase: 'NARUTO_DELEGATION_CONTEXT_READY',
+            questions_allowed: false,
+            implementation_allowed: true,
+            subagents_required: true,
+            subagents_verified: false,
+            subagents_spawned: false,
+            subagents_reported: false,
+            subagent_evidence_file: 'subagent-evidence.json',
+            parent_summary_present: false,
+            native_sessions_required: false,
+            native_sessions_verified: false,
+            agents_required: false,
+            requested_subagents: preparedBudget.requestedSubagents,
+            target_subagents: preparedBudget.requestedSubagents,
+            max_threads: preparedBudget.maxThreads,
+            max_depth: preparedBudget.maxDepth,
+            official_subagent_run_id: preparedRunId,
+            session_scope: sessionKey,
+            stop_gate: NARUTO_GATE_FILENAME,
+            naruto_gate_file: NARUTO_GATE_FILENAME,
+            naruto_gate_passed: false,
+            reflection_invalidation_required: false,
+            reflection_invalidated_at: null,
+            reflection_invalidation_reason: null,
+            reflection_invalidated_for_workflow_run_id: null,
+            reflection_invalidated_for_proof_digest: null,
+            prompt: parsed.prompt
+        })
+    });
     const { plan, evidence: preparationEvidence, budget, verification, delegationPrompt, workflowRunId, configBlockers } = preparation;
-    await setCurrent(root, {
-        mission_id: id,
-        route: 'Naruto',
-        route_command: '$Naruto',
-        mode: 'NARUTO',
-        phase: 'NARUTO_DELEGATION_CONTEXT_READY',
-        questions_allowed: false,
-        implementation_allowed: true,
-        subagents_required: true,
-        subagents_verified: false,
-        native_sessions_required: false,
-        native_sessions_verified: false,
-        agents_required: false,
-        requested_subagents: budget.requestedSubagents,
-        max_threads: budget.maxThreads,
-        max_depth: budget.maxDepth,
-        official_subagent_run_id: workflowRunId,
-        session_scope: sessionKey,
-        stop_gate: NARUTO_GATE_FILENAME,
-        naruto_gate_file: NARUTO_GATE_FILENAME,
-        prompt: parsed.prompt
-    }, { sessionKey });
     const run = await runOfficialSubagentWorkflow({
         root,
         prompt: delegationPrompt,
@@ -114,117 +139,149 @@ async function narutoRunTransaction(parsed, root, appSession, sessionKey) {
         maxThreads: budget.maxThreads,
         appSession,
         missionId: id,
-        sessionKey
-    });
-    const completedPlan = await readJson(path.join(dir, SUBAGENT_PLAN_FILENAME), plan).catch(() => plan);
-    const finalBudget = {
-        ...budget,
-        requestedSubagents: Number(completedPlan?.requested_subagents || budget.requestedSubagents),
-        maxThreads: Number(completedPlan?.max_threads || budget.maxThreads),
-        firstWave: Number(completedPlan?.first_wave ?? budget.firstWave),
-        waveCount: Number(completedPlan?.wave_count ?? budget.waveCount),
-        capacity: completedPlan?.capacity_controller || budget.capacity
-    };
-    const runBoundParentSummary = bindTrustworthySubagentParentSummaryToRun(run.parent_summary, workflowRunId);
-    const effectiveParentSummary = await persistOrReuseTrustworthySubagentParentSummary(dir, runBoundParentSummary, {
-        workflowStatus: run.status,
-        runId: workflowRunId
-    });
-    const evidence = await writeSubagentEvidence(dir, {
-        requestedSubagents: finalBudget.requestedSubagents,
-        parentSummary: effectiveParentSummary,
-        workflowStatus: run.status,
-        preparationOnly: appSession,
-        runId: workflowRunId,
-        additionalBlockers: configBlockers
+        sessionKey,
+        ...(missionLease ? { onChildSpawn: missionLease.protectChildPid } : {})
     });
-    if (!appSession) {
-        const parentTelemetry = await recordOfficialSubagentParentOutcomesTelemetry({
-            root,
-            routeMissionId: id,
-            parentSummary: effectiveParentSummary,
-            plan: completedPlan
-        }).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(() => undefined);
+    const result = await withOfficialSubagentLifecycleLock(dir, async () => {
+        if (await officialSubagentPreparationInProgress(dir))
             return null;
+        const completedPlan = await readJson(path.join(dir, SUBAGENT_PLAN_FILENAME), plan).catch(() => plan);
+        if (String(completedPlan?.workflow_run_id || '').trim() !== workflowRunId)
+            return null;
+        const finalBudget = {
+            ...budget,
+            requestedSubagents: Number(completedPlan?.requested_subagents || budget.requestedSubagents),
+            maxThreads: Number(completedPlan?.max_threads || budget.maxThreads),
+            firstWave: Number(completedPlan?.first_wave ?? budget.firstWave),
+            waveCount: Number(completedPlan?.wave_count ?? budget.waveCount),
+            capacity: completedPlan?.capacity_controller || budget.capacity
+        };
+        const runBoundParentSummary = bindTrustworthySubagentParentSummaryToRun(run.parent_summary, workflowRunId);
+        const effectiveParentSummary = await persistOrReuseTrustworthySubagentParentSummary(dir, runBoundParentSummary, {
+            workflowStatus: run.status,
+            runId: workflowRunId
+        });
+        const waveLifecycle = await refreshSubagentWaveLifecycle(dir, {
+            plan: completedPlan
+        }).catch(() => completedPlan?.wave_lifecycle || null);
+        const countTarget = effectiveSubagentTarget(waveLifecycle ? { ...completedPlan, wave_lifecycle: waveLifecycle } : completedPlan, waveLifecycle?.cumulative_started || 0);
+        const evidence = await writeSubagentEvidence(dir, {
+            requestedSubagents: finalBudget.requestedSubagents,
+            countPolicy: countTarget.countPolicy,
+            targetSubagents: countTarget.targetSubagents,
+            parentSummary: effectiveParentSummary,
+            workflowStatus: run.status,
+            preparationOnly: appSession,
+            runId: workflowRunId,
+            additionalBlockers: configBlockers
         });
-        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(() => undefined);
+        if (!appSession) {
+            const parentTelemetry = await recordOfficialSubagentParentOutcomesTelemetry({
+                root,
+                routeMissionId: id,
+                parentSummary: effectiveParentSummary,
+                plan: completedPlan
+            }).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(() => undefined);
+                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(() => undefined);
+            }
         }
-    }
-    const candidatePassed = run.ok === true && evidence.ok === true && appSession === false;
-    const blockers = uniqueStrings([
-        ...(Array.isArray(evidence.blockers) ? evidence.blockers : []),
-        ...configBlockers,
-        ...(!appSession && run.ok !== true ? [`codex_parent_exit:${String(run.codex_exit_code ?? 'unknown')}`] : []),
-        ...(appSession ? ['official_subagent_execution_pending_in_current_parent'] : [])
-    ]);
-    const gate = await writeNarutoGate(dir, {
-        missionId: id,
-        workflowRunId,
-        evidence,
-        passed: candidatePassed,
-        blockers
-    });
-    const passed = gate.passed === true;
-    const status = passed
-        ? 'completed'
-        : appSession
-            ? 'delegation_context_ready'
-            : run.ok === true
-                ? 'incomplete'
-                : 'blocked';
-    const summary = buildNarutoSummary({
-        missionId: id,
-        workflowRunId,
-        budget: finalBudget,
-        evidence,
-        verification,
-        status,
-        ok: passed,
-        parentSummary: effectiveParentSummary,
-        blockers: gate.blockers,
-        appSession,
-        sessionKey,
-        suggestedAgents: Array.isArray(completedPlan?.suggested_agents) ? completedPlan.suggested_agents : []
+        const candidatePassed = run.ok === true && evidence.ok === true && appSession === false;
+        const blockers = uniqueStrings([
+            ...(Array.isArray(evidence.blockers) ? evidence.blockers : []),
+            ...configBlockers,
+            ...(Array.isArray(run.blockers) ? run.blockers : []),
+            ...(appSession ? ['official_subagent_execution_pending_in_current_parent'] : [])
+        ]);
+        const gate = await writeNarutoGate(dir, {
+            missionId: id,
+            workflowRunId,
+            evidence,
+            passed: candidatePassed,
+            blockers
+        });
+        const passed = gate.passed === true;
+        const status = passed
+            ? 'completed'
+            : appSession
+                ? 'delegation_context_ready'
+                : run.ok === true
+                    ? 'incomplete'
+                    : 'blocked';
+        const summary = buildNarutoSummary({
+            missionId: id,
+            workflowRunId,
+            budget: finalBudget,
+            evidence,
+            verification,
+            status,
+            ok: passed,
+            parentSummary: effectiveParentSummary,
+            blockers: gate.blockers,
+            appSession,
+            sessionKey,
+            suggestedAgents: Array.isArray(completedPlan?.suggested_agents) ? completedPlan.suggested_agents : [],
+            waveLifecycle
+        });
+        await writeJsonAtomic(path.join(dir, NARUTO_SUMMARY_FILENAME), summary);
+        await updateCurrentIfMissionAndRun(root, id, workflowRunId, {
+            mission_id: id,
+            official_subagent_run_id: workflowRunId,
+            session_scope: sessionKey,
+            phase: passed ? 'NARUTO_COMPLETE' : appSession ? 'NARUTO_DELEGATION_CONTEXT_READY' : 'NARUTO_BLOCKED',
+            subagents_verified: evidence.ok === true,
+            requested_subagents: finalBudget.requestedSubagents,
+            target_subagents: evidence.target_subagents,
+            max_threads: finalBudget.maxThreads,
+            naruto_gate_passed: passed,
+            route_closed: false
+        }, { sessionKey });
+        if (!appSession) {
+            await closeWorkOrderLedgerForRouteResult(dir, { ok: passed, blockers: gate.blockers });
+            if (!passed)
+                process.exitCode = 1;
+        }
+        return {
+            ...summary,
+            mission_id: id,
+            attached_to_pending_run: false,
+            additionalContext: appSession ? run.additionalContext : undefined,
+            artifacts: narutoArtifactLinks(evidence)
+        };
     });
-    await writeJsonAtomic(path.join(dir, NARUTO_SUMMARY_FILENAME), summary);
-    await setCurrent(root, {
-        mission_id: id,
-        official_subagent_run_id: workflowRunId,
-        session_scope: sessionKey,
-        phase: passed ? 'NARUTO_COMPLETE' : appSession ? 'NARUTO_DELEGATION_CONTEXT_READY' : 'NARUTO_BLOCKED',
-        subagents_verified: evidence.ok === true,
-        requested_subagents: finalBudget.requestedSubagents,
-        max_threads: finalBudget.maxThreads,
-        naruto_gate_passed: passed,
-        route_closed: false
-    }, { sessionKey });
-    if (!appSession) {
-        await closeWorkOrderLedgerForRouteResult(dir, { ok: passed, blockers: gate.blockers });
-        if (!passed)
-            process.exitCode = 1;
+    if (!result) {
+        const currentSummary = await readJson(path.join(dir, NARUTO_SUMMARY_FILENAME), null).catch(() => null);
+        const currentEvidence = await readJson(path.join(dir, 'subagent-evidence.json'), null).catch(() => null);
+        const staleResult = {
+            ...(currentSummary || {}),
+            schema: NARUTO_RESULT_SCHEMA,
+            ok: currentSummary?.ok === true,
+            completion_evidence: currentSummary?.completion_evidence === true,
+            mission_id: id,
+            attached_to_pending_run: true,
+            stale_run_discarded: workflowRunId,
+            artifacts: narutoArtifactLinks(currentEvidence)
+        };
+        return emit(parsed, staleResult, () => renderRunResult(staleResult));
     }
-    const result = {
-        ...summary,
-        mission_id: id,
-        attached_to_pending_run: false,
-        additionalContext: appSession ? run.additionalContext : undefined,
-        artifacts: narutoArtifactLinks(evidence)
-    };
     return emit(parsed, result, () => renderRunResult(result));
 }
-async function readPendingAppNarutoRun(root, mission, sessionKey) {
+async function readPendingAppNarutoRun(root, mission, sessionKey, prompt) {
+    if (await officialSubagentPreparationInProgress(mission.dir))
+        return null;
     const [plan, evidence, summary, gate, state] = await Promise.all([
         readJson(path.join(mission.dir, SUBAGENT_PLAN_FILENAME), null),
         readJson(path.join(mission.dir, 'subagent-evidence.json'), null),
@@ -238,6 +295,7 @@ async function readPendingAppNarutoRun(root, mission, sessionKey) {
         && plan?.schema === 'sks.subagent-plan.v1'
         && plan?.workflow === 'official_codex_subagent'
         && plan?.mission_id === mission.id
+        && String(plan?.goal || '').trim() === String(prompt || '').trim()
         && plan?.session_scope === sessionKey
         && evidence?.run_id === workflowRunId
         && evidence?.preparation_only === true
@@ -285,6 +343,16 @@ function narutoArtifactLinks(evidence) {
         gate: NARUTO_GATE_FILENAME
     };
 }
+function terminalNarutoArtifactLinks(response) {
+    return {
+        plan: SUBAGENT_PLAN_FILENAME,
+        events: SUBAGENT_EVENT_LOG_FILENAME,
+        parent_summary: response.parent_summary_present === true ? SUBAGENT_PARENT_SUMMARY_FILENAME : null,
+        evidence: 'subagent-evidence.json',
+        summary: NARUTO_SUMMARY_FILENAME,
+        gate: NARUTO_GATE_FILENAME
+    };
+}
 async function narutoStatus(parsed) {
     const resolved = await resolveReadMission(parsed);
     if (!resolved)
@@ -302,7 +370,10 @@ async function narutoStatus(parsed) {
         mission_id: resolved.id,
         status: summary?.status || evidence?.status || 'prepared',
         requested_subagents: plan?.requested_subagents ?? evidence?.requested_subagents ?? null,
+        count_policy: evidence?.count_policy ?? plan?.wave_lifecycle?.count_policy ?? null,
+        target_subagents: evidence?.target_subagents ?? plan?.wave_lifecycle?.target_subagents ?? null,
         max_threads: plan?.max_threads ?? null,
+        wave_lifecycle: plan?.wave_lifecycle ?? null,
         started_subagents: evidence?.started_threads ?? 0,
         completed_subagents: evidence?.completed_threads ?? 0,
         failed_subagents: evidence?.failed_threads ?? 0,
@@ -325,6 +396,8 @@ async function narutoSubagents(parsed) {
         action: 'subagents',
         mission_id: resolved.id,
         requested_subagents: evidence?.requested_subagents ?? null,
+        count_policy: evidence?.count_policy ?? null,
+        target_subagents: evidence?.target_subagents ?? null,
         started_subagents: evidence?.started_threads ?? 0,
         completed_subagents: evidence?.completed_threads ?? 0,
         failed_subagents: evidence?.failed_threads ?? 0,
@@ -339,25 +412,11 @@ async function narutoProof(parsed) {
     const resolved = await resolveReadMission(parsed);
     if (!resolved)
         return missingMission(parsed, 'proof');
-    const [evidence, summary, gate] = await Promise.all([
-        readJson(path.join(resolved.dir, 'subagent-evidence.json'), null),
-        readJson(path.join(resolved.dir, NARUTO_SUMMARY_FILENAME), null),
-        readJson(path.join(resolved.dir, NARUTO_GATE_FILENAME), null)
-    ]);
-    const result = {
-        schema: NARUTO_RESULT_SCHEMA,
-        ok: gate?.passed === true && evidence?.ok === true,
-        action: 'proof',
-        mission_id: resolved.id,
-        workflow: 'official_codex_subagent',
-        evidence,
-        summary,
-        gate
-    };
+    const result = await buildNarutoProofProjection({ artifactDir: resolved.dir, missionId: resolved.id });
     return emit(parsed, result, () => {
-        console.log(`Naruto proof ${resolved.id}: ${result.ok ? 'passed' : 'incomplete'}`);
-        if (Array.isArray(gate?.blockers) && gate.blockers.length)
-            console.log(`Blockers: ${gate.blockers.join(', ')}`);
+        console.log(`Naruto proof ${resolved.id}: ${result.status}`);
+        if (result.blockers?.length)
+            console.log(`Blockers: ${result.blockers.join(', ')}`);
     });
 }
 function narutoHelp(parsed) {
@@ -391,6 +450,7 @@ async function resolveRunMission(root, parsed, sessionKey = null) {
             mode: 'naruto',
             prompt: parsed.prompt,
             sessionKey,
+            syncRequestIntake: true,
             selectMissionId: (state) => {
                 const route = String(state?.route || state?.route_command || state?.mode || '').replace(/^\$/, '').toUpperCase();
                 const sessionMatches = state?._session_key === sessionStateKey(sessionKey);
@@ -502,19 +562,10 @@ export function parseNarutoArgs(args) {
 }
 function positionalValues(args) {
     const valueFlags = new Set([
-        '--agents', '--max-threads', '--mission', '--mission-id',
-        '--backend', '--concurrency', '--target-active-slots', '--work-items',
-        '--write-mode', '--max-write-agents', '--service-tier', '--messages',
-        '--parallelism', '--tournament', '--ollama-model', '--local-model-model',
-        '--ollama-base-url', '--local-model-base-url', '--scheduler', '--scheduler-mode',
-        '--pool', '--pool-size', '--model', '--parent-model', '--worker-model',
-        '--expert-model', '--agent-model', '--clone-model', '--reasoning-effort', '--engine'
+        '--agents', '--max-threads', '--mission', '--mission-id'
     ]);
     const booleanFlags = new Set([
-        '--json', '--readonly', '--read-only', '--real', '--mock', '--no-open-zellij',
-        '--no-zellij', '--attach', '--smoke', '--apply-patches', '--dry-run-patches',
-        '--dry-run-patch', '--ollama', '--local-model', '--no-ollama', '--no-local-model',
-        '--parallel-write', '--fast', '--no-fast'
+        '--json', '--readonly', '--read-only'
     ]);
     const result = [];
     for (let index = 0; index < args.length; index += 1) {
@@ -637,6 +688,14 @@ function missingMission(parsed, action) {
         status: 'missing_mission'
     }, () => console.log('No Naruto mission found.'));
 }
+function missingRunMission(parsed) {
+    return emit(parsed, {
+        schema: NARUTO_RESULT_SCHEMA,
+        ok: false,
+        status: 'blocked',
+        blockers: [`naruto_mission_not_found:${parsed.missionId}`]
+    }, () => console.error(`Naruto mission not found: ${parsed.missionId}`), true);
+}
 function emit(parsed, result, human, failed = false) {
     if (failed)
         process.exitCode = 1;
@@ -648,7 +707,7 @@ function emit(parsed, result, human, failed = false) {
 }
 function renderRunResult(result) {
     console.log(`$sks-naruto ${result.status}: ${result.mission_id}`);
-    console.log(`Official subagents: requested ${result.requested_subagents}, max threads ${result.max_threads}`);
+    console.log(`Official subagents: requested ${result.requested_subagents}, target ${result.target_subagents ?? result.requested_subagents}, policy ${result.count_policy || 'exact'}, max threads ${result.max_threads}`);
     console.log(`Started/completed/failed: ${result.started_subagents}/${result.completed_subagents}/${result.failed_subagents}`);
     if (result.status === 'delegation_context_ready')
         console.log('Continue in the current Codex parent and wait for every requested subagent before summarizing.');
@@ -657,6 +716,7 @@ function renderRunResult(result) {
 }
 function renderStatusResult(result) {
     console.log(`Naruto ${result.action || 'status'}: ${result.mission_id}`);
+    console.log(`Requested/target/policy: ${result.requested_subagents ?? 0}/${result.target_subagents ?? result.requested_subagents ?? 0}/${result.count_policy || 'exact'}`);
     console.log(`Started/completed/failed: ${result.started_subagents || 0}/${result.completed_subagents || 0}/${result.failed_subagents || 0}`);
 }
 function uniqueStrings(values) {

package/dist/core/doctor/current-project-guidance.js

@@ -10,7 +10,7 @@ import { inspectConfinedPath, moveConfinedPath, removeManagedPathVerified, uniqu
 import { collectNestedProjectRoots } from './current-project-guidance-nested.js';
 export const CURRENT_PROJECT_GUIDANCE_SCHEMA = 'sks.current-project-guidance.v1';
 const AGENTS_MARKER = 'BEGIN Sneakoscope Codex GX MANAGED BLOCK';
-const RETIRED_COMMAND_NAMES = ['team', 'mad-db', 'tmux', 'xai', 'swarm', 'agent', 'ralph', 'db'];
+const RETIRED_COMMAND_NAMES = ['team', 'mad-db', 'tmux', 'xai', 'swarm', 'agent', 'ralph', 'db', 'ui'];
 const RETIRED_DOLLAR_COMMAND_NAMES = ['Agent', 'Team', 'MAD-DB', 'Swarm', 'ShadowClone', 'Kagebunshin', 'Ralph'];
 const LEGACY_UNPREFIXED_DOLLAR_COMMAND_NAMES = Array.from(new Set([
     ...RETIRED_DOLLAR_COMMAND_NAMES,

package/dist/core/doctor/doctor-dirty-planner.js

@@ -123,7 +123,7 @@ function phaseInputFiles(id) {
         return ['src/core/codex-native', 'src/scripts/native-capability-postcheck-check.ts'];
     if (id.includes('secret'))
         return ['safety-mutation-allowlist.json', 'src/scripts/secret-preservation-check.ts'];
-    return ['package.json', 'config/codex-releases/rust-v0.144.1.json'];
+    return ['package.json', 'config/codex-releases/rust-v0.144.5.json'];
 }
 function packageIdentity() {
     const root = packageRoot();

package/dist/core/doctor/retired-managed-residue-missions.js

@@ -132,31 +132,46 @@ export async function reconcileMissionIndex(root, fix, quarantineRoot, counters)
         return;
     }
     const value = await readJson(file, null).catch(() => null);
-    if (!value || !Array.isArray(value.missions))
+    const indexSchemaCurrent = value?.schema === 'sks.mission-index.v1';
+    const missionRows = Array.isArray(value?.missions) ? value.missions : [];
+    const retiredRows = missionRows.filter((row) => isRetiredMissionIdentity(row));
+    const retiredCount = retiredRows.length;
+    const malformedOrForeign = !value || !indexSchemaCurrent || !Array.isArray(value?.missions);
+    if (!malformedOrForeign && retiredCount === 0)
         return;
-    const retiredCount = value.missions.filter((row) => isRetiredMissionIdentity(row)).length;
-    if (retiredCount === 0)
-        return;
-    counters.detected += retiredCount;
+    const retiredMissionIds = retiredRows
+        .map((row) => String(row?.id || ''))
+        .filter(Boolean);
+    const detectedCount = Math.max(1, retiredCount);
+    counters.detected += detectedCount;
     if (!fix) {
-        counters.remaining += retiredCount;
-        if (value.schema !== 'sks.mission-index.v1')
+        counters.remaining += detectedCount;
+        if (malformedOrForeign)
             counters.preserved += 1;
         return;
     }
     try {
-        if (value.schema !== 'sks.mission-index.v1') {
+        if (malformedOrForeign) {
             await quarantineUserPath(root, file, quarantineRoot);
             counters.preserved += 1;
         }
+        const verifiedRetiredMissionIds = [];
+        for (const missionId of retiredMissionIds) {
+            const mission = await readJson(path.join(root, '.sneakoscope', 'missions', missionId, 'mission.json'), null).catch(() => null);
+            if (mission && isRetiredMissionIdentity(mission))
+                verifiedRetiredMissionIds.push(missionId);
+        }
         const { refreshMissionIndex } = await import('../retention.js');
-        await refreshMissionIndex(root);
-        counters.removed += retiredCount;
+        const refreshed = await refreshMissionIndex(root, { excludeMissionIds: verifiedRetiredMissionIds });
+        if (refreshed.missions.some((row) => isRetiredMissionIdentity(row))) {
+            throw new Error('retired_mission_index_identity_survived');
+        }
+        counters.removed += detectedCount;
         counters.rewrittenState += 1;
     }
     catch {
         counters.errors += 1;
-        counters.remaining += retiredCount;
+        counters.remaining += detectedCount;
     }
 }
 async function reconcileSksOwnedRetiredMission(root, missionRoot, missionRecord, fix, quarantineRoot, counters) {

package/dist/core/doctor/retired-managed-residue-private.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { inspectConfinedPath, moveConfinedPath, removeEmptyTreeVerified, uniqueConfinedPath, walkConfinedEntries } from '../managed-path-safety.js';
 /** Cleanup-only inventory. These names are never registered, listed, or redirected. */
-export const REMOVED_PUBLIC_COMMANDS = ['team', 'mad-db', 'tmux', 'xai', 'swarm', 'agent', 'ralph'];
+export const REMOVED_PUBLIC_COMMANDS = ['team', 'mad-db', 'tmux', 'xai', 'swarm', 'agent', 'ralph', 'ui'];
 const RETIRED_COMMAND_TOMBSTONES = new Set(REMOVED_PUBLIC_COMMANDS);
 const RETIRED_MISSION_MODES = new Set([
     ...REMOVED_PUBLIC_COMMANDS,