sneakoscope 6.0.3 → 6.1.2

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

@@ -1,1232 +1,722 @@
-import fs from 'node:fs';
 import path from 'node:path';
 import { ui as cliUi } from '../../cli/cli-theme.js';
-import { createMission, findLatestMission, loadMission, setCurrent } from '../mission.js';
-import { createAndWriteWorkOrderLedgerForPrompt, closeWorkOrderLedgerForRouteResult } from '../work-order-ledger.js';
-import { nowIso, readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
-import { runNativeAgentOrchestrator } from '../agents/agent-orchestrator.js';
-import { classifyOllamaWorkerSlice } from '../agents/agent-runner-ollama.js';
-import { buildNarutoCloneRoster, systemSafeNarutoConcurrency } from '../agents/agent-roster.js';
-import { DEFAULT_NARUTO_CLONES, MAX_NARUTO_AGENT_COUNT } from '../agents/agent-schema.js';
-import { normalizeServiceTier } from '../agents/fast-mode-policy.js';
-import { resolveOllamaWorkerConfig } from '../agents/ollama-worker-config.js';
-import { attachZellijSessionInteractive, launchZellijLayout } from '../zellij/zellij-launcher.js';
-import { maybePromptZellijUpdateForLaunch } from '../zellij/zellij-update.js';
-import { buildNarutoWorkGraph } from '../naruto/naruto-work-graph.js';
-import { buildNarutoRoleDistribution } from '../naruto/naruto-role-policy.js';
-import { decideNarutoConcurrency } from '../naruto/naruto-concurrency-governor.js';
-import { runNarutoRealActivePool } from '../naruto/naruto-active-pool.js';
-import { collectActualNarutoWorker, killAllActiveNarutoWorkers, spawnActualNarutoWorker } from '../naruto/naruto-real-worker-runtime.js';
-import { runZellij } from '../zellij/zellij-command.js';
-import { allocateNarutoTasksToWorkers } from '../naruto/naruto-allocation-policy.js';
-import { rebalanceNarutoReadyWork } from '../naruto/naruto-rebalance-policy.js';
-import { buildNarutoVerificationDag } from '../naruto/naruto-verification-dag.js';
-import { runNarutoVerificationPool } from '../naruto/naruto-verification-pool.js';
-import { evaluateNarutoFinalizer } from '../naruto/naruto-finalizer.js';
-import { buildNarutoGptFinalPack } from '../naruto/naruto-gpt-final-pack.js';
-import { planNarutoZellijDashboard } from '../zellij/zellij-naruto-dashboard.js';
-import { checkPromptPlaceholders } from '../prompt/prompt-placeholder-guard.js';
-import { evaluateGitWorktreeCapability } from '../git/git-worktree-capability.js';
-import { buildNarutoRealWriteProof } from '../naruto/naruto-real-write-proof.js';
-import { buildRuntimeProofSummary, renderRuntimeProofSummary } from '../agents/runtime-proof-summary.js';
-import { writeCodex0138CapabilityArtifacts } from '../codex-control/codex-0138-capability.js';
-import { writeCodex0139CapabilityArtifacts } from '../codex-control/codex-0139-capability.js';
-import { writeFinalStopGate } from '../stop-gate/stop-gate-writer.js';
-import { extractNarutoPromptPaths } from '../naruto/naruto-task-hints.js';
-const NARUTO_RESULT_SCHEMA = 'sks.naruto-command-result.v1';
-const NARUTO_ROUTE = '$Naruto';
-// $Naruto — Shadow Clone Swarm (影分身 / Kage Bunshin no Jutsu).
-// A high-scale variant of the native agent orchestrator that fans out up to
-// MAX_NARUTO_AGENT_COUNT (100) identical clone sessions in parallel, reusing the
-// proven scheduler / work-queue / patch-swarm machinery (lease-based safe parallel
-// writes). The standard 20-agent ceiling is lifted only for this route.
+import { createMission, findLatestMission, getOrCreateSessionMission, loadStateForSession, loadMission, sessionStateKey, setCurrent } 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 { withFileLock } from '../locks/file-lock.js';
+import { resolveSubagentThreadBudget } from '../subagents/thread-budget.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 { recordOfficialSubagentParentOutcomesTelemetry } from '../zellij/zellij-official-subagent-telemetry.js';
+export { buildNarutoGateResult } from '../subagents/official-subagent-preparation.js';
+const LEGACY_FLAG_WARNING = 'SKS: --clones is deprecated; use --agents. Naruto now uses Codex subagents.';
+const LEGACY_WORKERS_WARNING = 'SKS: naruto workers is deprecated; use naruto subagents.';
+const REMOVED_LEGACY_SUBCOMMANDS = new Set(['dashboard']);
 export async function narutoCommand(commandOrArgs = 'naruto', maybeArgs = []) {
-    const args = Array.isArray(commandOrArgs) ? commandOrArgs : maybeArgs;
-    // Normal Naruto is a GPT-5.6-family-only route. Keep the historical GLM
-    // implementation reachable only through the explicitly separate
-    // `sks --mad --glm --naruto` global mode; a command-local --glm flag must
-    // never bypass the Luna/Terra/Sol catalog and backend guards below.
-    if (args.includes('--glm')) {
-        const result = {
-            schema: 'sks.naruto-command-result.v1',
-            ok: false,
-            mode: 'NARUTO',
-            status: 'blocked',
-            reason: 'naruto_gpt_5_6_family_only_glm_override_forbidden',
-            blockers: ['naruto_gpt_5_6_family_only_glm_override_forbidden'],
-            hint: 'Use normal sks naruto for Luna/Terra/Sol. The separate legacy GLM route requires: sks --mad --glm --naruto.'
-        };
-        process.exitCode = 1;
-        if (args.includes('--json'))
-            console.log(JSON.stringify(result, null, 2));
-        else
-            console.error(`$Naruto blocked: ${result.reason}. ${result.hint}`);
-        return result;
-    }
+    const args = Array.isArray(commandOrArgs) ? commandOrArgs.map(String) : maybeArgs.map(String);
+    if (args.some((arg) => arg === '--glm' || arg.startsWith('--glm=')))
+        return blockGlmOverride(args.includes('--json'));
     const parsed = parseNarutoArgs(args);
+    if (parsed.clonesAliasUsed)
+        console.warn(LEGACY_FLAG_WARNING);
+    if (parsed.workersAliasUsed)
+        console.warn(LEGACY_WORKERS_WARNING);
+    if (parsed.argumentErrors.length) {
+        return emit(parsed, argumentBlock(parsed.argumentErrors), () => {
+            console.error(`$Naruto argument error: ${parsed.argumentErrors.join(', ')}`);
+        }, true);
+    }
+    if (parsed.unsupportedLegacyFlags.length) {
+        return emit(parsed, legacyFlagBlock(parsed.unsupportedLegacyFlags), () => {
+            console.error('$Naruto uses only the Codex official subagent workflow. Legacy process, scheduler, pool, backend, and model flags were removed.');
+        }, true);
+    }
     if (!parsed.json)
-        cliUi.banner(parsed.action === 'run' ? 'swarm' : `naruto ${parsed.action}`);
-    if (!parsed.json && parsed.action !== 'run')
-        cliUi.ok('naruto command surface ready');
+        cliUi.banner(parsed.action === 'run' ? 'naruto subagents' : `naruto ${parsed.action}`);
     if (parsed.action === 'help')
         return narutoHelp(parsed);
     if (parsed.action === 'status')
         return narutoStatus(parsed);
-    if (parsed.action === 'dashboard')
-        return narutoDashboard(parsed);
-    if (parsed.action === 'workers')
-        return narutoWorkers(parsed);
+    if (parsed.action === 'subagents')
+        return narutoSubagents(parsed);
     if (parsed.action === 'proof')
         return narutoProof(parsed);
-    // Like the Codex CLI update prompt: check the installed zellij version and
-    // offer an upgrade to the latest stable release before the live session
-    // opens. Never blocks the run.
-    if (!parsed.json && !parsed.mock && !parsed.noOpenZellij) {
-        await maybePromptZellijUpdateForLaunch(args, { label: '$Naruto launch' }).catch(() => undefined);
-    }
     return narutoRun(parsed);
 }
 async function narutoRun(parsed) {
-    // 20차 P0-2: a real (non---mock) run must never be silently downgraded to
-    // the fake Codex SDK adapter by a stray inherited env var (leaked shell
-    // export, leftover CI job config, etc). Clear the escape hatches for this
-    // process before any codex task executes; --mock runs and NODE_ENV=test
-    // are unaffected since they set/rely on these independently downstream.
-    if (!parsed.mock && process.env.NODE_ENV !== 'test') {
-        delete process.env.SKS_CODEX_SDK_FAKE;
-        delete process.env.SKS_CODEX_SDK_FIXTURE;
-    }
     const root = await sksRoot();
-    const writeCapable = parsed.readonly !== true && parsed.writeMode !== 'off';
-    const patchEnvelopeBasePath = '.sneakoscope/naruto/patch-envelopes';
-    const explicitPromptPaths = writeCapable ? extractNarutoPromptPaths(parsed.prompt) : [];
-    // Keep an empty target list when the prompt does not name a concrete file.
-    // buildNarutoWorkGraph then derives one patch-envelope path per work item;
-    // passing the base directory as a target would collapse every write lease
-    // onto the same path and force an avoidable serial merge bottleneck.
-    const targetPaths = explicitPromptPaths;
-    const fixtureLeaseTargetsAllowed = parsed.backend === 'fake' || parsed.mock;
-    const placeholderGuard = checkPromptPlaceholders({
-        prompt: parsed.prompt,
-        writeCapable,
-        targetPaths: writeCapable
-            ? (targetPaths.length ? targetPaths : fixtureLeaseTargetsAllowed ? [patchEnvelopeBasePath] : [])
-            : []
-    });
-    if (!placeholderGuard.ok) {
-        process.exitCode = 1;
+    const appSession = detectCodexAppSession();
+    const sessionKey = appSession ? codexAppSessionKey() : null;
+    if (appSession && sessionKey) {
+        return withFileLock({
+            lockPath: path.join(root, '.sneakoscope', 'state', `naruto-session-${sessionStateKey(sessionKey)}.lock`),
+            timeoutMs: 20_000,
+            staleMs: 120_000
+        }, () => narutoRunTransaction(parsed, root, appSession, sessionKey));
+    }
+    return narutoRunTransaction(parsed, root, appSession, sessionKey);
+}
+async function narutoRunTransaction(parsed, root, appSession, sessionKey) {
+    const mission = await resolveRunMission(root, parsed, sessionKey);
+    if (!mission) {
         return emit(parsed, {
             schema: NARUTO_RESULT_SCHEMA,
             ok: false,
-            mode: 'NARUTO',
-            action: 'run',
             status: 'blocked',
-            prompt_placeholder_guard: placeholderGuard,
-            blockers: placeholderGuard.blockers,
-            hint: placeholderGuard.blockers.includes('write_capable_prompt_target_paths_empty')
-                ? 'Name the target source path(s), or run Naruto read-only discovery before starting a write-capable worker swarm.'
-                : null
-        }, () => {
-            console.log('$Naruto blocked before work graph creation: unresolved prompt placeholder or empty write target path.');
-            for (const blocker of placeholderGuard.blockers)
-                console.log('- ' + blocker);
-        });
+            blockers: [`naruto_mission_not_found:${parsed.missionId}`]
+        }, () => console.error(`Naruto mission not found: ${parsed.missionId}`), true);
     }
-    const roster = buildNarutoCloneRoster({
-        clones: parsed.clones,
-        prompt: parsed.prompt,
-        readonly: parsed.readonly,
-        maxAgentCount: MAX_NARUTO_AGENT_COUNT
-    });
-    const mission = await createMission(root, { mode: 'naruto', prompt: parsed.prompt });
-    await createAndWriteWorkOrderLedgerForPrompt(mission.dir, { missionId: mission.id, route: 'Naruto', prompt: parsed.prompt });
-    await writeCodex0138CapabilityArtifacts(root, { missionId: mission.id }).catch(() => null);
-    await writeCodex0139CapabilityArtifacts(root, { missionId: mission.id }).catch(() => null);
-    const gitWorktreeCapability = writeCapable
-        ? await evaluateGitWorktreeCapability({ root, missionId: mission.id })
-        : null;
-    const worktreePolicy = gitWorktreeCapability?.mode === 'git-worktree'
-        ? {
-            mode: 'git-worktree',
-            required: true,
-            main_repo_root: gitWorktreeCapability.detection.root,
-            worktree_root: gitWorktreeCapability.root_resolution?.root || null,
-            fallback_reason: null
-        }
-        : {
-            mode: 'patch-envelope-only',
-            required: false,
-            main_repo_root: gitWorktreeCapability?.detection.root || null,
-            worktree_root: null,
-            fallback_reason: writeCapable ? (gitWorktreeCapability?.blockers.join(';') || 'not_git_repo_or_worktree_unavailable') : 'readonly_or_write_disabled'
-        };
-    // The clone roster is the full work fan-out; live concurrency is throttled to a
-    // system-safe number so naruto never spawns the whole count at once unless an
-    // explicit operator override asks for a higher target.
-    const localWorker = await resolveNarutoLocalWorkerMode(parsed);
-    const schedulerBackend = parsed.backend;
-    const safe = systemSafeNarutoConcurrency({ backend: schedulerBackend });
-    const baseWorkGraph = buildNarutoWorkGraph({
-        prompt: parsed.prompt,
-        requestedClones: roster.agent_count,
-        totalWorkItems: parsed.workItems,
-        honorExplicitTotalWorkItems: parsed.workItemsExplicit,
-        readonly: parsed.readonly,
-        writeCapable,
-        targetPaths,
-        leaseBasePath: patchEnvelopeBasePath,
-        maxActiveWorkers: parsed.concurrency || safe.cap,
-        worktreePolicy,
-        tournament: parsed.tournament
-    });
-    const baseRoleDistribution = buildNarutoRoleDistribution(baseWorkGraph.work_items, { readonly: parsed.readonly });
-    const allocationWorkers = buildNarutoAllocationWorkers(baseWorkGraph, baseRoleDistribution, roster);
-    const allocationAssignments = allocateNarutoTasksToWorkers(baseWorkGraph.work_items, allocationWorkers);
-    const workGraph = buildNarutoWorkGraph({
-        prompt: parsed.prompt,
-        requestedClones: roster.agent_count,
-        totalWorkItems: parsed.workItems,
-        honorExplicitTotalWorkItems: parsed.workItemsExplicit,
-        readonly: parsed.readonly,
-        writeCapable,
-        targetPaths,
-        leaseBasePath: patchEnvelopeBasePath,
-        maxActiveWorkers: parsed.concurrency || safe.cap,
-        worktreePolicy,
-        allocationAssignments,
-        tournament: parsed.tournament
-    });
-    const roleDistribution = buildNarutoRoleDistribution(workGraph.work_items, { readonly: parsed.readonly });
-    const allocationPolicy = {
-        schema: 'sks.naruto-allocation-policy.v1',
-        generated_at: nowIso(),
-        ok: allocationWorkers.length > 0 && allocationAssignments.length === workGraph.work_items.length,
-        scoring_model: {
-            same_primary_role: 18,
-            declared_role: 12,
-            same_path_lane: 12,
-            overlap_each: 4,
-            assigned_task_penalty_each: -4,
-            write_conflict_penalty: -20,
-            dependency_incomplete: '-Infinity'
-        },
-        workers: allocationWorkers,
-        assignments: allocationAssignments.map((row) => ({
-            task_id: row.id,
-            owner: row.owner,
-            score: Number.isFinite(row.allocation_score) ? row.allocation_score : '-Infinity',
-            reason: row.allocation_reason,
-            role: row.required_role,
-            kind: row.kind,
-            paths: row.hints.paths,
-            domains: row.hints.domains,
-            write_paths: row.hints.writePaths
-        })),
-        blockers: allocationWorkers.length ? [] : ['naruto_allocation_workers_missing']
-    };
-    const rebalanceDecisions = rebalanceNarutoReadyWork({
-        tasks: workGraph.work_items.map((item) => ({ ...item, status: 'pending' })),
-        workers: allocationWorkers.map((worker) => ({ ...worker, alive: true, state: 'idle' })),
-        completedTaskIds: [],
-        reclaimedTaskIds: []
-    });
-    const rebalancePolicy = {
-        schema: 'sks.naruto-rebalance-policy.v1',
-        generated_at: nowIso(),
-        ok: true,
-        trigger: 'idle_worker_ready_queue',
-        decisions: rebalanceDecisions,
-        blocked_by_dependency_count: workGraph.work_items.filter((item) => item.dependencies.length > 0).length,
-        blockers: []
-    };
-    const governor = decideNarutoConcurrency({
-        requestedClones: roster.agent_count,
-        totalWorkItems: workGraph.total_work_items,
-        pendingWorkQueueSize: workGraph.total_work_items,
-        backend: schedulerBackend,
-        parallelismMode: parsed.parallelism
-    });
-    const activeCap = Math.min(safe.cap, governor.safe_active_workers);
-    const activeSlots = Math.max(1, Math.min(roster.agent_count, parsed.concurrency || activeCap, activeCap));
-    const zellijVisiblePanes = Math.max(1, Math.min(activeSlots, governor.safe_zellij_visible_panes));
-    const runPreRunSmoke = parsed.smoke === true || process.env.SKS_NARUTO_PRE_RUN_SMOKE === '1';
-    const realActivePoolSmoke = runPreRunSmoke
-        ? await runNarutoControlPlaneSmoke({
-            root,
-            missionId: mission.id,
-            prompt: parsed.prompt,
-            rosterCount: roster.agent_count,
-            totalWorkItems: workGraph.total_work_items,
-            patchEnvelopeBasePath,
-            worktreePolicy,
-            governor,
-            activeSlots,
-            zellijVisiblePanes
-        })
-        : {
-            schema: 'sks.naruto-active-pool.v1',
-            ok: false,
-            status: 'skipped',
-            runtime_source_of_truth: 'agent-orchestrator-scheduler',
-            production_runtime_source_of_truth: 'agent-orchestrator-scheduler',
-            fallback_reason: 'pre_run_smoke_never_owns_production_runtime',
-            reason: 'pre_run_smoke_disabled_for_production',
-            active_cap: 0,
-            max_observed_active_workers: 0,
-            average_active_workers: 0,
-            active_pool_utilization: 0,
-            refill_latency_ms_p95: 0,
-            visible_workers: 0,
-            headless_workers: 0,
-            worker_lifecycle: [],
-            smoke_graph_total_work_items: 0
-        };
-    const verificationCommand = resolveNarutoVerificationCommand(root);
-    const verificationDag = buildNarutoVerificationDag(workGraph, { cwd: root, command: verificationCommand });
-    const gptFinalPack = buildNarutoGptFinalPack({
-        missionId: mission.id,
-        graph: workGraph,
-        roleDistribution,
-        localLlmMetrics: localWorker,
-        worktreePolicy,
-        worktreeDiffs: []
-    });
-    const zellijDashboard = planNarutoZellijDashboard({
-        targetActiveWorkers: activeSlots,
-        visiblePaneCap: governor.safe_zellij_visible_panes,
-        backpressure: governor.backpressure,
-        roles: roleDistribution.work_item_roles.map((row) => row.role),
-        backend: schedulerBackend,
-        worktreePolicy
-    });
-    const ledgerRoot = path.join(mission.dir, 'agents');
-    await writeNarutoArtifacts(ledgerRoot, {
-        workGraph,
-        roleDistribution,
-        governor,
-        realActivePool: realActivePoolSmoke,
-        allocationPolicy,
-        rebalancePolicy,
-        verificationDag,
-        gptFinalPack,
-        zellijDashboard,
-        placeholderGuard,
-        gitWorktreeCapability
-    });
-    await writeJsonAtomic(path.join(mission.dir, 'naruto-gate.json'), {
-        schema: 'sks.naruto-gate.v1',
-        passed: false,
-        mission_id: mission.id,
-        clone_roster_built: true,
-        clone_count: roster.agent_count,
-        work_graph_ready: workGraph.ok === true,
-        role_distribution_ready: roleDistribution.ok === true,
-        allocation_ready: allocationPolicy.ok === true,
-        rebalance_ready: rebalancePolicy.ok === true,
-        concurrency_governor_ready: true,
-        active_pool_ready: true,
-        verification_dag_ready: verificationDag.configured,
-        verification_dag_unconfigured_reason: verificationDag.unconfigured_reason,
-        verification_dag_executed: false,
-        gpt_final_pack_ready: Boolean(gptFinalPack?.schema),
-        zellij_dashboard_ready: zellijDashboard.ok === true,
-        native_agent_proof: false,
-        final_arbiter_accepted: false,
-        session_cleanup: false,
-        blockers: [...(workGraph.blockers || []), ...(allocationPolicy.blockers || [])],
-        updated_at: nowIso()
+    const { id, dir } = mission;
+    if (appSession && sessionKey) {
+        const pending = await readPendingAppNarutoRun(root, { id, dir }, sessionKey);
+        if (pending)
+            return emit(parsed, pending, () => renderRunResult(pending));
+    }
+    await createAndWriteWorkOrderLedgerForPrompt(dir, {
+        missionId: id,
+        route: 'Naruto',
+        prompt: parsed.prompt
     });
+    const preparation = await withFileLock({
+        lockPath: path.join(dir, '.naruto-preparation.lock'),
+        timeoutMs: 5_000,
+        staleMs: 60_000
+    }, () => prepareOfficialSubagentMission({
+        root,
+        dir,
+        missionId: id,
+        goal: parsed.prompt,
+        route: '$Naruto',
+        sessionScope: sessionKey,
+        ...(parsed.requestedSubagents === undefined ? {} : { requestedSubagents: parsed.requestedSubagents }),
+        requestedSubagentsExplicit: parsed.requestedSubagents !== undefined,
+        ...(parsed.maxThreads === undefined ? {} : { maxThreads: parsed.maxThreads }),
+        mode: 'naruto',
+        readOnly: parsed.readOnly,
+        preparationOnly: true
+    }));
+    const { plan, evidence: preparationEvidence, budget, verification, delegationPrompt, workflowRunId, configBlockers } = preparation;
     await setCurrent(root, {
-        mission_id: mission.id,
+        mission_id: id,
         route: 'Naruto',
         route_command: '$Naruto',
         mode: 'NARUTO',
-        phase: 'NARUTO_NATIVE_AGENT_INTAKE',
+        phase: 'NARUTO_DELEGATION_CONTEXT_READY',
         questions_allowed: false,
         implementation_allowed: true,
-        context7_required: false,
-        context7_verified: parsed.mock,
         subagents_required: true,
         subagents_verified: false,
-        native_sessions_required: true,
+        native_sessions_required: false,
         native_sessions_verified: false,
-        reflection_required: true,
-        visible_progress_required: true,
-        required_skills: ['naruto', 'pipeline-runner', 'prompt-pipeline', 'honest-mode'],
-        stop_gate: 'naruto-gate.json',
-        clone_count: roster.agent_count,
-        target_active_slots: activeSlots,
-        work_graph_ready: workGraph.ok === true,
-        naruto_gate_file: 'naruto-gate.json',
+        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,
+        requestedSubagents: budget.requestedSubagents,
+        maxThreads: budget.maxThreads,
+        appSession,
+        missionId: id,
+        sessionKey
     });
-    let liveZellij = null;
-    if (!parsed.json) {
-        console.log('$Naruto starting:');
-        console.log('  clones requested: ' + roster.agent_count);
-        console.log('  work items: ' + workGraph.total_work_items);
-        console.log('  target active workers: ' + activeSlots);
-        console.log('  visible panes: ' + zellijVisiblePanes);
-        console.log('  headless workers: ' + Math.max(0, activeSlots - zellijVisiblePanes));
-        console.log('  backend: ' + schedulerBackend);
-        console.log('  parallelism mode: ' + parsed.parallelism);
-        if (activeSlots < roster.agent_count)
-            console.log('  cap reasons: ' + (governor.reasons.join(', ') || 'host safety cap'));
-        // Backpressure used to throttle silently (50% when throttled, 25% when
-        // saturated); always tell the operator when host pressure reduced workers.
-        if (governor.backpressure !== 'normal')
-            console.log('  backpressure: ' + governor.backpressure + ' — host resource pressure reduced active workers (memory/cpu/fd/disk thresholds)');
-        if (parsed.parallelism !== 'safe' && activeSlots < 10)
-            console.log('  warning: active workers below 10 in non-safe mode');
-    }
-    if (!parsed.json && !parsed.mock && !parsed.noOpenZellij) {
-        liveZellij = await launchZellijLayout({
+    const completedPlan = await readJson(path.join(dir, SUBAGENT_PLAN_FILENAME), plan).catch(() => plan);
+    const finalBudget = resolveSubagentThreadBudget({
+        requested: Number(completedPlan?.requested_subagents || budget.requestedSubagents),
+        configuredMaxThreads: Number(completedPlan?.max_threads || budget.maxThreads)
+    });
+    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
+    });
+    if (!appSession) {
+        const parentTelemetry = await recordOfficialSubagentParentOutcomesTelemetry({
             root,
-            missionId: mission.id,
-            ledgerRoot,
-            kind: 'naruto',
-            slotCount: 0,
-            dryRun: false,
-            attach: false
+            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 (liveZellij?.ok && liveZellij.capability?.status === 'ok') {
-            liveZellij.dashboard_pane = null;
-            liveZellij.right_column_mode = 'spawn-on-first-worker';
-            await writeJsonAtomic(path.join(mission.dir, 'zellij-initial-ui.json'), {
-                schema: 'sks.zellij-initial-ui.v1',
-                ok: true,
-                mission_id: mission.id,
-                session_name: liveZellij.session_name,
-                initial_panes: 'main-only',
-                dashboard_created: false,
-                worker_panes_created: 0,
-                right_column_mode: 'spawn-on-first-worker',
-                visible_pane_cap: zellijVisiblePanes
-            });
-            console.log('Zellij: started main-only session ' + liveZellij.session_name + '; right column opens on first visible worker spawn. Attach with: ' + (liveZellij.attach_command_with_env || liveZellij.attach_command));
-            if (parsed.attach)
-                attachZellijSessionInteractive(liveZellij.session_name, { cwd: process.cwd(), configPath: liveZellij.clipboard_config_path });
-        }
-        else if (liveZellij?.ok) {
-            console.log('Zellij: optional live panes unavailable (' + ((liveZellij.warnings || []).join('; ') || liveZellij.capability?.status || 'unknown') + ')');
-        }
-        else {
-            console.log('Zellij: blocked (' + Array.from(new Set(liveZellij?.blockers || [])).join('; ') + ')');
+        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 result = await withNarutoSwarmInterruptCleanup({ missionId: mission.id, zellijSessionName: liveZellij?.session_name || null }, () => runNativeAgentOrchestrator({
-        missionId: mission.id,
-        prompt: parsed.prompt,
-        route: NARUTO_ROUTE,
-        routeCommand: 'sks naruto run',
-        routeBlackboxKind: 'actual_naruto_command',
-        roster,
-        agents: roster.agent_count,
-        concurrency: activeSlots,
-        targetActiveSlots: activeSlots,
-        visualLaneCount: zellijVisiblePanes,
-        desiredWorkItemCount: workGraph.total_work_items,
-        minimumWorkItems: workGraph.total_work_items,
-        maxAgentCount: MAX_NARUTO_AGENT_COUNT,
-        narutoMode: true,
-        clones: roster.agent_count,
-        backend: parsed.backend,
-        backendExplicit: parsed.backendExplicit,
-        noOllama: parsed.noOllama,
-        ollamaEnabled: parsed.ollamaEnabled,
-        ollamaModel: parsed.ollamaModel,
-        ollamaBaseUrl: parsed.ollamaBaseUrl,
-        mock: parsed.mock,
-        real: parsed.real,
-        readonly: parsed.readonly,
-        zellijSessionName: liveZellij?.session_name || `sks-${mission.id}`,
-        workerPlacement: parsed.json || parsed.noOpenZellij ? 'process' : 'zellij-pane',
-        zellijPaneWorker: true,
-        zellijVisiblePaneCap: zellijVisiblePanes,
-        ...(parsed.fastMode === undefined ? {} : { fastMode: parsed.fastMode }),
-        ...(parsed.serviceTier === undefined ? {} : { serviceTier: parsed.serviceTier }),
-        noFast: parsed.noFast,
-        writeMode: writeCapable ? parsed.writeMode || 'parallel' : 'off',
-        applyPatches: parsed.applyPatches,
-        dryRunPatches: parsed.dryRunPatches,
-        maxWriteAgents: parsed.maxWriteAgents,
-        gitWorktreePolicy: worktreePolicy,
-        narutoWorkGraph: workGraph,
-        narutoAllocationPolicy: allocationPolicy,
-        narutoRebalancePolicy: rebalancePolicy,
-        json: parsed.json
-    }));
-    const realWriteProof = await maybeWriteNarutoRealWriteProof(mission.dir, mission.id, parsed, result);
-    const parallelRuntime = result.parallel_runtime_proof || null;
-    const nativeProofOk = result.proof?.ok === true || result.proof?.status === 'passed';
-    const finalAccepted = result.proof?.status === 'passed' || result.proof?.gpt_final_status === 'approved';
-    // Real backends must actually prove parallel runtime; mock backends (no real
-    // process fan-out to observe) and small rosters below the 16-worker proof
-    // threshold are exempt. Previously this was inverted (`!parsed.mock`), which
-    // skipped the proof precisely when it mattered most — real execution.
-    const parallelRuntimeOk = parsed.mock || roster.agent_count < 16 || (parallelRuntime?.passed === true
-        && Number(parallelRuntime.max_observed_active_workers || 0) >= Math.min(16, activeSlots));
-    // Verification starts only after clone workers finish so two process pools do
-    // not compete for CPU, memory, and disk at the same time.
-    const verificationDagResult = verificationDag.configured && verificationDag.tasks.length > 0
-        ? await runNarutoVerificationPool(verificationDag, governor, { cwd: root, logDir: path.join(mission.dir, 'agents', 'verification-logs') })
-        : null;
-    if (verificationDagResult)
-        await writeJsonAtomic(path.join(mission.dir, 'naruto-verification-dag-result.json'), verificationDagResult);
-    const verificationDagOk = !verificationDag.configured || verificationDagResult === null ? true : verificationDagResult.ok === true;
-    const regressionProof = summarizeRegressionProof(workGraph, result);
-    await writeJsonAtomic(path.join(mission.dir, 'regression-proof-summary.json'), regressionProof);
-    const tddOk = !regressionProof.required || (regressionProof.regression_test_added && regressionProof.regression_test_failed_before_fix && regressionProof.regression_test_passed_after_fix);
-    const narutoGateFullPassed = result.ok === true && nativeProofOk && finalAccepted && (realWriteProof ? realWriteProof.ok === true : true) && parallelRuntimeOk && tddOk && workGraph.ok === true && allocationPolicy.ok === true && verificationDagOk;
-    const narutoGateFullBlockers = [...(result.proof?.blockers || []), ...(realWriteProof && !realWriteProof.ok ? realWriteProof.blockers : []), ...(parallelRuntimeOk ? [] : ['naruto_parallel_runtime_proof_below_gate']), ...(tddOk ? [] : ['tdd_evidence_missing']), ...(verificationDagOk ? [] : ['naruto_verification_dag_failed']), ...(workGraph.blockers || []), ...(allocationPolicy.blockers || [])];
-    await writeJsonAtomic(path.join(mission.dir, 'naruto-gate.json'), {
-        schema: 'sks.naruto-gate.v1',
-        passed: narutoGateFullPassed,
-        mission_id: mission.id,
-        clone_roster_built: true,
-        clone_count: roster.agent_count,
-        work_graph_ready: workGraph.ok === true,
-        role_distribution_ready: roleDistribution.ok === true,
-        allocation_ready: allocationPolicy.ok === true,
-        rebalance_ready: rebalancePolicy.ok === true,
-        concurrency_governor_ready: true,
-        active_pool_ready: true,
-        verification_dag_ready: verificationDagOk,
-        verification_dag_configured: verificationDag.configured,
-        verification_dag_unconfigured_reason: verificationDag.unconfigured_reason,
-        verification_dag_executed: verificationDagResult !== null,
-        verification_dag_result: verificationDagResult ? 'naruto-verification-dag-result.json' : null,
-        gpt_final_pack_ready: Boolean(gptFinalPack?.schema),
-        zellij_dashboard_ready: zellijDashboard.ok === true,
-        native_agent_proof: nativeProofOk,
-        naruto_real_write_proof: realWriteProof ? 'naruto-real-write-proof.json' : null,
-        parallel_runtime_proof: parallelRuntimeOk,
-        regression_test_added: regressionProof.regression_test_added,
-        regression_test_failed_before_fix: regressionProof.regression_test_failed_before_fix,
-        regression_test_passed_after_fix: regressionProof.regression_test_passed_after_fix,
-        regression_proof: 'regression-proof-summary.json',
-        final_arbiter_accepted: finalAccepted,
-        session_cleanup: result.proof?.all_sessions_closed === true || nativeProofOk,
-        blockers: narutoGateFullBlockers,
-        updated_at: nowIso()
-    });
-    await closeWorkOrderLedgerForRouteResult(mission.dir, { ok: narutoGateFullPassed, blockers: narutoGateFullBlockers });
-    const clones = result.roster?.agent_count ?? roster.agent_count;
-    const localWorkerSummary = summarizeNarutoLocalWorkerResult(localWorker, result);
-    // Finalizer policy: when local LLM workers contributed patches, the GPT
-    // final arbiter must have accepted before patches are considered final.
-    const finalizer = evaluateNarutoFinalizer({
-        localParticipated: Number(localWorkerSummary?.selected_worker_count || 0) > 0,
-        gptFinalStatus: result.proof?.gpt_final_status || null,
-        applyPatches: parsed.applyPatches
-    });
-    await writeJsonAtomic(path.join(mission.dir, 'naruto-finalizer.json'), {
-        ...finalizer,
-        generated_at: nowIso(),
-        mission_id: mission.id
+    const passed = 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 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,
+        appSession,
+        sessionKey
     });
-    const summaryOk = result.ok === true && tddOk && (parsed.applyPatches === true ? finalizer.ok === true : finalizer.run_ok === true);
+    await writeJsonAtomic(path.join(dir, NARUTO_SUMMARY_FILENAME), summary);
+    await writeNarutoGate(dir, { missionId: id, workflowRunId, evidence, passed, blockers });
     await setCurrent(root, {
-        mission_id: mission.id,
-        route: 'Naruto',
-        route_command: '$Naruto',
-        mode: 'NARUTO',
-        phase: summaryOk ? 'NARUTO_COMPLETE_OR_REVIEW' : 'NARUTO_BLOCKED',
-        native_sessions_verified: nativeProofOk,
-        subagents_verified: nativeProofOk,
-        naruto_gate_file: 'naruto-gate.json',
-        stop_gate: 'naruto-gate.json',
-        prompt: parsed.prompt
-    });
-    // 4.0.9: Write canonical stop-gate artifacts for hook resolution.
-    const narutoGatePassed = result.ok === true && nativeProofOk && finalAccepted && parallelRuntimeOk && tddOk;
-    await writeFinalStopGate({
-        root,
-        missionId: mission.id,
-        route: 'Naruto',
-        routeCommand: '$Naruto',
-        status: summaryOk ? 'passed' : 'blocked',
-        terminal: summaryOk,
-        terminalState: summaryOk ? 'completed' : 'blocked',
-        evidence: {
-            build_passed: summaryOk,
-            tests_passed: summaryOk,
-            route_evidence_passed: nativeProofOk && finalAccepted,
-            native_session_split_evidence: nativeProofOk ? 'native_agent_proof' : null,
-            ...(regressionProof.required ? {
-                regression_test_added: regressionProof.regression_test_added,
-                regression_test_failed_before_fix: regressionProof.regression_test_failed_before_fix,
-                regression_test_passed_after_fix: regressionProof.regression_test_passed_after_fix,
-                regression_proof_path: 'regression-proof-summary.json'
-            } : { regression_proof_path: null }),
-        },
-        blockers: summaryOk ? [] : [...(result.proof?.blockers || []), ...(parallelRuntimeOk ? [] : ['naruto_parallel_runtime_proof_below_gate']), ...(tddOk ? [] : ['tdd_evidence_missing'])],
-        nativeGateFile: 'naruto-gate.json',
-    }).catch(() => null);
-    const summary = {
+        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 });
+        if (!passed)
+            process.exitCode = 1;
+    }
+    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) {
+    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),
+        readJson(path.join(mission.dir, NARUTO_SUMMARY_FILENAME), null),
+        readJson(path.join(mission.dir, NARUTO_GATE_FILENAME), null),
+        loadStateForSession(root, sessionKey).catch(() => null)
+    ]);
+    const workflowRunId = String(plan?.workflow_run_id || '').trim();
+    const sessionMatches = state?._session_key === sessionStateKey(sessionKey);
+    const pending = Boolean(workflowRunId
+        && plan?.schema === 'sks.subagent-plan.v1'
+        && plan?.workflow === 'official_codex_subagent'
+        && plan?.mission_id === mission.id
+        && plan?.session_scope === sessionKey
+        && evidence?.run_id === workflowRunId
+        && evidence?.preparation_only === true
+        && evidence?.ok !== true
+        && summary?.workflow_run_id === workflowRunId
+        && summary?.mission_id === mission.id
+        && summary?.app_session === true
+        && summary?.session_scope === sessionKey
+        && summary?.status === 'delegation_context_ready'
+        && summary?.ok !== true
+        && summary?.completion_evidence !== true
+        && gate?.workflow_run_id === workflowRunId
+        && gate?.mission_id === mission.id
+        && gate?.passed !== true
+        && sessionMatches
+        && state?.mission_id === mission.id
+        && state?.official_subagent_run_id === workflowRunId
+        && state?.session_scope === sessionKey
+        && state?.route_closed !== true
+        && state?.phase === 'NARUTO_DELEGATION_CONTEXT_READY');
+    if (!pending)
+        return null;
+    return {
+        ...summary,
         schema: NARUTO_RESULT_SCHEMA,
-        ok: summaryOk,
-        mode: 'NARUTO',
-        jutsu: 'kage_bunshin_no_jutsu',
-        mission_id: result.mission_id,
-        backend: result.backend,
-        clones,
-        max_clones: MAX_NARUTO_AGENT_COUNT,
-        concurrency: result.target_active_slots ?? activeSlots,
-        target_active_slots: result.target_active_slots ?? activeSlots,
-        runtime_source_of_truth: 'agent-orchestrator-scheduler',
-        pre_run_real_active_pool_source: runPreRunSmoke ? 'smoke_only' : 'skipped',
-        concurrency_capped: clones > (result.target_active_slots ?? activeSlots),
-        system: { cores: safe.cores, free_gb: safe.free_gb, safe_concurrency: safe.cap, heavy_backend: safe.heavy },
-        work_graph: {
-            total_work_items: workGraph.total_work_items,
-            mixed_work_kinds: workGraph.mixed_work_kinds,
-            write_allowed_count: workGraph.write_allowed_count,
-            active_wave_count: workGraph.active_waves.length,
-            parallel_write_wave_count: workGraph.active_waves.filter((wave) => wave.write_paths.length > 1).length,
-            ok: workGraph.ok,
-            worktree_policy: workGraph.worktree_policy
-        },
-        git_worktree: gitWorktreeCapability,
-        role_distribution: roleDistribution,
-        allocation_policy: allocationPolicy,
-        rebalance_policy: rebalancePolicy,
-        concurrency_governor: governor,
-        active_pool: {
-            ok: realActivePoolSmoke.ok,
-            runtime_source_of_truth: realActivePoolSmoke.runtime_source_of_truth,
-            production_runtime_source_of_truth: realActivePoolSmoke.production_runtime_source_of_truth,
-            active_cap: realActivePoolSmoke.active_cap,
-            max_observed_active_workers: realActivePoolSmoke.max_observed_active_workers,
-            average_active_workers: realActivePoolSmoke.average_active_workers,
-            active_pool_utilization: realActivePoolSmoke.active_pool_utilization,
-            refill_latency_ms_p95: realActivePoolSmoke.refill_latency_ms_p95,
-            visible_workers: realActivePoolSmoke.visible_workers,
-            headless_workers: realActivePoolSmoke.headless_workers,
-            worker_lifecycle_count: realActivePoolSmoke.worker_lifecycle.length,
-            worker_lifecycle_sample: realActivePoolSmoke.worker_lifecycle.slice(0, 5)
-        },
-        parallel_runtime: parallelRuntime ? {
-            proof_path: path.join(result.ledger_root || '', 'parallel-runtime-proof.json'),
-            max_observed_active_workers: parallelRuntime.max_observed_active_workers,
-            unique_worker_pids: parallelRuntime.unique_worker_pids,
-            speedup_ratio: parallelRuntime.speedup_ratio,
-            visible_panes: parallelRuntime.visible_panes,
-            headless_workers: parallelRuntime.headless_workers,
-            passed: parallelRuntime.passed
-        } : null,
-        parallel_write_policy: result.parallel_write_policy || null,
-        local_worker: localWorkerSummary,
-        fast_mode_policy: result.fast_mode_policy || null,
-        fast_mode_propagation: result.fast_mode_propagation ? {
-            ok: result.fast_mode_propagation.ok === true,
-            fast_mode: result.fast_mode_propagation.fast_mode,
-            service_tier: result.fast_mode_propagation.service_tier,
-            worker_process_report_count: result.fast_mode_propagation.worker_process_report_count || 0,
-            blockers: result.fast_mode_propagation.blockers || []
-        } : null,
-        finalizer,
-        regression_proof: regressionProof,
-        proof: result.proof?.status || 'missing',
-        run: compactNarutoRunResult(result),
-        zellij: null
+        ok: false,
+        completion_evidence: false,
+        status: 'delegation_context_ready',
+        workflow_run_id: workflowRunId,
+        mission_id: mission.id,
+        app_session: true,
+        session_scope: sessionKey,
+        attached_to_pending_run: true,
+        additionalContext: plan.delegation_prompt,
+        artifacts: narutoArtifactLinks(evidence)
     };
-    summary.zellij = liveZellij;
-    return emit(parsed, summary, () => {
-        console.log('🍥 Shadow Clone Jutsu — Kage Bunshin no Jutsu');
-        console.log('Mission: ' + result.mission_id);
-        console.log('Clones: ' + summary.clones + ' / max ' + MAX_NARUTO_AGENT_COUNT + ', running ' + summary.target_active_slots + ' at a time' + (summary.concurrency_capped ? ` (throttled to host capacity: ${safe.cores} cores, ${safe.free_gb} GB free)` : ''));
-        console.log('Backend: ' + result.backend);
-        console.log('Roles: ' + roleDistribution.entries.map((entry) => `${entry.role}:${entry.count}`).join(', '));
-        console.log('Proof: ' + summary.proof);
-        if (!finalizer.ok)
-            console.log('Finalizer: blocked — ' + finalizer.blockers.join(', '));
-        if (summary.parallel_runtime) {
-            console.log('$Naruto parallel proof:');
-            console.log('  max active workers: ' + summary.parallel_runtime.max_observed_active_workers);
-            console.log('  unique PIDs: ' + summary.parallel_runtime.unique_worker_pids);
-            console.log('  speedup: ' + summary.parallel_runtime.speedup_ratio + 'x');
-            console.log('  result: ' + (summary.parallel_runtime.passed ? 'passed' : 'blocked'));
-        }
-        if (summary.zellij?.ok && summary.zellij.capability?.status === 'ok')
-            console.log('Zellij: prepared ' + zellijVisiblePanes + ' visible active clone lane(s) in ' + summary.zellij.session_name + '; dashboard tracks ' + Math.max(0, activeSlots - zellijVisiblePanes) + ' headless active worker(s)');
-        else if (summary.zellij?.ok)
-            console.log('Zellij: optional live panes unavailable (' + ((summary.zellij.warnings || []).join('; ') || summary.zellij.capability?.status || 'unknown') + ')');
-    });
 }
-async function maybeWriteNarutoRealWriteProof(missionDir, missionId, parsed, result) {
-    const enabled = parsed.backend === 'codex-sdk'
-        && parsed.readonly !== true
-        && parsed.applyPatches === true
-        && (parsed.writeMode || 'parallel') === 'parallel';
-    if (!enabled)
-        return null;
-    const ledgerRoot = path.join(missionDir, 'agents');
-    const [queue, applyResults, proofEvidence] = await Promise.all([
-        readJson(path.join(ledgerRoot, 'agent-patch-queue.json'), null),
-        readJson(path.join(ledgerRoot, 'agent-patch-apply-results.json'), null),
-        readJson(path.join(ledgerRoot, 'agent-proof-evidence.json'), null)
+function narutoArtifactLinks(evidence) {
+    return {
+        plan: SUBAGENT_PLAN_FILENAME,
+        events: SUBAGENT_EVENT_LOG_FILENAME,
+        parent_summary: evidence?.parent_summary_trustworthy === 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)
+        return missingMission(parsed, 'status');
+    const [plan, evidence, summary, gate] = await Promise.all([
+        readJson(path.join(resolved.dir, SUBAGENT_PLAN_FILENAME), null),
+        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 applyRows = Array.isArray(applyResults?.results) ? applyResults.results : [];
-    const entries = Array.isArray(queue?.entries) ? queue.entries : [];
-    const applyByEntry = new Map(applyRows.map((row) => [String(row.entry_id || row.envelope_id || ''), row]));
-    const patchEnvelopes = entries.map((entry) => {
-        const applied = applyByEntry.get(String(entry.id || '')) || applyByEntry.get(String(entry.envelope?.envelope_id || '')) || null;
-        return {
-            envelope_id: String(entry.id || entry.envelope?.envelope_id || ''),
-            agent_id: String(entry.agent_id || entry.envelope?.agent_id || ''),
-            changed_files: uniqueRelValues(applied?.changed_files?.length ? applied.changed_files : entry.write_paths || entry.envelope?.operations?.map((operation) => operation.path) || []),
-            applied: applied ? applied.ok !== false && String(entry.status || '') !== 'conflicted' && String(entry.status || '') !== 'rejected' : false
-        };
-    });
-    const changedFiles = uniqueRelValues([
-        ...applyRows.flatMap((row) => row.changed_files || []),
-        ...patchEnvelopes.flatMap((envelope) => envelope.applied ? envelope.changed_files : [])
+    const result = {
+        schema: NARUTO_RESULT_SCHEMA,
+        ok: Boolean(plan || evidence || summary || gate),
+        action: 'status',
+        mission_id: resolved.id,
+        status: summary?.status || evidence?.status || 'prepared',
+        requested_subagents: plan?.requested_subagents ?? evidence?.requested_subagents ?? null,
+        max_threads: plan?.max_threads ?? null,
+        started_subagents: evidence?.started_threads ?? 0,
+        completed_subagents: evidence?.completed_threads ?? 0,
+        failed_subagents: evidence?.failed_threads ?? 0,
+        gate_passed: gate?.passed === true,
+        blockers: gate?.blockers || evidence?.blockers || []
+    };
+    return emit(parsed, result, () => renderStatusResult(result));
+}
+async function narutoSubagents(parsed) {
+    const resolved = await resolveReadMission(parsed);
+    if (!resolved)
+        return missingMission(parsed, 'subagents');
+    const [evidence, events] = await Promise.all([
+        readJson(path.join(resolved.dir, 'subagent-evidence.json'), null),
+        readSubagentEvents(resolved.dir)
     ]);
-    const proof = buildNarutoRealWriteProof({
-        missionId,
-        changedFiles,
-        workerIds: uniqueRelValues(entries.map((entry) => entry.slot_id || entry.session_id || entry.agent_id || entry.envelope?.slot_id || entry.envelope?.session_id || entry.envelope?.agent_id)),
-        patchEnvelopes,
-        parentMergeArtifact: 'agents/agent-patch-swarm-runtime.json',
-        typecheck: {
-            ok: proofEvidence?.patch_verification_ok === true,
-            command: 'agents/agent-patch-verification-results.json'
-        },
-        cleanup: {
-            ok: result?.cleanup?.ok === true || result?.proof?.all_sessions_closed === true
-        },
-        blockers: [
-            ...(entries.length ? [] : ['patch_queue_entries_missing']),
-            ...(applyRows.length ? [] : ['patch_apply_results_missing']),
-            ...(result?.patch_swarm?.blockers || [])
-        ]
-    });
-    await writeJsonAtomic(path.join(missionDir, 'naruto-real-write-proof.json'), proof);
-    return proof;
-}
-function uniqueRelValues(values) {
-    return [...new Set((Array.isArray(values) ? values : []).map((value) => String(value || '').replace(/\\/g, '/').replace(/^\.\/+/, '').trim()).filter(Boolean))].sort();
-}
-function compactNarutoRunResult(result) {
-    return {
-        schema: result?.schema || 'sks.agent-run.v1',
-        ok: result?.ok === true,
-        mission_id: result?.mission_id || null,
-        route: result?.route || NARUTO_ROUTE,
-        backend: result?.backend || null,
-        parallel_write_policy: result?.parallel_write_policy || null,
-        target_active_slots: result?.target_active_slots ?? null,
-        proof: result?.proof ? {
-            ok: result.proof.ok === true,
-            status: result.proof.status || null,
-            blockers: result.proof.blockers || []
-        } : null,
-        scheduler: result?.scheduler ? {
-            state: {
-                completed_count: result.scheduler.state?.completed_count ?? result.scheduler.completed_count ?? null,
-                failed_count: result.scheduler.state?.failed_count ?? result.scheduler.failed_count ?? null,
-                blocked_count: result.scheduler.state?.blocked_count ?? result.scheduler.blocked_count ?? null,
-                max_observed_active_slots: result.scheduler.state?.max_observed_active_slots ?? result.scheduler.max_observed_active_slots ?? null
-            }
-        } : null,
-        artifacts: {
-            ledger_root: result?.ledger_root || null,
-            proof: 'agent-proof-evidence.json',
-            scheduler: 'agent-scheduler-state.json',
-            native_cli_session_swarm: 'agent-native-cli-session-swarm.json',
-            naruto_real_active_pool: 'naruto-real-active-pool.json'
-        }
+    const result = {
+        schema: NARUTO_RESULT_SCHEMA,
+        ok: Boolean(evidence),
+        action: 'subagents',
+        mission_id: resolved.id,
+        requested_subagents: evidence?.requested_subagents ?? null,
+        started_subagents: evidence?.started_threads ?? 0,
+        completed_subagents: evidence?.completed_threads ?? 0,
+        failed_subagents: evidence?.failed_threads ?? 0,
+        started_thread_ids: evidence?.started_thread_ids || [],
+        completed_thread_ids: evidence?.completed_thread_ids || [],
+        failed_thread_ids: evidence?.failed_thread_ids || [],
+        events
     };
+    return emit(parsed, result, () => renderStatusResult(result));
 }
-async function runNarutoControlPlaneSmoke(input) {
-    const smokeGraph = buildNarutoWorkGraph({
-        prompt: input.prompt,
-        requestedClones: Math.min(2, input.rosterCount),
-        totalWorkItems: Math.min(2, input.totalWorkItems),
-        readonly: true,
-        writeCapable: false,
-        leaseBasePath: input.patchEnvelopeBasePath,
-        maxActiveWorkers: Math.min(2, input.activeSlots),
-        worktreePolicy: {
-            mode: 'patch-envelope-only',
-            required: false,
-            main_repo_root: input.worktreePolicy.main_repo_root,
-            worktree_root: null,
-            fallback_reason: 'pre_run_smoke_never_owns_production_runtime'
-        }
-    });
-    const smokeWorktreePolicy = {
-        mode: 'patch-envelope-only',
-        required: false,
-        main_repo_root: input.worktreePolicy.main_repo_root,
-        worktree_root: null,
-        fallback_reason: 'pre_run_smoke_never_owns_production_runtime'
+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 realActivePool = await runNarutoRealActivePool({
-        graph: smokeGraph,
-        governor: { ...input.governor, safe_active_workers: Math.min(2, input.activeSlots), safe_zellij_visible_panes: Math.min(1, input.zellijVisiblePanes) },
-        spawnWorker: async (item, placement) => spawnActualNarutoWorker({
-            root: input.root,
-            missionId: input.missionId,
-            item,
-            placement,
-            backend: 'fake',
-            parentPrompt: input.prompt,
-            worktreePolicy: smokeWorktreePolicy,
-            zellijSessionName: `sks-${input.missionId}`,
-            visiblePaneCap: input.zellijVisiblePanes
-        }),
-        collectWorker: async (handle) => collectActualNarutoWorker(handle),
-        enqueueVerification: async () => undefined,
-        updateDashboard: async () => undefined
+    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(', ')}`);
     });
-    return {
-        ...realActivePool,
-        status: 'smoke_completed',
-        runtime_source_of_truth: 'pre_run_smoke_only',
-        production_runtime_source_of_truth: 'agent-orchestrator-scheduler',
-        fallback_reason: 'pre_run_smoke_never_owns_production_runtime',
-        smoke_graph_total_work_items: smokeGraph.total_work_items
-    };
 }
-function buildNarutoAllocationWorkers(workGraph, roleDistribution, roster) {
-    const workItems = Array.isArray(workGraph?.work_items) ? workGraph.work_items : [];
-    const roleByWorkItem = new Map((roleDistribution?.work_item_roles || []).map((row) => [String(row.work_item_id), String(row.role || '')]));
-    const rosterRows = Array.isArray(roster?.roster) ? roster.roster : [];
-    const count = Math.max(1, Math.min(Number(roster?.agent_count || rosterRows.length || workItems.length || 1), Math.max(1, workItems.length || 1)));
-    return Array.from({ length: count }, (_unused, index) => {
-        const agent = rosterRows[index] || {};
-        const item = workItems[index % Math.max(1, workItems.length)] || {};
-        const role = String(agent.naruto_role || agent.role || roleByWorkItem.get(String(item.id || '')) || item.required_role || 'worker');
-        return {
-            id: String(agent.id || `clone-${String(index + 1).padStart(3, '0')}`),
-            role,
-            lane: narutoAllocationLane(item)
-        };
+function narutoHelp(parsed) {
+    const result = buildNarutoHelpResult();
+    return emit(parsed, result, () => {
+        console.log('$Naruto — Codex official subagent workflow');
+        for (const line of result.usage)
+            console.log(`  ${line}`);
+        console.log(`Parent: ${result.parent.model} / ${result.parent.model_reasoning_effort}`);
+        const worker = result.agents.worker;
+        const expert = result.agents.expert;
+        if (worker)
+            console.log(`Worker: ${worker.model} / ${worker.model_reasoning_effort}`);
+        if (expert)
+            console.log(`Expert: ${expert.model} / ${expert.model_reasoning_effort}`);
+        console.log(`Default children: ${result.default_requested_subagents}; use explicit --agents N for wider parallelism`);
+        console.log(`Nesting: max_depth=${result.max_depth}; subagents must not spawn subagents`);
+        console.log('Context: bounded TriWiki attention.use_first anchors with on-demand source hydration');
+        console.log('Evidence: SubagentStop is lifecycle-only; completion requires subagent-parent-summary.json with one structured outcome per thread.');
     });
 }
-function narutoAllocationLane(item) {
-    const firstPath = String((item?.write_paths || item?.target_paths || item?.readonly_paths || [])[0] || '');
-    const parts = firstPath.replace(/\\/g, '/').split('/').filter(Boolean);
-    return parts.slice(0, Math.min(2, parts.length)).join('/') || null;
+async function resolveRunMission(root, parsed, sessionKey = null) {
+    if (parsed.missionId && parsed.missionId !== 'latest') {
+        const loaded = await loadMission(root, parsed.missionId).catch(() => null);
+        return loaded ? { id: parsed.missionId, dir: loaded.dir } : null;
+    }
+    if (sessionKey) {
+        const resolved = await getOrCreateSessionMission(root, {
+            mode: 'naruto',
+            prompt: parsed.prompt,
+            sessionKey,
+            selectMissionId: (state) => {
+                const route = String(state?.route || state?.route_command || state?.mode || '').replace(/^\$/, '').toUpperCase();
+                const sessionMatches = state?._session_key === sessionStateKey(sessionKey);
+                return sessionMatches && state?.mission_id && state?.route_closed !== true && route === 'NARUTO'
+                    ? String(state.mission_id)
+                    : null;
+            }
+        });
+        return { id: resolved.id, dir: resolved.dir };
+    }
+    const created = await createMission(root, { mode: 'naruto', prompt: parsed.prompt, sessionKey });
+    return { id: created.id, dir: created.dir };
 }
-function summarizeNarutoLocalWorkerResult(localWorker, result) {
-    const backendCounts = {};
-    const rows = Array.isArray(result?.results) ? result.results : [];
-    for (const row of rows) {
-        const selected = String(row?.backend_router_report?.selected_backend || row?.backend || 'unknown');
-        backendCounts[selected] = (backendCounts[selected] || 0) + 1;
+async function resolveReadMission(parsed) {
+    const root = await sksRoot();
+    const explicitId = parsed.missionId && parsed.missionId !== 'latest' ? parsed.missionId : null;
+    const sessionKey = detectCodexAppSession() ? codexAppSessionKey() : null;
+    let id = explicitId;
+    if (!id && sessionKey) {
+        const state = await loadStateForSession(root, sessionKey).catch(() => null);
+        const route = String(state?.route || state?.route_command || state?.mode || '').replace(/^\$/, '').toUpperCase();
+        if (state?._session_key === sessionStateKey(sessionKey) && state?.route_closed !== true && route === 'NARUTO') {
+            id = String(state.mission_id || '') || null;
+        }
+    }
+    if (!id && !sessionKey)
+        id = await findLatestMission(root, { mode: 'naruto' });
+    if (!id)
+        return null;
+    const loaded = await loadMission(root, id).catch(() => null);
+    return loaded ? { root, id, dir: loaded.dir } : null;
+}
+export function parseNarutoArgs(args) {
+    const helpRequested = args.includes('--help') || args.includes('-h');
+    const validationArgs = [...args];
+    const normalized = helpRequested
+        ? ['help', ...(args.includes('--json') ? ['--json'] : [])]
+        : args;
+    const first = normalized[0] && !normalized[0].startsWith('-') ? normalized[0] : '';
+    const workersAliasUsed = first === 'workers';
+    const actionName = workersAliasUsed ? 'subagents' : first;
+    const actions = new Set(['run', 'status', 'subagents', 'proof', 'help']);
+    const action = (actions.has(actionName) ? actionName : 'run');
+    const explicitAction = actions.has(actionName) || workersAliasUsed;
+    const rest = explicitAction ? normalized.slice(1) : normalized;
+    const optionArgs = validationArgs.includes('--') ? validationArgs.slice(0, validationArgs.indexOf('--')) : validationArgs;
+    const agentsOption = optionValue(optionArgs, '--agents');
+    const clonesOption = optionValue(optionArgs, '--clones');
+    const maxThreadsOption = optionValue(optionArgs, '--max-threads');
+    const missionOption = optionValue(optionArgs, '--mission');
+    const missionIdOption = optionValue(optionArgs, '--mission-id');
+    const argumentErrors = uniqueStrings([
+        ...optionErrors('--agents', agentsOption, true),
+        ...optionErrors('--clones', clonesOption, true),
+        ...optionErrors('--max-threads', maxThreadsOption, true),
+        ...optionErrors('--mission', missionOption, false),
+        ...optionErrors('--mission-id', missionIdOption, false),
+        ...(agentsOption.present && clonesOption.present ? ['conflicting_options:--agents,--clones'] : []),
+        ...booleanOptionErrors(validationArgs),
+        ...unknownOptionErrors(validationArgs)
+    ]);
+    if (REMOVED_LEGACY_SUBCOMMANDS.has(String(first || '').toLowerCase())) {
+        argumentErrors.push(`removed_legacy_subcommand:${String(first).toLowerCase()}`);
+    }
+    const requestedSubagents = strictPositiveInteger(agentsOption.value ?? clonesOption.value);
+    const maxThreads = strictPositiveInteger(maxThreadsOption.value);
+    const missionFlag = missionOption.value ?? missionIdOption.value;
+    const positional = positionalValues(rest);
+    const positionalMission = action === 'status' || action === 'subagents' || action === 'proof'
+        ? positional.find((value) => value === 'latest' || /^M-/.test(value))
+        : undefined;
+    const prompt = action === 'run'
+        ? positional.join(' ').trim()
+        : '';
+    const positionalHead = String(positional[0] || '').toLowerCase();
+    const subcommandNames = new Set(['run', 'status', 'subagents', 'workers', 'proof', 'help']);
+    if (explicitAction && action === 'run' && REMOVED_LEGACY_SUBCOMMANDS.has(positionalHead)) {
+        argumentErrors.push(`removed_legacy_subcommand:${positionalHead}`);
+    }
+    else if (explicitAction && action === 'run' && subcommandNames.has(positionalHead)) {
+        argumentErrors.push(`misplaced_subcommand:${positionalHead}`);
     }
+    else if (!explicitAction && REMOVED_LEGACY_SUBCOMMANDS.has(positionalHead)) {
+        argumentErrors.push(`removed_legacy_subcommand:${positionalHead}`);
+    }
+    else if (!explicitAction && subcommandNames.has(positionalHead)) {
+        argumentErrors.push(`misplaced_subcommand:${positionalHead}`);
+    }
+    if (action !== 'run') {
+        let missionConsumed = false;
+        for (const value of positional) {
+            if (!missionConsumed && positionalMission !== undefined && value === positionalMission) {
+                missionConsumed = true;
+                continue;
+            }
+            const normalizedValue = String(value || '').toLowerCase();
+            if (REMOVED_LEGACY_SUBCOMMANDS.has(normalizedValue)) {
+                argumentErrors.push(`removed_legacy_subcommand:${normalizedValue}`);
+            }
+            else if (subcommandNames.has(normalizedValue)) {
+                argumentErrors.push(`misplaced_subcommand:${normalizedValue}`);
+            }
+            else {
+                argumentErrors.push(`unexpected_positional:${value}`);
+            }
+        }
+    }
+    if (action === 'run' && !prompt)
+        argumentErrors.push('empty_task');
     return {
-        ...localWorker,
-        selected_worker_count: (backendCounts['local-llm'] || 0) + (backendCounts.ollama || 0),
-        backend_counts: backendCounts
+        action,
+        prompt,
+        requestedSubagents,
+        maxThreads,
+        missionId: String(missionFlag || positionalMission || 'latest'),
+        json: normalized.includes('--json'),
+        readOnly: normalized.includes('--readonly') || normalized.includes('--read-only'),
+        clonesAliasUsed: clonesOption.present,
+        workersAliasUsed,
+        unsupportedLegacyFlags: unsupportedLegacyFlags(validationArgs),
+        argumentErrors: uniqueStrings(argumentErrors)
     };
 }
-// Wraps the actual swarm execution so Ctrl-C (SIGINT) or SIGTERM during a
-// real Naruto run kills every active worker's process group and the live
-// zellij session instead of leaving them orphaned (20차 P1-5) — previously
-// nothing in the CLI entrypoint handled these signals at all, so Node's
-// default behavior (immediate exit, no cleanup) applied.
-async function withNarutoSwarmInterruptCleanup(input, fn) {
-    let interrupted = false;
-    const onSignal = (signal) => {
-        if (interrupted)
-            return;
-        interrupted = true;
-        killAllActiveNarutoWorkers(signal);
-        const cleanup = input.zellijSessionName
-            ? runZellij(['kill-session', input.zellijSessionName], { timeoutMs: 2500, optional: true }).catch(() => undefined)
-            : Promise.resolve(undefined);
-        cleanup.finally(() => process.exit(signal === 'SIGINT' ? 130 : 143));
-    };
-    process.on('SIGINT', onSignal);
-    process.on('SIGTERM', onSignal);
-    try {
-        return await fn();
-    }
-    finally {
-        process.off('SIGINT', onSignal);
-        process.off('SIGTERM', onSignal);
+function positionalValues(args) {
+    const valueFlags = new Set([
+        '--agents', '--clones', '--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'
+    ]);
+    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'
+    ]);
+    const result = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index] || '';
+        if (arg === '--') {
+            result.push(...args.slice(index + 1));
+            break;
+        }
+        if (valueFlags.has(arg)) {
+            index += 1;
+            continue;
+        }
+        if ([...valueFlags].some((flag) => arg.startsWith(`${flag}=`)))
+            continue;
+        if (booleanFlags.has(arg))
+            continue;
+        if (!arg.startsWith('--'))
+            result.push(arg);
     }
+    return result;
 }
-// Scales the default clone count (and, via clones*2 below, the default
-// work-item count) to apparent task size instead of always requesting
-// DEFAULT_NARUTO_CLONES — only the *default*; an explicit --clones/--agents
-// always wins over this (20차 P2-3). Broad-scope language or an unclear/
-// unmatched prompt keeps the full default rather than under-provisioning.
-function estimateNarutoDefaultCloneCount(prompt) {
-    const text = String(prompt || '');
-    const broadScope = /\b(entire|all files|whole codebase|across the codebase|comprehensive review|throughout the (?:repo|project|codebase))\b|전체|모든\s*파일|코드베이스\s*전체/i.test(text);
-    if (broadScope || !text.trim())
-        return DEFAULT_NARUTO_CLONES;
-    const fileRefs = extractNarutoPromptPaths(text).length;
-    const wordCount = text.trim().split(/\s+/).filter(Boolean).length;
-    if (fileRefs <= 1 && wordCount <= 20)
-        return 2;
-    if (fileRefs <= 4 && wordCount <= 60)
-        return 8;
-    return DEFAULT_NARUTO_CLONES;
-}
-// Resolves the project's real verification command for the Naruto
-// verification DAG. Returns '' (unconfigured) rather than a fabricated
-// no-op when the project type can't be detected — see naruto-verification-dag.ts.
-function resolveNarutoVerificationCommand(root) {
-    if (fs.existsSync(path.join(root, 'tsconfig.json'))) {
-        return 'node node_modules/typescript/bin/tsc -p tsconfig.json --noEmit --incremental';
+function unsupportedLegacyFlags(args) {
+    const optionArgs = args.includes('--') ? args.slice(0, args.indexOf('--')) : args;
+    const unsupportedBoolean = [
+        '--mock', '--ollama', '--local-model', '--no-ollama', '--no-local-model',
+        '--apply-patches', '--dry-run-patches', '--dry-run-patch', '--attach', '--smoke',
+        '--parallel-write', '--fast', '--no-fast', '--real', '--no-open-zellij',
+        '--no-zellij', '--incremental', '--mad'
+    ];
+    const unsupportedValues = [
+        '--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'
+    ];
+    const flags = unsupportedBoolean.filter((flag) => optionArgs.some((arg) => arg === flag || arg.startsWith(`${flag}=`)));
+    for (const flag of unsupportedValues) {
+        const option = optionValue(optionArgs, flag);
+        if (option.present)
+            flags.push(option.value === undefined ? flag : `${flag}=${option.value}`);
+    }
+    return uniqueStrings(flags);
+}
+function optionValue(args, name) {
+    const values = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index] || '';
+        if (arg === name) {
+            const next = args[index + 1];
+            values.push(next && !next.startsWith('--') ? next : undefined);
+            continue;
+        }
+        if (arg.startsWith(`${name}=`))
+            values.push(arg.slice(name.length + 1) || undefined);
     }
-    return '';
-}
-function summarizeRegressionProof(workGraph, result) {
-    const bugfixItems = (Array.isArray(workGraph?.work_items) ? workGraph.work_items : []).filter((item) => String(item?.kind || '') === 'bugfix');
-    const proofs = collectRegressionProofs(result).filter(validRegressionProof);
     return {
-        schema: 'sks.regression-proof-summary.v1',
-        generated_at: nowIso(),
-        required: bugfixItems.length > 0,
-        bugfix_work_item_count: bugfixItems.length,
-        proof_count: proofs.length,
-        regression_test_added: bugfixItems.length === 0 ? true : proofs.some((proof) => String(proof.test_file || '').trim().length > 0),
-        regression_test_failed_before_fix: bugfixItems.length === 0 ? true : proofs.some((proof) => proof.failed_before === true),
-        regression_test_passed_after_fix: bugfixItems.length === 0 ? true : proofs.some((proof) => proof.passed_after === true),
-        test_files: [...new Set(proofs.map((proof) => String(proof.test_file || '')).filter(Boolean))],
-        blockers: bugfixItems.length === 0 || proofs.length > 0 ? [] : ['tdd_evidence_missing']
+        present: values.length > 0,
+        value: values.at(-1),
+        missing: values.some((value) => value === undefined),
+        duplicate: values.length > 1
     };
 }
-function collectRegressionProofs(result) {
-    const rows = Array.isArray(result?.results) ? result.results : [];
-    return rows.flatMap((row) => [
-        row?.regression_proof,
-        ...(Array.isArray(row?.patch_envelopes) ? row.patch_envelopes.map((envelope) => envelope?.regression_proof) : [])
-    ]).filter(Boolean);
+function strictPositiveInteger(value) {
+    if (value === undefined || value === null || value === '')
+        return undefined;
+    if (!/^\d+$/.test(String(value)))
+        return undefined;
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+function optionErrors(name, option, numeric) {
+    const errors = [];
+    if (option.missing)
+        errors.push(`missing_option_value:${name}`);
+    if (option.duplicate)
+        errors.push(`duplicate_option:${name}`);
+    if (numeric && option.present && option.value !== undefined && strictPositiveInteger(option.value) === undefined) {
+        errors.push(`invalid_positive_integer:${name}=${option.value}`);
+    }
+    return errors;
 }
-function validRegressionProof(proof) {
-    return Boolean(proof && proof.failed_before === true && proof.passed_after === true && String(proof.test_file || '').trim());
+function unknownOptionErrors(args) {
+    const canonical = new Set([
+        '--agents', '--clones', '--max-threads', '--mission', '--mission-id',
+        '--json', '--readonly', '--read-only', '--help', '-h', '--'
+    ]);
+    const legacy = new Set([
+        '--mock', '--ollama', '--local-model', '--no-ollama', '--no-local-model',
+        '--apply-patches', '--dry-run-patches', '--dry-run-patch', '--attach', '--smoke',
+        '--parallel-write', '--fast', '--no-fast', '--real', '--no-open-zellij',
+        '--no-zellij', '--incremental', '--mad', '--glm', '--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'
+    ]);
+    const errors = [];
+    const optionArgs = args.includes('--') ? args.slice(0, args.indexOf('--')) : args;
+    for (const arg of optionArgs) {
+        if (!arg.startsWith('-') || arg === '-')
+            continue;
+        const name = arg.includes('=') ? arg.slice(0, arg.indexOf('=')) : arg;
+        if (!canonical.has(name) && !legacy.has(name))
+            errors.push(`unsupported_argument:${name}`);
+    }
+    return errors;
+}
+function booleanOptionErrors(args) {
+    const booleanNames = new Set(['--json', '--readonly', '--read-only', '--help', '-h']);
+    const optionArgs = args.includes('--') ? args.slice(0, args.indexOf('--')) : args;
+    const errors = [];
+    for (const arg of optionArgs) {
+        if (!arg.includes('='))
+            continue;
+        const name = arg.slice(0, arg.indexOf('='));
+        if (booleanNames.has(name))
+            errors.push(`boolean_option_value_not_supported:${name}`);
+    }
+    return errors;
 }
-async function narutoStatus(parsed) {
-    const root = await sksRoot();
-    const id = parsed.missionId && parsed.missionId !== 'latest' ? parsed.missionId : await findLatestMission(root, { mode: 'naruto' });
-    if (!id)
-        return emit(parsed, { schema: NARUTO_RESULT_SCHEMA, ok: false, action: 'status', status: 'missing_mission' }, () => console.log('No Naruto mission found.'));
-    const { dir } = await loadMission(root, id);
-    const proof = await readJson(path.join(dir, 'agents', 'agent-proof-evidence.json'), null);
-    const scheduler = await readJson(path.join(dir, 'agents', 'agent-scheduler-state.json'), null);
-    const roleDistribution = await readJson(path.join(dir, 'agents', 'naruto-role-distribution.json'), null);
-    const workGraph = await readJson(path.join(dir, 'agents', 'naruto-work-graph.json'), null);
-    const governor = await readJson(path.join(dir, 'agents', 'naruto-concurrency-governor.json'), null);
-    const summary = {
+function blockGlmOverride(json) {
+    const result = {
         schema: NARUTO_RESULT_SCHEMA,
-        ok: proof !== null,
-        action: 'status',
-        mission_id: id,
-        proof: proof?.status || 'missing',
-        target_active_slots: scheduler?.target_active_slots ?? null,
-        max_active_slots: scheduler?.max_active_slots ?? null,
-        completed: scheduler?.completed_count ?? null,
-        role_distribution: roleDistribution,
-        work_graph: workGraph ? {
-            total_work_items: workGraph.total_work_items,
-            mixed_work_kinds: workGraph.mixed_work_kinds,
-            write_allowed_count: workGraph.write_allowed_count,
-            active_wave_count: Array.isArray(workGraph.active_waves) ? workGraph.active_waves.length : null,
-            parallel_write_wave_count: Array.isArray(workGraph.active_waves) ? workGraph.active_waves.filter((wave) => Array.isArray(wave.write_paths) && wave.write_paths.length > 1).length : null
-        } : null,
-        concurrency_governor: governor
+        ok: false,
+        status: 'blocked',
+        reason: 'naruto_gpt_5_6_family_only_glm_override_forbidden',
+        blockers: ['naruto_gpt_5_6_family_only_glm_override_forbidden'],
+        hint: 'Use normal sks naruto for the official Codex subagent workflow. The separate legacy GLM route requires sks --mad --glm --naruto.'
     };
-    return emit(parsed, summary, () => {
-        console.log('🍥 Naruto mission: ' + id);
-        console.log('Proof: ' + summary.proof);
-        if (summary.target_active_slots !== null)
-            console.log('Active clones: ' + summary.target_active_slots + ' / max ' + summary.max_active_slots);
-        if (roleDistribution?.entries)
-            console.log('Roles: ' + roleDistribution.entries.map((entry) => `${entry.role}:${entry.count}`).join(', '));
-    });
+    process.exitCode = 1;
+    if (json)
+        console.log(JSON.stringify(result, null, 2));
+    else
+        console.error(`$Naruto blocked: ${result.reason}. ${result.hint}`);
+    return result;
 }
-async function narutoDashboard(parsed) {
-    const root = await sksRoot();
-    const id = parsed.missionId && parsed.missionId !== 'latest' ? parsed.missionId : await findLatestMission(root, { mode: 'naruto' });
-    if (!id)
-        return emit(parsed, { schema: NARUTO_RESULT_SCHEMA, ok: false, action: 'dashboard', status: 'missing_mission' }, () => console.log('No Naruto mission found.'));
-    const { dir } = await loadMission(root, id);
-    const snapshot = await readJson(path.join(dir, 'zellij-dashboard-snapshot.json'), null);
-    const rightColumnState = await readJson(path.join(dir, 'zellij-right-column-state.json'), null);
-    const summary = {
+function legacyFlagBlock(flags) {
+    return {
         schema: NARUTO_RESULT_SCHEMA,
-        ok: Boolean(snapshot || rightColumnState),
-        action: 'dashboard',
-        mission_id: id,
-        snapshot,
-        right_column_state: rightColumnState,
-        blockers: snapshot || rightColumnState ? [] : ['naruto_dashboard_missing']
+        ok: false,
+        status: 'blocked',
+        blockers: flags.map((flag) => `removed_legacy_process_flag:${flag}`),
+        hint: 'Naruto supports only the Codex official subagent workflow. Use --agents, --max-threads, --read-only, --mission, or --json.'
     };
-    return emit(parsed, summary, () => {
-        console.log('🍥 Naruto dashboard: ' + id);
-        console.log('Right column: ' + (rightColumnState?.status || 'missing'));
-        if (snapshot)
-            console.log('Active/visible/headless/queue: ' + [snapshot.active_workers, snapshot.visible_panes, snapshot.headless_workers, snapshot.queue_depth].join('/'));
-    });
 }
-async function narutoWorkers(parsed) {
-    const root = await sksRoot();
-    const id = parsed.missionId && parsed.missionId !== 'latest' ? parsed.missionId : await findLatestMission(root, { mode: 'naruto' });
-    if (!id)
-        return emit(parsed, { schema: NARUTO_RESULT_SCHEMA, ok: false, action: 'workers', status: 'missing_mission' }, () => console.log('No Naruto mission found.'));
-    const { dir } = await loadMission(root, id);
-    const swarm = await readJson(path.join(dir, 'agents', 'agent-native-cli-session-swarm.json'), null);
-    const state = await readJson(path.join(dir, 'zellij-right-column-state.json'), null);
-    const records = Array.isArray(swarm?.records) ? swarm.records : [];
-    const summary = {
+function argumentBlock(errors) {
+    return {
         schema: NARUTO_RESULT_SCHEMA,
-        ok: Boolean(swarm || state),
-        action: 'workers',
-        mission_id: id,
-        active: records.filter((row) => row.status === 'running' || row.status === 'launching').length,
-        completed: records.filter((row) => row.status === 'closed').length,
-        failed: records.filter((row) => row.status === 'failed').length,
-        visible_worker_panes: state?.visible_worker_panes || [],
-        headless_workers: state?.headless_workers || [],
-        records,
-        blockers: swarm || state ? [] : ['naruto_worker_records_missing']
+        ok: false,
+        status: 'blocked',
+        reason: 'invalid_naruto_arguments',
+        blockers: errors.map((error) => `invalid_naruto_argument:${error}`),
+        hint: 'Provide a non-empty quoted task and valid positive integers for --agents/--max-threads. Use only official Naruto options.'
     };
-    return emit(parsed, summary, () => {
-        console.log('🍥 Naruto workers: ' + id);
-        console.log(`Active ${summary.active} · completed ${summary.completed} · failed ${summary.failed} · visible ${summary.visible_worker_panes.length} · headless ${summary.headless_workers.length}`);
-    });
 }
-async function narutoProof(parsed) {
-    const root = await sksRoot();
-    const id = parsed.missionId && parsed.missionId !== 'latest' ? parsed.missionId : await findLatestMission(root, { mode: 'naruto' });
-    if (!id)
-        return emit(parsed, { schema: NARUTO_RESULT_SCHEMA, ok: false, action: 'proof', status: 'missing_mission' }, () => console.log('No Naruto mission found.'));
-    const summary = await buildRuntimeProofSummary(root, id, { maxMessages: parsed.messages });
-    return emit(parsed, { ...summary, action: 'proof' }, () => {
-        console.log(renderRuntimeProofSummary(summary));
-    });
-}
-async function narutoHelp(parsed) {
-    const help = {
+function missingMission(parsed, action) {
+    return emit(parsed, {
         schema: NARUTO_RESULT_SCHEMA,
-        ok: true,
-        action: 'help',
-        mode: 'NARUTO',
-        description: 'Shadow Clone Swarm: fan out up to ' + MAX_NARUTO_AGENT_COUNT + ' parallel clone sessions.',
-        usage: [
-            'sks naruto run "<task>" [--clones N] [--backend codex-sdk|fake|ollama|local-llm] [--local-model|--ollama|--no-ollama] [--work-items N] [--tournament 2-4] [--write-mode parallel|serial|off] [--apply-patches] [--dry-run-patches] [--real] [--readonly] [--json]',
-            'sks naruto status [--mission <id>] [--json]',
-            'sks naruto proof latest [--messages 20] [--json]'
-        ],
-        defaults: { clones: DEFAULT_NARUTO_CLONES, max_clones: MAX_NARUTO_AGENT_COUNT, backend: 'codex-sdk' }
-    };
-    return emit(parsed, help, () => {
-        console.log('🍥 $Naruto — Shadow Clone Swarm (影分身)');
-        console.log(help.description);
-        for (const line of help.usage)
-            console.log('  ' + line);
-    });
-}
-function parseNarutoArgs(args = []) {
-    if (hasFlag(args, '--help') || hasFlag(args, '-h'))
-        args = ['help', ...args.filter((arg) => arg !== '--help' && arg !== '-h')];
-    const first = args[0] && !String(args[0]).startsWith('--') ? String(args[0]) : '';
-    const actions = new Set(['run', 'status', 'help', 'dashboard', 'workers', 'proof']);
-    const action = (actions.has(first) ? first : 'run');
-    const rest = action === first ? args.slice(1) : args;
-    const json = hasFlag(args, '--json');
-    // Computed early (normally derived further down) so an explicit --clones/
-    // --agents can still override this exactly as before, but the *default*
-    // scales with apparent task size instead of unconditionally requesting
-    // DEFAULT_NARUTO_CLONES for every run, including a one-line typo fix
-    // (20차 P2-3). --work-items defaults to clones*2 below, so this alone
-    // scales that down proportionally too.
-    const promptSizingValueFlags = new Set(['--clones', '--agents', '--work-items', '--concurrency', '--target-active-slots', '--backend', '--write-mode', '--max-write-agents', '--service-tier', '--mission', '--mission-id', '--ollama-model', '--local-model-model', '--ollama-base-url', '--local-model-base-url', '--parallelism', '--messages', '--tournament']);
-    const promptForSizing = positionalArgs(rest, promptSizingValueFlags).join(' ').trim();
-    const requestedClones = Number(readOption(args, '--clones', readOption(args, '--agents', String(estimateNarutoDefaultCloneCount(promptForSizing)))));
-    const clones = clampClones(requestedClones);
-    const workItemsExplicit = hasOption(args, '--work-items');
-    const workItems = clampWorkItems(Number(readOption(args, '--work-items', clones * 2)), clones);
-    const concurrency = normalizeConcurrency(readOption(args, '--concurrency', readOption(args, '--target-active-slots', null)), clones);
-    const useOllamaProtocol = hasFlag(args, '--ollama');
-    const useLocalModel = hasFlag(args, '--local-model');
-    const useOllama = useOllamaProtocol || useLocalModel;
-    const noOllama = hasFlag(args, '--no-ollama') || hasFlag(args, '--no-local-model');
-    const backendExplicit = hasOption(args, '--backend') || useOllama || noOllama;
-    const defaultBackend = hasFlag(args, '--mock')
-        ? 'fake'
-        : useLocalModel && !noOllama
-            ? 'local-llm'
-            : useOllamaProtocol && !noOllama
-                ? 'ollama'
-                : 'codex-sdk';
-    const backend = String(readOption(args, '--backend', defaultBackend));
-    const mock = hasFlag(args, '--mock') || backend === 'fake';
-    const real = hasFlag(args, '--real');
-    const readonly = hasFlag(args, '--readonly') || hasFlag(args, '--read-only');
-    const writeModeRaw = String(readOption(args, '--write-mode', hasFlag(args, '--parallel-write') ? 'parallel' : '') || '');
-    const writeMode = (['proof-safe', 'parallel', 'serial', 'off'].includes(writeModeRaw) ? writeModeRaw : null);
-    const applyPatches = hasFlag(args, '--apply-patches');
-    const dryRunPatches = hasFlag(args, '--dry-run-patches') || hasFlag(args, '--dry-run-patch');
-    const maxWriteAgents = Math.max(0, Math.floor(Number(readOption(args, '--max-write-agents', '0')) || 0));
-    const explicitServiceTier = String(readOption(args, '--service-tier', '') || '');
-    const requestedServiceTier = normalizeServiceTier(explicitServiceTier, null) || undefined;
-    // Naruto clones always run in the fast service tier. The route-level skill and
-    // release docs explicitly treat --no-fast / standard as non-honored for clones.
-    const serviceTier = action === 'run' ? 'fast' : requestedServiceTier;
-    const fastMode = action === 'run'
-        ? true
-        : hasFlag(args, '--no-fast') || requestedServiceTier === 'standard'
-            ? false
-            : hasFlag(args, '--fast')
-                ? true
-                : undefined;
-    const noFast = action === 'run' ? false : hasFlag(args, '--no-fast');
-    const positionalMission = action === 'dashboard' || action === 'workers' || action === 'status' || action === 'proof'
-        ? positionalArgs(rest, new Set()).find((arg) => /^latest$|^M-/.test(arg))
-        : null;
-    const missionId = String(readOption(args, '--mission', readOption(args, '--mission-id', positionalMission || 'latest')));
-    const ollamaModel = String(readOption(args, '--ollama-model', readOption(args, '--local-model-model', '')) || '') || null;
-    const ollamaBaseUrl = String(readOption(args, '--ollama-base-url', readOption(args, '--local-model-base-url', '')) || '') || null;
-    const noOpenZellij = hasFlag(args, '--no-open-zellij') || hasFlag(args, '--no-zellij');
-    const attach = hasFlag(args, '--attach');
-    const smoke = hasFlag(args, '--smoke');
-    const parallelism = normalizeParallelism(readOption(args, '--parallelism', 'safe'));
-    const messages = normalizeMessages(readOption(args, '--messages', '8'));
-    const tournament = normalizeTournament(readOption(args, '--tournament', '0'));
-    const prompt = promptForSizing || 'Naruto shadow clone swarm run';
-    return { action, prompt, clones, workItems, workItemsExplicit, concurrency, backend, backendExplicit, mock, real, readonly, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, writeMode, applyPatches, dryRunPatches, maxWriteAgents, fastMode, serviceTier, noFast, json, missionId, noOpenZellij, attach, smoke, parallelism, messages, tournament };
-}
-function normalizeParallelism(value) {
-    const text = String(value || 'safe').toLowerCase();
-    if (text === 'safe' || text === 'balanced' || text === 'extreme')
-        return text;
-    return 'safe';
-}
-function normalizeMessages(value) {
-    const parsed = Number(value);
-    return Math.max(0, Math.min(100, Math.floor(Number.isFinite(parsed) ? parsed : 8)));
-}
-function normalizeTournament(value) {
-    const parsed = Number(value);
-    if (!Number.isFinite(parsed) || parsed < 2)
-        return 0;
-    return Math.max(2, Math.min(4, Math.floor(parsed)));
-}
-async function writeNarutoArtifacts(ledgerRoot, artifacts) {
-    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-work-graph.json'), artifacts.workGraph);
-    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-role-distribution.json'), artifacts.roleDistribution);
-    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-concurrency-governor.json'), artifacts.governor);
-    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-active-pool.json'), {
-        schema: 'sks.naruto-active-pool.v1',
-        ok: null,
-        status: 'not_computed',
-        reason: 'simulated_active_pool_removed_from_production_path_20cha_p3_5',
-        runtime_source_of_truth: 'agent-orchestrator-scheduler',
-        see: 'naruto-real-active-pool.json'
-    });
-    if (artifacts.realActivePool)
-        await writeJsonAtomic(path.join(ledgerRoot, 'naruto-real-active-pool.json'), artifacts.realActivePool);
-    if (artifacts.allocationPolicy)
-        await writeJsonAtomic(path.join(ledgerRoot, 'naruto-allocation-policy.json'), artifacts.allocationPolicy);
-    if (artifacts.rebalancePolicy)
-        await writeJsonAtomic(path.join(ledgerRoot, 'naruto-rebalance-policy.json'), artifacts.rebalancePolicy);
-    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-verification-dag.json'), artifacts.verificationDag);
-    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-gpt-final-pack.json'), artifacts.gptFinalPack);
-    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-zellij-dashboard.json'), artifacts.zellijDashboard);
-    await writeJsonAtomic(path.join(ledgerRoot, 'prompt-placeholder-guard.json'), artifacts.placeholderGuard);
-    if (artifacts.gitWorktreeCapability)
-        await writeJsonAtomic(path.join(ledgerRoot, 'git-worktree-capability.json'), artifacts.gitWorktreeCapability);
-}
-function clampClones(value) {
-    if (!Number.isFinite(value) || value < 1)
-        return DEFAULT_NARUTO_CLONES;
-    return Math.min(MAX_NARUTO_AGENT_COUNT, Math.floor(value));
-}
-function clampWorkItems(value, clones) {
-    if (!Number.isFinite(value) || value < 1)
-        return clones;
-    return Math.floor(value);
-}
-function normalizeConcurrency(value, clones) {
-    if (value == null || value === '')
-        return null;
-    const parsed = Number(value);
-    if (!Number.isFinite(parsed) || parsed < 1)
-        return null;
-    return Math.min(Math.floor(parsed), clones, MAX_NARUTO_AGENT_COUNT);
-}
-function hasFlag(args, flag) {
-    return args.includes(flag);
+        ok: false,
+        action,
+        status: 'missing_mission'
+    }, () => console.log('No Naruto mission found.'));
 }
-function readOption(args, name, fallback) {
-    const index = args.indexOf(name);
-    if (index >= 0 && args[index + 1] && !String(args[index + 1]).startsWith('--'))
-        return args[index + 1];
-    const prefixed = args.find((arg) => String(arg).startsWith(name + '='));
-    return prefixed ? prefixed.slice(name.length + 1) : fallback;
-}
-function hasOption(args, name) {
-    return args.includes(name) || args.some((arg) => String(arg).startsWith(name + '='));
-}
-function positionalArgs(args, valueFlags) {
-    const out = [];
-    for (let i = 0; i < args.length; i += 1) {
-        const arg = String(args[i]);
-        if (arg.startsWith('--')) {
-            if (valueFlags.has(arg) && args[i + 1] && !String(args[i + 1]).startsWith('--'))
-                i += 1;
-            continue;
-        }
-        out.push(arg);
-    }
-    return out;
-}
-function emit(parsed, result, text) {
-    if (parsed.json) {
+function emit(parsed, result, human, failed = false) {
+    if (failed)
+        process.exitCode = 1;
+    if (parsed.json)
         console.log(JSON.stringify(result, null, 2));
-        return result;
-    }
-    text();
+    else
+        human();
     return result;
 }
-async function resolveNarutoLocalWorkerMode(parsed) {
-    const configInput = {
-        ollamaEnabled: parsed.ollamaEnabled,
-        model: parsed.ollamaModel,
-        baseUrl: parsed.ollamaBaseUrl
-    };
-    if (parsed.backend === 'ollama')
-        configInput.backend = 'ollama';
-    const config = await resolveOllamaWorkerConfig(configInput).catch(() => null);
-    const policy = classifyOllamaWorkerSlice({
-        id: 'naruto-local-worker-probe',
-        role: parsed.readonly ? 'collector' : 'implementer',
-        description: parsed.prompt,
-        write_paths: parsed.readonly ? [] : ['<lease-scoped-worker-path>']
-    }, { route: NARUTO_ROUTE, agent: { role: parsed.readonly ? 'collector' : 'implementer' } });
-    const localAutoSelectCandidate = parsed.backend === 'codex-sdk'
-        && parsed.backendExplicit !== true
-        && parsed.noOllama !== true
-        && config?.ok === true
-        && config.enabled === true
-        && policy.ok === true;
-    return {
-        schema: 'sks.naruto-local-worker-mode.v1',
-        enabled: config?.enabled === true,
-        provider: config?.provider || 'ollama',
-        model: config?.model || null,
-        requested_backend: parsed.backend,
-        backend_explicit: parsed.backendExplicit,
-        auto_select_eligible: false,
-        worker_only: true,
-        no_strategy_planning_design: true,
-        policy,
-        blockers: [
-            ...(config?.blockers || (config ? [] : ['ollama_worker_config_unavailable'])),
-            ...(policy.blockers || []),
-            ...(localAutoSelectCandidate ? ['naruto_gpt_5_6_family_only_local_auto_select_forbidden'] : []),
-            ...(parsed.backendExplicit ? ['backend_explicit'] : []),
-            ...(parsed.noOllama ? ['no_ollama_requested'] : [])
-        ]
-    };
+function renderRunResult(result) {
+    console.log(`$Naruto ${result.status}: ${result.mission_id}`);
+    console.log(`Official subagents: requested ${result.requested_subagents}, 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.');
+    if (Array.isArray(result.blockers) && result.blockers.length)
+        console.log(`Blockers: ${result.blockers.join(', ')}`);
+}
+function renderStatusResult(result) {
+    console.log(`Naruto ${result.action || 'status'}: ${result.mission_id}`);
+    console.log(`Started/completed/failed: ${result.started_subagents || 0}/${result.completed_subagents || 0}/${result.failed_subagents || 0}`);
+}
+function uniqueStrings(values) {
+    return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))];
 }
 //# sourceMappingURL=naruto-command.js.map