sneakoscope 4.0.8 → 4.0.9

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "4.0.8"
+version = "4.0.9"
 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 4.0.8"),
+        Some("--version") => println!("sks-rs 4.0.9"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '4.0.8';
+const FAST_PACKAGE_VERSION = '4.0.9';
 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')),
+    'stop-gate': entry('beta', 'Check canonical stop-gate resolution for a route/mission', 'dist/core/commands/stop-gate-command.js', commandArgsCommand(() => import('../core/commands/stop-gate-command.js'), 'stopGateCommand', 'dist/core/commands/stop-gate-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')),

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

@@ -25,6 +25,7 @@ import { evaluateGitWorktreeCapability } from '../git/git-worktree-capability.js
 import { buildRuntimeProofSummary, renderRuntimeProofSummary } from '../agents/runtime-proof-summary.js';
 import { writeCodex0138CapabilityArtifacts } from '../codex-control/codex-0138-capability.js';
 import { writeCodex0139CapabilityArtifacts } from '../codex-control/codex-0139-capability.js';
+import { writeFinalStopGate } from '../stop-gate/stop-gate-writer.js';
 const NARUTO_RESULT_SCHEMA = 'sks.naruto-command-result.v1';
 const NARUTO_ROUTE = '$Naruto';
 // $Naruto — Shadow Clone Swarm (影分身 / Kage Bunshin no Jutsu).
@@ -34,6 +35,11 @@ const NARUTO_ROUTE = '$Naruto';
 // writes). The standard 20-agent ceiling is lifted only for this route.
 export async function narutoCommand(commandOrArgs = 'naruto', maybeArgs = []) {
     const args = Array.isArray(commandOrArgs) ? commandOrArgs : maybeArgs;
+    // 4.0.9: `sks naruto --glm` delegates to GLM Naruto before legacy Naruto starts.
+    if (args.includes('--glm')) {
+        const { glmNarutoCommand } = await import('../providers/glm/naruto/glm-naruto-command.js');
+        return glmNarutoCommand(args.filter((arg) => arg !== '--glm'));
+    }
     const parsed = parseNarutoArgs(args);
     if (parsed.action === 'help')
         return narutoHelp(parsed);
@@ -450,6 +456,25 @@ async function narutoRun(parsed) {
         stop_gate: 'naruto-gate.json',
         prompt: parsed.prompt
     });
+    // 4.0.9: Write canonical stop-gate artifacts for hook resolution.
+    const narutoGatePassed = result.ok === true && nativeProofOk && finalAccepted && parallelRuntimeOk;
+    await writeFinalStopGate({
+        root,
+        missionId: mission.id,
+        route: 'Naruto',
+        routeCommand: '$Naruto',
+        status: summaryOk ? 'passed' : 'blocked',
+        terminal: summaryOk,
+        terminalState: summaryOk ? 'completed' : 'blocked',
+        evidence: {
+            build_passed: summaryOk,
+            tests_passed: summaryOk,
+            route_evidence_passed: nativeProofOk && finalAccepted,
+            native_session_split_evidence: nativeProofOk ? 'native_agent_proof' : null,
+        },
+        blockers: summaryOk ? [] : [...(result.proof?.blockers || []), ...(parallelRuntimeOk ? [] : ['naruto_parallel_runtime_proof_below_gate'])],
+        nativeGateFile: 'naruto-gate.json',
+    }).catch(() => null);
     const summary = {
         schema: NARUTO_RESULT_SCHEMA,
         ok: summaryOk,

package/dist/core/commands/stop-gate-command.js

@@ -0,0 +1,63 @@
+import { sksRoot } from '../fsx.js';
+import { checkStopGate } from '../stop-gate/stop-gate-check.js';
+export async function stopGateCommand(command, args) {
+    const subcommand = args[0] === 'check' ? 'check' : (args[0] || 'check');
+    const rest = subcommand === 'check' ? args.slice(1) : args;
+    const json = rest.includes('--json');
+    const route = readOption(rest, '--route');
+    const missionId = readOption(rest, '--mission');
+    const gatePath = readOption(rest, '--gate');
+    if (subcommand !== 'check') {
+        const result = {
+            schema: 'sks.stop-gate-command.v1',
+            ok: false,
+            action: 'continue',
+            error: `Unknown subcommand: ${subcommand}. Available: check`,
+        };
+        if (json)
+            console.log(JSON.stringify(result, null, 2));
+        else
+            console.error(`Unknown stop-gate subcommand: ${subcommand}. Use: sks stop-gate check --route Naruto --json`);
+        return result;
+    }
+    const root = await sksRoot();
+    const result = await checkStopGate({
+        root,
+        ...(route ? { route } : {}),
+        ...(missionId ? { missionId } : {}),
+        ...(gatePath ? { explicitGatePath: gatePath } : {}),
+    });
+    if (json) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        if (result.action === 'allow_stop') {
+            console.log(`stop-gate: allow_stop — gate passed at ${result.gate_path}`);
+        }
+        else if (result.action === 'hard_blocked') {
+            console.log(`stop-gate: hard_blocked — ${result.feedback}`);
+        }
+        else {
+            console.error(`stop-gate: continue — ${result.feedback}`);
+        }
+        if (result.diagnostics.checked_paths.length > 0) {
+            console.log('Checked paths:');
+            for (const p of result.diagnostics.checked_paths)
+                console.log(`  ${p}`);
+        }
+        if (result.diagnostics.selected_gate_path) {
+            console.log(`Selected gate: ${result.diagnostics.selected_gate_path}`);
+        }
+    }
+    if (result.action === 'continue')
+        process.exitCode = 1;
+    return result;
+}
+function readOption(args, name) {
+    const index = args.indexOf(name);
+    if (index >= 0 && args[index + 1] && !String(args[index + 1]).startsWith('--'))
+        return args[index + 1];
+    const prefixed = args.find((arg) => String(arg).startsWith(name + '='));
+    return prefixed ? prefixed.slice(name.length + 1) : undefined;
+}
+//# sourceMappingURL=stop-gate-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 = '4.0.8';
+export const PACKAGE_VERSION = '4.0.9';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/pipeline-internals/runtime-gates.js

@@ -17,6 +17,7 @@ import { readAgentGateStatus } from '../agents/agent-gate.js';
 import { MISTAKE_RECALL_ARTIFACT, mistakeRecallGateStatus } from '../mistake-recall.js';
 import { SSOT_GUARD_ARTIFACT, validateSsotGuardArtifact } from '../safety/ssot-guard.js';
 import { validateTeamRuntimeArtifacts } from '../team-dag.js';
+import { checkStopGate } from '../stop-gate/stop-gate-check.js';
 import { clarificationStopReason, context7Evidence, hasContext7DocsEvidence, hasSubagentEvidence, subagentEvidence, } from './runtime-core.js';
 const REFLECTION_ARTIFACT = 'reflection.md';
 const REFLECTION_GATE = 'reflection-gate.json';
@@ -233,10 +234,33 @@ export async function evaluateStop(root, state, payload, opts = {}) {
         return complianceBlock(root, state, `SKS no-question run is not done. Continue autonomously, fix failing checks, update ${gate.file || 'the active gate file'}, and do not ask the user.${missing}`, { gate: gate.file || 'active-gate', missing: gate.missing });
     }
     if (state?.mission_id && state?.stop_gate && !['none', 'honest_mode', 'clarification-gate'].includes(state.stop_gate)) {
-        const gate = await passedActiveGate(root, state);
-        if (!gate.ok) {
-            const missing = gate.missing?.length ? ` Missing gate fields: ${gate.missing.join(', ')}.` : '';
-            return complianceBlock(root, state, `SKS ${state.route_command || state.mode} route cannot stop yet. Pass ${gate.file || state.stop_gate} or record a hard blocker with evidence before finishing.${missing}`, { gate: gate.file || state.stop_gate, missing: gate.missing });
+        // 4.0.9: Use canonical stop-gate resolver first for NARUTO/GLM_NARUTO routes.
+        const modeUpper = String(state?.mode || '').toUpperCase();
+        if (modeUpper === 'NARUTO' || state.stop_gate === 'stop-gate.json' || state.stop_gate === 'naruto-gate.json') {
+            const stopCheck = await checkStopGate({
+                root,
+                route: state.route || state.mode,
+                missionId: state.mission_id,
+                explicitGatePath: typeof state.stop_gate_abs_path === 'string' && state.stop_gate_abs_path ? state.stop_gate_abs_path : undefined,
+            });
+            if (stopCheck.action === 'allow_stop') {
+                // Gate passed via canonical resolver; fall through to remaining checks.
+            }
+            else if (stopCheck.action === 'hard_blocked') {
+                return { continue: true, systemMessage: `SKS: ${stopCheck.feedback}` };
+            }
+            else {
+                const missing = stopCheck.diagnostics.missing_fields?.length ? ` Missing gate fields: ${stopCheck.diagnostics.missing_fields.join(', ')}.` : '';
+                const checkedPaths = stopCheck.diagnostics.checked_paths?.length ? ` Checked: ${stopCheck.diagnostics.checked_paths.join(', ')}.` : '';
+                return complianceBlock(root, state, `SKS ${state.route_command || state.mode} route cannot stop yet. Pass ${stopCheck.gate_path || state.stop_gate} or record a hard blocker with evidence before finishing.${missing}${checkedPaths}`, { gate: stopCheck.gate_path || state.stop_gate, missing: stopCheck.diagnostics.missing_fields });
+            }
+        }
+        else {
+            const gate = await passedActiveGate(root, state);
+            if (!gate.ok) {
+                const missing = gate.missing?.length ? ` Missing gate fields: ${gate.missing.join(', ')}.` : '';
+                return complianceBlock(root, state, `SKS ${state.route_command || state.mode} route cannot stop yet. Pass ${gate.file || state.stop_gate} or record a hard blocker with evidence before finishing.${missing}`, { gate: gate.file || state.stop_gate, missing: gate.missing });
+            }
         }
     }
     const proofGate = await routeProofGateStatus(root, state);

package/dist/core/providers/glm/glm-bench.js

@@ -14,7 +14,7 @@ export async function runGlmBench(root, args = []) {
     if (execute && !live) {
         const blocked = {
             schema: 'sks.glm-bench-result.v1',
-            version: '4.0.8',
+            version: '4.0.9',
             generated_at: nowIso(),
             status: 'blocked',
             dry_run: true,
@@ -32,7 +32,7 @@ export async function runGlmBench(root, args = []) {
     if (live) {
         const blocked = {
             schema: 'sks.glm-bench-result.v1',
-            version: '4.0.8',
+            version: '4.0.9',
             generated_at: nowIso(),
             status: 'blocked',
             dry_run: false,
@@ -50,7 +50,7 @@ export async function runGlmBench(root, args = []) {
     if (execute) {
         const blocked = {
             schema: 'sks.glm-bench-result.v1',
-            version: '4.0.8',
+            version: '4.0.9',
             generated_at: nowIso(),
             status: 'blocked',
             dry_run: true,
@@ -69,7 +69,7 @@ export async function runGlmBench(root, args = []) {
     const deepTotals = SYNTHETIC_CASES.map((row) => row.deep.total_ms);
     const result = {
         schema: 'sks.glm-bench-result.v1',
-        version: '4.0.8',
+        version: '4.0.9',
         generated_at: nowIso(),
         status: 'dry_run',
         dry_run: true,

package/dist/core/providers/glm/glm-direct-run.js

@@ -60,7 +60,7 @@ export async function runGlmDirectSpeedRun(input) {
         return result(reason === 'glm_request_timeout' ? 'timeout' : 'failed', controller.state().run_id, input.task, termination.reason, artifactDir, [], [response.error.code], []);
     }
     controller.transition('model_guard');
-    const modelGuard = assertGlm52ActualModel(response.value.model || GLM_52_OPENROUTER_MODEL);
+    const modelGuard = assertGlm52ActualModel(response.value.model);
     if (!modelGuard.ok) {
         const termination = controller.terminate('blocked', 'glm_model_mismatch', [modelGuard.code]);
         const artifactDir = await writeGlmRunArtifacts({ cwd: input.cwd, state: controller.state(), termination, contextOmissions: context.omitted });

package/dist/core/providers/glm/glm-latency-trace.js

@@ -3,7 +3,7 @@ import { nowIso, writeJsonAtomic } from '../../fsx.js';
 export function createEmptyGlmLatencyTrace(mode) {
     return {
         schema: 'sks.glm-latency-trace.v1',
-        version: '4.0.8',
+        version: '4.0.9',
         mode,
         total_ms: 0,
         preflight_ms: 0,

package/dist/core/providers/glm/naruto/glm-naruto-bench.js

@@ -11,7 +11,7 @@ export async function runGlmNarutoBench(root, args = []) {
     if (!live) {
         return {
             schema: 'sks.glm-naruto-bench.v1',
-            version: '4.0.8',
+            version: '4.0.9',
             generated_at: nowIso(),
             status: 'dry_run',
             model: GLM_52_OPENROUTER_MODEL,
@@ -30,7 +30,7 @@ export async function runGlmNarutoBench(root, args = []) {
     // Live bench would require OpenRouter key and real API calls
     return {
         schema: 'sks.glm-naruto-bench.v1',
-        version: '4.0.8',
+        version: '4.0.9',
         generated_at: nowIso(),
         status: 'blocked',
         model: GLM_52_OPENROUTER_MODEL,
@@ -49,7 +49,7 @@ export async function runGlmNarutoBench(root, args = []) {
 function blocked(root, warnings) {
     return {
         schema: 'sks.glm-naruto-bench.v1',
-        version: '4.0.8',
+        version: '4.0.9',
         generated_at: nowIso(),
         status: 'blocked',
         model: GLM_52_OPENROUTER_MODEL,

package/dist/core/providers/glm/naruto/glm-naruto-judge.js

@@ -48,7 +48,7 @@ export async function runGlmJudge(input) {
     if (!response.ok) {
         return fallbackJudgeResult(validEnvelopes, [`judge_request_failed:${response.error.code}`]);
     }
-    const modelGuard = assertGlm52ActualModel(response.value.model || GLM_52_OPENROUTER_MODEL);
+    const modelGuard = assertGlm52ActualModel(response.value.model);
     if (!modelGuard.ok) {
         return fallbackJudgeResult(validEnvelopes, [`judge_model_guard:${modelGuard.code}`]);
     }

package/dist/core/providers/glm/naruto/glm-naruto-orchestrator.js

@@ -6,6 +6,7 @@ import { checkAndApplyGlmPatch } from '../glm-patch-apply.js';
 import { decomposeTask, validateWorkGraph } from './glm-naruto-decomposer.js';
 import { planShardCandidates, computeInitialLaneMix } from './glm-naruto-shard-planner.js';
 import { runPatchWorkerPool } from './glm-naruto-worker-pool.js';
+import { runVerifierWorker } from './glm-naruto-worker-runtime.js';
 import { buildConflictGraph } from './glm-naruto-conflict-graph.js';
 import { planMerge } from './glm-naruto-merge-planner.js';
 import { finalizeMergePlan } from './glm-naruto-finalizer.js';
@@ -14,6 +15,7 @@ import { createBudget, checkBudget, recordRequest } from './glm-naruto-budget.js
 import { createProviderHealthTracker } from '../../openrouter/openrouter-provider-health.js';
 import { createMissionTrace, recordWorkerTrace, writeMissionArtifacts, buildMissionSummary } from './glm-naruto-trace.js';
 import { runGlmJudge } from './glm-naruto-judge.js';
+import { writeFinalStopGate } from '../../../stop-gate/stop-gate-writer.js';
 import { GLM_NARUTO_LIMITS } from './glm-naruto-types.js';
 export async function runGlmNarutoMission(input) {
     const missionId = input.missionId || `glm-naruto-${nowIso().replace(/[:.]/g, '-')}`;
@@ -93,8 +95,38 @@ export async function runGlmNarutoMission(input) {
             failedShardIds = [...failedShardIds, ...repairPool.failedShardIds];
         }
     }
+    // 4.0.9: Verifier wave — run parallel verifier workers over gate-passed candidates.
+    let passedEnvelopes = envelopes.filter((e) => e.status === 'gate_passed');
+    if (passedEnvelopes.length > 0 && !input.noApply) {
+        const verifyApiKey = key.key;
+        const verifyResults = await Promise.allSettled(passedEnvelopes.map((env) => runVerifierWorker({
+            apiKey: verifyApiKey,
+            missionId,
+            workerId: env.worker_id,
+            envelope: env,
+            timeoutMs: 120_000,
+        })));
+        const verifiedEnvelopes = [];
+        for (let vi = 0; vi < passedEnvelopes.length; vi++) {
+            const env = passedEnvelopes[vi];
+            const res = verifyResults[vi];
+            if (res.status === 'fulfilled' && res.value.ok) {
+                verifiedEnvelopes.push({ ...env, verification_passed: true, status: 'gate_passed' });
+            }
+            else {
+                verifiedEnvelopes.push({ ...env, verification_passed: false, status: 'verification_failed' });
+            }
+            if (res.status === 'fulfilled') {
+                traceState = recordWorkerTrace(traceState, res.value.trace);
+            }
+        }
+        envelopes = envelopes.map((e) => {
+            const verified = verifiedEnvelopes.find((v) => v.worker_id === e.worker_id);
+            return verified ?? e;
+        });
+        passedEnvelopes = envelopes.filter((e) => e.status === 'gate_passed');
+    }
     // Build conflict graph and merge plan
-    const passedEnvelopes = envelopes.filter((e) => e.status === 'gate_passed');
     const nodes = passedEnvelopes.map((env) => ({
         patch_id: env.worker_id,
         shard_id: env.shard_id,
@@ -181,8 +213,29 @@ export async function runGlmNarutoMission(input) {
         termination: { schema: 'sks.glm-naruto-termination.v1', mission_id: missionId, terminal_state: terminalState, reason: terminationReason, wall_clock_ms: summary.wall_clock_ms },
         ...(applyResult ? { applyResult: { ...applyResult, schema: 'sks.glm-naruto-apply-result.v1' } } : {}),
         verificationSummary: { schema: 'sks.glm-naruto-verification.v1', verified: passedEnvelopes.length, total: envelopes.length },
-        missionResult: result
+        missionResult: result,
+        envelopes
     });
+    // 4.0.9: Write canonical stop-gate artifacts for hook resolution.
+    await writeFinalStopGate({
+        root: cwd,
+        missionId,
+        route: 'GLM_NARUTO',
+        routeCommand: '$Naruto',
+        status: result.ok ? 'passed' : (terminalState === 'blocked' ? 'blocked' : 'failed'),
+        terminal: terminalState === 'completed' || terminalState === 'blocked',
+        terminalState,
+        evidence: {
+            build_passed: result.ok,
+            tests_passed: result.ok,
+            route_evidence_passed: result.ok,
+            per_worker_artifacts: true,
+            verifier_wave_run: true,
+            model_guard_enforced: true,
+        },
+        blockers: result.blockers || [],
+        nativeGateFile: 'termination.json',
+    }).catch(() => null);
     return { ...result, artifact_dir: artifactDir };
 }
 function missionResult(missionId, task, status, reason, patchCandidates, startedMs, envelopes, traces, blockers, warnings) {

package/dist/core/providers/glm/naruto/glm-naruto-trace.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { nowIso, writeJsonAtomic } from '../../../fsx.js';
+import { ensureDir, nowIso, writeJsonAtomic } from '../../../fsx.js';
 export function createMissionTrace(missionId) {
     return {
         missionId,
@@ -12,6 +12,7 @@ export function recordWorkerTrace(state, trace) {
 }
 export async function writeMissionArtifacts(input) {
     const dir = path.join(input.root, '.sneakoscope', 'glm-naruto', input.missionId);
+    await ensureDir(dir);
     if (input.workGraph)
         await writeJsonAtomic(path.join(dir, 'work-graph.json'), input.workGraph);
     if (input.conflictGraph)
@@ -32,6 +33,45 @@ export async function writeMissionArtifacts(input) {
         await writeJsonAtomic(path.join(dir, 'verification-summary.json'), input.verificationSummary);
     if (input.missionResult)
         await writeJsonAtomic(path.join(dir, 'mission-result.json'), input.missionResult);
+    // 4.0.9: Write per-worker patch envelope / request-summary / stream-trace / gate-result artifacts.
+    if (input.envelopes && input.envelopes.length > 0) {
+        const workersDir = path.join(dir, 'workers');
+        await ensureDir(workersDir);
+        for (const env of input.envelopes) {
+            const workerId = String(env.worker_id || env.shard_id || 'unknown');
+            const workerDir = path.join(workersDir, workerId);
+            await ensureDir(workerDir);
+            await writeJsonAtomic(path.join(workerDir, 'patch-envelope.json'), env);
+            await writeJsonAtomic(path.join(workerDir, 'request-summary.json'), {
+                schema: 'sks.glm-naruto-worker-request-summary.v1',
+                worker_id: workerId,
+                shard_id: env.shard_id,
+                model: env.model || null,
+                provider: 'openrouter',
+                request_body_size: env.request_body_size ?? null,
+                cached: env.cached ?? false,
+                created_at: nowIso(),
+            });
+            await writeJsonAtomic(path.join(workerDir, 'stream-trace.json'), {
+                schema: 'sks.glm-naruto-worker-stream-trace.v1',
+                worker_id: workerId,
+                ttft_ms: env.ttft_ms ?? null,
+                chunk_count: env.chunk_count ?? null,
+                real_stream: env.real_stream ?? true,
+                idle_timeout_ms: env.idle_timeout_ms ?? null,
+                created_at: nowIso(),
+            });
+            await writeJsonAtomic(path.join(workerDir, 'gate-result.json'), {
+                schema: 'sks.glm-naruto-worker-gate-result.v1',
+                worker_id: workerId,
+                shard_id: env.shard_id,
+                status: env.status,
+                gate_passed: env.status === 'gate_passed',
+                verification_passed: env.verification_passed ?? (env.status === 'gate_passed'),
+                created_at: nowIso(),
+            });
+        }
+    }
     return dir;
 }
 export function buildMissionSummary(input) {

package/dist/core/providers/glm/naruto/glm-naruto-worker-runtime.js

@@ -53,7 +53,8 @@ export async function runPatchWorker(input) {
         const response = await sendOpenRouterChatCompletionStream({
             apiKey: input.apiKey,
             request: requestWithSession,
-            timeoutMs: input.timeoutMs
+            timeoutMs: input.timeoutMs,
+            idleTimeoutMs: 60_000
         });
         if (!response.ok) {
             return {
@@ -63,7 +64,7 @@ export async function runPatchWorker(input) {
                 error: response.error.code
             };
         }
-        const modelGuard = assertGlm52ActualModel(response.value.model || GLM_52_OPENROUTER_MODEL);
+        const modelGuard = assertGlm52ActualModel(response.value.model);
         if (!modelGuard.ok) {
             return {
                 envelope: null,
@@ -131,7 +132,8 @@ export async function runVerifierWorker(input) {
         const response = await sendOpenRouterChatCompletionStream({
             apiKey: input.apiKey,
             request: { ...request, session_id: sessionId },
-            timeoutMs: input.timeoutMs
+            timeoutMs: input.timeoutMs,
+            idleTimeoutMs: 60_000
         });
         if (!response.ok) {
             return {

package/dist/core/providers/openrouter/openrouter-stream.js

@@ -28,7 +28,7 @@ export async function sendOpenRouterChatCompletionStream(input) {
         }
         // Real streaming via ReadableStream reader
         if (response.body && typeof response.body.getReader === 'function') {
-            return { ok: true, value: await readRealStream(response.body, started) };
+            return { ok: true, value: await readRealStream(response.body, started, input.idleTimeoutMs) };
         }
         // Fallback: non-streaming response
         const text = await response.text();
@@ -37,12 +37,13 @@ export async function sendOpenRouterChatCompletionStream(input) {
     catch (err) {
         if (timeout)
             clearTimeout(timeout);
-        if (err instanceof Error && err.name === 'AbortError') {
+        if (err instanceof Error && (err.name === 'AbortError' || err.message === 'glm_stream_idle_timeout' || err.message === 'glm_stream_idle_timeout_after_ttft')) {
+            const isIdle = err.message.startsWith('glm_stream_idle');
             return {
                 ok: false,
                 error: {
-                    code: 'glm_request_timeout',
-                    message: `OpenRouter stream aborted after ${input.timeoutMs || 'external'}ms.`,
+                    code: isIdle ? err.message : 'glm_request_timeout',
+                    message: isIdle ? `OpenRouter stream idle timeout after ${input.idleTimeoutMs || 0}ms.` : `OpenRouter stream aborted after ${input.timeoutMs || 'external'}ms.`,
                     severity: 'failed'
                 }
             };
@@ -57,7 +58,7 @@ export async function sendOpenRouterChatCompletionStream(input) {
         };
     }
 }
-async function readRealStream(body, startedAtMs) {
+async function readRealStream(body, startedAtMs, idleTimeoutMs) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
     const events = [];
@@ -67,14 +68,33 @@ async function readRealStream(body, startedAtMs) {
     let ttft = null;
     let buffer = '';
     let chunkCount = 0;
+    let lastChunkMs = startedAtMs;
     try {
         while (true) {
-            const { done, value } = await reader.read();
+            // 4.0.9: Idle timeout between chunks — abort if stream stalls.
+            const readPromise = reader.read();
+            let idleTimer = null;
+            if (idleTimeoutMs && idleTimeoutMs > 0) {
+                idleTimer = setTimeout(() => {
+                    const code = ttft === null ? 'glm_stream_idle_timeout' : 'glm_stream_idle_timeout_after_ttft';
+                    reader.cancel(code).catch(() => undefined);
+                }, idleTimeoutMs);
+            }
+            let result;
+            try {
+                result = await readPromise;
+            }
+            finally {
+                if (idleTimer)
+                    clearTimeout(idleTimer);
+            }
+            const { done, value } = result;
             if (done)
                 break;
             buffer += decoder.decode(value, { stream: true });
             const lines = buffer.split(/\r?\n/);
             buffer = lines.pop() || '';
+            let hadChunk = false;
             for (const line of lines) {
                 if (!line.startsWith('data:'))
                     continue;
@@ -93,6 +113,8 @@ async function readRealStream(body, startedAtMs) {
                             ttft = Math.max(0, Date.now() - startedAtMs);
                         content += delta;
                         chunkCount++;
+                        lastChunkMs = Date.now();
+                        hadChunk = true;
                         events.push({ type: 'chunk', content_delta: delta, ...(model ? { model } : {}), raw });
                     }
                 }
@@ -100,6 +122,8 @@ async function readRealStream(body, startedAtMs) {
                     events.push({ type: 'error', raw: data });
                 }
             }
+            if (hadChunk)
+                lastChunkMs = Date.now();
         }
     }
     finally {
@@ -111,6 +135,7 @@ async function readRealStream(body, startedAtMs) {
         ...(model ? { model } : {}),
         ...(usage ? { usage } : {}),
         ttft_ms: ttft,
+        last_chunk_ms: lastChunkMs,
         total_ms: Math.max(0, Date.now() - startedAtMs),
         chunk_count: chunkCount,
         events,

package/dist/core/stop-gate/stop-gate-check.js

@@ -0,0 +1,208 @@
+import path from 'node:path';
+import { ensureDir, exists, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+import { missionDir } from '../mission.js';
+import { resolveStopGate, gateStatInfo } from './stop-gate-resolver.js';
+const HARD_BLOCKER_FILE = 'hard-blocker.json';
+function normalizeRoute(route) {
+    if (!route)
+        return null;
+    const upper = route.toUpperCase().replace(/^\$/, '');
+    if (upper === 'GLM_NARUTO' || upper === 'NARUTO')
+        return 'Naruto';
+    return route;
+}
+function rawGateToV1(raw, gatePath, route) {
+    if (!raw)
+        return null;
+    // If already canonical schema, cast
+    if (raw.schema === 'sks.stop-gate.v1') {
+        return raw;
+    }
+    // Normalize from legacy naruto-gate.json / glm-naruto termination
+    const passed = raw.passed === true;
+    const status = passed ? 'passed' : (raw.status || 'blocked');
+    const terminalState = raw.terminal_state || (passed ? 'completed' : 'blocked');
+    const evidence = raw.evidence || {};
+    return {
+        schema: 'sks.stop-gate.v1',
+        route: route || String(raw.route || 'Naruto'),
+        route_command: String(raw.route_command || '$Naruto'),
+        mission_id: String(raw.mission_id || ''),
+        gate_file: path.basename(gatePath),
+        gate_abs_path: gatePath,
+        status: status,
+        passed,
+        terminal: raw.terminal === true || passed,
+        terminal_state: terminalState,
+        evidence: evidence,
+        blockers: Array.isArray(raw.blockers) ? raw.blockers : [],
+        missing_fields: Array.isArray(raw.missing_fields) ? raw.missing_fields : [],
+        created_at: String(raw.created_at || raw.updated_at || nowIso()),
+    };
+}
+async function checkHardBlocker(root, missionId) {
+    if (!missionId)
+        return { ok: false, file: null, reason: null, evidence: [] };
+    const file = path.join(missionDir(root, missionId), HARD_BLOCKER_FILE);
+    if (!(await exists(file)))
+        return { ok: false, file: null, reason: null, evidence: [] };
+    const blocker = await readJson(file, null);
+    if (!blocker)
+        return { ok: false, file, reason: null, evidence: [] };
+    const ok = blocker.passed === true
+        && String(blocker.reason || '').trim().length > 0
+        && Array.isArray(blocker.evidence)
+        && blocker.evidence.length > 0;
+    return { ok, file, reason: String(blocker.reason || ''), evidence: blocker.evidence || [] };
+}
+export async function checkStopGate(input) {
+    const root = path.resolve(input.root);
+    const resolution = await resolveStopGate({
+        root,
+        ...(input.route ? { route: input.route } : {}),
+        ...(input.missionId ? { missionId: input.missionId } : {}),
+        ...(input.explicitGatePath ? { explicitGatePath: input.explicitGatePath } : {}),
+    });
+    const route = normalizeRoute(resolution.route) ?? normalizeRoute(input.route ?? null) ?? 'Naruto';
+    const missionId = resolution.mission_id;
+    const statInfo = resolution.gate_path ? await gateStatInfo(resolution.gate_path) : { mtime: null, sha256: null };
+    // Check hard blocker first
+    const hardBlocker = await checkHardBlocker(root, missionId);
+    if (hardBlocker.ok) {
+        const action = 'hard_blocked';
+        const diagnostics = {
+            schema: 'sks.stop-gate-diagnostics.v1',
+            resolved_root: root,
+            route,
+            mission_id: missionId,
+            checked_paths: resolution.checked_paths,
+            selected_gate_path: hardBlocker.file,
+            selected_gate_schema: 'sks.hard-blocker.v1',
+            selected_gate_sha256: null,
+            selected_gate_mtime: null,
+            current_state_path: resolution.current_state_path,
+            current_state_mission_id: resolution.current_state_mission_id,
+            reason: `hard_blocker: ${hardBlocker.reason}`,
+            missing_fields: [],
+            blockers: [],
+        };
+        return {
+            schema: 'sks.stop-gate-check.v1',
+            ok: true,
+            action,
+            route,
+            mission_id: missionId,
+            gate_path: hardBlocker.file,
+            diagnostics,
+            feedback: `Stop allowed: hard blocker recorded with evidence. Reason: ${hardBlocker.reason}`,
+        };
+    }
+    const normalizedGate = rawGateToV1(resolution.gate_raw, resolution.gate_path || '', route);
+    if (!normalizedGate || !resolution.gate_path) {
+        const diagnostics = {
+            schema: 'sks.stop-gate-diagnostics.v1',
+            resolved_root: root,
+            route,
+            mission_id: missionId,
+            checked_paths: resolution.checked_paths,
+            selected_gate_path: null,
+            selected_gate_schema: null,
+            selected_gate_sha256: null,
+            selected_gate_mtime: null,
+            current_state_path: resolution.current_state_path,
+            current_state_mission_id: resolution.current_state_mission_id,
+            reason: 'no_gate_file_found',
+            missing_fields: [],
+            blockers: [],
+        };
+        return {
+            schema: 'sks.stop-gate-check.v1',
+            ok: false,
+            action: 'continue',
+            route,
+            mission_id: missionId,
+            gate_path: null,
+            diagnostics,
+            feedback: `Stop blocked: no gate file found. Checked paths: ${resolution.checked_paths.join(', ')}`,
+        };
+    }
+    const missingFields = [];
+    if (normalizedGate.passed !== true)
+        missingFields.push('passed');
+    if (!normalizedGate.terminal)
+        missingFields.push('terminal');
+    if (normalizedGate.passed === true && missingFields.length === 0) {
+        const action = 'allow_stop';
+        const diagnostics = {
+            schema: 'sks.stop-gate-diagnostics.v1',
+            resolved_root: root,
+            route,
+            mission_id: missionId,
+            checked_paths: resolution.checked_paths,
+            selected_gate_path: resolution.gate_path,
+            selected_gate_schema: resolution.gate_schema,
+            selected_gate_sha256: statInfo.sha256,
+            selected_gate_mtime: statInfo.mtime,
+            current_state_path: resolution.current_state_path,
+            current_state_mission_id: resolution.current_state_mission_id,
+            reason: 'gate_passed',
+            missing_fields: [],
+            blockers: [],
+        };
+        await writeDiagnostics(root, missionId, diagnostics);
+        return {
+            schema: 'sks.stop-gate-check.v1',
+            ok: true,
+            action,
+            route,
+            mission_id: missionId,
+            gate_path: resolution.gate_path,
+            normalized_gate: normalizedGate,
+            diagnostics,
+            feedback: `Stop allowed: gate passed at ${resolution.gate_path}`,
+        };
+    }
+    // Gate not passed
+    const action = 'continue';
+    const diagnostics = {
+        schema: 'sks.stop-gate-diagnostics.v1',
+        resolved_root: root,
+        route,
+        mission_id: missionId,
+        checked_paths: resolution.checked_paths,
+        selected_gate_path: resolution.gate_path,
+        selected_gate_schema: resolution.gate_schema,
+        selected_gate_sha256: statInfo.sha256,
+        selected_gate_mtime: statInfo.mtime,
+        current_state_path: resolution.current_state_path,
+        current_state_mission_id: resolution.current_state_mission_id,
+        reason: `gate_not_passed:${normalizedGate.status}`,
+        missing_fields: missingFields,
+        blockers: normalizedGate.blockers,
+    };
+    await writeDiagnostics(root, missionId, diagnostics);
+    return {
+        schema: 'sks.stop-gate-check.v1',
+        ok: false,
+        action,
+        route,
+        mission_id: missionId,
+        gate_path: resolution.gate_path,
+        normalized_gate: normalizedGate,
+        diagnostics,
+        feedback: `Stop blocked: gate not passed. Selected: ${resolution.gate_path}. Missing fields: ${missingFields.join(', ') || 'none'}. Checked: ${resolution.checked_paths.join(', ')}`,
+    };
+}
+async function writeDiagnostics(root, missionId, diagnostics) {
+    // Global report
+    const reportsDir = path.join(root, '.sneakoscope', 'reports');
+    await ensureDir(reportsDir);
+    await writeJsonAtomic(path.join(reportsDir, 'stop-gate-last-check.json'), diagnostics);
+    // Mission-local
+    if (missionId) {
+        const dir = missionDir(root, missionId);
+        await ensureDir(dir);
+        await writeJsonAtomic(path.join(dir, 'stop-gate-last-check.json'), diagnostics);
+    }
+}
+//# sourceMappingURL=stop-gate-check.js.map

package/dist/core/stop-gate/stop-gate-diagnostics.js

@@ -0,0 +1,4 @@
+export { checkStopGate } from './stop-gate-check.js';
+export { resolveStopGate } from './stop-gate-resolver.js';
+export { writeFinalStopGate } from './stop-gate-writer.js';
+//# sourceMappingURL=stop-gate-diagnostics.js.map

package/dist/core/stop-gate/stop-gate-resolver.js

@@ -0,0 +1,122 @@
+import path from 'node:path';
+import fsp from 'node:fs/promises';
+import { exists, readJson, sha256 } from '../fsx.js';
+import { missionDir, missionsDir, stateFile, findLatestMission } from '../mission.js';
+const GATE_FILE_CANDIDATES = ['stop-gate.json', 'naruto-gate.json'];
+const GLM_NARUTO_DIR = '.sneakoscope/glm-naruto';
+async function statOrNull(filePath) {
+    try {
+        const stat = await fsp.stat(filePath);
+        const content = await fsp.readFile(filePath, 'utf8');
+        return { mtime: stat.mtime.toISOString(), sha: sha256(content), size: stat.size };
+    }
+    catch {
+        return null;
+    }
+}
+export async function resolveStopGate(input) {
+    const root = path.resolve(input.root);
+    const checkedPaths = [];
+    const route = input.route ?? null;
+    // 1. explicit absolute path
+    if (input.explicitGatePath) {
+        const abs = path.isAbsolute(input.explicitGatePath) ? input.explicitGatePath : path.resolve(root, input.explicitGatePath);
+        checkedPaths.push(abs);
+        if (await exists(abs)) {
+            const raw = await readJson(abs, null);
+            return makeResolution(root, route, null, abs, raw, checkedPaths, null, null, 'explicit_gate_path');
+        }
+    }
+    // 2. current.json → mission_id + stop_gate_abs_path
+    const statePath = stateFile(root);
+    let state = {};
+    let stateMissionId = null;
+    if (await exists(statePath)) {
+        checkedPaths.push(statePath);
+        state = await readJson(statePath, {});
+        stateMissionId = typeof state.mission_id === 'string' ? state.mission_id : null;
+    }
+    const missionId = input.missionId ?? stateMissionId;
+    // 2a. stop_gate_abs_path from current state
+    if (typeof state.stop_gate_abs_path === 'string' && state.stop_gate_abs_path) {
+        const abs = path.isAbsolute(state.stop_gate_abs_path) ? state.stop_gate_abs_path : path.resolve(root, state.stop_gate_abs_path);
+        checkedPaths.push(abs);
+        if (await exists(abs)) {
+            const raw = await readJson(abs, null);
+            return makeResolution(root, route, missionId, abs, raw, checkedPaths, statePath, stateMissionId, 'state.stop_gate_abs_path');
+        }
+    }
+    // 3. mission dir candidates
+    if (missionId) {
+        const dir = missionDir(root, missionId);
+        for (const file of GATE_FILE_CANDIDATES) {
+            const p = path.join(dir, file);
+            checkedPaths.push(p);
+            if (await exists(p)) {
+                const raw = await readJson(p, null);
+                return makeResolution(root, route, missionId, p, raw, checkedPaths, statePath, stateMissionId, 'mission_dir');
+            }
+        }
+        // GLM Naruto termination / mission-result
+        const glmDir = path.join(root, GLM_NARUTO_DIR, missionId);
+        for (const file of ['termination.json', 'mission-result.json']) {
+            const p = path.join(glmDir, file);
+            checkedPaths.push(p);
+            if (await exists(p)) {
+                const raw = await readJson(p, null);
+                return makeResolution(root, route, missionId, p, raw, checkedPaths, statePath, stateMissionId, 'glm_naruto_dir');
+            }
+        }
+    }
+    // 4. latest mission fallback
+    const latest = await findLatestMission(root);
+    if (latest) {
+        const dir = missionDir(root, latest);
+        for (const file of GATE_FILE_CANDIDATES) {
+            const p = path.join(dir, file);
+            checkedPaths.push(p);
+            if (await exists(p)) {
+                const raw = await readJson(p, null);
+                return makeResolution(root, route, latest, p, raw, checkedPaths, statePath, stateMissionId, 'latest_mission');
+            }
+        }
+    }
+    return makeResolution(root, route, missionId, null, null, checkedPaths, statePath, stateMissionId, 'no_gate_found');
+}
+function makeResolution(root, route, missionId, gatePath, gateRaw, checkedPaths, statePath, stateMissionId, reason) {
+    let gateSchema = null;
+    if (gateRaw) {
+        gateSchema = typeof gateRaw.schema === 'string' ? gateRaw.schema : guessSchemaFromPath(gatePath);
+    }
+    return {
+        root,
+        route,
+        mission_id: missionId,
+        gate_path: gatePath,
+        gate_schema: gateSchema,
+        gate_raw: gateRaw,
+        checked_paths: checkedPaths,
+        current_state_path: statePath,
+        current_state_mission_id: stateMissionId,
+        reason,
+    };
+}
+function guessSchemaFromPath(gatePath) {
+    if (!gatePath)
+        return null;
+    const base = path.basename(gatePath);
+    if (base === 'stop-gate.json' || base === 'stop-gate.latest.json')
+        return 'sks.stop-gate.v1';
+    if (base === 'naruto-gate.json')
+        return 'sks.naruto-gate';
+    if (base === 'termination.json')
+        return 'sks.glm-naruto-termination';
+    if (base === 'mission-result.json')
+        return 'sks.glm-naruto-mission-result';
+    return 'sks.gate';
+}
+export async function gateStatInfo(gatePath) {
+    const info = await statOrNull(gatePath);
+    return { mtime: info?.mtime ?? null, sha256: info?.sha ?? null };
+}
+//# sourceMappingURL=stop-gate-resolver.js.map

package/dist/core/stop-gate/stop-gate-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stop-gate-types.js.map

package/dist/core/stop-gate/stop-gate-writer.js

@@ -0,0 +1,76 @@
+import path from 'node:path';
+import { ensureDir, nowIso, readJson, writeJsonAtomic, exists } from '../fsx.js';
+import { missionDir } from '../mission.js';
+import { setCurrent } from '../mission.js';
+export async function writeFinalStopGate(input) {
+    const dir = missionDir(input.root, input.missionId);
+    await ensureDir(dir);
+    const passed = input.status === 'passed';
+    const nativeGateFile = input.nativeGateFile ?? 'naruto-gate.json';
+    const nativeGatePath = path.join(dir, nativeGateFile);
+    const canonicalGatePath = path.join(dir, 'stop-gate.json');
+    const latestGatePath = path.join(dir, 'stop-gate.latest.json');
+    const verifyPath = path.join(dir, 'stop-gate-write-verify.json');
+    const gate = {
+        schema: 'sks.stop-gate.v1',
+        route: input.route,
+        route_command: input.routeCommand,
+        mission_id: input.missionId,
+        gate_file: nativeGateFile,
+        gate_abs_path: canonicalGatePath,
+        status: input.status,
+        passed,
+        terminal: input.terminal,
+        terminal_state: input.terminalState,
+        evidence: input.evidence,
+        blockers: input.blockers ?? [],
+        missing_fields: input.missingFields ?? [],
+        created_at: nowIso(),
+    };
+    // 1. Write route-native gate file (backwards compat)
+    await writeJsonAtomic(nativeGatePath, { ...gate, schema: 'sks.naruto-gate' });
+    // 2. Write canonical stop-gate.json
+    await writeJsonAtomic(canonicalGatePath, gate);
+    // 3. Write stop-gate.latest.json
+    await writeJsonAtomic(latestGatePath, gate);
+    // 4. Update current state with absolute path
+    await setCurrent(input.root, {
+        mission_id: input.missionId,
+        route: input.route,
+        route_command: input.routeCommand,
+        mode: input.route === 'GLM_NARUTO' ? 'NARUTO' : (input.route === 'Naruto' ? 'NARUTO' : input.route),
+        stop_gate: 'stop-gate.json',
+        stop_gate_abs_path: canonicalGatePath,
+        stop_gate_status: input.status,
+        stop_gate_passed: passed,
+        route_evidence_passed: input.evidence.route_evidence_passed ?? passed,
+        terminal: input.terminal,
+        terminal_state: input.terminalState,
+    });
+    // 5. Re-read and verify
+    const verifyResult = {
+        schema: 'sks.stop-gate-write-verify.v1',
+        verified: false,
+        checked_paths: [nativeGatePath, canonicalGatePath, latestGatePath],
+        created_at: nowIso(),
+    };
+    const errors = [];
+    for (const [label, p] of [['native', nativeGatePath], ['canonical', canonicalGatePath], ['latest', latestGatePath]]) {
+        if (!(await exists(p))) {
+            errors.push(`${label}:file_missing:${p}`);
+            continue;
+        }
+        const re = await readJson(p, null);
+        if (!re) {
+            errors.push(`${label}:unreadable`);
+        }
+        else if (re.passed !== passed) {
+            errors.push(`${label}:passed_mismatch:expected=${passed}:got=${re.passed}`);
+        }
+    }
+    verifyResult.errors = errors;
+    verifyResult.verified = errors.length === 0;
+    await writeJsonAtomic(verifyPath, verifyResult);
+    return gate;
+}
+//# sourceMappingURL=stop-gate-writer.js.map

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '4.0.8';
+export const PACKAGE_VERSION = '4.0.9';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "4.0.8",
+  "version": "4.0.9",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",