sneakoscope 8.3.2 → 8.4.0

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;
+}

package/dist/core/pipeline-internals/runtime-core.js

@@ -38,7 +38,10 @@ import { NARUTO_GATE_FILENAME, NARUTO_SUMMARY_FILENAME, SUBAGENT_PLAN_FILENAME,
 import { buildSubagentEvidence, readSubagentEvents, recordSubagentEvent, SUBAGENT_EVIDENCE_FILENAME, SUBAGENT_EVENT_LOG_FILENAME, SUBAGENT_PARENT_SUMMARY_FILENAME } from '../subagents/subagent-evidence.js';
 import { effectiveSubagentTarget, normalizeLegacySubagentCountFields, subagentCountContractBlockers } from '../subagents/wave-lifecycle.js';
 import { officialSubagentEvidenceReady } from '../subagents/terminal-subagent-state.js';
+import { createArchitectureMapPlanBinding, maybeSeedArchitectureMapForPlan, planStagesArchitectureMap } from '../architecture-map-pipeline.js';
+import { BLOCKING_GATE_LIMITS, LIGHTWEIGHT_ROUTES, GATE_PROFILE_STAGES, STAGE_BLOCKING_GATE, selectPipelineLane, buildPipelineStages, planVerification, pipelineInvariants } from './pipeline-stage-builder.js';
 export { routePrompt };
+export { LIGHTWEIGHT_ROUTES, GATE_PROFILE_STAGES, STAGE_BLOCKING_GATE, BLOCKING_GATE_LIMITS };
 export const PIPELINE_PLAN_ARTIFACT = 'pipeline-plan.json';
 export const PIPELINE_PLAN_SCHEMA_VERSION = 1;
 const SKILL_DREAM_HOT_PATH_COUNTERS = new Map();
@@ -60,44 +63,6 @@ const HARD_BLOCKER_ARTIFACT = 'hard-blocker.json';
 const DEFAULT_COMPLIANCE_LOOP_LIMIT = 3;
 const CLARIFICATION_BYPASS_ROUTES = new Set(['Answer', 'DFix', 'Help', 'Wiki', 'ComputerUse', 'Goal']);
 const QUESTION_GATE_ROUTES = new Set(['QALoop', 'PPT']);
-const LIGHTWEIGHT_ROUTES = new Set(['Answer', 'DFix', 'Help', 'Wiki', 'Goal']);
-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']
-});
-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',
-    engineering_sanity_check: 'verification',
-    listed_verification: 'verification',
-    triwiki_validate_before_final: 'verification',
-    completion_proof: 'verification',
-    reflection: 'verification',
-    honest_summary: 'verification'
-});
-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 reflectionInstructionText(commandPrefix = 'sks') {
     return `Post-route reflection: full routes load \`reflection\` after work/tests and before final; DFix/Answer/Help/Wiki/SKS discovery are exempt. Write ${REFLECTION_ARTIFACT}; record only real misses/gaps, or no_issue_acknowledged. For lessons, append TriWiki claim rows to ${REFLECTION_MEMORY_PATH}. Run "${commandPrefix} wiki refresh" or pack, validate, then pass ${REFLECTION_GATE}.`;
 }
@@ -182,6 +147,7 @@ export function buildPipelinePlan(input = {}) {
         verification_budget: verificationBudget,
         verification,
         engineering_sanity_review: null,
+        architecture_map: null,
         invariants,
         proof_field: proof,
         ssot_guard: buildSsotGuard({ route: route?.id || 'SKS', mode: route?.mode || 'SKS', task }),
@@ -219,6 +185,9 @@ export async function writePipelinePlan(dir, input = {}) {
             changed_scope_base: resolveChangedScopeBase(root)
         };
     }
+    if (planStagesArchitectureMap(plan)) {
+        plan.architecture_map = createArchitectureMapPlanBinding();
+    }
     await writeJsonAtomic(path.join(dir, PIPELINE_PLAN_ARTIFACT), plan);
     if (plan.engineering_sanity_review) {
         const report = await writeCodeStructureReport(root, dir, {
@@ -232,6 +201,9 @@ export async function writePipelinePlan(dir, input = {}) {
             await writeJsonAtomic(reviewFile, createEngineeringSanityReviewSeed(plan.route?.command || plan.route?.id || null, report, reportText));
         }
     }
+    await maybeSeedArchitectureMapForPlan({
+        root, dir, plan, missionId: input.missionId, taskProfile
+    });
     return plan;
 }
 function planStagesEngineeringSanityReview(plan) {
@@ -244,7 +216,8 @@ export function pipelinePlanState(plan) {
         pipeline_plan_ready: validatePipelinePlan(plan).ok,
         pipeline_plan_path: PIPELINE_PLAN_ARTIFACT,
         engineering_sanity_required: Boolean(sanity),
-        engineering_sanity_scope_base: sanity?.changed_scope_base || null
+        engineering_sanity_scope_base: sanity?.changed_scope_base || null,
+        architecture_map_required: Boolean(plan?.architecture_map)
     };
 }
 export async function writeRequestIntakeArtifact(dir, input = {}) {
@@ -488,130 +461,6 @@ function routeEconomyPlan(proof = {}) {
         deletion_policy: 'do_not_delete_or_skip_pipeline_stages_until_report_only_metrics_are_calibrated'
     };
 }
-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 };
-}
-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 (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 };
-    });
-}
-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];
-}
-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;
-}
 function planNextActions(route, task, taskProfile, ambiguity, lane) {
     if (taskProfile === 'passthrough' || taskProfile === 'answer')
         return [];
@@ -1593,15 +1442,7 @@ function strictNarutoIntegerOption(text, option) {
 function routeState(id, route, phase, context7Required, extra = {}) {
     const reasoning = routeReasoning(route, extra.prompt || '');
     const subagentsRequired = routeRequiresSubagents(route, extra.prompt || '');
-    return { mission_id: id, route: route.id, route_command: route.command, mode: route.mode, phase, context7_required: context7Required, context7_verified: false, subagents_required: subagentsRequired, subagents_verified: !subagentsRequired, native_sessions_required: false, native_sessions_verified: false, reflection_required: reflectionRequiredForRoute(route), engineering_sanity_required: false, engineering_sanity_scope_base: null, visible_progress_required: true, context_tracking: 'triwiki', required_skills: route.requiredSkills, stop_gate: route.stopGate, reasoning_effort: reasoning.effort, reasoning_profile: reasoning.profile, reasoning_temporary: true, goal_continuation: ambientGoalContinuation(), ...extra };
-}
-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 || ''));
+    return { mission_id: id, route: route.id, route_command: route.command, mode: route.mode, phase, context7_required: context7Required, context7_verified: false, subagents_required: subagentsRequired, subagents_verified: !subagentsRequired, native_sessions_required: false, native_sessions_verified: false, reflection_required: reflectionRequiredForRoute(route), engineering_sanity_required: false, engineering_sanity_scope_base: null, architecture_map_required: false, visible_progress_required: true, context_tracking: 'triwiki', required_skills: route.requiredSkills, stop_gate: route.stopGate, reasoning_effort: reasoning.effort, reasoning_profile: reasoning.profile, reasoning_temporary: true, goal_continuation: ambientGoalContinuation(), ...extra };
 }
 function routeContext(route, id, task, required, next) {
     const visibleTask = stripVisibleDecisionAnswerBlocks(task);

package/dist/core/pipeline-internals/runtime-gates.js

@@ -17,6 +17,8 @@ import { checkStopGate } from '../stop-gate/stop-gate-check.js';
 import { readWorkOrderLedger, evaluateWorkOrderCoverage } from '../work-order-ledger.js';
 import { DB_ACCESS_REVIEW_ARTIFACT, DB_REVIEW_ARTIFACT, validateDbAccessReviewArtifact, validateDbReview, validateMadSksSqlPlaneCompletion } from '../db-review.js';
 import { ENGINEERING_SANITY_REVIEW_ARTIFACT, validateEngineeringSanityReviewArtifact } from '../engineering-sanity-review.js';
+import { ARCHITECTURE_MAP_REVIEW_ARTIFACT } from '../architecture-map-review.js';
+import { architectureMapGateStatus } from '../architecture-map-pipeline.js';
 import { clarificationStopReason, context7Evidence, hasContext7DocsEvidence, hasSubagentEvidence, subagentEvidence, PIPELINE_PLAN_ARTIFACT, } from './runtime-core.js';
 import { projectTriwikiToAgentsMd } from '../triwiki/agents-md-projector.js';
 import { effectiveSubagentTarget, normalizeLegacySubagentCountFields, subagentCountContractBlockers } from '../subagents/wave-lifecycle.js';
@@ -256,6 +258,7 @@ export async function evaluateStop(root, state, payload, opts = {}) {
         && !completionProofRequired
         && !reflectionRequired
         && state?.engineering_sanity_required !== true
+        && state?.architecture_map_required !== true
         && state?.db_access_review_required !== true) {
         return null;
     }
@@ -267,12 +270,14 @@ export async function evaluateStop(root, state, payload, opts = {}) {
         && activeGatePreview?.covered_gate === 'official-subagent-evidence';
     const dbAccessPromise = dbAccessReviewGateStatus(root, state, jsonCache);
     const engineeringSanityPromise = engineeringSanityGateStatus(root, state, jsonCache);
+    const architectureMapPromise = architectureMapGateStatus(root, state);
     const context7Promise = state?.context7_required ? hasContext7DocsEvidence(root, state) : Promise.resolve(true);
     const subagentPromise = state?.subagents_required && !activeGateNotApplicable ? hasSubagentEvidence(root, state) : Promise.resolve(true);
     const mistakeRecallPromise = mistakeRecallGateStatus(root, state);
-    const [dbAccess, engineeringSanity, context7Ok, subagentOk, mistakeRecall] = await Promise.all([
+    const [dbAccess, engineeringSanity, architectureMap, context7Ok, subagentOk, mistakeRecall] = await Promise.all([
         dbAccessPromise,
         engineeringSanityPromise,
+        architectureMapPromise,
         context7Promise,
         subagentPromise,
         mistakeRecallPromise
@@ -280,6 +285,7 @@ export async function evaluateStop(root, state, payload, opts = {}) {
     await resolveRecoveredComplianceBlocker(root, state, {
         [DB_ACCESS_REVIEW_ARTIFACT]: dbAccess.ok,
         [ENGINEERING_SANITY_REVIEW_ARTIFACT]: engineeringSanity.ok,
+        [ARCHITECTURE_MAP_REVIEW_ARTIFACT]: architectureMap.ok,
         'context7-evidence': context7Ok,
         'official-subagent-evidence': subagentOk
     });
@@ -289,6 +295,9 @@ export async function evaluateStop(root, state, payload, opts = {}) {
     if (!engineeringSanity.ok) {
         return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} must complete the engineering sanity review before completion. Static candidates are advisory only; inspect added hunks and real callers for SOLID boundaries, N+1/repeated I/O, bounded render/recursion/event/retry/polling behavior, and verification bypasses. Missing: ${(engineeringSanity.blockers || []).join(', ')}.`, { gate: ENGINEERING_SANITY_REVIEW_ARTIFACT, missing: engineeringSanity.blockers });
     }
+    if (!architectureMap.ok) {
+        return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} must seal Architecture Map baseline before mutation and produce a passing architecture-map-review before completion. Missing: ${(architectureMap.blockers || []).join(', ')}.`, { gate: ARCHITECTURE_MAP_REVIEW_ARTIFACT, missing: architectureMap.blockers });
+    }
     if (state?.context7_required && !context7Ok) {
         return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} requires Context7 evidence before completion. Use Context7 resolve-library-id, then query-docs, so SKS can record context7-evidence.jsonl.`, { gate: 'context7-evidence' });
     }
@@ -518,6 +527,8 @@ async function markReflectionInvalidatedForGateFailure(root, state = {}, detail
         return;
     if (/^work-order-ledger$/i.test(gate) || /^completion-proof$/i.test(gate))
         return;
+    if (/^atlas:/.test(gate) || /^architecture-map:/.test(gate) || /(^|[\\/])?(architecture-atlas-review|architecture-map-review|atlas-gate)(\.json)?$/i.test(gate))
+        return;
     await setCurrent(root, {
         mission_id: state.mission_id,
         reflection_invalidation_required: true,