sneakoscope 3.1.0 → 3.1.2

package/dist/core/agents/native-cli-session-swarm.js

@@ -12,6 +12,7 @@ import { resolveZellijWorkerPaneUiMode } from '../zellij/zellij-ui-mode.js';
 import { appendZellijSlotTelemetry } from '../zellij/zellij-slot-telemetry.js';
 import { appendParallelRuntimeEvent } from './parallel-runtime-proof.js';
 import { appendAgentMessage } from './agent-message-bus.js';
+import { markLoopWorkerInterrupted, registerLoopActiveWorker } from '../loops/loop-interrupt-registry.js';
 export const NATIVE_CLI_SESSION_SWARM_SCHEMA = 'sks.agent-native-cli-session-swarm.v1';
 export function createNativeCliSessionSwarmRecorder(root, input) {
     return new NativeCliSessionSwarmRecorder(root, input);
@@ -176,6 +177,13 @@ class NativeCliSessionSwarmRecorder {
         });
         record.pid = child.pid || null;
         record.process_id = child.pid || null;
+        const loopHandle = await registerLoopWorkerHandle({
+            root: ctx.opts.projectRoot || this.input.projectRoot || ctx.opts.cwd || packageRoot(),
+            env: ctx.opts.env || {},
+            agentId: String(ctx.agent.id || ctx.agent.session_id || 'agent'),
+            sessionId: ctx.agent.session_id || null,
+            pid: child.pid || null
+        });
         record.status = 'running';
         await appendParallelRuntimeEvent(this.root, this.input.missionId, {
             event_type: 'worker_process_spawned',
@@ -211,6 +219,9 @@ class NativeCliSessionSwarmRecorder {
         record.exit_code = exit.code;
         record.signal = exit.signal;
         record.status = exit.code === 0 ? 'closed' : 'failed';
+        if (loopHandle) {
+            await markLoopWorkerInterrupted(ctx.opts.projectRoot || this.input.projectRoot || ctx.opts.cwd || packageRoot(), loopHandle.mission_id, loopHandle.worker_id, record.status === 'closed' ? 'completed' : 'failed').catch(() => undefined);
+        }
         if (record.worker_placement === 'headless') {
             await closeWorkerInRightColumn({
                 root: this.root,
@@ -343,6 +354,13 @@ class NativeCliSessionSwarmRecorder {
                 stdoutRel: input.stdoutRel,
                 stderrRel: input.stderrRel
             });
+        let loopHandle = await registerLoopWorkerHandle({
+            root: input.ctx.opts.projectRoot || this.input.projectRoot || input.ctx.opts.cwd || packageRoot(),
+            env: input.ctx.opts.env || {},
+            agentId: String(input.ctx.agent.id || input.ctx.agent.session_id || 'agent'),
+            sessionId: input.ctx.agent.session_id || null,
+            pid: processRun?.pid || null
+        });
         if (processRun?.pid) {
             input.record.pid = processRun.pid;
             input.record.process_id = processRun.pid;
@@ -379,6 +397,7 @@ class NativeCliSessionSwarmRecorder {
                 serviceTier: this.input.fastModePolicy.service_tier,
                 worktree: worktree ? { id: worktree.id, path: worktree.path, branch: worktree.branch } : null,
                 backend: this.input.backend,
+                taskTitle: String(input.ctx.slice?.title || input.ctx.slice?.description || input.ctx.slice?.id || '') || null,
                 uiMode,
                 projectRoot: input.ctx.opts.projectRoot || this.input.projectRoot || input.ctx.opts.cwd,
                 rightColumnMode: 'spawn-on-first-worker',
@@ -484,7 +503,23 @@ class NativeCliSessionSwarmRecorder {
             session_id: input.ctx.agent.session_id,
             worker_artifact_dir: input.workerDirRel
         });
-        const parsed = await waitForWorkerResult(path.join(this.root, input.resultRel), Number(process.env.SKS_ZELLIJ_WORKER_RESULT_TIMEOUT_MS || 120000));
+        const parsed = await this.waitForWorkerResultWithActivity({
+            resultPath: path.join(this.root, input.resultRel),
+            activityPaths: [
+                path.join(this.root, input.heartbeatRel),
+                path.join(this.root, input.stdoutRel),
+                path.join(this.root, input.stderrRel),
+                path.join(this.root, input.workerDirRel, 'codex-sdk-events.jsonl'),
+                path.join(this.root, input.workerDirRel, 'python-codex-sdk-events.jsonl'),
+                path.join(this.root, input.workerDirRel, 'local-llm-events.jsonl')
+            ],
+            stdoutPath: path.join(this.root, input.stdoutRel),
+            ctx: input.ctx,
+            heartbeatRel: input.heartbeatRel,
+            resultRel: input.resultRel,
+            stdoutRel: input.stdoutRel,
+            stderrRel: input.stderrRel
+        });
         const compactExit = processRun ? await processRun.wait(parsed ? 10000 : 1000) : null;
         this.active.delete(activeToken);
         input.record.closed_at = nowIso();
@@ -525,6 +560,15 @@ class NativeCliSessionSwarmRecorder {
         }
         input.record.pid = Number(workerProcessReport?.pid || processRun?.pid) || null;
         input.record.process_id = input.record.pid;
+        if (!loopHandle && input.record.pid) {
+            loopHandle = await registerLoopWorkerHandle({
+                root: input.ctx.opts.projectRoot || this.input.projectRoot || input.ctx.opts.cwd || packageRoot(),
+                env: input.ctx.opts.env || {},
+                agentId: String(input.ctx.agent.id || input.ctx.agent.session_id || 'agent'),
+                sessionId: input.ctx.agent.session_id || null,
+                pid: input.record.pid
+            });
+        }
         input.record.compact_worker_exit_code = compactExit?.code ?? null;
         input.record.compact_worker_signal = compactExit?.signal ?? null;
         input.record.sdk_thread_id = sdkThreadId;
@@ -533,6 +577,9 @@ class NativeCliSessionSwarmRecorder {
         input.record.structured_output_valid = workerProcessReport?.structured_output_valid === true || workerProcessReport?.backend_router_report?.structured_output_valid === true;
         input.record.exit_code = parsed ? (parsed.status === 'done' ? 0 : 1) : 1;
         input.record.status = parsed?.status === 'done' ? 'closed' : 'failed';
+        if (loopHandle) {
+            await markLoopWorkerInterrupted(input.ctx.opts.projectRoot || this.input.projectRoot || input.ctx.opts.cwd || packageRoot(), loopHandle.mission_id, loopHandle.worker_id, input.record.status === 'closed' ? 'completed' : 'failed').catch(() => undefined);
+        }
         const heartbeatOk = await hasHeartbeat(path.join(this.root, input.heartbeatRel));
         input.record.blockers = [
             ...(parsed ? parsed.blockers || [] : ['zellij_worker_result_timeout']),
@@ -593,6 +640,45 @@ class NativeCliSessionSwarmRecorder {
             artifacts: [...new Set([...(Array.isArray(parsed.artifacts) ? parsed.artifacts : []), input.stdoutRel, input.stderrRel, path.join(input.workerDirRel, 'zellij-worker-pane.json')])]
         });
     }
+    // Root-cause-2 fix: a fixed 2-minute wall-clock result timeout killed live codex-sdk
+    // workers (real runs exceed 2 min), marking false zellij_worker_result_timeout failures and
+    // freezing the UI while the worker kept running. Replace it with an activity-aware wait: keep
+    // waiting as long as ANY worker artifact (heartbeat, stdout/stderr, sdk event jsonl) was touched
+    // recently. Only give up after SKS_ZELLIJ_WORKER_INACTIVITY_TIMEOUT_MS of silence (default 5min)
+    // OR an absolute cap SKS_ZELLIJ_WORKER_RESULT_TIMEOUT_MS (default 1h; 0 = no cap). While waiting,
+    // emit a heartbeat telemetry event every ~10s so the SLOTS snapshot updated_at stays fresh from
+    // the orchestrator side too.
+    async waitForWorkerResultWithActivity(input) {
+        const inactivityTimeoutMs = Math.max(1000, Number(process.env.SKS_ZELLIJ_WORKER_INACTIVITY_TIMEOUT_MS || 300000));
+        const absoluteCapRaw = Number(process.env.SKS_ZELLIJ_WORKER_RESULT_TIMEOUT_MS ?? 3600000);
+        const absoluteCapMs = Number.isFinite(absoluteCapRaw) ? absoluteCapRaw : 3600000;
+        const start = Date.now();
+        let lastActivityMs = start;
+        let lastHeartbeatEmit = 0;
+        for (;;) {
+            const result = await readJson(input.resultPath, null).catch(() => null);
+            if (result)
+                return result;
+            const now = Date.now();
+            const newestActivity = await newestMtimeMs(input.activityPaths);
+            if (newestActivity != null && newestActivity > lastActivityMs)
+                lastActivityMs = newestActivity;
+            if (absoluteCapMs > 0 && now - start >= absoluteCapMs)
+                return null;
+            if (now - lastActivityMs >= inactivityTimeoutMs)
+                return null;
+            if (now - lastHeartbeatEmit >= 10000) {
+                lastHeartbeatEmit = now;
+                await this.telemetry(input.ctx, {
+                    eventType: 'heartbeat',
+                    status: 'running',
+                    artifacts: [input.heartbeatRel, input.resultRel, input.stdoutRel, input.stderrRel],
+                    logTail: await tailFile(input.stdoutPath, 600)
+                });
+            }
+            await new Promise((resolve) => setTimeout(resolve, 250));
+        }
+    }
     async finalize() {
         await this.persist();
         return this.summary();
@@ -777,15 +863,19 @@ function buildPaneWorkerHeader(input) {
         'status: running'
     ].join('\n');
 }
-async function waitForWorkerResult(file, timeoutMs) {
-    const deadline = Date.now() + Math.max(1000, timeoutMs);
-    while (Date.now() < deadline) {
-        const result = await readJson(file, null).catch(() => null);
-        if (result)
-            return result;
-        await new Promise((resolve) => setTimeout(resolve, 250));
+async function newestMtimeMs(files) {
+    let newest = null;
+    for (const file of files) {
+        try {
+            const mtime = (await fs.promises.stat(file)).mtimeMs;
+            if (newest == null || mtime > newest)
+                newest = mtime;
+        }
+        catch {
+            // missing file: no activity signal from it
+        }
     }
-    return null;
+    return newest;
 }
 async function waitForWorkerHeartbeat(file, timeoutMs) {
     const deadline = Date.now() + Math.max(1000, timeoutMs);
@@ -855,6 +945,22 @@ function normalizeParallelPlacement(value) {
         return text;
     return 'unknown';
 }
+async function registerLoopWorkerHandle(input) {
+    const missionId = String(input.env.SKS_MISSION_ID || input.env.SKS_PARENT_MISSION_ID || '').trim();
+    const loopId = String(input.env.SKS_LOOP_ID || '').trim();
+    const phase = String(input.env.SKS_LOOP_PHASE || '').trim();
+    if (!missionId || !loopId || (phase !== 'maker' && phase !== 'checker'))
+        return null;
+    return registerLoopActiveWorker(input.root, {
+        mission_id: missionId,
+        loop_id: loopId,
+        phase,
+        worker_id: input.agentId,
+        session_id: input.sessionId,
+        pid: input.pid,
+        interrupt_supported: Boolean(input.pid || input.sessionId)
+    }).catch(() => null);
+}
 async function tailFile(file, max) {
     try {
         const text = await fs.promises.readFile(file, 'utf8');

package/dist/core/agents/no-subagent-scaling-policy.js

@@ -3,6 +3,7 @@ import { nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
 export const NO_SUBAGENT_SCALING_POLICY_SCHEMA = 'sks.no-subagent-scaling-policy.v1';
 export async function writeNoSubagentScalingPolicy(root, input = {}) {
     const nativeProof = input.nativeProof || await readJson(path.join(root, 'native-cli-session-proof.json'), null);
+    const officialSubagentHelperPolicy = input.officialSubagentHelperPolicy || await readJson(path.join(root, 'official-subagent-helper-policy.json'), null);
     const swarm = await readJson(path.join(root, 'agent-native-cli-session-swarm.json'), null);
     const events = await readText(path.join(root, 'agent-events.jsonl'), '');
     const subagentEventCount = String(events).split(/\n/).filter((line) => /Subagent(Start|Stop)|subagent/i.test(line)).length;
@@ -11,7 +12,8 @@ export async function writeNoSubagentScalingPolicy(root, input = {}) {
     const blockers = [
         ...(allowedScalingPrimitives.has(String(swarm?.scaling_primitive || '')) ? [] : ['main_scaling_primitive_not_native_cli_process']),
         ...(nativeProcessCount > 0 ? [] : ['native_cli_worker_process_proof_missing']),
-        ...(nativeProof?.worker_proof_is_only_subagent_events === true ? ['worker_proof_only_subagent_events'] : [])
+        ...(nativeProof?.worker_proof_is_only_subagent_events === true ? ['worker_proof_only_subagent_events'] : []),
+        ...(officialSubagentHelperPolicy?.ok === false ? officialSubagentHelperPolicy.blockers || ['official_subagent_helper_policy_not_ok'] : [])
     ];
     const report = {
         schema: NO_SUBAGENT_SCALING_POLICY_SCHEMA,
@@ -21,6 +23,13 @@ export async function writeNoSubagentScalingPolicy(root, input = {}) {
         subagent_events_counted_as_worker_sessions: false,
         scout_events_counted_as_worker_sessions: false,
         worker_internal_scout_usage_allowed_as_helper_only: true,
+        official_codex_subagent_helper_lane_allowed: officialSubagentHelperPolicy?.ok !== false,
+        official_codex_subagent_helper_policy: officialSubagentHelperPolicy ? 'official-subagent-helper-policy.json' : null,
+        official_helper_lane_worker_capacity_credit: 0,
+        official_helper_lane_observed_subagent_event_count: Number(officialSubagentHelperPolicy?.observed_subagent_event_count || 0),
+        official_helper_lane_events_counted_as_worker_sessions: false,
+        codex_builtin_capability_lane_allowed: officialSubagentHelperPolicy?.official_codex_subagent_helper_lane_enabled === true,
+        codex_builtin_imagegen_helper_allowed: officialSubagentHelperPolicy?.codex_builtin_imagegen_helper_allowed === true,
         native_worker_process_count: nativeProcessCount,
         subagent_event_count: subagentEventCount,
         worker_process_proof: 'native-cli-session-proof.json',

package/dist/core/agents/official-subagent-helper-policy.js

@@ -0,0 +1,62 @@
+import path from 'node:path';
+import { nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
+export const OFFICIAL_SUBAGENT_HELPER_POLICY_SCHEMA = 'sks.official-subagent-helper-policy.v1';
+export async function writeOfficialSubagentHelperPolicy(root, input = {}) {
+    const nativeProof = input.nativeProof || await readJson(path.join(root, 'native-cli-session-proof.json'), null);
+    const events = await readText(path.join(root, 'agent-events.jsonl'), '');
+    const subagentEventCount = String(events).split(/\n/).filter((line) => /Subagent(Start|Stop)|subagent/i.test(line)).length;
+    const nativeProcessCount = Number(nativeProof?.spawned_worker_process_count || 0);
+    const workerCapacityCredit = 0;
+    const subagentEventsCountedAsWorkerSessions = false;
+    const builtInAgentsAllowed = ['default', 'worker', 'explorer'];
+    const codexAppCapabilitiesAllowed = [
+        'image_generation',
+        'computer_use_for_native_app_targets',
+        'in_app_browser_for_allowed_web_targets',
+        'web_search',
+        'mcp_tools',
+        'product_design_plugin'
+    ];
+    const requiredOutputProofForGeneratedImages = ['path', 'sha256', 'bytes', 'dimensions', 'model_or_surface'];
+    const blockers = [
+        ...(workerCapacityCredit === 0 ? [] : ['official_helper_worker_capacity_credit_not_zero']),
+        ...(subagentEventsCountedAsWorkerSessions === false ? [] : ['official_helper_subagent_events_counted_as_worker_sessions']),
+        ...(codexAppCapabilitiesAllowed.includes('image_generation') ? [] : ['official_helper_image_generation_capability_missing']),
+        ...(requiredOutputProofForGeneratedImages.includes('sha256') && requiredOutputProofForGeneratedImages.includes('dimensions')
+            ? []
+            : ['official_helper_image_output_proof_incomplete'])
+    ];
+    const report = {
+        schema: OFFICIAL_SUBAGENT_HELPER_POLICY_SCHEMA,
+        generated_at: nowIso(),
+        ok: blockers.length === 0,
+        official_codex_subagent_helper_lane_enabled: true,
+        official_codex_subagents_allowed: true,
+        helper_lane_role: 'capability_helper_only',
+        helper_lane_may_run_in_parallel_with_native_workers: true,
+        worker_capacity_source: 'native-cli-session-proof.json',
+        worker_capacity_credit: workerCapacityCredit,
+        subagent_events_counted_as_worker_sessions: subagentEventsCountedAsWorkerSessions,
+        native_worker_process_count: nativeProcessCount,
+        observed_subagent_event_count: subagentEventCount,
+        built_in_agents_allowed: builtInAgentsAllowed,
+        codex_app_capabilities_allowed: codexAppCapabilitiesAllowed,
+        codex_builtin_imagegen_helper_allowed: true,
+        preferred_image_generation_surface: 'Codex App $imagegen/gpt-image-2',
+        codex_app_builtin_evidence_class: 'codex_app_builtin',
+        api_fallback_evidence_class: 'api_fallback',
+        provider_surface_evidence_required: true,
+        imagegen_api_fallback_counts_as_codex_app_evidence: false,
+        required_output_proof_for_generated_images: requiredOutputProofForGeneratedImages,
+        proof_rule: 'Official Codex subagents and app tools may assist native workers, but never increase requested_agents, target_active_slots, spawned_worker_process_count, or max_observed_worker_process_count.',
+        limitations: [
+            'helper_subagent_events_do_not_prove_worker_capacity',
+            'codex_app_capability_detection_is_not_generated_output_proof',
+            'image_generation_claims_require_real_raster_output_evidence'
+        ],
+        blockers
+    };
+    await writeJsonAtomic(path.join(root, 'official-subagent-helper-policy.json'), report);
+    return report;
+}
+//# sourceMappingURL=official-subagent-helper-policy.js.map

package/dist/core/codex-app.js

@@ -809,8 +809,6 @@ async function codexFastModeConfigStatus(opts = {}) {
         blockers.push('user.fast_mode.visible_missing');
     if (!/(^|\n)\s*enabled\s*=\s*true\s*(?:#.*)?(?=\n|$)/.test(fastMode))
         blockers.push('user.fast_mode.enabled_missing');
-    if (!/(^|\n)\s*default_profile\s*=\s*"sks-fast-high"\s*(?:#.*)?(?=\n|$)/.test(fastMode))
-        blockers.push('user.fast_mode.default_profile_missing');
     return {
         ok: blockers.length === 0,
         checked: true,

package/dist/core/codex-control/codex-task-runner.js

@@ -290,6 +290,15 @@ async function runLocalControlTask(root, task, schema, routerDecision) {
         ...(validation.ok ? [] : ['local_llm_structured_output_invalid', ...validation.issues.map((issue) => `schema:${issue}`)])
     ];
     const workerResult = normalizeWorkerResult(structuredOutput, task, finalBlockers, validation.ok, 'local-llm');
+    // Stamp the local-llm request id as backend proof on model-authored patch
+    // envelopes; without it agent-patch-schema rejects every local-llm patch
+    // with model_authored_backend_proof_missing (the model cannot know the id).
+    if (Array.isArray(workerResult.patch_envelopes)) {
+        workerResult.patch_envelopes = workerResult.patch_envelopes.map((envelope) => ({
+            ...envelope,
+            backend_ollama_request_id: envelope?.backend_ollama_request_id || adapterResult.requestId
+        }));
+    }
     const workerResultPath = path.join(root, 'local-llm-worker-result.json');
     await writeJsonAtomic(workerResultPath, workerResult);
     const patchEnvelopePath = Array.isArray(workerResult.patch_envelopes) && workerResult.patch_envelopes.length

package/dist/core/commands/fast-mode-command.js

@@ -62,7 +62,7 @@ export async function fastModeCommand(args = []) {
     else if (action === 'clear')
         console.log(`Cleared: ${removed ? 'yes' : 'already default'}`);
     else if (!preference)
-        console.log('Preference: implicit fast');
+        console.log('Preference: implicit standard');
     console.log('Dollar: $Fast-On | $Fast-Off | $Fast-Mode');
     return result;
 }

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

@@ -1,12 +1,15 @@
 import path from 'node:path';
 import { printJson } from '../../cli/output.js';
 import { createMission, findLatestMission, loadMission, setCurrent } from '../mission.js';
-import { readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
-import { loopGraphProofPath, loopPlanPath, loopRoot } from '../loops/loop-artifacts.js';
+import { readJson, sksRoot } from '../fsx.js';
+import { loopActiveWorkerHandlesPath, loopIntegrationMergePath, loopLatestCheckpointPath, loopPlanPath, loopProofPath, loopRoot, loopSideEffectReportPath } from '../loops/loop-artifacts.js';
+import { finalizeLoopGraph } from '../loops/loop-finalizer.js';
 import { readLoopGraphProof } from '../loops/loop-observability.js';
 import { planLoopsFromRequest } from '../loops/loop-planner.js';
 import { renderLoopProofSummary } from '../loops/loop-proof-summary.js';
-import { runLoopPlan } from '../loops/loop-runtime.js';
+import { runLoopNode, runLoopPlan } from '../loops/loop-runtime.js';
+import { scheduleLoopGraph } from '../loops/loop-scheduler.js';
+import { writeLoopKillRequest } from '../loops/loop-runtime-control.js';
 import { flag, promptOf, readFlagValue } from './command-utils.js';
 export async function loopCommand(subcommand = 'help', args = []) {
     const action = subcommand || 'help';
@@ -21,7 +24,7 @@ export async function loopCommand(subcommand = 'help', args = []) {
     if (action === 'kill')
         return loopKill(args);
     if (action === 'resume')
-        return loopRun(args);
+        return loopResume(args);
     if (action === 'graph')
         return loopGraph(args);
     console.log(`SKS Loop
@@ -32,7 +35,7 @@ Usage:
   sks loop status latest [--json]
   sks loop proof latest [--json]
   sks loop kill <loop-id|all>
-  sks loop resume latest
+  sks loop resume latest [--rerun-completed]
   sks loop graph latest
 `);
 }
@@ -78,13 +81,33 @@ async function loopStatus(args) {
     const plan = await readJson(loopPlanPath(root, missionId), null);
     const proof = await readLoopGraphProof(root, missionId);
     const states = await Promise.all((plan?.graph.nodes || []).map((node) => readJson(path.join(loopRoot(root, missionId), node.loop_id, 'loop-state.json'), null)));
-    const result = { schema: 'sks.loop-status-command.v1', mission_id: missionId, plan_ok: Boolean(plan && plan.blockers.length === 0), graph: proof, states };
+    const proofs = await Promise.all((plan?.graph.nodes || []).map((node) => readJson(loopProofPath(root, missionId, node.loop_id), null)));
+    const checkpoints = await Promise.all((plan?.graph.nodes || []).map((node) => readJson(loopLatestCheckpointPath(root, missionId, node.loop_id), null)));
+    const activeWorkerHandles = await readJsonl(loopActiveWorkerHandlesPath(root, missionId));
+    const merge = await readJson(loopIntegrationMergePath(root, missionId), null);
+    const sideEffects = await readJson(loopSideEffectReportPath(root, missionId), null);
+    const result = { schema: 'sks.loop-status-command.v1', mission_id: missionId, plan_ok: Boolean(plan && plan.blockers.length === 0), graph: proof, states, proofs, checkpoints, active_worker_handles: activeWorkerHandles, merge, side_effects: sideEffects };
     if (flag(args, '--json'))
         return printJson(result);
     console.log(`Loop status: ${missionId}`);
     for (const state of states.filter(Boolean)) {
-        console.log(`  ${String(state.loop_id).padEnd(18)} ${String(state.status).padEnd(10)} iter ${state.iteration} owner ${(Array.isArray(state.acting_on?.files) ? state.acting_on.files.join(', ') : '-')}`);
+        const loopId = String(state.loop_id);
+        const nodeProof = proofs.find((row) => row?.loop_id === loopId);
+        const checkpoint = checkpoints.find((row) => row?.loop_id === loopId);
+        const backend = nodeProof?.maker_result?.backend || 'blocked';
+        const gates = nodeProof?.gate_result ? `${nodeProof.gate_result.passed_gates.length}/${nodeProof.gate_result.selected_gates.length}` : '-';
+        const worktree = nodeProof?.worktree?.id || state.acting_on?.worktree_id || '-';
+        const resumable = checkpoint?.resumable ? `resumable:${checkpoint.phase}` : 'resumable:-';
+        const active = activeWorkerHandles.filter((row) => row.loop_id === loopId && row.status === 'running').length;
+        const mergeStatus = merge?.merge_attempts?.[loopId]?.selected_strategy || '-';
+        console.log(`  ${loopId.padEnd(18)} ${String(state.status).padEnd(10)} backend ${String(backend).padEnd(24)} workers ${String(active).padEnd(2)} gates ${gates.padEnd(5)} worktree ${String(worktree).padEnd(18)} merge ${String(mergeStatus).padEnd(14)} ${resumable}`);
     }
+    if (merge)
+        console.log(`Merge: ${merge.ok ? 'passed' : 'blocked'} strategy=${JSON.stringify(merge.strategy_summary || {})}`);
+    if (sideEffects)
+        console.log(`Side effects: ${sideEffects.ok ? 'passed' : 'blocked'} blockers=${sideEffects.blockers?.length || 0}`);
+    if (proof?.gpt_final_arbiter)
+        console.log(`Final arbiter: ${proof.gpt_final_arbiter.verdict || 'unknown'} handled_by=${proof.gpt_final_arbiter.handled_by || 'loop-finalizer'}`);
 }
 async function loopProof(args) {
     const root = await sksRoot();
@@ -97,6 +120,12 @@ async function loopProof(args) {
     if (flag(args, '--json'))
         return printJson(proof);
     console.log(renderLoopProofSummary(proof));
+    if (proof.integration_merge)
+        console.log(`Merge: ${proof.integration_merge.ok ? 'passed' : 'blocked'} ${JSON.stringify(proof.integration_merge.strategy_summary || {})}`);
+    if (proof.side_effect_report)
+        console.log(`Side effects: ${proof.side_effect_report.ok ? 'passed' : 'blocked'} ${proof.side_effect_report.blockers?.join(', ') || 'none'}`);
+    if (proof.gpt_final_arbiter)
+        console.log(`Final arbiter: ${proof.gpt_final_arbiter.verdict || 'unknown'} contract=${proof.gpt_final_arbiter.gate_contract_path || 'missing'}`);
 }
 async function loopGraph(args) {
     const root = await sksRoot();
@@ -112,14 +141,43 @@ async function loopKill(args) {
     const target = args[0];
     if (!missionId || !target)
         throw new Error('Usage: sks loop kill <loop-id|all>');
-    await writeJsonAtomic(path.join(loopRoot(root, missionId), 'kill-request.json'), {
-        schema: 'sks.loop-kill-request.v1',
-        mission_id: missionId,
-        target,
-        requested_at: new Date().toISOString()
-    });
+    await writeLoopKillRequest(root, missionId, target);
     console.log(`Loop kill requested: ${target}`);
 }
+async function loopResume(args) {
+    const root = await sksRoot();
+    const missionId = await resolveLoopMission(root, args[0]);
+    if (!missionId)
+        throw new Error('Usage: sks loop resume <mission-id|latest> [--rerun-completed]');
+    const plan = await readJson(loopPlanPath(root, missionId));
+    const rerunCompleted = flag(args, '--rerun-completed');
+    const existingProofs = await Promise.all(plan.graph.nodes.map((node) => readJson(loopProofPath(root, missionId, node.loop_id), null)));
+    const completed = new Set(existingProofs.filter((proof) => proof !== null && proof.status === 'completed').map((proof) => proof.loop_id));
+    const runnable = rerunCompleted ? plan.graph.nodes : plan.graph.nodes.filter((node) => !completed.has(node.loop_id));
+    const schedule = scheduleLoopGraph(runnable, normalizeParallelism(readFlagValue(args, '--parallelism', 'balanced')));
+    const started = Date.now();
+    const resumedProofs = [];
+    for (const batch of schedule.batches) {
+        const batchProofs = await Promise.all(batch.map((node) => runLoopNode({ root, plan, node })));
+        resumedProofs.push(...batchProofs);
+    }
+    const mergedProofs = [
+        ...existingProofs.filter((proof) => proof !== null && proof.status === 'completed' && !rerunCompleted),
+        ...resumedProofs
+    ];
+    const graphProof = await finalizeLoopGraph({
+        root,
+        plan,
+        proofs: mergedProofs,
+        maxActiveLoops: schedule.max_active_loops,
+        maxActiveWorkers: Math.max(1, mergedProofs.reduce((sum, proof) => sum + proof.maker_result.worker_count + proof.checker_result.worker_count, 0)),
+        wallMs: Math.max(1, Date.now() - started)
+    });
+    await setCurrent(root, { mission_id: missionId, mode: 'LOOP', route: 'Loop', route_command: '$Loop', phase: graphProof.ok ? 'LOOP_COMPLETED' : 'LOOP_BLOCKED', stop_gate: 'loop-graph-proof.json' });
+    if (flag(args, '--json'))
+        return printJson({ schema: 'sks.loop-resume-command.v1', ok: graphProof.ok, mission_id: missionId, resumed_loops: resumedProofs.map((proof) => proof.loop_id), skipped_completed: [...completed], graph_proof: graphProof });
+    console.log(renderLoopProofSummary(graphProof));
+}
 async function resolveLoopMission(root, arg) {
     if (arg && arg !== 'latest')
         return arg;
@@ -132,4 +190,19 @@ async function resolveLoopMission(root, arg) {
 function normalizeParallelism(value) {
     return value === 'safe' || value === 'extreme' ? value : 'balanced';
 }
+async function readJsonl(file) {
+    const text = await import('node:fs/promises').then((fs) => fs.readFile(file, 'utf8')).catch(() => '');
+    return String(text).split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter(Boolean);
+}
 //# sourceMappingURL=loop-command.js.map

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

@@ -5,6 +5,7 @@ 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';
@@ -380,11 +381,13 @@ async function narutoRun(parsed) {
         workerPlacement: parsed.json || parsed.noOpenZellij ? 'process' : 'zellij-pane',
         zellijPaneWorker: true,
         zellijVisiblePaneCap: zellijVisiblePanes,
-        // Shadow clones ALWAYS run in fast service tier — never honor --no-fast/standard.
-        fastMode: true,
-        serviceTier: 'fast',
-        noFast: false,
+        ...(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,
@@ -418,18 +421,6 @@ async function narutoRun(parsed) {
         blockers: [...(result.proof?.blockers || []), ...(parallelRuntimeOk ? [] : ['naruto_parallel_runtime_proof_below_gate'])],
         updated_at: nowIso()
     });
-    await setCurrent(root, {
-        mission_id: mission.id,
-        route: 'Naruto',
-        route_command: '$Naruto',
-        mode: 'NARUTO',
-        phase: result.ok === true ? '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
-    });
     const clones = result.roster?.agent_count ?? roster.agent_count;
     const localWorkerSummary = summarizeNarutoLocalWorkerResult(localWorker, result);
     // Finalizer policy: when local LLM workers contributed patches, the GPT
@@ -437,16 +428,29 @@ async function narutoRun(parsed) {
     const finalizer = evaluateNarutoFinalizer({
         localParticipated: Number(localWorkerSummary?.selected_worker_count || 0) > 0,
         gptFinalStatus: result.proof?.gpt_final_status || null,
-        applyPatches: writeCapable
+        applyPatches: parsed.applyPatches
     });
     await writeJsonAtomic(path.join(mission.dir, 'naruto-finalizer.json'), {
         ...finalizer,
         generated_at: nowIso(),
         mission_id: mission.id
     });
+    const summaryOk = result.ok === true && (parsed.applyPatches === true ? finalizer.ok === true : finalizer.run_ok === true);
+    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
+    });
     const summary = {
         schema: NARUTO_RESULT_SCHEMA,
-        ok: result.ok === true,
+        ok: summaryOk,
         mode: 'NARUTO',
         jutsu: 'kage_bunshin_no_jutsu',
         mission_id: result.mission_id,
@@ -502,6 +506,7 @@ async function narutoRun(parsed) {
             headless_workers: parallelRuntime.headless_workers,
             passed: parallelRuntime.passed
         } : null,
+        parallel_write_policy: result.parallel_write_policy || null,
         local_worker: localWorkerSummary,
         finalizer,
         proof: result.proof?.status || 'missing',
@@ -538,6 +543,7 @@ function compactNarutoRunResult(result) {
         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,
@@ -754,7 +760,7 @@ async function narutoHelp(parsed) {
         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-model|--no-ollama] [--work-items N] [--real] [--readonly] [--json]',
+            'sks naruto run "<task>" [--clones N] [--backend codex-sdk|fake|ollama] [--local-model|--no-ollama] [--work-items N] [--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]'
         ],
@@ -788,6 +794,13 @@ function parseNarutoArgs(args = []) {
     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 serviceTier = normalizeServiceTier(explicitServiceTier, null) || undefined;
+    const fastMode = hasFlag(args, '--no-fast') || serviceTier === 'standard' ? false : hasFlag(args, '--fast') ? true : undefined;
+    const noFast = 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;
@@ -799,9 +812,9 @@ function parseNarutoArgs(args = []) {
     const smoke = hasFlag(args, '--smoke');
     const parallelism = normalizeParallelism(readOption(args, '--parallelism', 'extreme'));
     const messages = normalizeMessages(readOption(args, '--messages', '8'));
-    const valueFlags = new Set(['--clones', '--agents', '--work-items', '--concurrency', '--target-active-slots', '--backend', '--write-mode', '--mission', '--mission-id', '--ollama-model', '--local-model-model', '--ollama-base-url', '--local-model-base-url', '--parallelism', '--messages']);
+    const valueFlags = 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']);
     const prompt = positionalArgs(rest, valueFlags).join(' ').trim() || 'Naruto shadow clone swarm run';
-    return { action, prompt, clones, workItems, concurrency, backend, backendExplicit, mock, real, readonly, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, writeMode, json, missionId, noOpenZellij, attach, smoke, parallelism, messages };
+    return { action, prompt, clones, workItems, 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 };
 }
 function normalizeParallelism(value) {
     const text = String(value || 'extreme').toLowerCase();

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

@@ -25,6 +25,7 @@ async function redirectTeamCreateToNaruto(args = []) {
             redirected_to: 'sks naruto run',
             route_command: '$Naruto',
             deprecated_route: '$Team',
+            parallel_write_policy: result?.parallel_write_policy || result?.run?.parallel_write_policy || null,
             created_at: nowIso(),
             args: list
         });