sneakoscope 7.3.0 → 7.6.0

package/dist/core/mcp-config/config-reader.js

@@ -1,5 +1,6 @@
 import fsp from 'node:fs/promises';
 import { parseCodexConfigToml } from '../codex/codex-config-toml.js';
+import { errorCodeOf } from '../errors/message.js';
 import { publicMcpCommand, redactMcpError, redactMcpUrl, sanitizeMcpArgs } from './redaction.js';
 import { normalizeApprovalMode } from './secret-policy.js';
 import { MCP_DEFAULT_STARTUP_TIMEOUT_SEC, MCP_DEFAULT_TOOL_TIMEOUT_SEC, MCP_SERVER_CONFIG_SCHEMA } from './types.js';
@@ -16,7 +17,7 @@ export class McpConfigReadError extends Error {
     }
 }
 export async function readMcpConfigDocument(ref) {
-    const stat = await fsp.lstat(ref.configPath).catch((error) => errorCode(error) === 'ENOENT' ? null : Promise.reject(error));
+    const stat = await fsp.lstat(ref.configPath).catch((error) => errorCodeOf(error) === 'ENOENT' ? null : Promise.reject(error));
     if (!stat)
         return { ref, exists: false, text: '', parsed: {}, rawServers: {} };
     if (stat.isSymbolicLink())
@@ -142,6 +143,3 @@ function positiveNumber(value) {
     const number = Number(value);
     return Number.isFinite(number) && number > 0 ? number : null;
 }
-function errorCode(error) {
-    return error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
-}

package/dist/core/mcp-config/scope.js

@@ -1,6 +1,7 @@
 import fsp from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
+import { errorCodeOf } from '../errors/message.js';
 export class McpScopeError extends Error {
     code;
     constructor(code) {
@@ -41,7 +42,7 @@ export function isPathInside(root, candidate) {
     return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
 }
 async function assertSafeDirectory(directory, boundary, strictNoSymlink) {
-    const stat = await fsp.lstat(directory).catch((error) => errorCode(error) === 'ENOENT' ? null : Promise.reject(error));
+    const stat = await fsp.lstat(directory).catch((error) => errorCodeOf(error) === 'ENOENT' ? null : Promise.reject(error));
     if (!stat)
         return;
     if (strictNoSymlink && stat.isSymbolicLink())
@@ -53,7 +54,7 @@ async function assertSafeDirectory(directory, boundary, strictNoSymlink) {
         throw new McpScopeError('mcp_codex_home_escape_refused');
 }
 async function assertSafeConfig(configPath, boundary) {
-    const stat = await fsp.lstat(configPath).catch((error) => errorCode(error) === 'ENOENT' ? null : Promise.reject(error));
+    const stat = await fsp.lstat(configPath).catch((error) => errorCodeOf(error) === 'ENOENT' ? null : Promise.reject(error));
     if (!stat)
         return;
     if (stat.isSymbolicLink())
@@ -64,6 +65,3 @@ async function assertSafeConfig(configPath, boundary) {
     if (!resolved || !isPathInside(boundary, resolved))
         throw new McpScopeError('mcp_config_escape_refused');
 }
-function errorCode(error) {
-    return error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
-}

package/dist/core/naruto/context-graph-advisor-scope.js

@@ -0,0 +1,242 @@
+import { incomingEdges, outgoingEdges } from '../triwiki/context-graph/graph-index.js';
+import { contextGraphPathFromId } from '../triwiki/context-graph/ids.js';
+import { isWorkspaceRelativePosixPath } from '../triwiki/context-graph/paths.js';
+import { normalizeNarutoPath } from './naruto-work-item.js';
+export const NARUTO_ADVISOR_CAPS = {
+    maxDepth: 2,
+    maxNodesPerWalk: 512,
+    maxEdgesPerWalk: 4096,
+    maxSharedPathsPerPair: 12,
+    maxRecommendationsPerSlice: 24,
+    maxTaskTokens: 32,
+    maxNodesPerLabel: 8
+};
+const DEPENDENCY_EDGE_TYPES = new Set(['imports', 'reexports', 'depends_on', 'references', 'calls', 'routes_to']);
+const IMPACT_EDGE_TYPES = new Set([
+    'imports', 'reexports', 'references', 'calls', 'tests', 'affected_by', 'verified_by', 'gated_by', 'depends_on', 'owns', 'routes_to'
+]);
+const SEED_EXPANSION_EDGE_TYPES = new Set(['defines', 'contains']);
+function explanationStep(edge) {
+    return { edgeId: edge.id, type: edge.type, from: edge.from, to: edge.to, confidence: edge.confidence, path: edge.provenance.path };
+}
+function nodePathOf(node) {
+    return node.path ?? contextGraphPathFromId(node.id);
+}
+function isTestNode(node) {
+    return node.kind === 'test' || node.metadata.isTest === true;
+}
+function isProtectedGateNode(node) {
+    return node.risk === 'protected' || node.metadata.requiredForPublish === true || node.metadata.alwaysOnRelease === true;
+}
+function riskDomainOf(node) {
+    if (node.kind === 'risk_domain')
+        return node.label || null;
+    if (node.kind !== 'gate')
+        return null;
+    const declared = node.metadata.namespace;
+    return (typeof declared === 'string' && declared ? declared : node.label.split(':')[0]) || null;
+}
+export function narutoAdvisorWorkspacePath(value) {
+    const normalized = normalizeNarutoPath(value);
+    return normalized && isWorkspaceRelativePosixPath(normalized) ? normalized : null;
+}
+export function narutoAdvisorPathList(values) {
+    return [...new Set((values ?? []).map(narutoAdvisorWorkspacePath).filter((value) => value !== null))].sort();
+}
+function rootHit(nodeId) {
+    return { nodeId, depth: 0, reasonPath: [nodeId], explanation: [] };
+}
+function walkGraph(index, roots, direction, types, maxDepth) {
+    const hits = new Map();
+    const queue = [];
+    for (const root of roots) {
+        if (hits.has(root.nodeId) || !index.nodesById.has(root.nodeId))
+            continue;
+        hits.set(root.nodeId, root);
+        queue.push(root);
+    }
+    let edgesVisited = 0;
+    for (let head = 0; head < queue.length; head += 1) {
+        const current = queue[head];
+        if (!current || current.depth >= maxDepth)
+            continue;
+        for (const edge of direction === 'out' ? outgoingEdges(index, current.nodeId) : incomingEdges(index, current.nodeId)) {
+            edgesVisited += 1;
+            if (edgesVisited > NARUTO_ADVISOR_CAPS.maxEdgesPerWalk)
+                return { hits, truncated: true };
+            if (!types.has(edge.type))
+                continue;
+            const next = direction === 'out' ? edge.to : edge.from;
+            if (hits.has(next) || !index.nodesById.has(next))
+                continue;
+            if (hits.size >= NARUTO_ADVISOR_CAPS.maxNodesPerWalk)
+                return { hits, truncated: true };
+            const hit = {
+                nodeId: next,
+                depth: current.depth + 1,
+                reasonPath: [...current.reasonPath, direction === 'out' ? edge.type : `<-${edge.type}`, next],
+                explanation: [...current.explanation, explanationStep(edge)]
+            };
+            hits.set(next, hit);
+            queue.push(hit);
+        }
+    }
+    return { hits, truncated: false };
+}
+export function narutoAdvisorProvenance(index, hit) {
+    const out = [];
+    const seen = new Set();
+    for (const step of hit.explanation) {
+        const edge = index.edgesById.get(step.edgeId);
+        if (!edge)
+            continue;
+        const key = `${edge.provenance.path}#${edge.provenance.line ?? 0}#${edge.provenance.hash}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const line = edge.provenance.line;
+        out.push({ path: edge.provenance.path, ...(line === undefined ? {} : { line }), hash: edge.provenance.hash });
+    }
+    if (out.length)
+        return out;
+    const node = index.nodesById.get(hit.nodeId);
+    const nodePath = node ? nodePathOf(node) : null;
+    if (node?.contentHash && nodePath)
+        out.push({ path: nodePath, hash: node.contentHash });
+    return out;
+}
+function resolveSeedNodes(index, paths, labels, unresolved) {
+    const out = [];
+    const seen = new Set();
+    const push = (id) => {
+        if (!seen.has(id) && index.nodesById.has(id)) {
+            seen.add(id);
+            out.push(id);
+        }
+    };
+    const miss = (value) => {
+        if (value && !unresolved.includes(value))
+            unresolved.push(value);
+    };
+    for (const raw of paths) {
+        const rel = narutoAdvisorWorkspacePath(raw);
+        const ids = rel ? index.nodesByPath.get(rel) ?? [] : [];
+        if (!ids.length)
+            miss(raw);
+        for (const id of ids)
+            push(id);
+    }
+    for (const label of labels) {
+        const ids = index.nodesByLabel.get(String(label ?? '').toLowerCase()) ?? [];
+        if (!ids.length || ids.length > NARUTO_ADVISOR_CAPS.maxNodesPerLabel)
+            miss(String(label ?? ''));
+        else
+            for (const id of ids)
+                push(id);
+    }
+    return out;
+}
+export function narutoAdvisorTaskTokens(text) {
+    const tokens = [];
+    for (const raw of String(text ?? '').split(/[^\w$./-]+/)) {
+        const token = raw.replace(/^[./-]+/, '').replace(/[./-]+$/, '');
+        if (token.length < 3 || tokens.includes(token))
+            continue;
+        if (!/^[A-Za-z_$][\w$]*$/.test(token) && !/^[\w$./-]+\.[A-Za-z]\w*$/.test(token))
+            continue;
+        tokens.push(token);
+        if (tokens.length >= NARUTO_ADVISOR_CAPS.maxTaskTokens)
+            break;
+    }
+    return tokens;
+}
+function expandRoots(index, seeds) {
+    const roots = seeds.map(rootHit);
+    const seen = new Set(seeds);
+    for (const seed of seeds) {
+        for (const edge of outgoingEdges(index, seed)) {
+            if (!SEED_EXPANSION_EDGE_TYPES.has(edge.type) || seen.has(edge.to))
+                continue;
+            seen.add(edge.to);
+            roots.push({ nodeId: edge.to, depth: 0, reasonPath: [seed, edge.type, edge.to], explanation: [explanationStep(edge)] });
+            if (roots.length >= NARUTO_ADVISOR_CAPS.maxNodesPerWalk)
+                return roots;
+        }
+    }
+    return roots;
+}
+function closurePaths(index, walk) {
+    const out = new Map();
+    for (const hit of walk.hits.values()) {
+        const node = index.nodesById.get(hit.nodeId);
+        if (!node || isTestNode(node))
+            continue;
+        const nodePath = nodePathOf(node);
+        if (nodePath && !out.has(nodePath))
+            out.set(nodePath, hit);
+    }
+    return out;
+}
+function recommendationsFrom(index, sliceId, writeSet, impact) {
+    const out = [];
+    for (const hit of impact.hits.values()) {
+        const node = index.nodesById.get(hit.nodeId);
+        if (!node)
+            continue;
+        const isGate = node.kind === 'gate';
+        if (!isGate && !isTestNode(node))
+            continue;
+        const nodePath = nodePathOf(node);
+        if (!nodePath || (!isGate && writeSet.has(nodePath)))
+            continue;
+        out.push({
+            slice_id: sliceId,
+            kind: isGate ? 'gate' : 'test',
+            id: isGate ? node.label : nodePath,
+            path: nodePath,
+            protected: isGate ? isProtectedGateNode(node) : false,
+            risk_domain: isGate ? riskDomainOf(node) : null,
+            reason_path: [...hit.reasonPath],
+            explanation: [...hit.explanation],
+            provenance: narutoAdvisorProvenance(index, hit)
+        });
+        if (out.length >= NARUTO_ADVISOR_CAPS.maxRecommendationsPerSlice)
+            break;
+    }
+    return out.sort((a, b) => (a.kind === b.kind ? (a.id < b.id ? -1 : a.id > b.id ? 1 : 0) : a.kind < b.kind ? -1 : 1));
+}
+export function buildNarutoSliceState(index, slice, taskTokens, maxDepth) {
+    const unresolved = [];
+    const writePaths = narutoAdvisorPathList(slice.writePaths);
+    const labels = [...(slice.symbols ?? [])];
+    if (!writePaths.length && !labels.length)
+        labels.push(...narutoAdvisorTaskTokens(slice.title ?? ''), ...taskTokens);
+    const seeds = resolveSeedNodes(index, writePaths, labels, unresolved);
+    const walk = walkGraph(index, seeds.map(rootHit), 'out', DEPENDENCY_EDGE_TYPES, maxDepth);
+    const impact = walkGraph(index, expandRoots(index, seeds), 'in', IMPACT_EDGE_TYPES, maxDepth);
+    const closure = closurePaths(index, walk);
+    const writeSet = new Set(writePaths);
+    return {
+        scope: {
+            slice_id: slice.id,
+            seed_node_ids: [...seeds].sort(),
+            write_paths: writePaths,
+            write_closure: [...closure.keys()].sort(),
+            unresolved_seeds: [...new Set(unresolved)].sort(),
+            truncated: walk.truncated || impact.truncated
+        },
+        closure,
+        writeSet,
+        recommendations: recommendationsFrom(index, slice.id, writeSet, impact)
+    };
+}
+export function emptyNarutoScope(sliceId, slice) {
+    return {
+        slice_id: sliceId,
+        seed_node_ids: [],
+        write_paths: narutoAdvisorPathList(slice?.writePaths),
+        write_closure: [],
+        unresolved_seeds: [],
+        truncated: false
+    };
+}

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

@@ -8,6 +8,7 @@ import { runProcess, writeJsonAtomic } from '../fsx.js';
 import { listMcpInventory } from '../mcp-config/index.js';
 import { RemoteSshWorkerClient } from '../remote/ssh-worker-client.js';
 import { TelegramHubRouter } from '../telegram/hub.js';
+import { buildTelegramConfigV2, telegramTokenFingerprint } from '../telegram/config.js';
 import { TelegramActionBroker, TelegramAuditLedger, TelegramIdempotencyLedger, TelegramTopicRegistry } from '../telegram/ledgers.js';
 import { TelegramMessageProjector } from '../telegram/messages.js';
 import { TelegramHubRuntime } from '../telegram/runtime.js';
@@ -124,10 +125,14 @@ async function measureUpdateCacheRead(tmp, count) {
 }
 async function measureTelegramAck(tmp, count) {
     const base = path.join(tmp, 'telegram');
-    const config = {
-        schema: 'sks.telegram-config.v1', bot_token_ref: { type: 'external_file', path: '/dev/null' },
-        paired_chat_ids: ['1'], paired_user_ids: ['1']
-    };
+    const config = buildTelegramConfigV2({
+        botTokenRef: { type: 'external_file', path: '/dev/null' },
+        botUserId: '99',
+        botTokenFingerprint: telegramTokenFingerprint('123456789:ABCDEFGHIJKLMNOPQRSTUVWX'),
+        pairedChatId: '1',
+        pairedUserId: '1',
+        configGeneration: 1
+    });
     let ackAt = 0;
     const api = {
         call: async (method) => {
@@ -257,6 +262,7 @@ function nativeHarnessSource() {
     return `let application = NSApplication.shared
 application.setActivationPolicy(.accessory)
 let processClient = ProcessClient(actionScript: AppRuntime.actionScript, logPath: AppRuntime.lastActionLogPath, projectRoot: AppRuntime.projectRoot)
+let telegramHubSupervisor = TelegramHubSupervisor(processClient: processClient, actionScript: AppRuntime.actionScript, projectRoot: AppRuntime.projectRoot)
 let operations = OperationCoordinator(directory: AppRuntime.operationDirectory)
 let notifications = NotificationCoordinator()
 let status = StatusItemController(processClient: processClient, operations: operations, notifications: notifications, openControlCenter: { _ in })
@@ -264,11 +270,11 @@ let firstStart = DispatchTime.now().uptimeNanoseconds
 status.start()
 let firstMs = Double(DispatchTime.now().uptimeNanoseconds - firstStart) / 1_000_000
 status.stop()
-let control = ControlCenterWindowController(processClient: processClient, operations: operations, notifications: notifications)
+let control = ControlCenterWindowController(processClient: processClient, telegramHubSupervisor: telegramHubSupervisor, operations: operations, notifications: notifications)
 let controlStart = DispatchTime.now().uptimeNanoseconds
 control.show(section: .overview)
 let controlMs = Double(DispatchTime.now().uptimeNanoseconds - controlStart) / 1_000_000
-control.window?.orderOut(nil)
+control.window?.orderOut(nil as Any?)
 let data = try! JSONSerialization.data(withJSONObject: ["menu_bar_first_state_render_ms": firstMs, "control_center_open_ms": controlMs])
 print(String(data: data, encoding: .utf8)!)`;
 }

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

@@ -14,6 +14,7 @@ import { writeMistakeMemoryReport } from '../mistake-memory.js';
 import { MISTAKE_RECALL_ARTIFACT, mistakeRecallGateStatus } from '../mistake-recall.js';
 import { recordSkillDreamEvent, SKILL_DREAM_POLICY, writeSkillForgeReport } from '../skill-forge.js';
 import { evaluateResearchGate, researchPaperArtifactForPlan, writeResearchPlan } from '../research.js';
+import { ALIGN_GATE_ARTIFACT, ALIGN_LEDGER_ARTIFACT, ALIGN_PLAN_ARTIFACT, alignNextActionText, writeAlignRouteArtifacts } from '../align/align-route.js';
 import { PPT_REQUIRED_GATE_FIELDS, writePptRouteArtifacts } from '../ppt.js';
 import { writeQaLoopArtifacts } from '../qa-loop.js';
 import { IMAGE_UX_REVIEW_GATE_ARTIFACT, IMAGE_UX_REVIEW_POLICY_ARTIFACT, IMAGE_UX_REVIEW_SCREEN_INVENTORY_ARTIFACT, IMAGE_UX_REVIEW_GENERATED_REVIEW_LEDGER_ARTIFACT, IMAGE_UX_REVIEW_ISSUE_LEDGER_ARTIFACT, IMAGE_UX_REVIEW_ITERATION_REPORT_ARTIFACT, IMAGE_UX_REVIEW_REQUIRED_GATE_FIELDS, writeImageUxReviewRouteArtifacts } from '../image-ux-review.js';
@@ -678,6 +679,8 @@ export function promptPipelineContext(prompt, route = null) {
         lines.push('MAD-SKS SQL-plane: explicit invocation is the approval boundary. Use the mission-local write-capable Supabase MCP profile only for the bound cycle, verify execute_sql/apply_migration inventory before claiming ready, execute requested SQL-plane mutations, read back postconditions, then close the capability/profile and prove normal read-only restoration. Supabase project/account/billing/credential control-plane actions remain denied.');
     if (route?.id === 'GX')
         lines.push('GX route: use deterministic vgraph/beta render, validate, drift, and snapshot artifacts.');
+    if (route?.id === 'Align')
+        lines.push('Align route: modernize SKS prompts, settings, and skill/command surfaces to latest GPT-5.6 official prompting, programmatic tool calling, agents, and openai/skills guidance. Latest-version only: delete legacy compat knobs, deduplicate redundant prompt/config content, protect immutable core skills, update align-ledger.json, and pass align-gate.json.');
     return lines.join('\n');
 }
 export function dfixQuickContext(prompt, route = routePrompt(prompt)) {
@@ -791,6 +794,8 @@ export async function prepareRoute(root, prompt, state = {}, opts = {}) {
         return finish(await prepareResearch(root, route, task, required, { sessionKey }));
     if (route.id === 'AutoResearch')
         return finish(await prepareAutoResearch(root, route, task, required, { sessionKey }));
+    if (route.id === 'Align')
+        return finish(await prepareAlign(root, route, task, required, { sessionKey }));
     if (route.id === 'DB')
         return finish(await prepareDb(root, route, task, required, { sessionKey }));
     if (route.id === 'GX')
@@ -956,6 +961,16 @@ export async function activeRouteContext(root, state) {
         return `Route contract sealed for ${state.route_command || state.route || state.mode}. Use decision-contract.json and ${PIPELINE_PLAN_ARTIFACT} before executing the route. Before the next route phase, read relevant TriWiki context, hydrate low-trust claims from source, and refresh/validate TriWiki again after new findings or artifact changes. Next atomic action: continue the original route lifecycle with the inferred goal, constraints, non-goals, risk boundary, and test scope.${planNote}`;
     }
     if (state.mode === 'NARUTO') {
+        if (state.session_scope) {
+            const parentEvidenceState = await appNarutoParentEvidenceState(root, state);
+            if (parentEvidenceState === 'completed') {
+                return `Active Codex App Naruto mission ${state.mission_id || 'latest'} has trustworthy current-run parent evidence and a passed Naruto gate. Do not resubmit or expose the sks.subagent-parent-summary.v1 JSON. Return concise Markdown in the user's language with an explicit completion summary, verification, remaining gaps, and Honest Mode.${reasoningNote}${planNote}`;
+            }
+            if (parentEvidenceState === 'blocked') {
+                return `Active Codex App Naruto mission ${state.mission_id || 'latest'} has trustworthy current-run blocked or failed parent evidence. Do not resubmit or expose the sks.subagent-parent-summary.v1 JSON. Return concise Markdown in the user's language that states the blocker or failure first, avoids completion or success wording, and includes verification, remaining gaps, and Honest Mode.${reasoningNote}${planNote}`;
+            }
+            return `Active Codex App Naruto mission ${state.mission_id || 'latest'} uses the official Codex subagent workflow. Read subagent-plan.json, keep ${SUBAGENT_EVENT_LOG_FILENAME} and ${SUBAGENT_EVIDENCE_FILENAME} current from SubagentStart/SubagentStop, and wait for all requested agent threads. Build the exact sks.subagent-parent-summary.v1 object with run_id matching subagent-plan.json.workflow_run_id, then send it only through stdin to "sks naruto parent-summary --mission ${state.mission_id} --stdin --json". Do not expose, paste, embed, quote, or fence that JSON in the user-visible response. Only after the command accepts it, return concise Markdown in the user's language with completion summary, verification, remaining gaps/blockers, and Honest Mode. A successful response must visibly include the completion summary and Honest Mode assessment. If any parent/thread status is blocked or failed, or blockers remain, state that first and do not use completion or success wording. Do not substitute process counts, PID evidence, retired process-pool artifacts, or a custom active pool.${reasoningNote}${planNote}`;
+        }
         return `Active Naruto mission ${state.mission_id || 'latest'} uses the official Codex subagent workflow. Read subagent-plan.json, keep ${SUBAGENT_EVENT_LOG_FILENAME} and ${SUBAGENT_EVIDENCE_FILENAME} current from SubagentStart/SubagentStop, wait for all requested agent threads, then return the exact sks.subagent-parent-summary.v1 JSON result so SKS can persist ${SUBAGENT_PARENT_SUMMARY_FILENAME} and derive naruto-summary.json/naruto-gate.json. Do not substitute process counts, PID evidence, retired process-pool artifacts, or a custom active pool.${reasoningNote}${planNote}`;
     }
     if (state.subagents_required && !(await hasSubagentEvidence(root, state))) {
@@ -968,6 +983,40 @@ export async function activeRouteContext(root, state) {
     }
     return planNote.trim();
 }
+async function appNarutoParentEvidenceState(root, state) {
+    const missionId = String(state?.mission_id || '').trim();
+    const workflowRunId = String(state?.official_subagent_run_id || '').trim();
+    if (!missionId || !workflowRunId)
+        return null;
+    const dir = missionDir(root, missionId);
+    const [evidence, summary, gate] = await Promise.all([
+        subagentEvidence(root, state).catch(() => null),
+        readJson(path.join(dir, NARUTO_SUMMARY_FILENAME), null).catch(() => null),
+        readJson(path.join(dir, NARUTO_GATE_FILENAME), null).catch(() => null)
+    ]);
+    const currentRun = evidence?.run_id === workflowRunId
+        && summary?.workflow_run_id === workflowRunId
+        && gate?.workflow_run_id === workflowRunId;
+    if (!currentRun || evidence?.parent_summary_trustworthy !== true)
+        return null;
+    if (evidence.ok === true
+        && evidence.status === 'completed'
+        && summary?.status === 'completed'
+        && summary?.completion_evidence === true
+        && gate?.passed === true
+        && gate?.terminal === true
+        && gate?.terminal_state === 'completed') {
+        return 'completed';
+    }
+    if (evidence.parent_summary_status === 'failed'
+        && ['blocked', 'incomplete'].includes(String(summary?.status || ''))
+        && summary?.completion_evidence !== true
+        && gate?.passed !== true
+        && gate?.terminal_state === 'blocked') {
+        return 'blocked';
+    }
+    return null;
+}
 async function activePipelinePlanNote(root, state = {}) {
     if (!state?.mission_id)
         return '';
@@ -1263,6 +1312,35 @@ async function prepareGx(root, route, task, required, opts = {}) {
     await setCurrent(root, routeState(id, route, 'GX_VALIDATE_REQUIRED', required, { prompt: task, ...pipelinePlanState(pipelinePlan) }), { sessionKey: opts.sessionKey });
     return routeContext(route, id, task, required, 'Run sks gx init/render/validate/drift/snapshot, then pass gx-gate.json.');
 }
+async function prepareAlign(root, route, task, required, opts = {}) {
+    const { id, dir } = await createMission(root, { mode: 'align', prompt: task, sessionKey: opts.sessionKey });
+    const artifacts = await writeAlignRouteArtifacts(dir, id, task);
+    await writeJsonAtomic(path.join(dir, 'route-context.json'), {
+        route: route.id,
+        command: route.command,
+        mode: route.mode,
+        task,
+        mission_id: id,
+        required_skills: route.requiredSkills,
+        context7_required: required,
+        context_tracking: triwikiContextTracking(),
+        stop_gate: route.stopGate,
+        official_guides: artifacts.plan.official_guides,
+        workstreams: artifacts.plan.workstreams,
+        artifacts: {
+            plan: ALIGN_PLAN_ARTIFACT,
+            ledger: ALIGN_LEDGER_ARTIFACT,
+            gate: ALIGN_GATE_ARTIFACT
+        }
+    });
+    const pipelinePlan = await writePipelinePlan(dir, { missionId: id, route, task, required, ambiguity: { required: false, status: 'direct_route' } });
+    await setCurrent(root, routeState(id, route, 'ALIGN_PREPARED', required, {
+        prompt: task,
+        stop_gate: route.stopGate,
+        ...pipelinePlanState(pipelinePlan)
+    }), { sessionKey: opts.sessionKey });
+    return routeContext(route, id, task, required, alignNextActionText(id));
+}
 async function prepareLightRoute(root, route, task, required, opts = {}) {
     const { id, dir } = await createMission(root, { mode: route.id.toLowerCase(), prompt: task, sessionKey: opts.sessionKey });
     await writeJsonAtomic(path.join(dir, 'route-context.json'), { route: route.id, command: route.command, task, required_skills: route.requiredSkills, context7_required: required, context_tracking: triwikiContextTracking(), stop_gate: 'honest_mode' });

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

@@ -413,6 +413,7 @@ function fireAndForgetProjectMemory(root, state = {}) {
         return appendJsonl(path.join(missionDir(root, id), 'events.jsonl'), {
             ts: nowIso(),
             type: 'triwiki.agents_md_projected',
+            proof_invalidating: false,
             ok: report.ok,
             reason: report.reason,
             written: report.written
@@ -424,6 +425,7 @@ function fireAndForgetProjectMemory(root, state = {}) {
         return appendJsonl(path.join(missionDir(root, id), 'events.jsonl'), {
             ts: nowIso(),
             type: 'triwiki.agents_md_project_failed',
+            proof_invalidating: false,
             error: err?.message || String(err)
         }).catch(() => undefined);
     });
@@ -473,7 +475,7 @@ async function complianceBlock(root, state = {}, reason = '', detail = {}) {
         missing: Array.isArray(detail.missing) ? detail.missing : []
     };
     await writeJsonAtomic(guardPath, record);
-    await appendJsonl(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'pipeline.compliance_loop_guard', gate: record.gate, repeat_count: count, limit, tripped: record.tripped, missing: record.missing });
+    await appendJsonl(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'pipeline.compliance_loop_guard', proof_invalidating: false, gate: record.gate, repeat_count: count, limit, tripped: record.tripped, missing: record.missing });
     if (!record.tripped)
         return { decision: 'block', reason, gate: detail.gate || state.stop_gate || null, missing: Array.isArray(detail.missing) ? detail.missing : [] };
     await writeJsonAtomic(path.join(dir, HARD_BLOCKER_ARTIFACT), {
@@ -492,7 +494,7 @@ async function complianceBlock(root, state = {}, reason = '', detail = {}) {
             'Pipeline stopped as a hard blocker instead of looping indefinitely; no completion success is claimed.'
         ]
     });
-    await appendJsonl(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'pipeline.compliance_loop_guard.tripped', gate: record.gate, repeat_count: count, limit });
+    await appendJsonl(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'pipeline.compliance_loop_guard.tripped', proof_invalidating: false, gate: record.gate, repeat_count: count, limit });
     return { decision: 'escalate', reason, gate: detail.gate || state.stop_gate || null, repeat_count: count, message: '동일 사유가 반복됩니다. 사용자 개입이 필요합니다.', systemMessage: '동일 사유가 반복됩니다. 사용자 개입이 필요합니다.' };
 }
 async function markReflectionInvalidatedForGateFailure(root, state = {}, detail = {}) {
@@ -611,6 +613,7 @@ async function resolveRecoveredComplianceBlocker(root, state = {}, recovered) {
     await appendJsonl(path.join(dir, 'events.jsonl'), {
         ts: nowIso(),
         type: 'pipeline.compliance_loop_guard.resolved',
+        proof_invalidating: false,
         gate,
         recovery_artifact: artifactName,
         hard_blocker_sha256: blockerSha256,

package/dist/core/policy/latest-version-guidance.js

@@ -0,0 +1,113 @@
+export const LATEST_VERSION_GUIDANCE_SCHEMA = 'sks.latest-version-guidance.v1';
+const SEMVER_RE = /\b\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?\b/g;
+export const GUIDANCE_TRIGGERS = [
+    'current release',
+    'current version',
+    'currently',
+    'preferred',
+    'minimum',
+    'at least',
+    'requires',
+    'required',
+    'require',
+    'must be',
+    'must use',
+    'update to',
+    'upgrade to',
+    'recommend',
+    'recommended',
+    'or later',
+    'or newer',
+    'or above',
+    'supported version',
+    'baseline remains',
+    '이상',
+    '권장',
+    '최소',
+    '필요합니다',
+    '사용하세요'
+];
+export const HISTORICAL_MARKERS = [
+    'changelog',
+    'historical',
+    'history',
+    'previously',
+    'fixed in',
+    'regression',
+    'released in',
+    'shipped in',
+    'was released',
+    'compatibility matrix',
+    'compatibility snapshot',
+    'schema revision',
+    'fixture',
+    'reproduces',
+    'as of the',
+    'no longer'
+];
+const STRING_LITERAL_RE = /'(?:[^'\\\n]|\\.)*'|"(?:[^"\\\n]|\\.)*"|`(?:[^`\\]|\\.)*`/g;
+const WINDOW_CHARS = 90;
+function containsTrigger(haystack) {
+    const lower = haystack.toLowerCase();
+    for (const trigger of GUIDANCE_TRIGGERS) {
+        if (lower.includes(trigger.toLowerCase()))
+            return trigger;
+    }
+    return null;
+}
+function isHistorical(haystack) {
+    const lower = haystack.toLowerCase();
+    return HISTORICAL_MARKERS.some((marker) => lower.includes(marker));
+}
+function excerpt(line) {
+    const compact = line.trim().replace(/\s+/g, ' ');
+    return compact.length > 160 ? `${compact.slice(0, 157)}...` : compact;
+}
+export function scanLatestVersionGuidance(relativePath, text, options = {}) {
+    const findings = [];
+    const lines = text.split(/\r?\n/);
+    for (const [index, rawLine] of lines.entries()) {
+        const line = rawLine ?? '';
+        const candidates = [];
+        if (options.stringLiteralsOnly) {
+            STRING_LITERAL_RE.lastIndex = 0;
+            let match;
+            while ((match = STRING_LITERAL_RE.exec(line)))
+                candidates.push(match[0]);
+        }
+        else {
+            candidates.push(line);
+        }
+        if (!candidates.length)
+            continue;
+        let reported = false;
+        for (const candidate of candidates) {
+            if (reported)
+                break;
+            SEMVER_RE.lastIndex = 0;
+            let match;
+            while ((match = SEMVER_RE.exec(candidate))) {
+                const window = candidate.slice(Math.max(0, match.index - WINDOW_CHARS), match.index + match[0].length + WINDOW_CHARS);
+                if (isHistorical(window))
+                    continue;
+                const trigger = containsTrigger(window);
+                if (!trigger)
+                    continue;
+                findings.push({ path: relativePath, line: index + 1, version: match[0], trigger, excerpt: excerpt(line) });
+                reported = true;
+                break;
+            }
+        }
+    }
+    return findings;
+}
+export const LATEST_VERSION_GUIDANCE_TEXT = 'Use the official latest stable SKS and Codex CLI releases. Run `sks update-check` and read the capability report for the current state — feature support is decided by capability probes, not by a pinned version number.';
+export function latestVersionGuidanceReport(findings, scannedFiles, exemptions) {
+    return {
+        schema: LATEST_VERSION_GUIDANCE_SCHEMA,
+        ok: findings.length === 0,
+        scannedFiles,
+        findings: [...findings].sort((left, right) => left.path.localeCompare(right.path) || left.line - right.line),
+        exemptions: [...exemptions].sort()
+    };
+}