sneakoscope 4.8.6 → 5.1.2

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

@@ -0,0 +1,102 @@
+import path from 'node:path';
+import { exists, readJson } from '../fsx.js';
+import { imageDimensions, sha256File } from '../wiki-image/image-hash.js';
+export async function evaluateGate(root, missionId, gateFile) {
+    const gatePath = path.isAbsolute(gateFile)
+        ? gateFile
+        : path.join(root, '.sneakoscope', 'missions', missionId, gateFile);
+    if (!(await exists(gatePath))) {
+        return { pass: false, verdict: 'missing', reasons: ['gate_file_missing'], gate_path: gatePath, gate: null };
+    }
+    const gate = await readJson(gatePath, null);
+    if (!gate || typeof gate !== 'object' || Array.isArray(gate)) {
+        return { pass: false, verdict: 'invalid', reasons: ['gate_json_invalid'], gate_path: gatePath, gate: null };
+    }
+    const blockers = Array.isArray(gate.blockers) ? gate.blockers : null;
+    const reasons = [];
+    if (gate.execution_class === 'mock_fixture') {
+        if (gate.passed !== true)
+            reasons.push('gate_not_passed');
+        if (gate.ok === false)
+            reasons.push('gate_ok_false');
+        if (!blockers)
+            reasons.push('gate_blockers_not_array');
+        else if (blockers.length > 0)
+            reasons.push('gate_blockers_present');
+        return { pass: false, verdict: 'mock_only', reasons: reasons.length ? reasons : ['gate_execution_class_mock_fixture'], gate_path: gatePath, gate };
+    }
+    if (gate.passed !== true)
+        reasons.push('gate_not_passed');
+    if (gate.ok === false)
+        reasons.push('gate_ok_false');
+    if (!blockers)
+        reasons.push('gate_blockers_not_array');
+    else if (blockers.length > 0)
+        reasons.push('gate_blockers_present');
+    if (gateFile === 'mad-sks-gate.json' || /mad-sks-gate\.json$/.test(gatePath)) {
+        const sqlPlane = gate.sql_plane;
+        if (sqlPlane?.requested === true) {
+            if (sqlPlane.read_back_passed !== true)
+                reasons.push('mad_sks_sql_plane_read_back_not_passed');
+            if (sqlPlane.profile_closed !== true)
+                reasons.push('mad_sks_sql_plane_profile_not_closed');
+        }
+    }
+    if (gateFile === 'image-ux-review-gate.json' || /image-ux-review-gate\.json$/.test(gatePath)) {
+        const needsFullImagegenEvidence = gate.full_review_passed === true
+            || gate.gpt_image_2_callout_generated === true
+            || (gate.passed === true && gate.reference_only !== true);
+        if (needsFullImagegenEvidence) {
+            reasons.push(...await imagegenResponseGateReasons(root, path.dirname(gatePath)));
+        }
+    }
+    if (gateFile === 'ppt-gate.json' || /ppt-gate\.json$/.test(gatePath)) {
+        const imagegenEvidence = gate.imagegen_evidence;
+        if (imagegenEvidence?.required === true && imagegenEvidence.passed !== true) {
+            reasons.push('ppt_imagegen_evidence_not_passed');
+        }
+    }
+    if (reasons.length > 0) {
+        return { pass: false, verdict: 'fail', reasons, gate_path: gatePath, gate };
+    }
+    return { pass: true, verdict: 'pass', reasons: [], gate_path: gatePath, gate };
+}
+async function imagegenResponseGateReasons(root, missionDir) {
+    const reasons = [];
+    const response = await readJson(path.join(missionDir, 'image-ux-gpt-image-2-response.json'), null);
+    if (!response || typeof response !== 'object')
+        return ['imagegen_response_artifact_missing'];
+    if (response.schema !== 'sks.image-ux-gpt-image-2-response.v1')
+        reasons.push('imagegen_response_schema_invalid');
+    if (response.ok !== true || response.status !== 'generated')
+        reasons.push(response.blocker || 'imagegen_response_not_generated');
+    const evidenceClass = String(response.evidence_class || '');
+    if (evidenceClass !== 'codex_app_imagegen')
+        reasons.push(evidenceClass ? `imagegen_response_evidence_class_not_codex_app:${evidenceClass}` : 'imagegen_response_evidence_class_missing');
+    const outputSource = String(response.output_source || '');
+    if (!['manual_attach', 'auto_discovered_generated_images'].includes(outputSource))
+        reasons.push('imagegen_response_output_source_invalid');
+    const outputPath = String(response.output_image_path || '');
+    const expectedSha = String(response.output_sha256 || response.output_image_sha256 || '');
+    if (!outputPath)
+        reasons.push('imagegen_response_output_path_missing');
+    if (!expectedSha)
+        reasons.push('imagegen_response_output_sha256_missing');
+    if (outputPath) {
+        const absolute = path.isAbsolute(outputPath) ? outputPath : path.resolve(root, outputPath);
+        try {
+            const actualSha = await sha256File(absolute);
+            if (expectedSha && actualSha !== expectedSha)
+                reasons.push('imagegen_response_output_sha256_mismatch');
+            const dims = await imageDimensions(absolute);
+            if (!Number.isFinite(Number(dims.width)) || !Number.isFinite(Number(dims.height)) || Number(dims.width) <= 0 || Number(dims.height) <= 0) {
+                reasons.push('imagegen_response_output_dimensions_invalid');
+            }
+        }
+        catch {
+            reasons.push('imagegen_response_output_file_unreadable');
+        }
+    }
+    return [...new Set(reasons)];
+}
+//# sourceMappingURL=gate-evaluator.js.map

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

@@ -49,10 +49,13 @@ async function checkHardBlocker(root, missionId) {
     const blocker = await readJson(file, null);
     if (!blocker)
         return { hardBlocked: false, file, reason: null, evidence: [] };
+    const evidence = blocker.evidence || [];
     const hardBlocked = String(blocker.status || '') === 'hard_blocked'
         && blocker.passed !== true
-        && String(blocker.reason || '').trim().length > 0;
-    return { hardBlocked, file, reason: String(blocker.reason || ''), evidence: blocker.evidence || [] };
+        && String(blocker.reason || '').trim().length > 0
+        && Array.isArray(evidence)
+        && evidence.length > 0;
+    return { hardBlocked, file, reason: String(blocker.reason || ''), evidence };
 }
 export async function checkStopGate(input) {
     const root = path.resolve(input.root);
@@ -61,6 +64,7 @@ export async function checkStopGate(input) {
         ...(input.route ? { route: input.route } : {}),
         ...(input.missionId ? { missionId: input.missionId } : {}),
         ...(input.explicitGatePath ? { explicitGatePath: input.explicitGatePath } : {}),
+        ...(input.allowLatestFallback === false ? { allowLatestFallback: false } : {}),
     });
     const route = normalizeRoute(resolution.route) ?? normalizeRoute(input.route ?? null) ?? 'Naruto';
     const missionId = resolution.mission_id;
@@ -128,15 +132,24 @@ export async function checkStopGate(input) {
         };
     }
     const missingFields = [];
+    if (normalizedGate.status !== 'passed')
+        missingFields.push('status');
     if (normalizedGate.passed !== true)
         missingFields.push('passed');
     if (normalizedGate.blockers.length > 0)
         missingFields.push('blockers');
     if (normalizedGate.missing_fields.length > 0)
         missingFields.push(...normalizedGate.missing_fields.map((field) => `missing_fields:${field}`));
-    if (normalizedGate.passed === true
+    const bugfixMission = await missionHasBugfixWork(root, missionId, normalizedGate);
+    if (bugfixMission && normalizedGate.evidence.regression_test_added !== true)
+        missingFields.push('regression_test_added');
+    if (bugfixMission && normalizedGate.evidence.regression_test_failed_before_fix !== true)
+        missingFields.push('regression_test_failed_before_fix');
+    if (normalizedGate.status === 'passed'
+        && normalizedGate.passed === true
         && normalizedGate.blockers.length === 0
-        && normalizedGate.missing_fields.length === 0) {
+        && normalizedGate.missing_fields.length === 0
+        && missingFields.length === 0) {
         const action = 'allow_stop';
         const diagnostics = {
             schema: 'sks.stop-gate-diagnostics.v1',
@@ -198,6 +211,15 @@ export async function checkStopGate(input) {
         feedback: `Stop blocked: gate not passed. Selected: ${resolution.gate_path}. Missing fields: ${missingFields.join(', ') || 'none'}. Checked: ${resolution.checked_paths.join(', ')}`,
     };
 }
+async function missionHasBugfixWork(root, missionId, gate) {
+    const evidence = gate.evidence;
+    if (evidence.regression_test_added !== undefined || evidence.regression_test_failed_before_fix !== undefined)
+        return true;
+    if (!missionId)
+        return false;
+    const graph = await readJson(path.join(missionDir(root, missionId), 'agents', 'naruto-work-graph.json'), null);
+    return Array.isArray(graph?.work_items) && graph.work_items.some((item) => String(item?.kind || '') === 'bugfix');
+}
 async function writeDiagnostics(root, missionId, diagnostics) {
     // Global report
     const reportsDir = path.join(root, '.sneakoscope', 'reports');

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

@@ -68,8 +68,9 @@ export async function resolveStopGate(input) {
             }
         }
     }
-    // 4. latest mission fallback
-    const latest = await findLatestMission(root);
+    // 4. latest mission fallback. Interactive hooks disable this path so a stale
+    // mission cannot satisfy the current session's stop gate by accident.
+    const latest = input.allowLatestFallback === false ? null : await findLatestMission(root);
     if (latest) {
         const dir = missionDir(root, latest);
         for (const file of GATE_FILE_CANDIDATES) {
@@ -77,12 +78,27 @@ export async function resolveStopGate(input) {
             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');
+                if (!gateMatchesRoute(raw, route))
+                    continue;
+                if (stateMissionId && stateMissionId !== latest) {
+                    console.error(`SKS stop-gate warning: latest mission fallback selected ${latest}, current state mission is ${stateMissionId}. Pass --mission or --gate to avoid fallback.`);
+                }
+                return makeResolution(root, route, latest, p, raw, checkedPaths, statePath, stateMissionId, 'latest_mission_fallback_warn');
             }
         }
     }
     return makeResolution(root, route, missionId, null, null, checkedPaths, statePath, stateMissionId, 'no_gate_found');
 }
+function gateMatchesRoute(raw, route) {
+    if (!route || !raw)
+        return true;
+    const expected = normalizeRoute(route);
+    const actual = normalizeRoute(String(raw.route || raw.route_command || ''));
+    return !actual || actual === expected;
+}
+function normalizeRoute(value) {
+    return String(value || '').replace(/^\$/, '').replace(/_/g, '-').toLowerCase();
+}
 function makeResolution(root, route, missionId, gatePath, gateRaw, checkedPaths, statePath, stateMissionId, reason) {
     let gateSchema = null;
     if (gateRaw) {

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

@@ -3,6 +3,9 @@ import { ensureDir, nowIso, readJson, writeJsonAtomic, exists } from '../fsx.js'
 import { missionDir } from '../mission.js';
 import { setCurrent } from '../mission.js';
 export async function writeFinalStopGate(input) {
+    return writeGateOwned(input);
+}
+export async function writeGateOwned(input) {
     const dir = missionDir(input.root, input.missionId);
     await ensureDir(dir);
     const evidenceBlockers = input.status === 'passed' ? evidenceMissingBlockers(input.evidence) : [];
@@ -15,6 +18,13 @@ export async function writeFinalStopGate(input) {
     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 gateOwner = {
+        mission_id: input.missionId,
+        route: input.route,
+        route_command: input.routeCommand,
+        writer_pid: process.pid,
+        written_at: nowIso()
+    };
     const gate = {
         schema: 'sks.stop-gate.v1',
         route: input.route,
@@ -29,6 +39,7 @@ export async function writeFinalStopGate(input) {
         evidence: input.evidence,
         blockers,
         missing_fields: missingFields,
+        gate_owner: gateOwner,
         created_at: nowIso(),
     };
     // 1. Write route-native gate file (backwards compat), preserving detailed native fields by default.
@@ -51,6 +62,7 @@ export async function writeFinalStopGate(input) {
             },
             blockers,
             missing_fields: missingFields,
+            gate_owner: gateOwner,
             updated_at: nowIso()
         });
     }
@@ -67,6 +79,7 @@ export async function writeFinalStopGate(input) {
             evidence: input.evidence,
             blockers,
             missing_fields: missingFields,
+            gate_owner: gateOwner,
             updated_at: nowIso(),
             ...(input.nativeGatePatch ?? {})
         });
@@ -85,10 +98,12 @@ export async function writeFinalStopGate(input) {
         stop_gate_abs_path: canonicalGatePath,
         stop_gate_status: status,
         stop_gate_passed: passed,
+        gate_owner_mission_id: input.missionId,
+        gate_owner_route: input.route,
         route_evidence_passed: input.evidence.route_evidence_passed ?? passed,
         terminal: gate.terminal,
         terminal_state: gate.terminal_state,
-    });
+    }, { sessionKey: input.sessionKey || undefined });
     // 5. Re-read and verify
     const verifyResult = {
         schema: 'sks.stop-gate-write-verify.v1',
@@ -121,6 +136,10 @@ function evidenceMissingBlockers(evidence) {
         blockers.push('proof_not_passed');
     if (evidence.reflection_required === true && evidence.reflection_passed !== true && evidence.reflection_passed !== 'not_required')
         blockers.push('reflection_not_passed');
+    if (evidence.regression_test_added === false)
+        blockers.push('regression_test_not_added');
+    if (evidence.regression_test_failed_before_fix === false)
+        blockers.push('regression_test_failed_before_fix_missing');
     return blockers;
 }
 //# sourceMappingURL=stop-gate-writer.js.map