sneakoscope 3.1.0 → 3.1.1

package/README.md

@@ -35,7 +35,7 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## 🚀 Current Release
 
-SKS **3.1.0** is Codex 0.139-aware while it bundles @openai/codex-sdk 0.138.0 at this release boundary. It detects and uses 0.139 features from the external Codex CLI when that CLI supports them, with release gates that include hermetic fixtures and actual real probes for code-mode web search, preserved `oneOf`/`allOf` tool schemas, doctor env redaction, plugin marketplace `source` and cache behavior, the `-P` profile alias, the multi-agent v2 `interrupt_agent` rename, image referenced-path routing, sandbox/proxy preservation, Zellij stacked/fallback pane proof, pane-lock openWorkerPane integration, release cache safety fixtures, runtime proof summaries, and release proof source-truth artifacts. See [docs/codex-0.139-compat.md](docs/codex-0.139-compat.md) and [docs/codex-0.139-real-probes.md](docs/codex-0.139-real-probes.md).
+SKS **3.1.1** is Codex 0.139-aware while it bundles @openai/codex-sdk 0.138.0 at this release boundary. It detects and uses 0.139 features from the external Codex CLI when that CLI supports them, with release gates that include hermetic fixtures and actual real probes for code-mode web search, preserved `oneOf`/`allOf` tool schemas, doctor env redaction, plugin marketplace `source` and cache behavior, the `-P` profile alias, the multi-agent v2 `interrupt_agent` rename, image referenced-path routing, sandbox/proxy preservation, Zellij stacked/fallback pane proof, pane-lock openWorkerPane integration, release cache safety fixtures, runtime proof summaries, and release proof source-truth artifacts. See [docs/codex-0.139-compat.md](docs/codex-0.139-compat.md) and [docs/codex-0.139-real-probes.md](docs/codex-0.139-real-probes.md).
 
 SKS 3.0.0 was the parallel-runtime stabilization release. The whole live-swarm experience — what you actually *see* while 5, 20, or 100 workers run — was rebuilt and proven end-to-end.
 

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "3.1.0"
+version = "3.1.1"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "3.1.0"
+version = "3.1.1"
 edition = "2021"
 
 [dependencies]

package/crates/sks-core/src/main.rs

@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek, SeekFrom};
 fn main() {
     let mut args = std::env::args().skip(1);
     match args.next().as_deref() {
-        Some("--version") => println!("sks-rs 3.1.0"),
+        Some("--version") => println!("sks-rs 3.1.1"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/.sks-build-stamp.json

@@ -1,8 +1,8 @@
 {
   "schema": "sks.dist-build-stamp.v1",
   "package_name": "sneakoscope",
-  "package_version": "3.1.0",
-  "source_digest": "0eed1c5f95e3d3e67d263680e28b27bfd1dabe232ff7265720a57d7d377252e8",
-  "source_file_count": 2392,
-  "built_at_source_time": 1781256416238
+  "package_version": "3.1.1",
+  "source_digest": "ea95ac89533e71474a3f68a4dbf879d966eb64159ca24da208d6bb066fb7c573",
+  "source_file_count": 2410,
+  "built_at_source_time": 1781345242524
 }

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '3.1.0';
+const FAST_PACKAGE_VERSION = '3.1.1';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

package/dist/commands/zellij-slot-column-anchor.js

@@ -7,7 +7,9 @@ export async function run(_command = 'zellij-slot-column-anchor', args = []) {
     const intervalMs = Math.max(250, Number(readOption(args, '--interval-ms', '1000') || 1000));
     for (;;) {
         const text = await renderZellijSlotColumnAnchorFromArtifacts({ artifactRoot, missionId, mode });
-        process.stdout.write('\x1Bc' + text + '\n');
+        // Cursor-home + clear-to-end redraw; `\x1Bc` (RIS) resets the pane's
+        // scrollback/modes every tick and intermittently breaks scrolling.
+        process.stdout.write('\x1b[H' + text + '\n\x1b[0J');
         if (!watch)
             break;
         await new Promise((resolve) => setTimeout(resolve, intervalMs));

package/dist/commands/zellij-slot-pane.js

@@ -1,4 +1,4 @@
-import { renderZellijSlotPaneFromArtifacts, renderZellijSlotPaneStatusFromArtifacts } from '../core/zellij/zellij-slot-pane-renderer.js';
+import { renderZellijSlotPaneFromArtifacts, renderZellijSlotPaneStatusFromArtifacts, resolveZellijSlotPaneExit } from '../core/zellij/zellij-slot-pane-renderer.js';
 export async function run(_command = 'zellij-slot-pane', args = []) {
     const artifactDir = readOption(args, '--artifact-dir', process.cwd()) || process.cwd();
     const artifactRoot = readOption(args, '--artifact-root', artifactDir) || artifactDir;
@@ -18,9 +18,19 @@ export async function run(_command = 'zellij-slot-pane', args = []) {
     }
     for (;;) {
         const text = await renderZellijSlotPaneFromArtifacts({ artifactDir, artifactRoot, missionId, slotId, generationIndex, backend, role, mode });
-        process.stdout.write('\x1Bc' + text + '\n');
+        process.stdout.write(redrawFrame(text));
         if (!watch)
             break;
+        // Root-cause-3 fix: exit the pane once the worker has reached a terminal state and written its
+        // result, so the pane closes (or shows the final exited frame) instead of looping forever and
+        // perpetually re-reporting telemetry staleness.
+        const shouldExit = await resolveZellijSlotPaneExit({ artifactDir, artifactRoot, missionId, slotId, generationIndex }).catch(() => false);
+        if (shouldExit) {
+            await new Promise((resolve) => setTimeout(resolve, 5000));
+            const finalText = await renderZellijSlotPaneFromArtifacts({ artifactDir, artifactRoot, missionId, slotId, generationIndex, backend, role, mode });
+            process.stdout.write(redrawFrame(finalText));
+            return;
+        }
         await new Promise((resolve) => setTimeout(resolve, intervalMs));
     }
 }
@@ -28,6 +38,13 @@ function readOption(args, name, fallback) {
     const index = args.indexOf(name);
     return index >= 0 && args[index + 1] ? String(args[index + 1]) : fallback;
 }
+// Redraw in place with cursor-home + clear-to-end instead of `\x1Bc` (RIS).
+// RIS performs a full terminal reset every tick, which wipes the Zellij pane's
+// scrollback and resets scroll position/modes — the cause of intermittent
+// "scrolling stops working" while a watch pane is refreshing.
+function redrawFrame(text) {
+    return '\x1b[H' + text + '\n\x1b[0J';
+}
 function hasFlag(args, flag) {
     return args.includes(flag);
 }

package/dist/core/agents/agent-janitor.js

@@ -164,7 +164,16 @@ async function listFiles(dir) {
     const out = [];
     if (!(await exists(dir)))
         return out;
-    for (const entry of await fsp.readdir(dir, { withFileTypes: true })) {
+    let entries;
+    try {
+        entries = await fsp.readdir(dir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT' || error?.code === 'ENOTDIR')
+            return out;
+        throw error;
+    }
+    for (const entry of entries) {
         const file = path.join(dir, entry.name);
         if (entry.isDirectory())
             out.push(...await listFiles(file));

package/dist/core/agents/agent-orchestrator.js

@@ -477,6 +477,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         visiblePanes: visualLaneCount,
         expectedWorkerRuntimeMs: targetActiveSlots >= 10 ? 8000 : targetActiveSlots >= 2 ? 2000 : 25,
         minActiveWorkers: Math.min(targetActiveSlots, desiredWorkItemCount),
+        ...(backend === 'codex-sdk' && opts.real === true ? { minSpeedupRatio: 3 } : {}),
         proofMode: opts.mock === true ? 'mock-process' : 'production',
         requireWorkerPids: opts.nativeCliSwarm !== false && targetActiveSlots >= 16
     });

package/dist/core/agents/agent-runner-ollama.js

@@ -132,19 +132,25 @@ export function classifyOllamaWorkerSlice(slice, input = {}) {
         input.agent?.persona_id,
         slice?.role,
         slice?.domain,
+        slice?.kind,
         slice?.title,
         slice?.description,
         ...(Array.isArray(slice?.target_paths) ? slice.target_paths : [])
     ].map((value) => String(value || '')).join('\n');
-    const bannedRole = /(?:^|\b)(architect|verifier|safety|integrator|schema|release|ux|db)(?:\b|$)/i.test(String(input.agent?.role || slice?.role || ''));
+    const bannedRole = /(?:^|\b)(architect|verifier|checker|reviewer|researcher|safety|integrator|schema|release|ux|db)(?:\b|$)/i.test(String(input.agent?.role || slice?.role || ''));
     const collection = /\b(collect|gather|extract|inventory|list|scan|grep|tail|summarize|catalog)\b|수집|추출|목록|스캔|인벤토리/i.test(text);
     const coding = /\b(code|implement|patch|write|edit|fix|mechanical|simple)\b|코드|작성|수정|구현|패치|단순/i.test(text);
-    const banned = /\b(strategy|strategize|planning|plan|architecture|architect|design|review|verify|verification|safety|risk|consensus|debate|orchestrate|policy|decide|decision|migration|database|schema)\b|전략|기획|설계|디자인|검증|리뷰|안전|위험|합의|토론|결정|마이그레이션|데이터베이스/i.test(text);
-    const allowed = !bannedRole && !banned && (writePaths.length > 0 || collection || coding);
+    const banned = /\b(strategy|strategize|planning|plan|architecture|architect|design|review|verify|verification|audit|inspect|safety|risk|consensus|debate|orchestrate|policy|decide|decision|migration|database|schema)\b|전략|기획|설계|디자인|검증|검수|리뷰|감사|안전|위험|합의|토론|결정|마이그레이션|데이터베이스/i.test(text);
+    // Web research / external lookup must run on GPT, never on the local model:
+    // local LLMs hallucinate sources and cannot browse. This wins even over the
+    // collection allowlist (e.g. "web research and collect docs" stays on GPT).
+    const research = /\b(web|research|browse|browser|crawl|fetch docs|websearch|web search|search the web|investigate|context7)\b|웹|리서치|조사|웹서치|웹 ?검색|검색/i.test(text);
+    const allowed = !bannedRole && !banned && !research && (writePaths.length > 0 || collection || coding);
     const blockers = [
         ...(allowed ? [] : ['ollama_worker_task_not_simple_code_or_collection']),
         ...(bannedRole ? ['ollama_worker_role_blocked'] : []),
-        ...(banned ? ['ollama_worker_strategy_planning_design_blocked'] : [])
+        ...(banned ? ['ollama_worker_strategy_planning_design_blocked'] : []),
+        ...(research ? ['ollama_worker_web_research_blocked'] : [])
     ];
     return {
         schema: OLLAMA_WORKER_POLICY_SCHEMA,
@@ -156,6 +162,7 @@ export function classifyOllamaWorkerSlice(slice, input = {}) {
         write_path_count: writePaths.length,
         collection_detected: collection,
         coding_detected: coding,
+        research_detected: research,
         blockers
     };
 }

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

@@ -379,6 +379,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 +485,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();
@@ -593,6 +610,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 +833,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);

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/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 { loopLatestCheckpointPath, loopPlanPath, loopProofPath, loopRoot } 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,12 +81,21 @@ 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 result = { schema: 'sks.loop-status-command.v1', mission_id: missionId, plan_ok: Boolean(plan && plan.blockers.length === 0), graph: proof, states, proofs, checkpoints };
     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:-';
+        console.log(`  ${loopId.padEnd(18)} ${String(state.status).padEnd(10)} backend ${String(backend).padEnd(24)} gates ${gates.padEnd(5)} worktree ${String(worktree).padEnd(18)} ${resumable}`);
     }
 }
 async function loopProof(args) {
@@ -112,14 +124,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;

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

@@ -385,6 +385,9 @@ async function narutoRun(parsed) {
         serviceTier: 'fast',
         noFast: false,
         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,9 @@ 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 positionalMission = action === 'dashboard' || action === 'workers' || action === 'status' || action === 'proof'
         ? positionalArgs(rest, new Set()).find((arg) => /^latest$|^M-/.test(arg))
         : null;
@@ -799,9 +808,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', '--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, 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
         });

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '3.1.0';
+export const PACKAGE_VERSION = '3.1.1';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/locks/file-lock.js

@@ -0,0 +1,88 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { ensureDir, nowIso, randomId, writeJsonAtomic } from '../fsx.js';
+import { guardedRm, guardContextForRoute } from '../safety/mutation-guard.js';
+import { CONFIRMATION_REQUIRED, REQUESTED_SCOPE_CONTRACT_SCHEMA } from '../safety/requested-scope-contract.js';
+export async function withFileLock(input, fn) {
+    const lockPath = path.resolve(input.lockPath);
+    const timeoutMs = Math.max(1, input.timeoutMs);
+    const staleMs = Math.max(1, input.staleMs);
+    const started = Date.now();
+    const owner = `${process.pid}-${randomId(8)}`;
+    await ensureDir(path.dirname(lockPath));
+    while (true) {
+        try {
+            await fsp.mkdir(lockPath);
+            await writeJsonAtomic(path.join(lockPath, 'owner.json'), {
+                schema: 'sks.file-lock-owner.v1',
+                owner,
+                pid: process.pid,
+                acquired_at: nowIso(),
+                stale_ms: staleMs
+            });
+            break;
+        }
+        catch (err) {
+            const code = errorCode(err);
+            if (code !== 'EEXIST')
+                throw err;
+            await recoverStaleLock(lockPath, staleMs);
+            if (Date.now() - started > timeoutMs) {
+                throw new Error(`file_lock_timeout:${lockPath}`);
+            }
+            await sleep(jitterDelay());
+        }
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        await removeLockDir(lockPath).catch(() => undefined);
+    }
+}
+async function recoverStaleLock(lockPath, staleMs) {
+    try {
+        const stat = await fsp.stat(lockPath);
+        if (Date.now() - stat.mtimeMs > staleMs) {
+            await removeLockDir(lockPath);
+        }
+    }
+    catch { }
+}
+async function removeLockDir(lockPath) {
+    await guardedRm(guardContextForRoute(process.cwd(), lockScopeContract(lockPath), 'remove SKS file lock directory'), lockPath, {
+        recursive: true,
+        force: true
+    });
+}
+function lockScopeContract(lockPath) {
+    const resolved = path.resolve(lockPath);
+    return {
+        schema: REQUESTED_SCOPE_CONTRACT_SCHEMA,
+        route: 'internal:file-lock',
+        user_request: 'Remove only the current SKS file-lock directory.',
+        allowed_mutations: {
+            project_files: true,
+            global_codex_config: false,
+            codex_app_process: false,
+            codex_lb_auth: false,
+            package_install: false,
+            zellij_install: false,
+            network: false,
+            skill_snapshot_promotion: false
+        },
+        allowed_paths: [resolved, `${resolved}/**`],
+        forbidden_paths: ['~/.codex/config.toml', '/Applications/**'],
+        requires_explicit_confirmation: [...CONFIRMATION_REQUIRED]
+    };
+}
+function jitterDelay() {
+    return 15 + Math.floor(Math.random() * 45);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function errorCode(err) {
+    return err && typeof err === 'object' && 'code' in err ? String(err.code) : '';
+}
+//# sourceMappingURL=file-lock.js.map