sneakoscope 4.8.7 → 5.1.2

package/dist/core/routes.js

@@ -140,7 +140,7 @@ export const ROUTES = [
         lifecycle: ['micro_task_list', 'targeted_inspection', 'listed_edits_only', 'cheap_verification'],
         context7Policy: 'optional',
         reasoningPolicy: 'medium',
-        stopGate: 'none',
+        stopGate: 'dfix-gate.json',
         cliEntrypoint: 'sks dfix',
         examples: ['$DFix 글자 색 바꿔줘', '$DFix README 오타 고쳐줘']
     },
@@ -172,6 +172,34 @@ export const ROUTES = [
         cliEntrypoint: 'sks commands',
         examples: ['$SKS show me available workflows']
     },
+    {
+        id: 'Planner',
+        command: '$Plan',
+        mode: 'PLAN',
+        route: 'planning-only frontdoor',
+        description: 'Decision-complete planning only. Writes .sneakoscope/plans/<slug>.md and keeps implementation disallowed until $Work runs the plan.',
+        requiredSkills: ['plan', 'honest-mode'],
+        lifecycle: ['plan_intake', 'scope_and_acceptance', 'write_plan_artifact', 'implementation_allowed_false', 'honest_mode'],
+        context7Policy: 'if_external_docs',
+        reasoningPolicy: 'high',
+        stopGate: 'plan-only',
+        cliEntrypoint: 'Codex App prompt route only: $Plan "task"',
+        examples: ['$Plan "결제 모듈 리팩터"', '$Plan "dashboard polish without editing code"']
+    },
+    {
+        id: 'Review',
+        command: '$Review',
+        mode: 'REVIEW',
+        route: 'machine-first diff review',
+        description: 'Review staged or selected diffs with machine evidence sorted above LLM opinion.',
+        requiredSkills: ['review', 'honest-mode'],
+        lifecycle: ['diff_collection', 'machine_checks', 'read_only_review_lenses', 'dedupe_findings', 'optional_one_fix_attempt', 'review_report'],
+        context7Policy: 'optional',
+        reasoningPolicy: 'high',
+        stopGate: 'review-report.json',
+        cliEntrypoint: 'sks review [--staged|--diff <ref>] [--fix] [--json]',
+        examples: ['$Review', 'sks review --staged']
+    },
     {
         id: 'FastMode',
         command: '$Fast-Mode',
@@ -231,14 +259,14 @@ export const ROUTES = [
         route: 'hardware-safe massive parallel work swarm',
         description: '$Naruto mode launches a hardware-safe massive parallel work swarm. Clones may implement, modify, verify, test, research, document, and resolve conflicts according to role and lease policy; write-capable output is accepted only through patch envelopes, verification DAG, mutation guard, and GPT final arbiter.',
         requiredSkills: ['naruto', 'pipeline-runner', 'prompt-pipeline', 'honest-mode'],
-        dollarAliases: ['$ShadowClone', '$Kagebunshin'],
-        appSkillAliases: ['shadow-clone', 'kage-bunshin'],
+        dollarAliases: ['$ShadowClone', '$Kagebunshin', '$Work', '$Swarm'],
+        appSkillAliases: ['shadow-clone', 'kage-bunshin', 'work', 'swarm'],
         lifecycle: ['clone_roster_build', 'massive_work_graph', 'hardware_safe_governor', 'dynamic_active_pool', 'lease_based_write_swarm', 'parallel_verification_dag', 'gpt_final_arbiter_pack', 'per_clone_proof', 'session_cleanup', 'honest_mode'],
         context7Policy: 'optional',
         reasoningPolicy: 'high',
         stopGate: 'naruto-gate.json',
         cliEntrypoint: 'sks naruto run "task" [--clones N] [--backend codex-sdk|fake|ollama] [--parallel-write] | sks naruto status',
-        examples: ['$Naruto run sweep the codebase for TODO comments with 50 clones', '$ShadowClone --clones 100 fan out and draft tests for every module']
+        examples: ['$Naruto run sweep the codebase for TODO comments with 50 clones', '$Work', '$Swarm "fix all lint errors"']
     },
     {
         id: 'ReleaseReview',
@@ -310,7 +338,7 @@ export const ROUTES = [
         lifecycle: ['fast_intake', 'focused_computer_use_steps', 'evidence_summary', 'final_triwiki_refresh_validate', 'honest_mode'],
         context7Policy: 'optional',
         reasoningPolicy: 'low',
-        stopGate: 'none',
+        stopGate: 'computer-use-gate.json',
         cliEntrypoint: 'Codex App prompt route only: $Computer-Use <target/task>',
         examples: ['$Computer-Use inspect this native Mac settings dialog', '$CU set up the local desktop app permission prompt']
     },
@@ -324,7 +352,7 @@ export const ROUTES = [
         lifecycle: ['goal_bridge_artifact', 'native_goal_create_or_control', 'selected_sks_route_continuation', 'honest_mode'],
         context7Policy: 'if_external_docs',
         reasoningPolicy: 'medium',
-        stopGate: 'none',
+        stopGate: 'loop-graph-proof.json',
         cliEntrypoint: 'sks goal create|pause|resume|clear|status',
         examples: ['$Goal persist this migration workflow with native /goal continuation']
     },
@@ -409,7 +437,7 @@ export const ROUTES = [
         lifecycle: ['experiment_ledger', 'metric', 'keep_or_discard', 'falsification', 'post_route_reflection', 'honest_conclusion'],
         context7Policy: 'required',
         reasoningPolicy: 'xhigh',
-        stopGate: 'autoresearch-gate.json',
+        stopGate: 'research-gate.json',
         cliEntrypoint: 'sks pipeline status',
         examples: ['$AutoResearch improve this workflow with experiments']
     },
@@ -431,29 +459,34 @@ export const ROUTES = [
         id: 'MadDB',
         command: '$MAD-DB',
         mode: 'MADDB',
-        route: 'first-class MadDB SQL-plane execution',
-        description: 'Explicit one-cycle MadDB route. When invoked by $MAD-DB or sks mad-db run|exec|apply-migration, SQL-plane mutations such as CREATE, ALTER, table/schema DROP, column add/drop/rename, INSERT, UPDATE, DELETE including all-row mutations, TRUNCATE, execute_sql, and apply_migration are authorized for the bound Supabase project and must be executed with tool-result plus read-back proof. Supabase project/account/billing/credential control-plane actions remain denied.',
-        requiredSkills: ['mad-db', 'db-safety-guard', 'pipeline-runner', 'context7-docs', REFLECTION_SKILL_NAME, 'honest-mode'],
+        route: 'deprecated alias to MAD-SKS SQL-plane executor',
+        description: 'Deprecated compatibility alias. $MAD-DB is merged into $MAD-SKS; SQL-plane execution now runs as the MAD-SKS sql-plane executor with the same read-back and control-plane safeguards.',
+        deprecated: true,
+        hidden: true,
+        aliasTo: '$MAD-SKS',
+        deprecationMessage: '$MAD-DB is merged into $MAD-SKS. SQL-plane execution now runs as the MAD-SKS sql-plane executor with the same read-back and control-plane safeguards.',
+        requiredSkills: ['mad-sks', 'db-safety-guard', 'pipeline-runner', 'context7-docs', REFLECTION_SKILL_NAME, 'honest-mode'],
         appSkillAliases: ['mad-db'],
-        lifecycle: ['explicit_invocation', 'single_mission_capability_v2', 'ephemeral_write_profile', 'tool_inventory', 'execute_sql_or_apply_migration', 'read_back_verification', 'close_and_read_only_restore', 'post_route_reflection', 'honest_mode'],
+        lifecycle: ['deprecated_alias_redirect', 'mad_sks_gate', 'honest_mode'],
         context7Policy: 'required',
         reasoningPolicy: 'xhigh',
-        stopGate: 'mad-db-gate.json',
-        cliEntrypoint: 'sks mad-db run|exec|apply-migration|status|close|revoke|doctor',
+        stopGate: 'mad-sks-gate.json',
+        cliEntrypoint: 'sks mad-db run|exec|apply-migration|status|close|revoke|doctor (deprecated; redirects to sks mad-sks sql|apply-migration)',
         examples: ['$MAD-DB public.users legacy_code 컬럼 삭제', '$MAD-DB truncate public.staging_events']
     },
     {
         id: 'MadSKS',
         command: '$MAD-SKS',
         mode: 'MADSKS',
-        route: 'explicit scoped permission-widening modifier',
-        description: 'Explicit high-risk authorization modifier that can be combined with other $ commands to temporarily open approved target-project scopes such as files, shell, package installs, services, network, Computer Use/browser workflows, generated assets, file permissions, migrations, Supabase MCP DB writes, direct execute SQL, schema cleanup, and normal targeted DB writes for the active invocation, while preserving catastrophic wipe/all-row/project-management, credential-exfiltration, persistent security-weakening, and unrequested fallback safeguards. It is not the first-class MadDB destructive SQL-plane route.',
+        route: 'explicit scoped permission-widening modifier plus SQL-plane execution',
+        description: 'Explicit high-risk authorization modifier that can be combined with other $ commands to temporarily open approved target-project scopes such as files, shell, package installs, services, network, Computer Use/browser workflows, generated assets, file permissions, migrations, Supabase MCP DB writes, direct execute SQL, schema cleanup, and normal targeted DB writes for the active invocation. It also includes the merged MadDB SQL-plane executor: CREATE, ALTER, table/schema DROP, column add/drop/rename, INSERT, UPDATE, DELETE including all-row mutations, TRUNCATE, execute_sql, and apply_migration are authorized only for the bound Supabase project, must keep Supabase project/account/billing/credential control-plane actions denied, and must finish with tool-result plus read-back proof and read-only restoration.',
         requiredSkills: ['mad-sks', 'db-safety-guard', 'pipeline-runner', 'context7-docs', REFLECTION_SKILL_NAME, 'honest-mode'],
-        lifecycle: ['explicit_invocation', 'auto_sealed_permission_scope', 'scoped_permission_override', 'catastrophic_guard', 'permission_deactivation', 'post_route_reflection', 'honest_mode'],
+        appSkillAliases: ['mad-sks'],
+        lifecycle: ['explicit_invocation', 'auto_sealed_permission_scope', 'single_mission_capability_v2', 'ephemeral_write_profile', 'tool_inventory', 'scoped_permission_override', 'catastrophic_guard', 'execute_sql_or_apply_migration', 'read_back_verification', 'close_and_read_only_restore', 'permission_deactivation', 'post_route_reflection', 'honest_mode'],
         context7Policy: 'required',
         reasoningPolicy: 'xhigh',
         stopGate: 'mad-sks-gate.json',
-        cliEntrypoint: 'Codex App prompt route only: $MAD-SKS <task>',
+        cliEntrypoint: 'sks mad-sks plan|run|apply|sql|apply-migration|status|close|rollback-apply',
         examples: ['$MAD-SKS $Team target project maintenance with package/service/file and DB scopes', '$DB Supabase 점검 $MAD-SKS']
     },
     {
@@ -524,7 +557,10 @@ export const COMMAND_CATALOG = [
     { name: 'triwiki', usage: 'sks triwiki index|affected|proof-bank [--json]', description: 'Inspect TriWiki module cards, gate impact maps, affected graphs, and proof bank status.' },
     { name: 'daemon', usage: 'sks daemon status|warm|stop [--json]', description: 'Inspect or warm the local SKS daemon cache state for build/proof reuse.' },
     { name: 'run', usage: 'sks run "task" [--visual|--research|--db] [--json]', description: 'Classify a plain-language task, materialize a mission, and route it through the SKS trust kernel.' },
+    { name: 'plan', usage: 'sks plan "task" [--json]', description: 'Write a planning-only artifact under .sneakoscope/plans without editing code.' },
     { name: 'status', usage: 'sks status [--json]', description: 'Show the active mission, route, phase, proof, trust, native agent, image voxel, DB safety, and next action.' },
+    { name: 'review', usage: 'sks review [--staged|--diff <ref>] [--fix] [--json]', description: 'Review a diff with machine-evidence findings sorted above LLM review notes.' },
+    { name: 'ui', usage: 'sks ui [--port 4477] [--mission latest] [--once] [--json]', description: 'Open the localhost SKS dashboard with live swarm slots, events, and gate status.' },
     { name: 'usage', usage: `sks usage [${USAGE_TOPICS}]`, description: 'Print copy-ready workflows for common tasks.' },
     { name: 'quickstart', usage: 'sks quickstart', description: 'Show the shortest safe setup and verification flow.' },
     { name: 'bootstrap', usage: 'sks bootstrap [--install-scope global|project] [--local-only] [--json]', description: 'Initialize the current project, install SKS Codex App files/skills, check Context7/Codex App/Zellij, and print ready true/false.' },
@@ -539,7 +575,7 @@ export const COMMAND_CATALOG = [
     { name: 'codex-lb', usage: 'sks codex-lb status|health|metrics|doctor|circuit|repair|setup ...', description: 'Configure, health-check, repair, and record circuit evidence for codex-lb provider auth without confusing ChatGPT OAuth and proxy keys.' },
     { name: 'zellij', usage: 'sks zellij status|repair [--json] | sks naruto dashboard latest | sks --mad', description: 'Inspect Zellij runtime status, explain repair (no auto-install), and open the SKS Zellij runtime used by MAD and Naruto lane UI.' },
     { name: 'tmux', usage: 'removed-runtime migration notice (replacement: zellij)', description: 'Show the removed-runtime migration notice and point operators to Zellij.' },
-    { name: 'mad-sks', usage: 'sks mad-sks plan|run|status|proof ... | sks --mad [--high]', description: 'Open or inspect MAD-SKS scoped permission workflows and the Zellij permission launcher.' },
+    { name: 'mad-sks', usage: 'sks mad-sks plan|run|apply|sql|apply-migration|status|close|rollback-apply ... | sks --mad [--high]', description: 'Open or inspect MAD-SKS scoped permission workflows, merged SQL-plane execution, and the Zellij permission launcher.' },
     { name: 'auto-review', usage: 'sks auto-review status|enable|start [--high] | sks --Auto-review --high', description: 'Enable Codex automatic approval review and launch SKS Zellij with the auto-review profile.' },
     { name: 'dollar-commands', usage: 'sks dollar-commands [--json]', description: 'List Codex App $ commands such as $DFix and $Naruto.' },
     { name: 'fast-mode', usage: 'sks fast-mode on|off|status|clear [--project] [--json]', description: 'Toggle the global Codex Desktop GPT 5.5 Fast default used by $Fast-On/$Fast-Off and keep project worker preference in sync; pass --project for project-local only.' },
@@ -588,6 +624,7 @@ export const COMMAND_CATALOG = [
     { name: 'rust', usage: 'sks rust status|smoke [--json] [--require-native]', description: 'Inspect optional Rust accelerator availability and verify JS fallback parity for image hash, voxel validation, and secret scanning.' },
     { name: 'validate-artifacts', usage: 'sks validate-artifacts [mission-id|latest] [--json]', description: 'Validate schema-backed mission artifacts for work orders, effort decisions, visual maps, dogfood reports, skills, mistake memory, Team dashboard state, and Honest Mode.' },
     { name: 'wiki', usage: 'sks wiki coords|pack|refresh|publish|rebuild-index|validate|validate-shared|wrongness ...', description: 'Build, refresh, publish shared shards, rebuild ignored indexes, validate, and attach wrongness-memory context to RGBA/trig LLM Wiki packs with attention.use_first and attention.hydrate_first for compact recall plus source hydration.' },
+    { name: 'memory', usage: 'sks memory build [--json] | sks memory gc [--dry-run]', description: 'Project TriWiki context-pack memory into managed AGENTS.md blocks or run bounded memory cleanup.' },
     { name: 'hproof', usage: 'sks hproof check [mission-id|latest]', description: 'Evaluate the H-Proof done gate for a mission.' },
     { name: 'agent', usage: 'sks agent run|status|close|cleanup <mission-id|latest> [--agents N] [--work-items N] [--target-active-slots N] [--mock] [--apply|--dry-run] [--drain] [--stale-ms N] [--json] | sks agent rollback-patches [mission-id|latest] [--patch-entry-id id] [--dry-run|--apply] [--json]', description: 'Run, inspect, close, clean, or rollback native multi-session agent missions with agents as target active slots, work items as the route queue size, cleanup executor proof for stale runtime resources, and patch rollback proof for applied patch entries.' },
     { name: 'team', usage: 'sks team \"task\" | sks team log|tail|watch|lane|status|dashboard|event|message|open-zellij|attach-zellij|cleanup-zellij ...', description: 'Deprecated compatibility command: new tasks redirect to Naruto; observation subcommands remain for old Team missions.' },
@@ -613,6 +650,10 @@ export function routeByDollarCommand(commandName) {
     const key = String(commandName || '').replace(/^\$/, '').toLowerCase();
     if (key === 'team' || key === 'from-chat-img')
         return routeById('Naruto');
+    if (key === 'work' || key === 'swarm')
+        return routeById('Naruto');
+    if (key === 'plan')
+        return routeById('Planner');
     return ROUTES.find((route) => [
         dollarSkillName(route.command),
         ...(route.dollarAliases || []).map((alias) => dollarSkillName(alias)),
@@ -737,6 +778,12 @@ export function looksLikeUltraSearchRequest(prompt = '') {
 }
 export function routePrompt(prompt) {
     const text = stripVisibleDecisionAnswerBlocks(prompt);
+    if (/^\$?plan\b/i.test(text))
+        return routeById('Planner');
+    if (/^\$?work\b/i.test(text))
+        return routeById('Naruto');
+    if (/^\$?swarm\b/i.test(text))
+        return routeById('Naruto');
     const command = dollarCommand(text);
     if (command) {
         if (command === 'MAD-SKS') {

package/dist/core/safety/mutation-guard.js

@@ -168,8 +168,12 @@ export async function guardedPackageInstall(ctx, spec, opts) {
             runOpts.env = opts.env;
         if (opts.maxOutputBytes !== undefined)
             runOpts.maxOutputBytes = opts.maxOutputBytes;
+        if (opts.onStdout !== undefined)
+            runOpts.onStdout = opts.onStdout;
+        if (opts.onStderr !== undefined)
+            runOpts.onStderr = opts.onStderr;
         const result = await runProcess(opts.command, opts.args, runOpts);
-        return { code: result.code, stdout: result.stdout, stderr: result.stderr };
+        return { code: result.code, stdout: result.stdout, stderr: result.stderr, timedOut: result.timedOut === true };
     });
 }
 export async function guardedSkillSnapshotPromotion(ctx, skillTarget, opts, apply) {

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

@@ -140,10 +140,16 @@ export async function checkStopGate(input) {
         missingFields.push('blockers');
     if (normalizedGate.missing_fields.length > 0)
         missingFields.push(...normalizedGate.missing_fields.map((field) => `missing_fields:${field}`));
+    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',
@@ -205,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-writer.js

@@ -136,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

package/dist/core/triwiki/agents-md-projector.js

@@ -0,0 +1,184 @@
+import path from 'node:path';
+import fsp from 'node:fs/promises';
+import { ensureDir, nowIso, readJson, readText, writeTextAtomic } from '../fsx.js';
+const BEGIN = '<!-- BEGIN SKS PROJECT MEMORY (auto) -->';
+const END = '<!-- END SKS PROJECT MEMORY -->';
+export async function projectTriwikiToAgentsMd(root, opts = {}) {
+    const pack = await readJson(path.join(root, '.sneakoscope', 'wiki', 'context-pack.json'), null);
+    if (!pack)
+        return { ok: false, reason: 'no_context_pack', written: [] };
+    const written = [];
+    const rootContent = buildRootSections(pack);
+    written.push(await upsertManagedBlock(path.join(root, 'AGENTS.md'), rootContent));
+    const hotDirs = await scoreComplexDirs(root, pack, opts.maxLocalFiles ?? 8);
+    for (const dir of hotDirs) {
+        written.push(await upsertManagedBlock(path.join(root, dir.path, 'AGENTS.md'), buildLocalSection(pack, dir)));
+    }
+    return { ok: true, reason: null, written, hot_dirs: hotDirs };
+}
+export async function removeTriwikiAgentsMdBlocks(root) {
+    const files = await collectAgentsMdFiles(root);
+    const changed = [];
+    for (const file of files) {
+        const prev = await readText(file, '');
+        const next = removeManagedBlock(String(prev || '')).trim();
+        if (next !== String(prev || '').trim()) {
+            await writeTextAtomic(file, next ? `${next}\n` : '');
+            changed.push(file);
+        }
+    }
+    return changed;
+}
+async function upsertManagedBlock(file, content) {
+    const prev = await readText(file, '');
+    const block = `${BEGIN}\n${content.trim()}\n${END}`;
+    const next = String(prev || '').includes(BEGIN)
+        ? String(prev || '').replace(new RegExp(`${escapeRe(BEGIN)}[\\s\\S]*?${escapeRe(END)}`), block)
+        : `${String(prev || '').trim()}\n\n${block}\n`;
+    if (next !== prev) {
+        await ensureDir(path.dirname(file));
+        await writeTextAtomic(file, next.trimStart());
+    }
+    return file;
+}
+function removeManagedBlock(text) {
+    return text.replace(new RegExp(`\\n?${escapeRe(BEGIN)}[\\s\\S]*?${escapeRe(END)}\\n?`, 'g'), '\n').replace(/\n{3,}/g, '\n\n');
+}
+function buildRootSections(pack) {
+    const claims = compactClaims(pack).slice(0, 8);
+    const modules = compactModules(pack).slice(0, 8);
+    const wrongness = compactWrongness(pack).slice(0, 5);
+    return [
+        `# SKS Project Memory`,
+        ``,
+        `Generated: ${nowIso()}`,
+        `Source: .sneakoscope/wiki/context-pack.json`,
+        ``,
+        `## Architecture Summary`,
+        claims.length ? claims.map((claim) => `- ${claim}`).join('\n') : '- No high-trust TriWiki claims available yet.',
+        ``,
+        `## Core Modules`,
+        modules.length ? modules.map((item) => `- ${item}`).join('\n') : '- No module map entries available yet.',
+        ``,
+        `## Recent Lessons`,
+        wrongness.length ? wrongness.map((item) => `- ${item}`).join('\n') : '- No wrongness-ledger lessons available yet.'
+    ].join('\n');
+}
+function buildLocalSection(pack, dir) {
+    const claims = compactClaims(pack)
+        .filter((claim) => claim.includes(dir.path))
+        .slice(0, 6);
+    return [
+        `# SKS Local Project Memory: ${dir.path}`,
+        ``,
+        `Generated: ${nowIso()}`,
+        ``,
+        `## Local Anchors`,
+        dir.files.slice(0, 8).map((file) => `- ${file}`).join('\n') || '- No file anchors available.',
+        ``,
+        `## TriWiki Notes`,
+        claims.length ? claims.map((claim) => `- ${claim}`).join('\n') : '- Use root AGENTS.md SKS Project Memory plus nearby source files as authority.'
+    ].join('\n');
+}
+async function scoreComplexDirs(root, pack, maxLocalFiles) {
+    const sourcePaths = extractSourcePaths(pack).filter((file) => !file.includes('node_modules') && !file.startsWith('.git/'));
+    const scores = new Map();
+    for (const file of sourcePaths) {
+        const dir = firstInterestingDir(file);
+        if (!dir)
+            continue;
+        const row = scores.get(dir) || { path: dir, score: 0, files: new Set() };
+        row.score += 2;
+        row.files.add(file);
+        scores.set(dir, row);
+    }
+    for (const dir of ['src/core', 'src/commands', 'src/scripts', 'src/cli']) {
+        const count = await countFiles(path.join(root, dir)).catch(() => 0);
+        if (!count)
+            continue;
+        const row = scores.get(dir) || { path: dir, score: 0, files: new Set() };
+        row.score += count;
+        scores.set(dir, row);
+    }
+    return [...scores.values()]
+        .filter((row) => row.path.split('/').length <= 3)
+        .sort((a, b) => b.score - a.score || a.path.localeCompare(b.path))
+        .slice(0, Math.max(0, maxLocalFiles))
+        .map((row) => ({ path: row.path, score: row.score, files: [...row.files].slice(0, 12) }));
+}
+function compactClaims(pack) {
+    const rows = flattenRecords(pack).filter((row) => typeof row.claim === 'string' || typeof row.text === 'string' || typeof row.summary === 'string');
+    return rows
+        .map((row) => sanitizeLine(row.claim || row.text || row.summary))
+        .filter(Boolean)
+        .slice(0, 40);
+}
+function compactModules(pack) {
+    const rows = flattenRecords(pack).filter((row) => row.path || row.source_path || row.file);
+    return rows
+        .map((row) => sanitizeLine(`${row.path || row.source_path || row.file}${row.summary ? ` - ${row.summary}` : ''}`))
+        .filter(Boolean)
+        .slice(0, 40);
+}
+function compactWrongness(pack) {
+    const rows = flattenRecords(pack).filter((row) => /wrong|lesson|mistake|stale|failure/i.test(String(row.kind || row.type || row.id || '')));
+    return rows.map((row) => sanitizeLine(row.lesson || row.summary || row.text || row.claim || row.id)).filter(Boolean).slice(0, 20);
+}
+function extractSourcePaths(pack) {
+    return [...new Set(flattenRecords(pack).flatMap((row) => [row.path, row.source_path, row.file, row.rel, row.relative_path]).map((value) => String(value || '').replace(/^\.\//, '')).filter((value) => value.includes('/')))];
+}
+function flattenRecords(value, depth = 0) {
+    if (depth > 5 || value == null)
+        return [];
+    if (Array.isArray(value))
+        return value.flatMap((item) => flattenRecords(item, depth + 1));
+    if (typeof value !== 'object')
+        return [];
+    const own = value;
+    return [own, ...Object.values(own).flatMap((child) => flattenRecords(child, depth + 1))];
+}
+function firstInterestingDir(file) {
+    const parts = file.split('/').filter(Boolean);
+    if (parts.length < 2)
+        return null;
+    if (parts[0] === 'src' && parts.length >= 3)
+        return `${parts[0]}/${parts[1]}`;
+    return parts[0] || null;
+}
+async function countFiles(dir) {
+    const rows = await fsp.readdir(dir, { withFileTypes: true });
+    let total = 0;
+    for (const row of rows) {
+        if (row.name === 'node_modules' || row.name === '.git' || row.name === 'dist')
+            continue;
+        const file = path.join(dir, row.name);
+        total += row.isDirectory() ? await countFiles(file) : row.isFile() ? 1 : 0;
+    }
+    return total;
+}
+async function collectAgentsMdFiles(root) {
+    const files = [];
+    async function walk(dir, depth) {
+        if (depth > 4)
+            return;
+        const rows = await fsp.readdir(dir, { withFileTypes: true }).catch(() => []);
+        for (const row of rows) {
+            if (['.git', 'node_modules', 'dist'].includes(row.name))
+                continue;
+            const file = path.join(dir, row.name);
+            if (row.isFile() && row.name === 'AGENTS.md')
+                files.push(file);
+            else if (row.isDirectory())
+                await walk(file, depth + 1);
+        }
+    }
+    await walk(root, 0);
+    return files;
+}
+function sanitizeLine(value) {
+    return String(value || '').replace(/\s+/g, ' ').trim().slice(0, 220);
+}
+function escapeRe(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+//# sourceMappingURL=agents-md-projector.js.map

package/dist/core/triwiki-wrongness/wrongness-schema.js

@@ -140,7 +140,9 @@ export function createWrongnessRecord(input = {}) {
         corrective_action: normalizeCorrectiveAction(row.corrective_action),
         avoidance_rule: normalizeAvoidanceRule(row.avoidance_rule, kind, avoidanceText, severity),
         correction: normalizeCorrection(row.correction ?? row.corrected_anchor),
-        links: normalizeLinks(row.links)
+        links: normalizeLinks(row.links),
+        ...(row.rule_compiled === undefined ? {} : { rule_compiled: Boolean(row.rule_compiled) }),
+        ...(row.compiled_rule_id === undefined ? {} : { compiled_rule_id: stringOrNull(row.compiled_rule_id) })
     };
 }
 export function emptyWrongnessLedger(scope = 'project', missionId = null) {

package/dist/core/trust-kernel/trust-kernel-schema.js

@@ -5,6 +5,7 @@ export const TRUST_REPORT_SCHEMA = 'sks.trust-report.v1';
 export const TRUST_STATUSES = [
     'verified',
     'verified_partial',
+    'mock_only',
     'blocked',
     'failed',
     'not_verified'

package/dist/core/trust-kernel/trust-report.js

@@ -102,7 +102,7 @@ export function buildTrustReport({ proof = {}, evidenceIndex = {}, contract = {}
     return {
         schema: TRUST_REPORT_SCHEMA,
         ...trustKernelMetadata(),
-        ok: issues.length === 0 && !['blocked', 'failed', 'not_verified'].includes(finalStatus),
+        ok: issues.length === 0 && !['blocked', 'failed', 'not_verified', 'mock_only'].includes(finalStatus),
         mission_id: proof.mission_id || contract.mission_id || null,
         route: proof.route || contract.route || null,
         status: finalStatus,

package/dist/core/trust-kernel/trust-status.js

@@ -7,6 +7,8 @@ export function combineTrustStatus(statuses = []) {
         return 'blocked';
     if (values.includes('not_verified'))
         return 'not_verified';
+    if (values.includes('mock_only'))
+        return 'mock_only';
     if (values.includes('verified_partial'))
         return 'verified_partial';
     return values.length ? 'verified' : 'not_verified';