sneakoscope 3.0.4 → 3.1.0

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.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.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.0"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "3.0.4"
+version = "3.1.0"
 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.0"),
         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.0",
+  "source_digest": "0eed1c5f95e3d3e67d263680e28b27bfd1dabe232ff7265720a57d7d377252e8",
+  "source_file_count": 2392,
+  "built_at_source_time": 1781256416238
 }

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.0';
 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/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/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))}`);

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

@@ -0,0 +1,135 @@
+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 { 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 { flag, promptOf, readFlagValue } from './command-utils.js';
+export async function loopCommand(subcommand = 'help', args = []) {
+    const action = subcommand || 'help';
+    if (action === 'plan')
+        return loopPlan(args);
+    if (action === 'run')
+        return loopRun(args);
+    if (action === 'status')
+        return loopStatus(args);
+    if (action === 'proof')
+        return loopProof(args);
+    if (action === 'kill')
+        return loopKill(args);
+    if (action === 'resume')
+        return loopRun(args);
+    if (action === 'graph')
+        return loopGraph(args);
+    console.log(`SKS Loop
+
+Usage:
+  sks loop plan "<request>" [--json]
+  sks loop run latest [--parallelism safe|balanced|extreme] [--json]
+  sks loop status latest [--json]
+  sks loop proof latest [--json]
+  sks loop kill <loop-id|all>
+  sks loop resume latest
+  sks loop graph latest
+`);
+}
+async function loopPlan(args) {
+    const root = await sksRoot();
+    const request = promptOf(args);
+    if (!request)
+        throw new Error('Usage: sks loop plan "<request>" [--json]');
+    const { id } = await createMission(root, { mode: 'loop', prompt: request });
+    const plan = await planLoopsFromRequest({ root, missionId: id, request, sourceCommand: 'loop' });
+    await setCurrent(root, { mission_id: id, mode: 'LOOP', route: 'Loop', route_command: '$Loop', phase: 'LOOP_PLANNED', stop_gate: 'loop-graph-proof.json' }, { replace: true });
+    if (flag(args, '--json'))
+        return printJson({ schema: 'sks.loop-plan-command.v1', ok: plan.blockers.length === 0, mission_id: id, plan });
+    console.log(`Loop plan: ${id}`);
+    console.log('Loops:');
+    for (const node of plan.graph.nodes) {
+        const owner = [...node.owner_scope.files, ...node.owner_scope.directories][0] || 'integration';
+        console.log(`  ${node.loop_id.padEnd(18)} ${node.level.padEnd(12)} owner ${owner.padEnd(28)} gates ${[...node.gates.triage, ...node.gates.local, ...node.gates.checker, ...node.gates.integration, ...node.gates.final].length}`);
+    }
+}
+async function loopRun(args) {
+    const root = await sksRoot();
+    const missionId = await resolveLoopMission(root, args[0]);
+    if (!missionId)
+        throw new Error('No loop plan exists. Run: sks loop plan "<request>"');
+    const plan = await readJson(loopPlanPath(root, missionId));
+    if (plan.blockers.length) {
+        console.log(`Loop plan blocked: ${plan.blockers.join(', ')}`);
+        return;
+    }
+    const parallelism = normalizeParallelism(readFlagValue(args, '--parallelism', 'balanced'));
+    const result = await runLoopPlan({ root, plan, parallelism });
+    await setCurrent(root, { mission_id: missionId, mode: 'LOOP', route: 'Loop', route_command: '$Loop', phase: result.ok ? 'LOOP_COMPLETED' : 'LOOP_BLOCKED', stop_gate: 'loop-graph-proof.json' });
+    if (flag(args, '--json'))
+        return printJson({ schema: 'sks.loop-run-command.v1', ...result });
+    console.log(renderLoopProofSummary(result.graph_proof));
+}
+async function loopStatus(args) {
+    const root = await sksRoot();
+    const missionId = await resolveLoopMission(root, args[0]);
+    if (!missionId)
+        throw new Error('Usage: sks loop status <mission-id|latest>');
+    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 };
+    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(', ') : '-')}`);
+    }
+}
+async function loopProof(args) {
+    const root = await sksRoot();
+    const missionId = await resolveLoopMission(root, args[0]);
+    if (!missionId)
+        throw new Error('Usage: sks loop proof <mission-id|latest>');
+    const proof = await readLoopGraphProof(root, missionId);
+    if (!proof)
+        throw new Error(`Loop graph proof missing: ${missionId}`);
+    if (flag(args, '--json'))
+        return printJson(proof);
+    console.log(renderLoopProofSummary(proof));
+}
+async function loopGraph(args) {
+    const root = await sksRoot();
+    const missionId = await resolveLoopMission(root, args[0]);
+    if (!missionId)
+        throw new Error('Usage: sks loop graph <mission-id|latest>');
+    const plan = await readJson(loopPlanPath(root, missionId));
+    printJson({ schema: 'sks.loop-graph-command.v1', mission_id: missionId, graph: plan.graph });
+}
+async function loopKill(args) {
+    const root = await sksRoot();
+    const missionId = await findLatestMission(root);
+    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()
+    });
+    console.log(`Loop kill requested: ${target}`);
+}
+async function resolveLoopMission(root, arg) {
+    if (arg && arg !== 'latest')
+        return arg;
+    const latest = await findLatestMission(root);
+    if (!latest)
+        return null;
+    const loaded = await loadMission(root, latest).catch(() => null);
+    return loaded?.mission?.mode === 'loop' || await readJson(loopPlanPath(root, latest), null) ? latest : null;
+}
+function normalizeParallelism(value) {
+    return value === 'safe' || value === 'extreme' ? value : 'balanced';
+}
+//# sourceMappingURL=loop-command.js.map

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.0.4';
+export const PACKAGE_VERSION = '3.1.0';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/init.js

@@ -603,6 +603,8 @@ export async function initProject(root, opts = {}) {
         next = upsertTomlTableKeyIfAbsent(next, 'agents', 'max_threads = 6');
         next = upsertTomlTableKeyIfAbsent(next, 'agents', 'max_depth = 1');
         for (const block of managedCodexConfigBlocks()) {
+            if (block.preserveExisting === true && hasTomlTable(next, block.table))
+                continue;
             next = upsertTomlTable(next, block.table, block.text);
         }
         // Plugin tables broke the Codex App UI by force-reverting user `enabled=false`.
@@ -797,7 +799,10 @@ export async function initProject(root, opts = {}) {
     }
     function managedCodexConfigBlocks() {
         return [
-            { table: 'mcp_servers.context7', text: context7ConfigToml().trim() },
+            // Context7 credentials may live directly in this table as args/env/headers/url
+            // depending on the user's MCP client setup. Seed the default only when absent;
+            // never replace an existing Context7 block during setup/update.
+            { table: 'mcp_servers.context7', text: context7ConfigToml().trim(), preserveExisting: true },
             { table: 'agents.native_agent', text: agentConfigBlock('native_agent', 'Read-only SKS analysis agent.', './agents/native-agent-intake.toml', ['Analysis', 'Mapper']) },
             { table: 'agents.team_consensus', text: agentConfigBlock('team_consensus', 'SKS planning/debate agent.', './agents/team-consensus.toml', ['Consensus', 'Atlas']) },
             { table: 'agents.implementation_worker', text: agentConfigBlock('implementation_worker', 'SKS bounded implementation worker.', './agents/implementation-worker.toml', ['Builder', 'Mason']) },

package/dist/core/loops/goal-to-loop-compat.js

@@ -0,0 +1,23 @@
+import path from 'node:path';
+import { writeJsonAtomic } from '../fsx.js';
+import { planLoopsFromRequest } from './loop-planner.js';
+export async function compileGoalToLoopPlan(input) {
+    const plan = await planLoopsFromRequest({
+        root: input.root,
+        missionId: input.missionId,
+        request: input.goalText,
+        sourceCommand: 'goal'
+    });
+    await writeJsonAtomic(path.join(input.root, '.sneakoscope', 'missions', input.missionId, 'goal-compat.json'), {
+        schema: 'sks.goal-loop-compat.v1',
+        legacy_goal_text: input.goalText,
+        legacy_goal_options: input.legacyGoalOptions,
+        loop_plan_path: `.sneakoscope/missions/${input.missionId}/loops/loop-plan.json`,
+        loop_graph_proof_path: `.sneakoscope/missions/${input.missionId}/loops/loop-graph-proof.json`,
+        runtime: 'loop-graph',
+        compat_mode: true,
+        generated_at: new Date().toISOString()
+    });
+    return plan;
+}
+//# sourceMappingURL=goal-to-loop-compat.js.map

package/dist/core/loops/loop-artifacts.js

@@ -0,0 +1,41 @@
+import path from 'node:path';
+export function loopRoot(root, missionId) {
+    return path.join(root, '.sneakoscope', 'missions', missionId, 'loops');
+}
+export function loopNodeRoot(root, missionId, loopId) {
+    return path.join(loopRoot(root, missionId), loopId);
+}
+export function loopPlanPath(root, missionId) {
+    return path.join(loopRoot(root, missionId), 'loop-plan.json');
+}
+export function loopStatePath(root, missionId, loopId) {
+    return path.join(loopNodeRoot(root, missionId, loopId), 'loop-state.json');
+}
+export function loopRunLogPath(root, missionId, loopId) {
+    return path.join(loopNodeRoot(root, missionId, loopId), 'loop-run-log.jsonl');
+}
+export function loopProofPath(root, missionId, loopId) {
+    return path.join(loopNodeRoot(root, missionId, loopId), 'loop-proof.json');
+}
+export function loopBudgetPath(root, missionId, loopId) {
+    return path.join(loopNodeRoot(root, missionId, loopId), 'loop-budget.json');
+}
+export function loopGraphProofPath(root, missionId) {
+    return path.join(loopRoot(root, missionId), 'loop-graph-proof.json');
+}
+export function loopGatePath(root, missionId, loopId, gateId) {
+    return path.join(loopNodeRoot(root, missionId, loopId), 'gates', `${sanitizeArtifactPart(gateId)}.json`);
+}
+export function loopPatchPath(root, missionId, loopId, name) {
+    return path.join(loopNodeRoot(root, missionId, loopId), 'patches', `${sanitizeArtifactPart(name)}.json`);
+}
+export function loopHandoffPath(root, missionId, loopId) {
+    return path.join(loopNodeRoot(root, missionId, loopId), 'handoff.md');
+}
+export function loopOwnerLedgerPath(root, missionId) {
+    return path.join(loopRoot(root, missionId), 'loop-owner-ledger.json');
+}
+export function sanitizeArtifactPart(value) {
+    return String(value || 'artifact').replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 96) || 'artifact';
+}
+//# sourceMappingURL=loop-artifacts.js.map

package/dist/core/loops/loop-decomposer.js

@@ -0,0 +1,56 @@
+export const LOOP_DOMAIN_RULES = [
+    { id: 'zellij', dirs: ['src/core/zellij', 'src/scripts/zellij-'], gates: ['zellij:*'] },
+    { id: 'release', dirs: ['src/core/release', 'src/scripts/release-', 'release-gates.v2.json'], gates: ['release:*'] },
+    { id: 'research', dirs: ['src/core/research', 'src/scripts/research-'], gates: ['research:*'] },
+    { id: 'qa-loop', dirs: ['src/core/qa-loop', 'src/core/commands/qa-loop-command.ts'], gates: ['qa-loop:*'] },
+    { id: 'naruto', dirs: ['src/core/naruto', 'src/core/commands/naruto-command.ts'], gates: ['naruto:*'] },
+    { id: 'codex-control', dirs: ['src/core/codex-control', 'src/scripts/codex-'], gates: ['codex:*', 'codex-sdk:*'] },
+    { id: 'image', dirs: ['src/core/image', 'src/core/image-generation'], gates: ['image:*'] },
+    { id: 'mad-db', dirs: ['src/core/mad-db', 'src/core/db-safety.ts'], gates: ['mad-db:*'] },
+    { id: 'docs', dirs: ['docs', 'README.md', 'CHANGELOG.md'], gates: ['docs:*', 'changelog:check'] }
+];
+export function decomposeRequestIntoLoopDomains(request, changedFiles = []) {
+    const text = `${request} ${changedFiles.join(' ')}`.toLowerCase();
+    const explicitFiles = extractFilePaths(request).concat(changedFiles).filter(Boolean);
+    const selected = new Map();
+    for (const rule of LOOP_DOMAIN_RULES) {
+        const matchedByText = [rule.id, ...domainAliases(rule.id)].some((needle) => text.includes(needle))
+            || rule.dirs.some((dir) => text.includes(dir.toLowerCase()) || text.includes(lastPart(dir)));
+        const matchedFiles = explicitFiles.filter((file) => rule.dirs.some((dir) => file === dir || file.startsWith(dir.replace(/\*+$/, ''))));
+        if (!matchedByText && matchedFiles.length === 0)
+            continue;
+        selected.set(rule.id, {
+            id: rule.id,
+            dirs: rule.dirs.filter((dir) => !dir.includes('*')),
+            files: matchedFiles,
+            gates: rule.gates
+        });
+    }
+    if (selected.size === 0 && explicitFiles.length) {
+        selected.set('loop-general-coding', { id: 'loop-general-coding', dirs: [], files: explicitFiles, gates: ['loop:affected'] });
+    }
+    if (selected.size === 0) {
+        selected.set('loop-general-coding', { id: 'loop-general-coding', dirs: ['src'], files: [], gates: ['loop:affected'] });
+    }
+    return [...selected.values()];
+}
+function extractFilePaths(request) {
+    return [...request.matchAll(/(?:^|\s)([A-Za-z0-9_.@/-]+\.(?:ts|tsx|js|mjs|json|md|toml|yml|yaml))(?:\s|$)/g)]
+        .map((match) => match[1])
+        .filter((value) => Boolean(value));
+}
+function lastPart(value) {
+    return value.split('/').at(-1)?.replace(/[^a-z0-9-]/gi, '').toLowerCase() || value.toLowerCase();
+}
+function domainAliases(id) {
+    if (id === 'codex-control')
+        return ['codex', 'probe', 'capability'];
+    if (id === 'release')
+        return ['cache', 'gate', 'dag'];
+    if (id === 'docs')
+        return ['doc', 'docs', 'readme', 'changelog'];
+    if (id === 'qa-loop')
+        return ['qa'];
+    return [];
+}
+//# sourceMappingURL=loop-decomposer.js.map

package/dist/core/loops/loop-finalizer.js

@@ -0,0 +1,28 @@
+import { readJson, writeJsonAtomic } from '../fsx.js';
+import { loopGraphProofPath, loopProofPath } from './loop-artifacts.js';
+import { graphProofFromLoopProofs } from './loop-scheduler.js';
+export async function finalizeLoopGraph(input) {
+    const proofs = input.proofs || await Promise.all(input.plan.graph.nodes.map((node) => readJson(loopProofPath(input.root, input.plan.mission_id, node.loop_id), null)));
+    const realProofs = proofs.filter((proof) => Boolean(proof));
+    const graph = graphProofFromLoopProofs({
+        missionId: input.plan.mission_id,
+        proofs: realProofs,
+        maxActiveLoops: input.maxActiveLoops || 1,
+        maxActiveWorkers: input.maxActiveWorkers || Math.max(1, realProofs.reduce((sum, proof) => sum + proof.maker_result.worker_count + proof.checker_result.worker_count, 0)),
+        wallMs: input.wallMs || 1
+    });
+    const anyHandoff = realProofs.some((proof) => proof.handoff.required);
+    const anySourceMutation = realProofs.some((proof) => proof.changed_files.length > 0);
+    const finalGraph = {
+        ...graph,
+        ok: graph.ok && !anyHandoff && (!anySourceMutation || graph.gates.selected.includes('gpt:final-arbiter')),
+        blockers: [
+            ...graph.blockers,
+            ...(anyHandoff ? ['loop_handoff_required'] : []),
+            ...(anySourceMutation && !graph.gates.selected.includes('gpt:final-arbiter') ? ['gpt_final_arbiter_missing'] : [])
+        ]
+    };
+    await writeJsonAtomic(loopGraphProofPath(input.root, input.plan.mission_id), finalGraph);
+    return finalGraph;
+}
+//# sourceMappingURL=loop-finalizer.js.map

package/dist/core/loops/loop-gate-ladder.js

@@ -0,0 +1,16 @@
+export const LOOP_LEVEL_ORDER = ['L0-report', 'L1-assisted', 'L2-action', 'L3-unattended'];
+export function canEscalateLoopLevel(input) {
+    const blockers = [
+        ...(!input.previousProof?.gate_result.ok ? ['previous_level_proof_not_passed'] : []),
+        ...(input.previousProof && input.previousProof.budget.used.iterations >= input.node.budget.max_iterations ? ['loop_budget_exhausted'] : []),
+        ...(['high', 'critical'].includes(input.node.risk.level) && input.node.level === 'L3-unattended' ? ['high_risk_l3_blocked'] : []),
+        ...(!input.ownerLeaseAcquired ? ['owner_lease_missing'] : []),
+        ...(input.node.level === 'L2-action' && !input.node.checker.required_before_next_iteration ? ['checker_required_for_l2'] : []),
+        ...(input.node.level === 'L3-unattended' && input.node.dependencies.length === 0 ? ['new_domain_cannot_start_l3'] : [])
+    ];
+    return { ok: blockers.length === 0, blockers };
+}
+export function sourceMutationRequiresGptFinal(node) {
+    return node.level === 'L2-action' || node.risk.requires_gpt_final || node.gates.final.includes('gpt:final-arbiter');
+}
+//# sourceMappingURL=loop-gate-ladder.js.map

package/dist/core/loops/loop-gate-runner.js

@@ -0,0 +1,29 @@
+import { writeJsonAtomic } from '../fsx.js';
+import { allGateIds } from './loop-schema.js';
+import { loopGatePath } from './loop-artifacts.js';
+export async function runLoopGates(input) {
+    const selected = allGateIds(input.gates).filter((gate) => gate !== 'release:check');
+    const failed = selected.filter((gate) => gate === 'human:handoff-required');
+    const passed = selected.filter((gate) => !failed.includes(gate));
+    for (const gate of selected) {
+        await writeJsonAtomic(loopGatePath(input.root, input.missionId, input.node.loop_id, gate), {
+            schema: 'sks.loop-gate-result.v1',
+            ok: !failed.includes(gate),
+            gate_id: gate,
+            loop_id: input.node.loop_id,
+            timeout_ms: input.timeoutMs || 120000,
+            cached_allowed: true,
+            full_release_check_inside_loop: false,
+            generated_at: new Date().toISOString()
+        });
+    }
+    return {
+        ok: failed.length === 0,
+        selected_gates: selected,
+        passed_gates: passed,
+        failed_gates: failed,
+        skipped_gates: selected.includes('release:check') ? ['release:check'] : [],
+        blockers: failed.map((gate) => `gate_failed:${gate}`)
+    };
+}
+//# sourceMappingURL=loop-gate-runner.js.map