sneakoscope 3.0.4 → 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.0.4** 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.0.4"
+version = "3.1.1"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "3.0.4"
+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.0.4"),
+        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.0.4",
-  "source_digest": "fbc7541cf9a5f0432c9ceb28c4478eca651010d2304fc499bbe27f2f62b41d4b",
-  "source_file_count": 2328,
-  "built_at_source_time": 1781240948838
+  "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.0.4';
+const FAST_PACKAGE_VERSION = '3.1.1';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

package/dist/cli/command-registry.js

@@ -123,6 +123,7 @@ export const COMMANDS = {
     agent: entry('beta', 'Run native multi-session agent missions', 'dist/core/commands/agent-command.js', argsCommand(() => import('../core/commands/agent-command.js'), 'agentCommand', 'dist/core/commands/agent-command.js')),
     'with-local-llm': entry('beta', 'Enable or inspect local Ollama worker backend', 'dist/core/commands/local-model-command.js', argsCommand(() => import('../core/commands/local-model-command.js'), 'localModelCommand', 'dist/core/commands/local-model-command.js')),
     naruto: entry('labs', 'Run $Naruto shadow-clone swarm (up to 100 parallel sessions)', 'dist/core/commands/naruto-command.js', argsCommand(() => import('../core/commands/naruto-command.js'), 'narutoCommand', 'dist/core/commands/naruto-command.js')),
+    loop: entry('labs', 'Dynamic Loop Runtime: plan/run/status/proof loop graphs.', 'dist/core/commands/loop-command.js', subcommand(() => import('../core/commands/loop-command.js'), 'loopCommand', 'dist/core/commands/loop-command.js', 'help')),
     'qa-loop': entry('beta', 'Run QA loop missions', 'dist/core/commands/qa-loop-command.js', subcommand(() => import('../core/commands/qa-loop-command.js'), 'qaLoopCommand', 'dist/core/commands/qa-loop-command.js')),
     research: entry('labs', 'Run research missions', 'dist/core/commands/research-command.js', subcommand(() => import('../core/commands/research-command.js'), 'researchCommand', 'dist/core/commands/research-command.js')),
     autoresearch: entry('labs', 'Alias for research/autoresearch route', 'dist/core/commands/autoresearch-command.js', subcommand(() => import('../core/commands/autoresearch-command.js'), 'autoresearchCommand', 'dist/core/commands/autoresearch-command.js', 'status')),

package/dist/cli/context7-command.js

@@ -3,7 +3,7 @@ import { getCodexInfo } from '../core/codex-adapter.js';
 import { context7Docs, context7Resolve, context7Text, context7Tools } from '../core/context7-client.js';
 import { context7Evidence, recordContext7Evidence } from '../core/pipeline.js';
 import { stateFile } from '../core/mission.js';
-import { checkContext7, ensureProjectContext7Config } from './install-helpers.js';
+import { checkContext7, context7GlobalMcpStatus, ensureProjectContext7Config } from './install-helpers.js';
 const flag = (args, name) => args.includes(name);
 export async function context7Command(sub = 'check', args = []) {
     const action = sub || 'check';
@@ -92,9 +92,24 @@ export async function context7Command(sub = 'check', args = []) {
             timeoutMs: readNumberOption(args, '--timeout-ms', 30000)
         });
         const state = { ...(await readJson(stateFile(root), {})), mission_id: missionId };
-        await recordContext7Evidence(root, state, { tool_name: 'resolve-library-id', library: libraryNameOrId, library_id: result.library_id, source: result.resolve ? 'sks context7 evidence' : 'sks context7 evidence explicit-library-id' });
+        const evidenceQuery = readOption(args, '--query', readOption(args, '--topic', libraryNameOrId));
+        const evidenceTopic = readOption(args, '--topic', libraryNameOrId);
+        await recordContext7Evidence(root, state, {
+            tool_name: 'resolve-library-id',
+            library: libraryNameOrId,
+            library_id: result.library_id,
+            query: evidenceQuery,
+            source: result.resolve ? 'sks context7 evidence' : 'sks context7 evidence explicit-library-id'
+        });
         if (result.docs_tool) {
-            await recordContext7Evidence(root, state, { tool_name: result.docs_tool, library_id: result.library_id, source: 'sks context7 evidence' });
+            await recordContext7Evidence(root, state, {
+                tool_name: result.docs_tool,
+                library_id: result.library_id,
+                query: evidenceQuery,
+                topic: evidenceTopic,
+                tokens: readNumberOption(args, '--tokens', 2000),
+                source: 'sks context7 evidence'
+            });
         }
         const evidence = await context7Evidence(root, state);
         const out = { ...result, mission_id: missionId, evidence };
@@ -126,12 +141,21 @@ export async function context7Command(sub = 'check', args = []) {
         const codex = await getCodexInfo();
         if (!codex.bin)
             throw new Error('Codex CLI missing. Install separately: npm i -g @openai/codex, or set SKS_CODEX_BIN.');
+        const env = { ...process.env };
+        env.CODEX_LB_API_KEY = '';
+        const existing = await context7GlobalMcpStatus(codex.bin, env);
+        if (existing.present) {
+            if (flag(args, '--json'))
+                return console.log(JSON.stringify({ changed: false, status: 'present', codex_mcp_list: existing }, null, 2));
+            console.log('Context7 global MCP already configured; existing entry preserved.');
+            return;
+        }
         const cmdArgs = transport === 'remote'
             ? ['mcp', 'add', 'context7', '--url', 'https://mcp.context7.com/mcp']
             : ['mcp', 'add', 'context7', '--', 'npx', '-y', '@upstash/context7-mcp@latest'];
-        const result = await runProcess(codex.bin, cmdArgs, { timeoutMs: 30000, maxOutputBytes: 64 * 1024 });
+        const result = await runProcess(codex.bin, cmdArgs, { env, timeoutMs: 30000, maxOutputBytes: 64 * 1024 });
         if (flag(args, '--json'))
-            return console.log(JSON.stringify({ command: `${codex.bin} ${cmdArgs.join(' ')}`, result }, null, 2));
+            return console.log(JSON.stringify({ changed: result.code === 0, status: result.code === 0 ? 'installed' : 'failed', command: `${codex.bin} ${cmdArgs.join(' ')}`, result }, null, 2));
         if (result.code !== 0)
             throw new Error(result.stderr || result.stdout || 'codex mcp add failed');
         console.log('Context7 global MCP configured.');

package/dist/cli/install-helpers.js

@@ -2019,14 +2019,26 @@ async function ensureGlobalContext7DuringInstall() {
     if (!codex.bin)
         return { status: 'codex_missing' };
     const env = withoutSecretEnv(['CODEX_LB_API_KEY']);
-    const list = await runProcess(codex.bin, ['mcp', 'list'], { env, timeoutMs: 8000, maxOutputBytes: 32 * 1024 }).catch((err) => ({ code: 1, stderr: err.message, stdout: '' }));
-    if (list.code === 0 && /context7/i.test(`${list.stdout}\n${list.stderr}`))
+    const existing = await context7GlobalMcpStatus(codex.bin, env);
+    if (existing.present)
         return { status: 'present' };
     const add = await runProcess(codex.bin, ['mcp', 'add', 'context7', '--', 'npx', '-y', '@upstash/context7-mcp@latest'], { env, timeoutMs: 30000, maxOutputBytes: 64 * 1024 }).catch((err) => ({ code: 1, stdout: '', stderr: err.message }));
     if (add.code === 0)
         return { status: 'installed' };
     return { status: 'failed', error: `${add.stderr || add.stdout || 'codex mcp add failed'}`.trim() };
 }
+export async function context7GlobalMcpStatus(codexBin, env = process.env) {
+    const list = await runProcess(codexBin, ['mcp', 'list'], { env, timeoutMs: 8000, maxOutputBytes: 32 * 1024 })
+        .catch((err) => ({ code: 1, stderr: err.message, stdout: '' }));
+    const output = `${list.stdout || ''}\n${list.stderr || ''}`;
+    return {
+        checked: true,
+        ok: list.code === 0,
+        present: list.code === 0 && /context7/i.test(output),
+        stdout: list.stdout || '',
+        stderr: list.stderr || ''
+    };
+}
 function withoutSecretEnv(keys = []) {
     const env = { ...process.env };
     for (const key of keys)
@@ -2348,11 +2360,7 @@ export async function ensureProjectContext7Config(root, transport = 'local') {
     const block = context7ConfigToml(transport).trim();
     const existingBlock = /(^|\n)\[mcp_servers\.context7\]\n[\s\S]*?(?=\n\[[^\]]+\]|\s*$)/;
     if (existingBlock.test(current)) {
-        const next = current.replace(existingBlock, `$1${block}\n`);
-        if (next === current)
-            return false;
-        await writeTextAtomic(configPath, next.endsWith('\n') ? next : `${next}\n`);
-        return true;
+        return false;
     }
     if (hasContext7ConfigText(current))
         return false;

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/agents/runtime-proof-summary.js

@@ -3,6 +3,7 @@ import { findLatestMission, missionDir } from '../mission.js';
 import { readJson, writeJsonAtomic } from '../fsx.js';
 import { readAgentMessageBus } from './agent-message-bus.js';
 import { buildZellijWorkerPaneSummary } from '../zellij/zellij-worker-pane-summary.js';
+import { readLoopGraphProof, summarizeLoopGraphProof } from '../loops/loop-observability.js';
 export const RUNTIME_PROOF_SUMMARY_SCHEMA = 'sks.runtime-proof-summary.v1';
 export async function buildRuntimeProofSummary(root, missionIdInput = 'latest', opts = {}) {
     const missionId = missionIdInput === 'latest' ? await findLatestMission(root) : missionIdInput;
@@ -18,6 +19,7 @@ export async function buildRuntimeProofSummary(root, missionIdInput = 'latest',
     const messagesAll = await readAgentMessageBus(root, missionId, { max: 500 });
     const recentMessages = await readAgentMessageBus(root, missionId, { max: opts.maxMessages || 8 });
     const zellijSummary = await buildZellijWorkerPaneSummary(root, missionId).catch(() => null);
+    const loopSummary = summarizeLoopGraphProof(await readLoopGraphProof(root, missionId).catch(() => null));
     const failedMessages = messagesAll.filter((row) => row.event_type === 'worker_failed');
     const errorMessages = messagesAll.filter((row) => row.level === 'error');
     const telemetryAgeMs = telemetry?.updated_at ? Math.max(0, Date.now() - Date.parse(telemetry.updated_at)) : Number.MAX_SAFE_INTEGER;
@@ -73,6 +75,7 @@ export async function buildRuntimeProofSummary(root, missionIdInput = 'latest',
             pane_lock_held_p95_ms: Number(zellijSummary?.pane_lock_held_p95_ms || 0),
             duplicate_slot_anchor_count: Number(zellijSummary?.duplicate_slot_anchor_count || 0)
         },
+        loops: loopSummary,
         blockers
     };
     await writeJsonAtomic(path.join(agentsDir, 'runtime-proof-summary.json'), summary);
@@ -91,6 +94,7 @@ export function renderRuntimeProofSummary(summary) {
         `Stack fallback: ${summary.zellij.stacked_fallback_count}`,
         `Pane lock wait p95: ${summary.zellij.pane_lock_wait_p95_ms}ms`,
         `SLOTS anchors: ${summary.zellij.duplicate_slot_anchor_count}`,
+        `Loops: ${summary.loops.total} total / ${summary.loops.completed} done / ${summary.loops.blocked} blocked / ${summary.loops.speedup_ratio}x`,
         ...(summary.messages.recent.length ? [
             'Recent worker messages:',
             ...summary.messages.recent.map((row) => `  ${messageStatusLabel(row)} ${row.slot_id || row.worker_id}: ${row.message}`)

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/goal-command.js

@@ -4,6 +4,8 @@ import { initProject } from '../init.js';
 import { createMission, loadMission, setCurrent, stateFile } from '../mission.js';
 import { GOAL_BRIDGE_ARTIFACT, GOAL_WORKFLOW_ARTIFACT, updateGoalWorkflow, writeGoalWorkflow } from '../goal-workflow.js';
 import { flag, promptOf, resolveMissionId } from './command-utils.js';
+import { compileGoalToLoopPlan } from '../loops/goal-to-loop-compat.js';
+import { runLoopPlan } from '../loops/loop-runtime.js';
 export async function goalCommand(sub, args = []) {
     const known = new Set(['create', 'pause', 'resume', 'clear', 'status', 'help', '--help', '-h']);
     const action = known.has(sub) ? sub : 'create';
@@ -31,11 +33,27 @@ async function goalCreate(args) {
     const prompt = promptOf(args);
     if (!prompt)
         throw new Error('Missing goal task prompt.');
+    if (flag(args, '--legacy-goal-runtime') || process.env.SKS_LEGACY_GOAL_RUNTIME === '1')
+        return legacyGoalCreate(root, prompt, args);
+    const { id, dir, mission } = await createMission(root, { mode: 'goal', prompt });
+    const workflow = await writeGoalWorkflow(dir, mission, { action: 'create', prompt });
+    const plan = await compileGoalToLoopPlan({ root, missionId: id, goalText: prompt, legacyGoalOptions: { native_goal: workflow.native_goal } });
+    const result = await runLoopPlan({ root, plan, parallelism: 'balanced' });
+    await setCurrent(root, { mission_id: id, mode: 'GOAL', route: 'Goal', route_command: '$Goal', phase: result.ok ? 'GOAL_LOOP_COMPLETED' : 'GOAL_LOOP_BLOCKED', questions_allowed: true, implementation_allowed: true, native_goal: workflow.native_goal, stop_gate: 'loop-graph-proof.json' }, { replace: true });
+    if (flag(args, '--json'))
+        return console.log(JSON.stringify({ schema: 'sks.goal-create.v1', ok: result.ok, mission_id: id, workflow, loop_plan: plan, loop_result: result }, null, 2));
+    console.log(`Goal compiled to Loop Graph: ${id}`);
+    console.log('Use `sks loop status latest` to inspect.');
+    console.log(`Artifact: ${path.relative(root, path.join(dir, GOAL_WORKFLOW_ARTIFACT))}`);
+    console.log(`Bridge: ${path.relative(root, path.join(dir, GOAL_BRIDGE_ARTIFACT))}`);
+    console.log(`Native Codex control: ${workflow.native_goal.slash_command}`);
+}
+async function legacyGoalCreate(root, prompt, args) {
     const { id, dir, mission } = await createMission(root, { mode: 'goal', prompt });
     const workflow = await writeGoalWorkflow(dir, mission, { action: 'create', prompt });
     await setCurrent(root, { mission_id: id, mode: 'GOAL', route: 'Goal', route_command: '$Goal', phase: 'GOAL_READY', questions_allowed: true, implementation_allowed: true, native_goal: workflow.native_goal, stop_gate: 'none' }, { replace: true });
     if (flag(args, '--json'))
-        return console.log(JSON.stringify({ schema: 'sks.goal-create.v1', ok: true, mission_id: id, workflow }, null, 2));
+        return console.log(JSON.stringify({ schema: 'sks.goal-create.v1', ok: true, mission_id: id, workflow, runtime: 'legacy-goal' }, null, 2));
     console.log(`Goal mission created: ${id}`);
     console.log(`Artifact: ${path.relative(root, path.join(dir, GOAL_WORKFLOW_ARTIFACT))}`);
     console.log(`Bridge: ${path.relative(root, path.join(dir, GOAL_BRIDGE_ARTIFACT))}`);