sneakoscope 4.0.7 → 4.0.9

package/dist/core/providers/openrouter/openrouter-provider-health.js

@@ -0,0 +1,46 @@
+import { nowIso, writeJsonAtomic } from '../../fsx.js';
+import path from 'node:path';
+export function createProviderHealthTracker(providerSlug = 'openrouter', model = 'z-ai/glm-5.2') {
+    let health = {
+        schema: 'sks.openrouter-provider-health.v1',
+        provider_slug: providerSlug,
+        model,
+        p50_ttft_ms: 0,
+        p90_ttft_ms: 0,
+        p50_throughput: 0,
+        p90_throughput: 0,
+        count_429: 0,
+        count_5xx: 0,
+        last_success: null,
+        last_failure: null,
+        updated_at: nowIso()
+    };
+    const ttftSamples = [];
+    return {
+        record: (entry) => {
+            if (typeof entry.p50_ttft_ms === 'number')
+                ttftSamples.push(entry.p50_ttft_ms);
+            const p50 = ttftSamples.length > 0 ? (ttftSamples[Math.floor(ttftSamples.length * 0.5)] ?? 0) : 0;
+            const p90 = ttftSamples.length > 0 ? (ttftSamples[Math.floor(ttftSamples.length * 0.9)] ?? 0) : 0;
+            health = {
+                ...health,
+                ...entry,
+                p50_ttft_ms: p50,
+                p90_ttft_ms: p90,
+                count_429: health.count_429 + (entry.count_429 || 0),
+                count_5xx: health.count_5xx + (entry.count_5xx || 0),
+                last_success: entry.last_success || health.last_success,
+                last_failure: entry.last_failure || health.last_failure,
+                updated_at: nowIso()
+            };
+        },
+        getHealth: () => health,
+        snapshot: () => health
+    };
+}
+export async function writeProviderHealth(root, health) {
+    const out = path.join(root, '.sneakoscope', 'glm-naruto', 'provider-health.json');
+    await writeJsonAtomic(out, health);
+    return out;
+}
+//# sourceMappingURL=openrouter-provider-health.js.map

package/dist/core/providers/openrouter/openrouter-secret-store.js

@@ -110,4 +110,37 @@ async function ensureSecretDir(secretDir) {
     await fs.mkdir(secretDir, { recursive: true, mode: 0o700 });
     await fs.chmod(secretDir, 0o700).catch(() => undefined);
 }
+export async function promptForOpenRouterKeyHidden() {
+    const readline = await import('node:readline/promises');
+    const { stdin, stdout } = await import('node:process');
+    const rl = readline.createInterface({ input: stdin, output: stdout, terminal: true });
+    try {
+        // Use muted input for hidden key entry
+        let key = '';
+        const escaped = stdout.isTTY
+            ? await new Promise((resolve) => {
+                const onData = (char) => {
+                    const c = char.toString();
+                    if (c === '\r' || c === '\n' || c === '\u0004') {
+                        stdin.removeListener('data', onData);
+                        resolve(key);
+                    }
+                    else if (c === '\u0003') {
+                        stdin.removeListener('data', onData);
+                        resolve('');
+                    }
+                    else {
+                        key += c;
+                    }
+                };
+                stdin.on('data', onData);
+                stdout.write('Enter OpenRouter API key (input hidden): ');
+            })
+            : await rl.question('Enter OpenRouter API key: ');
+        return escaped.trim() || null;
+    }
+    finally {
+        rl.close();
+    }
+}
 //# sourceMappingURL=openrouter-secret-store.js.map

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

@@ -22,20 +22,28 @@ export async function sendOpenRouterChatCompletionStream(input) {
         });
         if (timeout)
             clearTimeout(timeout);
-        const text = await response.text();
-        if (!response.ok)
+        if (!response.ok) {
+            const text = await response.text();
             return { ok: false, error: normalizeOpenRouterError(response.status, text) };
-        return { ok: true, value: parseOpenRouterStreamText(text, started) };
+        }
+        // Real streaming via ReadableStream reader
+        if (response.body && typeof response.body.getReader === 'function') {
+            return { ok: true, value: await readRealStream(response.body, started, input.idleTimeoutMs) };
+        }
+        // Fallback: non-streaming response
+        const text = await response.text();
+        return { ok: true, value: parseOpenRouterStreamText(text, started, false) };
     }
     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'
                 }
             };
@@ -50,7 +58,91 @@ export async function sendOpenRouterChatCompletionStream(input) {
         };
     }
 }
-export function parseOpenRouterStreamText(text, startedAtMs = Date.now()) {
+async function readRealStream(body, startedAtMs, idleTimeoutMs) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    const events = [];
+    let content = '';
+    let model;
+    let usage;
+    let ttft = null;
+    let buffer = '';
+    let chunkCount = 0;
+    let lastChunkMs = startedAtMs;
+    try {
+        while (true) {
+            // 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;
+                const data = line.slice('data:'.length).trim();
+                if (!data || data === '[DONE]')
+                    continue;
+                try {
+                    const raw = JSON.parse(data);
+                    const delta = raw?.choices?.[0]?.delta?.content;
+                    if (typeof raw?.model === 'string')
+                        model = raw.model;
+                    if (raw?.usage)
+                        usage = raw.usage;
+                    if (typeof delta === 'string' && delta) {
+                        if (ttft === null)
+                            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 });
+                    }
+                }
+                catch {
+                    events.push({ type: 'error', raw: data });
+                }
+            }
+            if (hadChunk)
+                lastChunkMs = Date.now();
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    events.push({ type: 'done', ...(model ? { model } : {}), ...(usage ? { usage } : {}) });
+    return {
+        content,
+        ...(model ? { model } : {}),
+        ...(usage ? { usage } : {}),
+        ttft_ms: ttft,
+        last_chunk_ms: lastChunkMs,
+        total_ms: Math.max(0, Date.now() - startedAtMs),
+        chunk_count: chunkCount,
+        events,
+        real_stream: true
+    };
+}
+export function parseOpenRouterStreamText(text, startedAtMs = Date.now(), realStream = false) {
     const events = [];
     let content = '';
     let model;
@@ -88,7 +180,8 @@ export function parseOpenRouterStreamText(text, startedAtMs = Date.now()) {
         ttft_ms: ttft,
         total_ms: Math.max(0, Date.now() - startedAtMs),
         chunk_count: events.filter((event) => event.type === 'chunk').length,
-        events
+        events,
+        real_stream: realStream
     };
 }
 //# sourceMappingURL=openrouter-stream.js.map

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.6';
+export const PACKAGE_VERSION = '4.0.9';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "4.0.7",
+  "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",