sneakoscope 5.1.2 → 5.5.0

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

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { findLatestMission, loadMission } from '../mission.js';
+import { findLatestMission, loadMission, missionDir } from '../mission.js';
 import { readJson, readText, sksRoot, writeJsonAtomic } from '../fsx.js';
 import { runNativeAgentOrchestrator } from '../agents/agent-orchestrator.js';
 import { parseAgentCommandArgs } from '../agents/agent-command-surface.js';
@@ -23,6 +23,9 @@ export async function agentCommand(commandOrArgs = 'agent', maybeArgs = []) {
 }
 async function agentRun(parsed) {
     const result = await runNativeAgentOrchestrator({ ...parsed, routeCommand: 'sks agent run', routeBlackboxKind: 'actual_agent_command' });
+    if (normalizeRouteName(parsed.route) === 'release-review' && result.mission_id) {
+        await writeReleaseReviewNativeAgentPlan(parsed, result);
+    }
     return emit(parsed, result, () => {
         console.log('Native agent mission: ' + result.mission_id);
         console.log('Backend: ' + result.backend);
@@ -30,6 +33,37 @@ async function agentRun(parsed) {
         console.log('Proof: ' + result.proof.status);
     });
 }
+function normalizeRouteName(route = '') {
+    return String(route || '').replace(/^\$/, '').trim().toLowerCase();
+}
+/**
+ * $Release-Review runs through the generic native agent orchestrator (sks agent run
+ * --route "$Release-Review"), which does not itself know it is a release-review run.
+ * Write the route-specific release-review-native-agent-plan.json summary artifact here
+ * so `route-release-review`'s fixture contract (plan file + agent proof evidence +
+ * agent effort policy) is genuinely satisfied by this command rather than only partially.
+ */
+async function writeReleaseReviewNativeAgentPlan(parsed, result) {
+    const root = await sksRoot();
+    const dir = missionDir(root, result.mission_id);
+    const plan = {
+        schema: 'sks.release-review-native-agent-plan.v1',
+        ok: Boolean(result.ok),
+        mission_id: result.mission_id,
+        route: '$Release-Review',
+        route_command: 'sks agent run',
+        backend: result.backend,
+        prompt: parsed.prompt,
+        roster: {
+            agent_count: result.roster?.agent_count ?? parsed.agents ?? null,
+            concurrency: result.roster?.concurrency ?? parsed.concurrency ?? null
+        },
+        proof_status: result.proof?.status || null,
+        agent_proof_evidence: 'agents/agent-proof-evidence.json',
+        agent_effort_policy: 'agents/agent-effort-policy.json'
+    };
+    await writeJsonAtomic(path.join(dir, 'release-review-native-agent-plan.json'), plan);
+}
 async function agentPlan(parsed) {
     const root = await sksRoot();
     const roster = buildAgentRoster({ agents: parsed.agents, concurrency: parsed.concurrency, prompt: parsed.prompt, readonly: parsed.readonly });

package/dist/core/commands/basic-cli.js

@@ -1,15 +1,14 @@
 import path from 'node:path';
-import os from 'node:os';
-import fsp from 'node:fs/promises';
 import { spawnSync } from 'node:child_process';
 import { COMMANDS, LEGACY_COMMAND_ALIASES } from '../../cli/command-registry.js';
 import { flag } from '../../cli/args.js';
 import { printJson, sksTextLogo } from '../../cli/output.js';
 import { ui as cliUi } from '../../cli/cli-theme.js';
-import { PACKAGE_VERSION, ensureDir, exists, nowIso, projectRoot, readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
+import { PACKAGE_VERSION, ensureDir, exists, nowIso, projectRoot, readJson, sksRoot, tmpdir, writeJsonAtomic } from '../fsx.js';
 import { COMMAND_CATALOG, DOLLAR_COMMAND_ALIASES, DOLLAR_COMMANDS, USAGE_TOPICS, routePrompt, routeReasoning, reasoningInstruction } from '../routes.js';
 import { initProject, normalizeInstallScope, sksCommandPrefix } from '../init.js';
 import { buildFeatureRegistry, validateFeatureRegistry } from '../feature-registry.js';
+import { runFeatureFixture } from '../feature-fixture-executor.js';
 import { hooksExplainReport } from '../../cli/feature-commands.js';
 import { writeSelftestRouteProof } from '../proof/selftest-proof-fixtures.js';
 import { createMission } from '../mission.js';
@@ -281,9 +280,11 @@ export async function postinstallCommand(args = []) {
     return postinstall({ bootstrap: bootstrapCommand, args });
 }
 export async function selftestCommand(args = []) {
+    if (flag(args, '--real'))
+        return selftestRealCommand(args);
     process.env.CI = 'true';
     const root = await projectRoot();
-    const tmp = await fsp.mkdtemp(path.join(os.tmpdir(), 'sks-selftest-'));
+    const tmp = tmpdir('sks-selftest-');
     await ensureDir(tmp);
     const registry = await buildFeatureRegistry({ root });
     const coverage = validateFeatureRegistry(registry);
@@ -309,6 +310,62 @@ export async function selftestCommand(args = []) {
         return printJson(result);
     console.log('SKS selftest passed');
 }
+/**
+ * `sks selftest --real`: actually spawns every feature fixture whose kind is
+ * 'execute' or 'execute_and_validate_artifacts', derives real pass/fail status
+ * from the process exit code (and, for execute_and_validate_artifacts, from
+ * whether the declared expected_artifacts actually exist and match their
+ * declared schema), and writes a JSON report that explicitly lists fixtures
+ * skipped because they are mock/wiring_only kind rather than silently omitting
+ * them. This is additive: plain `sks selftest --mock` behavior is unchanged.
+ */
+export async function selftestRealCommand(args = []) {
+    process.env.CI = 'true';
+    const root = await projectRoot();
+    const registry = await buildFeatureRegistry({ root });
+    const executableKinds = new Set(['execute', 'execute_and_validate_artifacts']);
+    const results = [];
+    const skippedWiringOnly = [];
+    for (const feature of registry.features || []) {
+        const fx = feature.fixture || {};
+        if (executableKinds.has(fx.kind)) {
+            const run = await runFeatureFixture(feature, { root });
+            results.push(run);
+        }
+        else if (fx.kind === 'mock' || fx.kind === 'wiring_only' || fx.quality === 'wiring_only') {
+            skippedWiringOnly.push({ id: feature.id, kind: fx.kind, reason: fx.reason || 'mock_or_wiring_only_kind_not_executed' });
+        }
+    }
+    const failures = results.filter((row) => !row.ok);
+    const ok = failures.length === 0;
+    const report = {
+        schema: 'sks.selftest-real.v1',
+        ok,
+        version: PACKAGE_VERSION,
+        generated_at: nowIso(),
+        root,
+        checked: results.length,
+        passed: results.filter((row) => row.ok).length,
+        failed: failures.length,
+        results,
+        skipped_wiring_only: skippedWiringOnly,
+        skipped_wiring_only_count: skippedWiringOnly.length,
+        blockers: failures.flatMap((row) => row.blockers || [])
+    };
+    const reportPath = path.join(root, '.sneakoscope', 'reports', 'selftest-real-report.json');
+    await writeJsonAtomic(reportPath, report);
+    const output = { ...report, report_file: path.relative(root, reportPath) };
+    if (flag(args, '--json'))
+        return printJson(output);
+    console.log(`SKS selftest --real: ${ok ? 'passed' : 'blocked'} (checked=${results.length}, skipped_wiring_only=${skippedWiringOnly.length})`);
+    console.log(`Report: ${path.relative(root, reportPath)}`);
+    if (!ok) {
+        for (const blocker of report.blockers)
+            console.log(`- ${blocker}`);
+        process.exitCode = 1;
+    }
+    return output;
+}
 export async function reasoningCommand(args = []) {
     const prompt = args.filter((arg) => !String(arg).startsWith('--')).join(' ').trim();
     const route = routePrompt(prompt || '$SKS');

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

@@ -1,8 +1,17 @@
 import { findLatestMission, listSessionStates } from '../mission.js';
 import { DOLLAR_SKILL_NAMES, RECOMMENDED_SKILLS } from '../routes.js';
 export const flag = (args = [], name) => args.includes(name);
-export function promptOf(args = []) {
-    return args.filter((x) => !String(x).startsWith('--')).join(' ').trim();
+// Blindly dropping every "--"-prefixed argv token (the previous behavior of
+// promptOf/positionalArgs) silently deletes any part of an unquoted work-order
+// prompt that happens to contain a flag-lookalike phrase (e.g. "--files 로
+// 확인해라"). Only strip tokens that are actually recognized boolean/global
+// flags; anything else stays in the reconstructed prompt.
+const KNOWN_BOOLEAN_FLAGS = new Set([
+    '--json', '--mock', '--execute', '--auto', '--visual', '--research', '--db',
+    '--legacy-goal-runtime', '--help', '-h'
+]);
+export function promptOf(args = [], knownFlags = KNOWN_BOOLEAN_FLAGS) {
+    return args.filter((x) => !knownFlags.has(String(x))).join(' ').trim();
 }
 export async function resolveMissionId(root, arg) {
     if (arg && arg !== 'latest')
@@ -56,8 +65,9 @@ export function positionalArgs(args = []) {
             i += 1;
             continue;
         }
-        if (!arg.startsWith('--'))
-            out.push(arg);
+        if (KNOWN_BOOLEAN_FLAGS.has(arg))
+            continue;
+        out.push(arg);
     }
     return out;
 }

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

@@ -2,6 +2,7 @@ import path from 'node:path';
 import { exists, readJson, sksRoot } from '../fsx.js';
 import { initProject } from '../init.js';
 import { createMission, loadMission, setCurrent, stateFile } from '../mission.js';
+import { createAndWriteWorkOrderLedgerForPrompt, closeWorkOrderLedgerForRouteResult } from '../work-order-ledger.js';
 import { GOAL_BRIDGE_ARTIFACT, GOAL_WORKFLOW_ARTIFACT, updateGoalWorkflow, writeGoalWorkflow } from '../goal-workflow.js';
 import { flag, promptOf, resolveMissionId } from './command-utils.js';
 import { compileGoalToLoopPlan } from '../loops/goal-to-loop-compat.js';
@@ -37,11 +38,13 @@ async function goalCreate(args) {
     if (flag(args, '--legacy-goal-runtime') || process.env.SKS_LEGACY_GOAL_RUNTIME === '1')
         return legacyGoalCreate(root, prompt, args);
     const { id, dir, mission } = await createMission(root, { mode: 'goal', prompt });
+    await createAndWriteWorkOrderLedgerForPrompt(dir, { missionId: id, route: 'Goal', prompt });
     const workflow = await writeGoalWorkflow(dir, mission, { action: 'create', prompt });
     const plan = await compileGoalToLoopPlan({ root, missionId: id, goalText: prompt, legacyGoalOptions: { native_goal: workflow.native_goal } });
     const result = await runLoopPlan({ root, plan, parallelism: 'balanced' });
     const gate = await evaluateLocalGate({ root, missionId: id, gateFile: 'loop-graph-proof.json' });
     const ok = result.ok === true && gate.ok === true;
+    await closeWorkOrderLedgerForRouteResult(dir, { ok, blockers: gate.blockers || [] });
     await setCurrent(root, { mission_id: id, mode: 'GOAL', route: 'Goal', route_command: '$Goal', phase: ok ? 'GOAL_LOOP_COMPLETED' : 'GOAL_LOOP_BLOCKED', questions_allowed: true, implementation_allowed: true, native_goal: workflow.native_goal, stop_gate: 'loop-graph-proof.json', stop_gate_blockers: gate.blockers }, { replace: true });
     if (!ok)
         process.exitCode = 1;

package/dist/core/commands/image-ux-review-command.js

@@ -13,6 +13,7 @@ import { sha256File, imageDimensions } from '../wiki-image/image-hash.js';
 import { writeRouteCollaborationArtifacts } from '../agents/route-collaboration-ledger.js';
 import { codexChromeExtensionStatus } from '../codex-app.js';
 import { requireCodexImagegen } from '../imagegen/require-imagegen.js';
+import { evaluateGate } from '../stop-gate/gate-evaluator.js';
 const ONE_BY_ONE_PNG_BASE64 = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMB/axX7V8AAAAASUVORK5CYII=';
 const IMAGE_UX_REVIEW_ARTIFACT_PATHS = {
     policy: IMAGE_UX_REVIEW_POLICY_ARTIFACT,
@@ -358,9 +359,11 @@ async function statusImageUxReview(root, args = []) {
     const gate = await readJson(path.join(dir, 'image-ux-review-gate.json'), null);
     const issueLedger = await readJson(path.join(dir, IMAGE_UX_REVIEW_ISSUE_LEDGER_ARTIFACT), null);
     const generatedLedger = await readJson(path.join(dir, IMAGE_UX_REVIEW_GENERATED_REVIEW_LEDGER_ARTIFACT), null);
-    const result = { schema: 'sks.image-ux-review-status.v2', ok: true, mission_id: missionId, gate, issue_ledger: issueLedger, generated_review_ledger: generatedLedger };
+    const gateVerdict = await evaluateGate(root, missionId, 'image-ux-review-gate.json');
+    const result = { schema: 'sks.image-ux-review-status.v2', ok: true, mission_id: missionId, gate, gate_verdict: gateVerdict, issue_ledger: issueLedger, generated_review_ledger: generatedLedger };
     if (flag(args, '--json'))
         return printJson(result);
+    console.log(gateVerdict.verdict);
     console.log(`Image UX Review mission: ${missionId}`);
     console.log(`Gate: ${gate?.status || (gate?.passed ? 'passed' : gate ? 'present' : 'missing')}`);
     if (gate?.verified_level)

package/dist/core/commands/mad-sks-command.js

@@ -26,6 +26,7 @@ import { repairZellijForSks } from '../zellij/zellij-self-heal.js';
 import { buildMadGlmLaunchArtifact, buildMadGlmLaunchProfileNoWrite, resolveMadGlmLaunchKey, writeMadGlmCodexWrapper } from '../providers/glm/glm-mad-launch.js';
 import { GLM_MAD_MODE } from '../providers/glm/glm-52-settings.js';
 import { assertNonGlmMadRoute } from '../routes/model-mode-router.js';
+import { evaluateGate } from '../stop-gate/gate-evaluator.js';
 const MAD_SKS_DEFAULT_TTL_MS = 10 * 60 * 1000;
 export async function madHighCommand(args = [], deps = {}) {
     const subcommand = firstSubcommand(args);
@@ -1013,6 +1014,12 @@ async function madSksSubcommand(subcommand, args = []) {
     if (subcommand === 'doctor' || subcommand === 'status') {
         const protectedCore = resolveProtectedCore({ packageRoot: packageRoot(), targetRoot });
         const before = await snapshotProtectedCore(packageRoot(), 'status');
+        const statusMissionId = await findLatestMission(root);
+        const gateVerdict = statusMissionId
+            ? await evaluateGate(root, statusMissionId, 'mad-sks-gate.json')
+            : await evaluateGate(root, 'no-mission', 'mad-sks-gate.json');
+        if (!json)
+            console.log(gateVerdict.verdict);
         return emit({
             schema: subcommand === 'doctor' ? 'sks.mad-sks-doctor.v1' : 'sks.mad-sks-status.v1',
             ok: true,
@@ -1022,7 +1029,9 @@ async function madSksSubcommand(subcommand, args = []) {
             protected_core_snapshot: before,
             protected_core_immutable: !protectedCore.engine_source_exception,
             protected_core_write_allowed: protectedCore.engine_source_exception,
-            permission_active: false
+            permission_active: false,
+            mission_id: statusMissionId,
+            gate_verdict: gateVerdict
         }, json);
     }
     if (subcommand === 'close' || subcommand === 'revoke') {

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

@@ -97,7 +97,8 @@ function printStatus(result) {
     console.log(`Running:   ${result.running ? 'yes' : 'no'}`);
     console.log(`Launchd:   ${result.launchd.ok ? result.launchd.state || 'present' : result.launchd.error || 'missing'}`);
     console.log(`Version:   ${result.build_stamp?.package_version || 'unknown'} (package ${result.package_version})`);
-    console.log(`Target:    ${result.action_target.sks_entry || 'missing'} ${result.action_target.sks_entry_exists ? '(ok)' : '(missing)'}`);
+    console.log(`Target:    ${result.action_target.sks_entry || 'runtime'} ${result.action_target.ok ? '(smoke ok)' : '(smoke failed)'}`);
+    console.log(`Codex sync:${result.codex_sync.bundle_id || 'disabled'} ${result.codex_sync.codex_running === null ? '' : result.codex_sync.codex_running ? '(running)' : '(not running)'}`);
     console.log(`Signature: ${result.signature.identifier || 'unknown'} ${result.signature.ok ? '(ok)' : '(check)'}`);
     if (result.warnings.length) {
         console.log('Warnings:');

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

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { ui as cliUi } from '../../cli/cli-theme.js';
 import { createMission, findLatestMission, loadMission, setCurrent } from '../mission.js';
+import { createAndWriteWorkOrderLedgerForPrompt, closeWorkOrderLedgerForRouteResult } from '../work-order-ledger.js';
 import { nowIso, readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
 import { runNativeAgentOrchestrator } from '../agents/agent-orchestrator.js';
 import { classifyOllamaWorkerSlice } from '../agents/agent-runner-ollama.js';
@@ -95,6 +96,7 @@ async function narutoRun(parsed) {
         maxAgentCount: MAX_NARUTO_AGENT_COUNT
     });
     const mission = await createMission(root, { mode: 'naruto', prompt: parsed.prompt });
+    await createAndWriteWorkOrderLedgerForPrompt(mission.dir, { missionId: mission.id, route: 'Naruto', prompt: parsed.prompt });
     await writeCodex0138CapabilityArtifacts(root, { missionId: mission.id }).catch(() => null);
     await writeCodex0139CapabilityArtifacts(root, { missionId: mission.id }).catch(() => null);
     const gitWorktreeCapability = writeCapable
@@ -280,13 +282,13 @@ async function narutoRun(parsed) {
         rebalance_ready: rebalancePolicy.ok === true,
         concurrency_governor_ready: true,
         active_pool_simulated: activePool.ok === true,
-        verification_dag_ready: true,
-        gpt_final_pack_ready: true,
+        verification_dag_ready: Array.isArray(verificationDag?.tasks),
+        gpt_final_pack_ready: Boolean(gptFinalPack?.schema),
         zellij_dashboard_ready: zellijDashboard.ok === true,
         native_agent_proof: false,
         final_arbiter_accepted: false,
         session_cleanup: false,
-        blockers: [],
+        blockers: [...(workGraph.blockers || []), ...(allocationPolicy.blockers || [])],
         updated_at: nowIso()
     });
     await setCurrent(root, {
@@ -417,9 +419,11 @@ async function narutoRun(parsed) {
     const regressionProof = summarizeRegressionProof(workGraph, result);
     await writeJsonAtomic(path.join(mission.dir, 'regression-proof-summary.json'), regressionProof);
     const tddOk = !regressionProof.required || (regressionProof.regression_test_added && regressionProof.regression_test_failed_before_fix && regressionProof.regression_test_passed_after_fix);
+    const narutoGateFullPassed = result.ok === true && nativeProofOk && finalAccepted && parallelRuntimeOk && tddOk && workGraph.ok === true && allocationPolicy.ok === true;
+    const narutoGateFullBlockers = [...(result.proof?.blockers || []), ...(parallelRuntimeOk ? [] : ['naruto_parallel_runtime_proof_below_gate']), ...(tddOk ? [] : ['tdd_evidence_missing']), ...(workGraph.blockers || []), ...(allocationPolicy.blockers || [])];
     await writeJsonAtomic(path.join(mission.dir, 'naruto-gate.json'), {
         schema: 'sks.naruto-gate.v1',
-        passed: result.ok === true && nativeProofOk && finalAccepted && parallelRuntimeOk && tddOk,
+        passed: narutoGateFullPassed,
         mission_id: mission.id,
         clone_roster_built: true,
         clone_count: roster.agent_count,
@@ -429,8 +433,8 @@ async function narutoRun(parsed) {
         rebalance_ready: rebalancePolicy.ok === true,
         concurrency_governor_ready: true,
         active_pool_simulated: activePool.ok === true,
-        verification_dag_ready: true,
-        gpt_final_pack_ready: true,
+        verification_dag_ready: Array.isArray(verificationDag?.tasks),
+        gpt_final_pack_ready: Boolean(gptFinalPack?.schema),
         zellij_dashboard_ready: zellijDashboard.ok === true,
         native_agent_proof: nativeProofOk,
         parallel_runtime_proof: parallelRuntimeOk,
@@ -440,9 +444,10 @@ async function narutoRun(parsed) {
         regression_proof: 'regression-proof-summary.json',
         final_arbiter_accepted: finalAccepted,
         session_cleanup: result.proof?.all_sessions_closed === true || nativeProofOk,
-        blockers: [...(result.proof?.blockers || []), ...(parallelRuntimeOk ? [] : ['naruto_parallel_runtime_proof_below_gate']), ...(tddOk ? [] : ['tdd_evidence_missing'])],
+        blockers: narutoGateFullBlockers,
         updated_at: nowIso()
     });
+    await closeWorkOrderLedgerForRouteResult(mission.dir, { ok: narutoGateFullPassed, blockers: narutoGateFullBlockers });
     const clones = result.roster?.agent_count ?? roster.agent_count;
     const localWorkerSummary = summarizeNarutoLocalWorkerResult(localWorker, result);
     // Finalizer policy: when local LLM workers contributed patches, the GPT

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

@@ -337,6 +337,45 @@ function mockPptFixtureGate(gate = {}) {
         blockers: ['ppt_fixture_mode_cannot_claim_real']
     };
 }
+// The image-asset-ledger's `assets` array (see buildPptImageAssetLedger in ../ppt.ts) is the
+// authoritative list of raster/bitmap image assets planned or generated for the deck; every
+// entry in it is a raster PNG produced (or pending) via Codex App $imagegen/gpt-image-2. When the
+// ledger omits `imagegen_evidence` outright, we must NOT assume the imagegen-required policy was
+// satisfied. Instead derive a safe default from that asset list: any raster asset present forces
+// the derived evidence to fail-closed (required + not passed) rather than silently pass.
+function deriveImagegenEvidenceDefault(imageAssetLedger) {
+    if (imageAssetLedger?.imagegen_evidence)
+        return imageAssetLedger.imagegen_evidence;
+    const rasterAssets = Array.isArray(imageAssetLedger?.assets) ? imageAssetLedger.assets : [];
+    const rasterAssetCount = rasterAssets.length;
+    if (rasterAssetCount === 0) {
+        return {
+            schema: 'sks.ppt-imagegen-evidence.v1',
+            required: false,
+            passed: true,
+            blockers: [],
+            derived: true,
+            derivation_basis: { raster_asset_count: 0, source: 'derived_default_no_raster_assets' }
+        };
+    }
+    return {
+        schema: 'sks.ppt-imagegen-evidence.v1',
+        required: true,
+        passed: false,
+        required_count: imageAssetLedger?.required_count || rasterAssetCount,
+        generated_count: imageAssetLedger?.generated_count || 0,
+        generated_image_evidence: false,
+        assets: [],
+        blockers: ['imagegen_evidence_missing'],
+        derived: true,
+        derivation_basis: {
+            raster_asset_count: rasterAssetCount,
+            source: 'derived_default_raster_assets_present',
+            note: `imagegen_evidence section was absent from the image-asset-ledger while ${rasterAssetCount} raster asset(s) were present; failing closed instead of silently passing.`
+        },
+        passed_note: 'imagegen_evidence_missing: ledger omitted imagegen_evidence despite raster assets requiring Codex App imagegen verification'
+    };
+}
 export async function evaluatePptGateArtifacts(dir, baseGate = {}) {
     const factLedger = await readJson(path.join(dir, PPT_FACT_LEDGER_ARTIFACT), null);
     const imageAssetLedger = await readJson(path.join(dir, PPT_IMAGE_ASSET_LEDGER_ARTIFACT), null);
@@ -370,7 +409,7 @@ export async function evaluatePptGateArtifacts(dir, baseGate = {}) {
     const renderReportPassed = renderReport?.passed === true;
     const factLedgerPassed = factLedger?.passed === true && Number(factLedger.unsupported_critical_claims_count || 0) === 0;
     const imageAssetLedgerPassed = imageAssetLedger?.passed === true;
-    const imagegenEvidence = imageAssetLedger?.imagegen_evidence || { schema: 'sks.ppt-imagegen-evidence.v1', required: false, passed: true, blockers: [] };
+    const imagegenEvidence = deriveImagegenEvidenceDefault(imageAssetLedger);
     const imagegenEvidencePassed = imagegenEvidence?.required === true ? imagegenEvidence?.passed === true : true;
     const reviewLedgerPassed = reviewLedger?.passed === true;
     const iterationReportPassed = iterationReport?.passed === true;

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

@@ -14,6 +14,7 @@ import { maybeFinalizeRoute } from '../proof/auto-finalize.js';
 import { runNativeAgentOrchestrator } from '../agents/agent-orchestrator.js';
 import { flag, promptOf, readBoundedIntegerFlag, readFlagValue, readMaxCycles, resolveMissionId, safeReadTextFile } from './command-utils.js';
 import { runCodexAppHandoff, qaLoopShouldRequestAppHandoff } from '../codex-app/codex-app-handoff.js';
+import { evaluateGate } from '../stop-gate/gate-evaluator.js';
 import { writeCodex0138CapabilityArtifacts } from '../codex-control/codex-0138-capability.js';
 import { writeCodexAccountUsageArtifacts } from '../usage/codex-account-usage.js';
 import { buildQaLoopBudgetPolicy, selectQaLoopEscalatedEffort } from '../qa-loop/qa-loop-budget-policy.js';
@@ -441,8 +442,10 @@ async function qaLoopStatus(args) {
     const desktop = await readJson(path.join(dir, 'qa-loop', 'app-handoff.json'), null);
     const desktopConfirmation = await readJson(path.join(dir, 'qa-loop', 'app-handoff-confirmation.json'), null);
     const desktopReviewComplete = desktopConfirmation?.verdict === 'pass';
+    const gateVerdict = await evaluateGate(root, id, 'qa-gate.json');
     if (flag(args, '--json'))
-        return console.log(JSON.stringify({ mission, state, qa: status, desktop_app_handoff: desktop, desktop_app_confirmation: desktopConfirmation, desktop_review_complete: desktopReviewComplete, native_agent_plan: nativeAgentPlan, agent_sessions: agentSessions?.sessions || null }, null, 2));
+        return console.log(JSON.stringify({ mission, state, qa: status, desktop_app_handoff: desktop, desktop_app_confirmation: desktopConfirmation, desktop_review_complete: desktopReviewComplete, native_agent_plan: nativeAgentPlan, agent_sessions: agentSessions?.sessions || null, gate_verdict: gateVerdict }, null, 2));
+    console.log(gateVerdict.verdict);
     console.log('SKS QA-LOOP Status\n');
     console.log(`Mission:   ${id}`);
     console.log(`Phase:     ${state.phase || mission.phase}`);

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

@@ -27,7 +27,7 @@ export async function releaseCommand(args = []) {
     await writeTextAtomic(stdoutPath, String(result.stdout || ''));
     await writeTextAtomic(stderrPath, String(result.stderr || ''));
     const readiness = await findReleaseReadinessReport(root);
-    const requiredSections = ['five_lane_review', 'integration_evidence', 'session_cleanup'];
+    const requiredSections = [];
     const missingSections = requiredSections.filter((section) => readiness.report?.[section] == null);
     if (readiness.report)
         await writeJsonAtomic(path.join(mission.dir, 'release-readiness-report.json'), readiness.report);
@@ -53,14 +53,14 @@ export async function releaseCommand(args = []) {
         stdout_tail: tail(String(result.stdout || '')),
         stderr_tail: tail(String(result.stderr || ''))
     };
+    if (!report.ok)
+        process.exitCode = result.status || 1;
     if (json)
         return printJson(report);
     if (result.stdout)
         process.stdout.write(result.stdout);
     if (result.stderr)
         process.stderr.write(result.stderr);
-    if (!report.ok)
-        process.exitCode = result.status || 1;
     return report;
 }
 async function findReleaseReadinessReport(root) {

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}`);