sneakoscope 5.3.0 → 5.5.1

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

@@ -23,6 +23,7 @@ import { readImplementationBlueprint, validateImplementationBlueprint } from '..
 import { readExperimentPlan, validateExperimentPlan } from '../research/experiment-plan.js';
 import { readReplicationPack, validateReplicationPack } from '../research/replication-pack.js';
 import { readResearchFinalReview } from '../research/research-final-reviewer.js';
+import { evaluateGate } from '../stop-gate/gate-evaluator.js';
 const RESEARCH_DEFAULT_MAX_CYCLES = 12;
 const RESEARCH_DEFAULT_CYCLE_TIMEOUT_MINUTES = 120;
 const RESEARCH_MIN_CYCLE_TIMEOUT_MINUTES = 15;
@@ -360,6 +361,8 @@ async function researchStatus(args) {
     const { dir, mission } = await loadMission(root, id);
     const state = await readJson(stateFile(root), {});
     const gate = await readJson(path.join(dir, 'research-gate.evaluated.json'), await readJson(path.join(dir, 'research-gate.json'), null));
+    const gateVerdict = await evaluateGate(root, id, 'research-gate.json');
+    console.log(gateVerdict.verdict);
     const ledger = await readJson(path.join(dir, 'novelty-ledger.json'), null);
     const sourceLedger = await readJson(path.join(dir, 'source-ledger.json'), null);
     const agentLedger = await readJson(path.join(dir, 'agent-ledger.json'), null);
@@ -398,6 +401,7 @@ async function researchStatus(args) {
         autoresearch_cycle_policy: plan?.autoresearch_cycle_policy || null,
         legacy_alias_policy: plan?.native_agent_plan?.legacy_artifact_alias_policy || null,
         gate,
+        gate_verdict: gateVerdict,
         novelty_entries: ledger?.entries?.length ?? null,
         source_entries: sourceLedger?.sources?.length ?? null,
         source_layers_required: sourceLayerRows.length || gate?.metrics?.source_layers_required || gate?.source_layers_required || null,

package/dist/core/commands/route-success-helpers.js

@@ -36,6 +36,8 @@ export async function evaluateLocalGate(input) {
             blockers.push('gate_not_passed');
         if (gate.ok === false)
             blockers.push('gate_ok_false');
+        if (gate.execution_class === 'mock_fixture')
+            blockers.push('gate_execution_class_mock_fixture');
         if (Array.isArray(gate.blockers) && gate.blockers.length)
             blockers.push(...gate.blockers.map(String));
         if (Array.isArray(gate.missing_fields) && gate.missing_fields.length)

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

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { exists, projectRoot, runProcess, writeJsonAtomic } from '../fsx.js';
 import { createMission, missionDir, setCurrent } from '../mission.js';
+import { createAndWriteWorkOrderLedgerForPrompt, closeWorkOrderLedgerForRouteResult } from '../work-order-ledger.js';
 import { maybeFinalizeRoute } from '../proof/auto-finalize.js';
 import { routePrompt } from '../routes.js';
 import { latestTrustReport } from '../trust-kernel/trust-report.js';
@@ -57,6 +58,7 @@ export async function runCommand(args = []) {
         console.log(`Next: ${classification.next_action}`);
         return result;
     }
+    await createAndWriteWorkOrderLedgerForPrompt(dir, { missionId: id, route: route.command, prompt });
     if (execute)
         return executeRunRoute(root, { id, dir, route, prompt, args, classification, auto });
     return finalizeMockRun(root, { id, route, prompt, args, classification, mode });
@@ -85,6 +87,7 @@ async function finalizeMockRun(root, { id, route, prompt, args, classification,
     });
     const trust = await loadTrustReport(root, id);
     const completionOk = proof.ok && proof.proof?.status !== 'mock_only' && gate.passed === true;
+    await closeWorkOrderLedgerForRouteResult(missionDir(root, id), { ok: completionOk, blockers: gate.blockers });
     await setCurrent(root, {
         mission_id: id,
         mode: 'RUN',
@@ -154,12 +157,14 @@ async function executeRunRoute(root, context) {
         : await loadTrustReport(root, id);
     const autoVerification = auto ? await runAutoVerification(root, id) : null;
     const autoOk = autoVerification?.ok ?? true;
+    const executeOk = execution.ok && proof.ok && autoOk;
+    await closeWorkOrderLedgerForRouteResult(dir, { ok: executeOk, blockers: execution.blockers });
     await setCurrent(root, {
         mission_id: id,
         mode: 'RUN',
         route: route.id,
         route_command: route.command,
-        phase: execution.ok && proof.ok && autoOk ? 'RUN_EXECUTE_DONE' : 'RUN_EXECUTE_BLOCKED',
+        phase: executeOk ? 'RUN_EXECUTE_DONE' : 'RUN_EXECUTE_BLOCKED',
         implementation_allowed: execution.ok,
         nested_mission_id: execution.nested_mission_id,
         completion_proof: 'completion-proof.json',
@@ -167,7 +172,7 @@ async function executeRunRoute(root, context) {
     });
     const result = {
         schema: 'sks.run.v2',
-        ok: execution.ok && proof.ok && autoOk,
+        ok: executeOk,
         mission_id: id,
         route: route.command,
         mode: auto ? 'auto' : 'execute',
@@ -242,11 +247,21 @@ async function executeRouteCommand(root, route, prompt, { auto = false } = {}) {
         });
     }
     const commandArgs = safeRouteExecutionArgs(route, prompt, { auto });
+    // safeRouteExecutionArgs() falls back to `team <prompt> --mock` for any route it
+    // doesn't have a dedicated safe live command for, and several dedicated branches
+    // (DB/Wiki/Fast-Mode/with-local-llm-on/Commit/Commit-And-Push) run a fixed
+    // command that never references the prompt at all. Both must be labeled
+    // honestly rather than as a live-route completion: a --mock invocation cannot
+    // claim a real completion (14차 honest-mock principle), and a fixed command
+    // that never saw the prompt cannot claim to have addressed it.
+    const isMockFallback = commandArgs.includes('--mock');
+    const promptDelivered = Boolean(prompt) && commandArgs.includes(prompt);
     const result = await runSks(root, commandArgs);
     return routeExecutionResult(route, ['sks', ...commandArgs].join(' '), result, {
-        okStatus: 'completed',
-        trustStatus: 'verified_partial',
-        executionKind: 'live_route',
+        okStatus: isMockFallback ? 'verified_partial' : 'completed',
+        trustStatus: isMockFallback ? 'mock_only' : 'verified_partial',
+        executionKind: isMockFallback ? 'mock_safe' : 'live_route',
+        promptDelivered,
     });
 }
 async function runAutoVerification(root, missionId) {
@@ -331,6 +346,8 @@ function routeExecutionResult(route, command, result, options = {}) {
     };
     if (options.steps)
         execution.steps = options.steps;
+    if (options.promptDelivered !== undefined)
+        execution.prompt_delivered = options.promptDelivered;
     return execution;
 }
 function classifyRunRoute(prompt, args) {

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

@@ -3,6 +3,7 @@ import { printJson } from '../../cli/output.js';
 import { projectRoot } from '../fsx.js';
 import { flag, readOption } from './command-utils.js';
 import { runSearchVisibilityApply, runSearchVisibilityAudit, runSearchVisibilityDoctor, runSearchVisibilityFixture, runSearchVisibilityPlan, runSearchVisibilityRollback, runSearchVisibilityStatus, runSearchVisibilityVerify, resolveSearchVisibilityMission, } from '../search-visibility/index.js';
+import { evaluateGate } from '../stop-gate/gate-evaluator.js';
 import { evaluateLocalGate } from './route-success-helpers.js';
 export async function seoCommand(args = []) {
     return runSearchVisibilityCommand('seo', args, 'seo');
@@ -22,8 +23,12 @@ export async function runSearchVisibilityCommand(mode, args = [], displayCommand
         if (!mission)
             blockers.push('mission_required_for_apply');
         else {
+            // explicit_apply_only precondition: a mutation plan must already exist on disk,
+            // proving a prior `plan` step was run and reviewed before this apply can mutate anything.
             const planGate = await evaluateLocalGate({ root: mission.root, dir: mission.dir, gateFile: mode === 'seo' ? 'seo-gate.json' : 'geo-gate.json', requiredArtifacts: ['search-visibility/mutation-plan.json'] });
-            blockers.push(...planGate.blockers.filter((blocker) => blocker !== 'gate_not_passed' && blocker !== 'gate_ok_false'));
+            if (planGate.blockers.includes('missing_artifact:search-visibility/mutation-plan.json'))
+                blockers.push('seo_apply_missing_mutation_plan');
+            blockers.push(...planGate.blockers.filter((blocker) => blocker !== 'gate_not_passed' && blocker !== 'gate_ok_false' && blocker !== 'missing_artifact:search-visibility/mutation-plan.json'));
         }
         if (blockers.length) {
             result = { schema: 'sks.search-visibility.apply-command.v1', ok: false, route: mode === 'seo' ? '$SEO-GEO-OPTIMIZER' : '$SEO-GEO-OPTIMIZER', status: 'blocked', blockers };
@@ -75,18 +80,38 @@ async function applySearchVisibilityGateResult(mode, action, result, options) {
         : action === 'status'
             ? []
             : ['search-visibility/verification-report.json'];
+    const gateFile = mode === 'seo' ? 'seo-gate.json' : 'geo-gate.json';
     const evaluated = await evaluateLocalGate({
         root: mission.root,
         dir: mission.dir,
-        gateFile: mode === 'seo' ? 'seo-gate.json' : 'geo-gate.json',
+        gateFile,
         requiredArtifacts
     });
     const blockers = [...new Set([...(result.blockers || []), ...evaluated.blockers])];
+    if (action === 'apply') {
+        // explicit_apply_only postcondition: apply must not report success unless both the mutation
+        // plan and the rollback manifest it produces are actually present on disk after execution.
+        if (blockers.includes('missing_artifact:search-visibility/mutation-plan.json') && !blockers.includes('seo_apply_missing_mutation_plan'))
+            blockers.push('seo_apply_missing_mutation_plan');
+        if (blockers.includes('missing_artifact:search-visibility/rollback-manifest.json') && !blockers.includes('seo_apply_missing_rollback_manifest'))
+            blockers.push('seo_apply_missing_rollback_manifest');
+    }
+    // Re-evaluate against the authoritative on-disk gate (catches mock/fixture-only gates,
+    // not just the presence checks `evaluateLocalGate` performs) before reporting final success.
+    const authoritative = await evaluateGate(mission.root, mission.id, gateFile);
+    if (!authoritative.pass) {
+        for (const reason of authoritative.reasons) {
+            if (!blockers.includes(reason))
+                blockers.push(reason);
+        }
+    }
+    const ok = result.ok === true && evaluated.ok === true && authoritative.pass === true && blockers.length === 0;
     return {
         ...result,
-        ok: result.ok === true && evaluated.ok === true,
-        status: result.ok === true && evaluated.ok === true ? result.status : 'blocked',
+        ok,
+        status: ok ? result.status : 'blocked',
         gate_evaluation: evaluated,
+        gate_verdict: authoritative.verdict,
         blockers
     };
 }
@@ -167,6 +192,8 @@ function isBlocked(value) {
 }
 function printHuman(mode, action, value) {
     const rec = value && typeof value === 'object' ? value : {};
+    if (action === 'status' && rec.gate_verdict)
+        console.log(String(rec.gate_verdict));
     console.log(`SKS ${mode.toUpperCase()} ${action}: ${rec.status || (rec.ok === false ? 'blocked' : 'ok')}`);
     if (rec.mission_id)
         console.log(`Mission: ${rec.mission_id}`);

package/dist/core/db-safety.js

@@ -645,7 +645,14 @@ async function scanSupabaseMcpConfigs(root) {
 }
 function extractSupabaseMcpUrls(text) {
     const out = new Set();
-    const re = /https:\/\/mcp\.supabase\.com\/mcp[^"'\s)>,]*/gi;
+    // Config files (TOML/JSON) always quote URL values, so a closing quote or
+    // whitespace is the only reliable terminator. A comma is a legitimate query-string
+    // character (e.g. "...&features=database,docs") - excluding it here silently
+    // truncated multi-value features lists, which happened to be benign only because
+    // the truncated remainder still contained an allowed feature. Stopping at ')'/'>' is
+    // unnecessary for structured config scanning and risks the same truncation for any
+    // URL whose query string legitimately contains those characters (URL-encoded or not).
+    const re = /https:\/\/mcp\.supabase\.com\/mcp[^"'\s]*/gi;
     let m;
     while ((m = re.exec(text)))
         out.add(m[0]);

package/dist/core/feature-fixture-executor.js

@@ -0,0 +1,262 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { resolveExpectedArtifactPath } from './feature-fixture-runner.js';
+import { findLatestMission } from './mission.js';
+const FIXTURE_COMMAND_TIMEOUT_MS = 60_000;
+/** Per-fixture override, set via the fixture()'s `extra.timeout_ms` for commands
+ * that are legitimately slower than the 60s default (real agent/swarm orchestration,
+ * multi-step pipelines) rather than actually hung. */
+function fixtureTimeoutMs(fixture) {
+    const override = Number(fixture?.timeout_ms);
+    return Number.isFinite(override) && override > 0 ? override : FIXTURE_COMMAND_TIMEOUT_MS;
+}
+/**
+ * Actually spawns a feature fixture's declared `command` string (safely tokenized,
+ * no shell interpolation) for `execute` / `execute_and_validate_artifacts` fixtures,
+ * checks the real exit code, validates any expected_artifacts that were declared
+ * (string path or { path, schema } object form), and derives a real pass/fail status
+ * from what actually happened rather than trusting fixture.status.
+ *
+ * This is distinct from runFeatureFixture() in feature-fixture-runner.ts, which only
+ * executes fixtures present in an explicit safe-args allowlist. This function executes
+ * whatever the fixture itself declares as its command, so it must tokenize defensively
+ * and never hand a raw string to a shell.
+ */
+export async function runFeatureFixture(feature, { root = process.cwd() } = {}) {
+    const id = feature?.id || feature?.featureId || 'unknown';
+    const fixture = feature?.fixture || feature || {};
+    const kind = fixture.kind;
+    const claimedStatus = fixture.status;
+    const expected = normalizeExpectedArtifacts(fixture.expected_artifacts);
+    if (kind !== 'execute' && kind !== 'execute_and_validate_artifacts') {
+        return {
+            id,
+            kind,
+            executed: false,
+            skipped: true,
+            skip_reason: kind === 'mock' || kind === 'wiring_only' ? 'mock_or_wiring_only' : `kind_not_executable:${kind}`,
+            claimed_status: claimedStatus,
+            actual_status: claimedStatus,
+            ok: true,
+            command: fixture.command || null,
+            artifacts: [],
+            blockers: []
+        };
+    }
+    if (!fixture.command || !String(fixture.command).trim()) {
+        return {
+            id,
+            kind,
+            executed: false,
+            skipped: false,
+            claimed_status: claimedStatus,
+            actual_status: 'missing',
+            ok: false,
+            command: null,
+            artifacts: [],
+            blockers: [`${id}:fixture_command_missing`]
+        };
+    }
+    const tokens = tokenizeCommand(fixture.command);
+    const spawnEnv = { ...process.env, CI: 'true', SKS_SKIP_NPM_FRESHNESS_CHECK: '1', SKS_ENSURE_DIST_NO_REBUILD: '1' };
+    const isSksCommand = tokens[0] === 'sks';
+    const [spawnCommand, spawnArgs] = isSksCommand
+        ? [process.execPath, [resolveSksEntrypoint(root), ...tokens.slice(1)]]
+        : [tokens[0] ?? '', tokens.slice(1)];
+    const timeoutMs = fixtureTimeoutMs(fixture);
+    const spawnResult = spawnSync(spawnCommand, spawnArgs, {
+        cwd: root,
+        encoding: 'utf8',
+        timeout: timeoutMs,
+        maxBuffer: 1024 * 1024 * 20,
+        env: spawnEnv
+    });
+    const timedOut = spawnResult.error?.code === 'ETIMEDOUT';
+    const exitOk = !timedOut && spawnResult.status === 0;
+    // Most fixture commands create a fresh, uniquely-IDed mission and write their
+    // expected artifacts (completion-proof.json, <route>-gate.json, ...) inside that
+    // mission's own directory, not at the project root. Without a mission id,
+    // resolveExpectedArtifactPath() falls back to root-relative resolution and every
+    // such artifact is reported "missing" even when the command succeeded. Prefer the
+    // mission id the command itself printed in its --json stdout (unambiguous, immune
+    // to races with unrelated concurrent sessions on a shared machine); only fall back
+    // to a filesystem mtime scan if the command's own output didn't carry one.
+    const missionIdFromOutput = extractMissionId(spawnResult.stdout);
+    const latestMissionId = missionIdFromOutput
+        ?? (kind === 'execute_and_validate_artifacts' ? await findLatestMission(root).catch(() => null) : null);
+    const artifacts = kind === 'execute_and_validate_artifacts'
+        ? expected.map((artifact) => inspectArtifact(root, artifact, latestMissionId))
+        : [];
+    const artifactFailures = artifacts.filter((artifact) => !artifact.ok).map((artifact) => `${id}:${artifact.path}:${artifact.failure || 'artifact_invalid'}`);
+    const blockers = [];
+    if (!exitOk)
+        blockers.push(timedOut ? `${id}:command_timeout_${timeoutMs}` : `${id}:command_exit_${spawnResult.status}`);
+    blockers.push(...artifactFailures);
+    const ok = blockers.length === 0;
+    const actualStatus = ok ? 'pass' : 'blocked';
+    // "ok" (the ultimate pass/fail signal selftest --real counts) must mean "the
+    // registry's claimed status matches reality" - NOT "the underlying command exited
+    // 0" - those are different questions. Several fixtures intentionally run a
+    // command that always exits non-zero by design (an honest mock/blocked
+    // demonstration, per the execution_class:'mock_fixture' hardening elsewhere in
+    // this codebase); such a fixture correctly declaring claimed_status:'blocked' is
+    // a PASSING self-consistency check, not a failure, even though blockers still
+    // faithfully records the real command_exit_N/artifact issues for anyone auditing
+    // what actually happened. Only an actual mismatch between claim and reality is a
+    // real fixture-registry defect worth failing selftest --real over.
+    const statusMatches = !claimedStatus || claimedStatus === actualStatus;
+    if (!statusMatches) {
+        blockers.push(`${id}:fixture_status_claim_mismatch:claimed=${claimedStatus}:actual=${actualStatus}`);
+    }
+    return {
+        id,
+        kind,
+        executed: true,
+        skipped: false,
+        command: fixture.command,
+        args: tokens.slice(1),
+        exit_code: spawnResult.status,
+        signal: spawnResult.signal || null,
+        timed_out: timedOut,
+        claimed_status: claimedStatus,
+        actual_status: actualStatus,
+        ok: statusMatches,
+        stdout_bytes: Buffer.byteLength(spawnResult.stdout || ''),
+        stderr_bytes: Buffer.byteLength(spawnResult.stderr || ''),
+        stderr_tail: String(spawnResult.stderr || '').slice(-800),
+        artifacts,
+        blockers,
+        resolved_mission_id: latestMissionId
+    };
+}
+/**
+ * Pulls a mission id out of a command's JSON stdout. Handles the common field
+ * names/shapes used across sks commands (`mission_id`, `missionId`, a top-level
+ * `id` that matches the `M-<timestamp>-<suffix>` pattern, or a nested `mission.id`),
+ * and tolerates stdout that has trailing non-JSON log lines by scanning for the
+ * last parseable JSON object.
+ */
+function extractMissionId(stdout) {
+    if (!stdout)
+        return null;
+    const candidates = [];
+    for (const line of String(stdout).split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('{'))
+            continue;
+        try {
+            candidates.push(JSON.parse(trimmed));
+        }
+        catch {
+            // not a standalone JSON line; the payload may still be a multi-line pretty-printed
+            // object, handled by the whole-stdout attempt below.
+        }
+    }
+    try {
+        candidates.push(JSON.parse(stdout));
+    }
+    catch {
+        // pretty-printed JSON mixed with other stdout; ignore.
+    }
+    const missionIdPattern = /^M-\d{8}-\d{6}-[a-z0-9]+$/i;
+    for (const parsed of candidates.reverse()) {
+        if (!parsed || typeof parsed !== 'object')
+            continue;
+        const direct = parsed.mission_id || parsed.missionId || parsed.mission?.id || parsed.completion_proof?.mission_id || parsed.decision?.mission_id;
+        if (typeof direct === 'string' && direct)
+            return direct;
+        if (typeof parsed.id === 'string' && missionIdPattern.test(parsed.id))
+            return parsed.id;
+    }
+    return null;
+}
+function inspectArtifact(root, artifact, latestMissionId) {
+    const file = resolveExpectedArtifactPath(root, artifact.path, { latestMissionId });
+    const exists = fs.existsSync(file);
+    const relPath = path.isAbsolute(artifact.path) ? artifact.path : artifact.path;
+    if (!exists) {
+        return { path: relPath, schema: artifact.schema, exists: false, ok: Boolean(artifact.optional), failure: artifact.optional ? undefined : 'missing' };
+    }
+    if (!file.endsWith('.json')) {
+        const content = fs.readFileSync(file, 'utf8');
+        return { path: relPath, schema: artifact.schema, exists: true, ok: content.trim().length > 0, failure: content.trim().length ? undefined : 'empty' };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return { path: relPath, schema: artifact.schema, exists: true, ok: false, failure: 'json_parse' };
+    }
+    if (!artifact.schema)
+        return { path: relPath, schema: null, exists: true, ok: true };
+    const schemaOk = parsed.schema === artifact.schema || parsed.schema_version != null;
+    return { path: relPath, schema: artifact.schema, exists: true, ok: schemaOk, failure: schemaOk ? undefined : 'schema_mismatch', actual_schema: parsed.schema || null };
+}
+function normalizeExpectedArtifacts(items = []) {
+    return (items || []).map((artifact) => {
+        if (typeof artifact === 'string')
+            return { path: artifact, schema: inferSchema(artifact) };
+        return { path: artifact.path, schema: artifact.schema || inferSchema(artifact.path), optional: Boolean(artifact.optional) };
+    });
+}
+function inferSchema(file = '') {
+    if (file.includes('completion-proof'))
+        return 'sks.completion-proof.v1';
+    if (file.includes('image-voxel-ledger'))
+        return 'sks.image-voxel-ledger.v1';
+    if (file.includes('visual-anchors'))
+        return 'sks.visual-anchors.v1';
+    return null;
+}
+function resolveSksEntrypoint(root) {
+    const candidates = [
+        path.join(root, 'dist', 'bin', 'sks.js'),
+        path.resolve('dist', 'bin', 'sks.js')
+    ];
+    const found = candidates.find((candidate) => fs.existsSync(candidate));
+    return found ?? candidates[0] ?? path.resolve('dist', 'bin', 'sks.js');
+}
+/**
+ * Minimal, defensive command-line tokenizer: splits on whitespace while respecting
+ * single and double quotes. Never passed to a shell — used purely to build a spawnSync
+ * argv array, so shell metacharacters inside tokens are inert.
+ */
+export function tokenizeCommand(command) {
+    const tokens = [];
+    let current = '';
+    let quote = null;
+    let hasToken = false;
+    for (let i = 0; i < command.length; i += 1) {
+        const ch = command[i] ?? '';
+        if (quote) {
+            if (ch === quote) {
+                quote = null;
+            }
+            else {
+                current += ch;
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            hasToken = true;
+            continue;
+        }
+        if (/\s/.test(ch)) {
+            if (hasToken) {
+                tokens.push(current);
+                current = '';
+                hasToken = false;
+            }
+            continue;
+        }
+        current += ch;
+        hasToken = true;
+    }
+    if (hasToken)
+        tokens.push(current);
+    return tokens;
+}
+//# sourceMappingURL=feature-fixture-executor.js.map