sneakoscope 8.3.2 → 8.6.0

package/dist/core/fsx.js

@@ -65,6 +65,20 @@ export async function canonicalFilesystemPath(p) {
     const resolved = path.resolve(p);
     return fsp.realpath(resolved).catch(() => resolved);
 }
+export function canonicalFilesystemPathSync(value) {
+    const resolved = path.resolve(value);
+    try {
+        return fs.realpathSync.native(resolved);
+    }
+    catch {
+        if (process.platform === 'darwin' && resolved.startsWith('/var/'))
+            return `/private${resolved}`;
+        return resolved;
+    }
+}
+export function sameFilesystemPathSync(left, right) {
+    return Boolean(left && right && canonicalFilesystemPathSync(left) === canonicalFilesystemPathSync(right));
+}
 export async function sameFilesystemPath(left, right) {
     const [leftCanonical, rightCanonical] = await Promise.all([
         canonicalFilesystemPath(left),

package/dist/core/git-hygiene/git-policy.js

@@ -17,6 +17,8 @@ export const SHARED_MEMORY_TRACK = [
 export const GENERATED_INDEX_IGNORE = [
     '.sneakoscope/wiki/indexes/**/*.json',
     '.sneakoscope/wiki/context-packs/**/*.json',
+    '.sneakoscope/wiki/architecture-map/**',
+    '.sneakoscope/wiki/architecture-map/**/*.mmd',
     '.sneakoscope/wiki/tmp/**'
 ];
 export const LOCAL_RUNTIME_IGNORE = [
@@ -53,6 +55,8 @@ export const LOCAL_RUNTIME_IGNORE = [
     '.sneakoscope/wiki/image-wrongness-index.json',
     '.sneakoscope/wiki/visual-anchors.json',
     '.sneakoscope/wiki/last-sweep-report.json',
+    '.sneakoscope/wiki/architecture-map/**',
+    '.sneakoscope/wiki/architecture-map/**/*.mmd',
     '.sneakoscope/**/*.log'
 ];
 export const SHARED_MEMORY_DIRS = [

package/dist/core/git-hygiene/gitignore-writer.js

@@ -32,6 +32,8 @@ export const GITIGNORE_BLOCK = `# BEGIN ${GIT_HYGIENE_BLOCK}
 # Generated TriWiki indexes and transient context packs
 .sneakoscope/wiki/indexes/
 .sneakoscope/wiki/context-packs/
+.sneakoscope/wiki/architecture-map/
+.sneakoscope/wiki/architecture-map/**
 .sneakoscope/wiki/tmp/
 .sneakoscope/wiki/context-pack.json
 .sneakoscope/wiki/image-assets.json

package/dist/core/gx-renderer.js

@@ -78,7 +78,8 @@ export function normalizeVGraph(vgraph = {}) {
         edges,
         invariants: Array.isArray(vgraph.invariants) ? vgraph.invariants : [],
         tests: Array.isArray(vgraph.tests) ? vgraph.tests : [],
-        risks: Array.isArray(vgraph.risks) ? vgraph.risks : []
+        risks: Array.isArray(vgraph.risks) ? vgraph.risks : [],
+        ...(vgraph.atlas && typeof vgraph.atlas === 'object' && !Array.isArray(vgraph.atlas) ? { atlas: vgraph.atlas } : {})
     };
 }
 export function vgraphHash(vgraph = {}) {

package/dist/core/init.js

@@ -11,13 +11,15 @@ import { OFFICIAL_SUBAGENT_REVIEW_POLICY_TEXT } from './official-subagent-review
 import { AWESOME_DESIGN_MD_REFERENCE, CODEX_APP_IMAGE_GENERATION_DOC_URL, CODEX_COMPUTER_USE_ONLY_POLICY, CODEX_IMAGEGEN_REQUIRED_POLICY, CODEX_WEB_VERIFICATION_POLICY, DEFAULT_CODEX_APP_PLUGINS, DESIGN_SYSTEM_SSOT, DOLLAR_COMMANDS, DOLLAR_COMMAND_ALIASES, DOLLAR_SKILL_NAMES, FROM_CHAT_IMG_CHECKLIST_ARTIFACT, FROM_CHAT_IMG_COVERAGE_ARTIFACT, FROM_CHAT_IMG_QA_LOOP_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS, GETDESIGN_REFERENCE, IMAGEGEN_SOCIAL_SOURCE_POLICY, LEGACY_DOLLAR_SKILL_NAMES, OPENAI_CHATGPT_IMAGES_2_DOC_URL, OPENAI_GPT_IMAGE_2_MODEL_DOC_URL, OPENAI_IMAGE_GENERATION_DOC_URL, PPT_CONDITIONAL_SKILL_ALLOWLIST, PPT_PIPELINE_MCP_ALLOWLIST, PPT_PIPELINE_SKILL_ALLOWLIST, RECOMMENDED_DESIGN_REFERENCES, RECOMMENDED_MCP_SERVERS, RECOMMENDED_SKILLS, RESERVED_CODEX_PLUGIN_SKILL_NAMES, SOLUTION_SCOUT_SKILL_NAME, chatCaptureIntakeText, context7ConfigToml, getdesignReferencePolicyText, imageUxReviewPipelinePolicyText, outcomeRubricPolicyText, pptPipelineAllowlistPolicyText, prefixKnownSksDollarReferences, productDesignPluginPolicyText, sksPrefixedDollarCommand, speedLanePolicyText, stackCurrentDocsPolicyText, triwikiContextTracking, triwikiContextTrackingText, triwikiStagePolicyText } from './routes.js';
 import { SKILL_DREAM_POLICY, skillDreamPolicyText } from './skill-forge.js';
 import { CODEX_HOOK_EVENT_STATE_KEYS } from './codex-compat/codex-hook-events.js';
+import { MANAGED_CODEX_FEATURE_FLAGS, REMOVED_CODEX_FEATURE_FLAGS } from './codex/codex-feature-flags.js';
+import { writeCodexConfigGuarded } from './codex/codex-config-guard.js';
 import { codexCommandHookCurrentHash } from './codex-hooks/codex-hook-hash.js';
 import { buildSksCoreSkillManifest, isCoreSkillName, legacyCoreSkillNames } from './codex-native/core-skill-manifest.js';
 import { syncCoreSkillsIntegrity } from './codex-native/core-skill-integrity.js';
 import { AUTHORITATIVE_SKS_SKILL_ROOT_REFERENCE } from './codex-native/sks-skill-paths.js';
 import { currentGeneratedFileInventory, installCodexAgents, pruneStaleGeneratedFiles, REMOVED_SKS_SKILL_NAMES } from './init/skills.js';
 import { reconcileManagedSkillInstallation } from './init/managed-skill-install.js';
-import { backupInvalidToml, inspectOfficialSubagentToml, mergeOfficialSubagentConfig, officialSubagentConfigOwnershipProof, officialSubagentConfigWarnings, readInheritedOfficialSubagentConfigText, resolveInheritedOfficialSubagentConfigPath } from './subagents/official-subagent-config.js';
+import { backupInvalidToml, inspectOfficialSubagentToml, mergeOfficialSubagentConfig, officialSubagentConfigOwnershipProof, officialSubagentConfigWarnings, readInheritedOfficialSubagentConfigText, resolveInheritedOfficialSubagentConfigPath, stampSksManagedCodexConfigMarker } from './subagents/official-subagent-config.js';
 import { escapeRegExp } from './text/regex.js';
 export { installGlobalSkills, installProjectSkills, installSkills } from './init/skills.js';
 const REFLECTION_MEMORY_PATH = '.sneakoscope/memory/q2_facts/post-route-reflection.md';
@@ -206,6 +208,8 @@ function upsertCodexTrustTomlTable(text, table, block) {
             break;
         }
     }
+    while (end > start + 1 && !String(lines[end - 1] || '').trim())
+        end -= 1;
     lines.splice(start, end - start, ...blockLines);
     return lines.join('\n').replace(/\n{3,}/g, '\n\n');
 }
@@ -631,14 +635,11 @@ export async function initProject(root, opts = {}) {
             project_install: 'npm i -D sneakoscope && npx sks setup --install-scope project'
         };
     }
-    const MANAGED_CODEX_FEATURE_FLAGS = ['hooks', 'fast_mode', 'apps'];
-    const REMOVED_CODEX_FEATURE_FLAGS = [
-        'remote_control', 'fast_mode_ui', 'codex_git_commit', 'computer_use', 'browser_use',
-        'browser_use_external', 'image_generation', 'in_app_browser', 'guardian_approval',
-        'tool_suggest', 'plugins', 'codex_hooks', 'multi_agent'
-    ];
     function mergeManagedCodexConfigToml(existingContent = '', opts = {}) {
         let next = String(existingContent || '').trimEnd();
+        if (opts.sksOwned === true || opts.configWasFresh === true) {
+            next = stampSksManagedCodexConfigMarker(next);
+        }
         next = removeTomlTableKey(next, 'notice', 'fast_default_opt_out');
         next = removeTomlTableKey(next, 'features', 'codex_hooks');
         next = upsertTopLevelTomlBooleanIfAbsent(next, 'suppress_unstable_features_warning', true);
@@ -918,6 +919,7 @@ export async function initProject(root, opts = {}) {
         else {
             const managedCodexConfig = await mergeGlobalCodexConfigIfAvailable(mergeManagedCodexConfigToml(existingCodexConfig, {
                 sksOwned: configPreviouslySksOwned,
+                configWasFresh,
                 inheritedText: inheritedCodexConfig
             }), generatedCodexConfigPath, { home: opts.home, codexHome: opts.codexHome });
             const managedConfigValidation = inspectOfficialSubagentToml(managedCodexConfig);
@@ -934,16 +936,37 @@ export async function initProject(root, opts = {}) {
                 created.push('.codex/config.toml merge skipped (manual repair required)');
             }
             else {
-                await writeTextAtomic(generatedCodexConfigPath, managedCodexConfig);
-                codexConfigInstall = {
-                    ok: true,
-                    status: managedCodexConfig === existingCodexConfig ? 'present' : 'written',
-                    config_path: generatedCodexConfigPath,
-                    backup_path: null,
-                    manual_blockers: [],
-                    warnings: officialSubagentConfigWarnings(managedCodexConfig, inheritedCodexConfig)
-                };
-                created.push('.codex/config.toml');
+                const guarded = await writeCodexConfigGuarded({
+                    root,
+                    configPath: generatedCodexConfigPath,
+                    before: existingCodexConfig,
+                    cause: 'sks-init-managed-project-config',
+                    ownershipVerified: configWasFresh || configPreviouslySksOwned,
+                    preserveTextFormatting: true,
+                    mutate: () => managedCodexConfig
+                });
+                codexConfigInstall = guarded.ok
+                    ? {
+                        ok: true,
+                        status: managedCodexConfig === existingCodexConfig ? 'present' : 'written',
+                        config_path: generatedCodexConfigPath,
+                        backup_path: guarded.backup_path,
+                        manual_blockers: [],
+                        warnings: officialSubagentConfigWarnings(managedCodexConfig, inheritedCodexConfig)
+                    }
+                    : {
+                        ok: false,
+                        status: guarded.status,
+                        config_path: generatedCodexConfigPath,
+                        backup_path: guarded.backup_path,
+                        manual_blockers: [`manual_unmanaged_project_codex_config:${guarded.status}`],
+                        warnings: [],
+                        operator_actions: [
+                            `${generatedCodexConfigPath} is not proven SKS-owned, so setup left it unchanged. `
+                                + 'Run `sks config adopt` to bring it under management, or delete it and re-run `sks setup`.'
+                        ]
+                    };
+                created.push(guarded.ok ? '.codex/config.toml' : '.codex/config.toml preserved (user-owned)');
             }
         }
     }

package/dist/core/managed-paths.js

@@ -29,6 +29,7 @@ export function defaultManagedPaths() {
         row('.sneakoscope/wiki/summaries', 'tracked shared markdown summaries', false, 'shared_memory', 'tracked'),
         row('.sneakoscope/wiki/indexes', 'ignored regenerated shared-memory indexes', true, 'generated_index', 'ignored'),
         row('.sneakoscope/wiki/context-packs', 'ignored regenerated context-pack snapshots', true, 'generated_index', 'ignored'),
+        row('.sneakoscope/wiki/architecture-map', 'ignored regenerated Architecture Map views', true, 'generated_index', 'ignored'),
         row('.sneakoscope/missions', 'local runtime mission state and proof artifacts', true, 'local_runtime', 'ignored'),
         row('.sneakoscope/reports', 'local runtime reports', true, 'local_runtime', 'ignored'),
         row('.sneakoscope/tmp', 'local temporary runtime files', true, 'local_runtime', 'ignored'),

package/dist/core/perf/release-latency-slo.js

@@ -1,4 +1,5 @@
 import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
@@ -31,7 +32,7 @@ export async function runReleaseLatencySlo(root, budgets, options = {}) {
             await capture('ssh_worker_hello', budgetMap, () => measureSshHello(tmp, runs(budgetMap, 'ssh_worker_hello', 5)))
         ];
         const native = platform === 'darwin'
-            ? await measureNativeMenuBar(tmp, budgetMap).catch((error) => nativeFailureMeasurements(budgetMap, error))
+            ? await measureNativeMenuBar(root, budgetMap).catch((error) => nativeFailureMeasurements(budgetMap, error))
             : ['menubar_first_state_render', 'control_center_open'].map((id) => ({
                 id,
                 budget_p95_ms: budgetMap.get(id)?.budget_p95_ms ?? RELEASE_LATENCY_LIMITS[id],
@@ -140,10 +141,11 @@ async function measureSshHello(tmp, count) {
     }
     return { producer: 'RemoteSshWorkerClient.connect:local_stdio_child', samples: values, evidence: { transport: 'local_process_ssh_stdio_fixture', network_included: false, process_startup_included: true } };
 }
-async function measureNativeMenuBar(tmp, budgets) {
+async function measureNativeMenuBar(root, budgets) {
+    const tmp = path.join(root, '.sneakoscope', 'cache', 'menubar-latency');
     const sourceDir = path.join(tmp, 'native-sources');
-    const executable = path.join(tmp, 'sks-menubar-latency');
     const home = path.join(tmp, 'native-home');
+    await fs.rm(home, { recursive: true, force: true });
     await Promise.all([sourceDir, home].map((dir) => fs.mkdir(dir, { recursive: true })));
     const cache = path.join(home, '.sneakoscope-global', 'cache', 'update-status.json');
     const cacheSnapshot = emptyUpdateStatus('6.3.0', new Date());
@@ -169,13 +171,9 @@ async function measureNativeMenuBar(tmp, budgets) {
         await fs.writeFile(path.join(sourceDir, source.name), content, { mode: 0o600 });
     }
     const files = sources.map((source) => path.join(sourceDir, source.name));
-    const compileStarted = performance.now();
-    const compile = await runProcess('swiftc', ['-framework', 'Cocoa', '-framework', 'UserNotifications', ...files, '-o', executable], {
-        cwd: tmp, timeoutMs: 90_000, maxOutputBytes: 128 * 1024
-    });
-    const compileMs = round(performance.now() - compileStarted);
-    if (compile.code !== 0)
-        throw new Error(`menubar_latency_compile_failed:${compile.stderr.slice(-400)}`);
+    const build = await buildNativeMenuBarHarness(tmp, files);
+    const executable = build.executable;
+    const compileMs = build.compile_duration_ms;
     const nativeRuns = Math.max(runs(budgets, 'menubar_first_state_render', 5), runs(budgets, 'control_center_open', 5));
     const first = [];
     const control = [];
@@ -191,7 +189,8 @@ async function measureNativeMenuBar(tmp, budgets) {
         control.push(Number(parsed.control_center_open_ms));
     }
     const evidence = {
-        source_count: sources.length, compile_exit_code: compile.code, compile_duration_ms: compileMs,
+        source_count: sources.length, compile_exit_code: 0, compile_duration_ms: compileMs,
+        compile_reused: build.reused, compile_source_digest: build.source_digest,
         link_frameworks: ['Cocoa', 'UserNotifications'], run_exit_codes: exitCodes,
         cache_based: true, cache_bytes: Buffer.byteLength(JSON.stringify(cacheSnapshot)), controller_prebuilt: true
     };
@@ -200,6 +199,53 @@ async function measureNativeMenuBar(tmp, budgets) {
         evaluateLatencySamples('control_center_open', budgets.get('control_center_open')?.budget_p95_ms ?? 400, 'ControlCenterWindowController.show:overview', control, evidence)
     ];
 }
+async function buildNativeMenuBarHarness(buildRoot, files) {
+    const toolchain = await runProcess('swiftc', ['--version'], { cwd: buildRoot, timeoutMs: 30_000, maxOutputBytes: 32 * 1024 });
+    const digest = createHash('sha256');
+    digest.update(toolchain.code === 0 ? toolchain.stdout : 'swiftc_version_unavailable');
+    digest.update('\0');
+    for (const file of [...files].sort()) {
+        digest.update(path.basename(file));
+        digest.update('\0');
+        digest.update(await fs.readFile(file));
+        digest.update('\0');
+    }
+    const sourceDigest = digest.digest('hex');
+    const binDir = path.join(buildRoot, 'bin');
+    const executable = path.join(binDir, `sks-menubar-latency-${sourceDigest}`);
+    await fs.mkdir(binDir, { recursive: true });
+    if (await pathIsFile(executable)) {
+        return { executable, compile_duration_ms: 0, source_digest: sourceDigest, reused: true };
+    }
+    const staged = `${executable}.${process.pid}.tmp`;
+    const compileStarted = performance.now();
+    const compile = await runProcess('swiftc', ['-framework', 'Cocoa', '-framework', 'UserNotifications', ...files, '-o', staged], {
+        cwd: buildRoot, timeoutMs: 90_000, maxOutputBytes: 128 * 1024
+    });
+    const compileMs = round(performance.now() - compileStarted);
+    if (compile.code !== 0) {
+        await fs.rm(staged, { force: true });
+        throw new Error(`menubar_latency_compile_failed:${compile.stderr.slice(-400)}`);
+    }
+    await fs.rename(staged, executable);
+    await pruneNativeHarnessBinaries(binDir, executable);
+    return { executable, compile_duration_ms: compileMs, source_digest: sourceDigest, reused: false };
+}
+async function pruneNativeHarnessBinaries(binDir, keep) {
+    const entries = await fs.readdir(binDir).catch(() => []);
+    await Promise.all(entries
+        .map((name) => path.join(binDir, name))
+        .filter((file) => file !== keep)
+        .map((file) => fs.rm(file, { force: true, recursive: true }).catch(() => undefined)));
+}
+async function pathIsFile(file) {
+    try {
+        return (await fs.stat(file)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
 function nativeHarnessSource() {
     return `let application = NSApplication.shared
 application.setActivationPolicy(.accessory)

package/dist/core/pipeline-internals/pipeline-stage-builder.js

@@ -0,0 +1,181 @@
+import { SPEED_LANE_POLICY } from '../proof-field.js';
+import { OFFICIAL_SUBAGENT_EXECUTION_STAGE_ID } from '../agents/agent-schema.js';
+import { normalizeOfficialSubagentPolicy, officialSubagentPipelineStage } from '../agents/agent-plan.js';
+import { looksLikeCodeChangingWork, reflectionRequiredForRoute, routeRequiresSubagents } from '../routes.js';
+import { classifyTaskProfile } from '../runtime/task-profile.js';
+import {} from '../runtime/verification-budget.js';
+export const LIGHTWEIGHT_ROUTES = new Set(['Answer', 'DFix', 'Help', 'Wiki', 'Goal']);
+export const BLOCKING_GATE_LIMITS = Object.freeze({
+    passthrough: 0,
+    answer: 0,
+    'tiny-change': 1,
+    'bounded-work': 2,
+    'parallel-read': 2,
+    'parallel-write': 3,
+    'high-risk': 4
+});
+function routeNeedsEngineeringSanityReview(route, task) {
+    const id = String(route?.id || '');
+    if (['DB', 'MadSKS'].includes(id))
+        return true;
+    if (['Answer', 'Help', 'Wiki', 'Goal', 'Research', 'AutoResearch', 'PPT', 'ImageUXReview', 'ComputerUse', 'GX'].includes(id))
+        return false;
+    return looksLikeCodeChangingWork(String(task || ''));
+}
+export const GATE_PROFILE_STAGES = Object.freeze({
+    none: [],
+    minimal: ['route_classification', 'listed_verification'],
+    scoped: ['route_classification', 'ownership', 'listed_verification', 'honest_summary'],
+    full: ['route_classification', 'ambiguity_gate', 'safety_gate', 'ownership', 'listed_verification', 'honest_summary']
+});
+export const STAGE_BLOCKING_GATE = Object.freeze({
+    ambiguity_gate: 'scope',
+    safety_gate: 'safety',
+    ssot_guard: 'safety',
+    context7_evidence: 'safety',
+    mistake_recall: 'safety',
+    ownership: 'ownership',
+    pipeline_plan: 'ownership',
+    focused_implementation: 'ownership',
+    triwiki_use_first: 'ownership',
+    subagent_plan: 'ownership',
+    official_subagent_execution: 'ownership',
+    parent_integration: 'ownership',
+    route_materialization: 'ownership',
+    work_order_coverage: 'ownership',
+    architecture_map_baseline: 'ownership',
+    engineering_sanity_check: 'verification',
+    listed_verification: 'verification',
+    triwiki_validate_before_final: 'verification',
+    architecture_map_review: 'verification',
+    completion_proof: 'verification',
+    reflection: 'verification',
+    honest_summary: 'verification'
+});
+export function selectPipelineLane(route, task, proof, taskProfile = classifyTaskProfile(task)) {
+    if (proof.attached && proof.lane) {
+        return {
+            lane: proof.lane,
+            source: 'proof_field',
+            fast_lane_allowed: Boolean(proof.fast_lane_allowed),
+            reason: proof.fast_lane_allowed ? 'Proof Field allowed the fast lane.' : `Proof Field selected ${proof.lane}.`,
+            blockers: proof.blockers || [],
+            skip_when_fast: proof.fast_lane_allowed ? SPEED_LANE_POLICY.skip_when_fast : [],
+            keep: proof.keep || SPEED_LANE_POLICY.always_keep
+        };
+    }
+    if (taskProfile === 'passthrough' || taskProfile === 'answer')
+        return { lane: 'no_pipeline', source: 'task_profile', fast_lane_allowed: true, reason: 'Light conversation does not create an execution pipeline.', blockers: [], skip_when_fast: [], keep: [] };
+    if (route?.id === 'ComputerUse')
+        return { lane: 'computer_use_fast_lane', source: 'route_policy', fast_lane_allowed: true, reason: 'Computer Use route is intentionally direct and defers wiki/honest checks to closeout.', blockers: [], skip_when_fast: ['planning_debate'], keep: ['focused_implementation', 'triwiki_validate_before_final', 'honest_mode'] };
+    if (taskProfile === 'tiny-change')
+        return { lane: 'minimal_change_lane', source: 'task_profile', fast_lane_allowed: true, reason: 'Tiny change uses one blocking gate and one focused check at most.', blockers: [], skip_when_fast: SPEED_LANE_POLICY.skip_when_fast, keep: ['listed_verification'] };
+    if (LIGHTWEIGHT_ROUTES.has(route?.id))
+        return { lane: `${String(route.id).toLowerCase()}_lightweight_lane`, source: 'route_policy', fast_lane_allowed: true, reason: 'Lightweight route bypasses full mission orchestration by design.', blockers: [], skip_when_fast: SPEED_LANE_POLICY.skip_when_fast, keep: ['focused_implementation', 'listed_verification', 'honest_mode'] };
+    if (routeRequiresSubagents(route, task, taskProfile))
+        return { lane: 'official_subagent_lane', source: 'task_profile', fast_lane_allowed: false, reason: 'Explicit Naruto or parallel work uses the Codex subagent workflow.', blockers: [], skip_when_fast: [], keep: ['subagent_plan', 'official_subagent_execution', 'parent_integration', 'listed_verification', 'honest_summary'] };
+    if (taskProfile === 'high-risk')
+        return { lane: SPEED_LANE_POLICY.full_lane, source: 'task_profile', fast_lane_allowed: false, reason: 'High-risk work uses the full risk gate profile.', blockers: [], skip_when_fast: [], keep: SPEED_LANE_POLICY.always_keep };
+    return { lane: SPEED_LANE_POLICY.balanced_lane, source: 'route_policy', fast_lane_allowed: false, reason: 'Balanced parent-owned route until Proof Field proves a narrower lane.', blockers: ['proof_field_not_attached'], skip_when_fast: [], keep: SPEED_LANE_POLICY.always_keep };
+}
+export function buildPipelineStages(route, task, taskProfile, gateProfile, ambiguity, lane, context7Required, officialSubagentPolicy = normalizeOfficialSubagentPolicy(route, task, {})) {
+    if (gateProfile === 'none')
+        return [];
+    const ids = [...GATE_PROFILE_STAGES[gateProfile]];
+    const specializedRoute = Boolean(route?.id && !LIGHTWEIGHT_ROUTES.has(route.id) && route.id !== 'SKS');
+    if (gateProfile === 'scoped' || gateProfile === 'full' || specializedRoute)
+        ids.push('pipeline_plan', 'focused_implementation');
+    if ((gateProfile === 'full' || specializedRoute) && !ids.includes('ssot_guard'))
+        ids.push('ssot_guard');
+    if (context7Required)
+        ids.push('context7_evidence');
+    if ((gateProfile === 'scoped' || gateProfile === 'full') && !LIGHTWEIGHT_ROUTES.has(route?.id)) {
+        ids.push('triwiki_use_first', 'triwiki_validate_before_final', 'mistake_recall', 'work_order_coverage');
+    }
+    if (routeNeedsEngineeringSanityReview(route, task))
+        ids.push('engineering_sanity_check');
+    if ((gateProfile === 'scoped' || gateProfile === 'full') && route?.id !== 'GX' && route?.id !== 'DB' && !LIGHTWEIGHT_ROUTES.has(route?.id)) {
+        ids.push('architecture_map_baseline', 'architecture_map_review');
+    }
+    if (routeRequiresSubagents(route, task, taskProfile))
+        ids.push('subagent_plan', 'official_subagent_execution', 'parent_integration');
+    if (specializedRoute)
+        ids.push('route_materialization');
+    if (specializedRoute)
+        ids.push('completion_proof');
+    if (reflectionRequiredForRoute(route))
+        ids.push('reflection');
+    return [...new Set(ids)].map((id) => {
+        const configuredGate = STAGE_BLOCKING_GATE[id] || null;
+        const blockingGate = configuredGate === 'safety' && gateProfile !== 'full'
+            ? 'ownership'
+            : configuredGate;
+        const blocking = Boolean(blockingGate);
+        const metadata = { blocking, blocking_gate: blocking ? blockingGate : null };
+        if (id === OFFICIAL_SUBAGENT_EXECUTION_STAGE_ID)
+            return { ...officialSubagentPipelineStage(officialSubagentPolicy), status: 'required', reason: officialSubagentPolicy.reason, ...metadata };
+        if (id === 'engineering_sanity_check') {
+            return {
+                id,
+                status: 'keep',
+                reason: 'required_for_code_and_database_quality',
+                checks: [
+                    'trace actual callers and preserve basic SOLID responsibility and dependency boundaries',
+                    'inspect loops, collections, resolvers, and serializers for N+1 or repeated I/O',
+                    'prove render, recursion, event, retry, and polling loops are bounded and cancellable',
+                    'reject disabled checks, swallowed errors, placeholder success, and verification bypasses',
+                    'for DB work, verify the existing canonical adapter and connection/pool lifecycle before changes',
+                    'for sensitive or multi-step DB work, verify transaction rollback, error propagation, idempotency, and post-commit invariants'
+                ],
+                ...metadata
+            };
+        }
+        if (id === 'ambiguity_gate' && ambiguity?.required === false)
+            return { id, status: 'not_applicable', reason: 'ambiguity_gate_not_required_for_entrypoint', ...metadata };
+        if (id === 'ambiguity_gate' && ambiguity?.passed)
+            return { id, status: 'passed', reason: 'ambiguity_contract_already_sealed', ...metadata };
+        return { id, status: 'keep', reason: lane.fast_lane_allowed ? 'task_profile_minimal_lane' : 'required_by_task_and_route_profile', ...metadata };
+    });
+}
+export function planVerification(route, task, proof, budget) {
+    if (budget === 'none')
+        return [];
+    const out = new Set(proof.verification || []);
+    if (budget === 'single-check')
+        out.add('run one focused check for the changed surface');
+    if (budget === 'affected')
+        out.add('run affected tests or checks for changed files');
+    if (budget === 'confidence') {
+        out.add('run the focused build or typecheck for the affected package');
+        out.add('run affected regression tests and the risk-specific safety check');
+    }
+    if (budget === 'release') {
+        out.add('npm run packcheck');
+        out.add('sks selftest --mock --json');
+    }
+    if (route?.id === 'Naruto')
+        out.add('validate official subagent evidence and the parent integration summary');
+    if (routeNeedsEngineeringSanityReview(route, task)) {
+        out.add('complete the engineering sanity review for SOLID boundaries, N+1/repeated I/O, bounded loops, and verification bypasses');
+    }
+    if (route?.id === 'DB' || route?.id === 'MadSKS') {
+        out.add('verify existing canonical DB access, pool lifecycle, and transaction integrity for sensitive or multi-step mutations');
+    }
+    if (reflectionRequiredForRoute(route))
+        out.add('sks wiki validate .sneakoscope/wiki/context-pack.json');
+    return [...out];
+}
+export function pipelineInvariants(input) {
+    const out = ['no_unrequested_fallback_code'];
+    if (input.stages.some((stage) => stage.id === 'engineering_sanity_check'))
+        out.push('engineering_sanity_check');
+    if (input.verificationBudget !== 'none')
+        out.push('listed_verification');
+    if (input.stages.some((stage) => stage.id === 'ssot_guard' && stage.status !== 'not_applicable'))
+        out.push('ssot_guard');
+    if (input.stages.some((stage) => stage.id === 'triwiki_validate_before_final'))
+        out.push('triwiki_validate_before_final');
+    if (input.gateProfile !== 'none')
+        out.push('honest_summary');
+    return out;
+}