sneakoscope 7.3.0 → 7.5.0

package/dist/core/commands/triwiki-graph-command.js

@@ -0,0 +1,160 @@
+import { flag, readOption } from '../../cli/args.js';
+import { CONTEXT_GRAPH_REPAIR_COMMAND } from '../triwiki/context-graph/contracts.js';
+import { contextGraphFreshnessPreflight } from '../hooks-runtime/context-graph-freshness-preflight.js';
+import { contextGraphExtractors } from '../triwiki/context-graph/extractors/index.js';
+import { runContextGraphLint } from '../triwiki/context-graph/lint/index.js';
+import { contextGraphQueryProfile } from '../triwiki/context-graph/profiles.js';
+import { queryContextGraph } from '../triwiki/context-graph/query/index.js';
+import { contextGraphStatus } from '../triwiki/context-graph/store/graph-status.js';
+import { readContextGraphMeta, readContextGraphSnapshot } from '../triwiki/context-graph/store/snapshot-store.js';
+export const TRIWIKI_GRAPH_SUBCOMMANDS = ['graph-status', 'graph-lint', 'graph-query'];
+export function isTriWikiGraphSubcommand(value) {
+    return typeof value === 'string' && TRIWIKI_GRAPH_SUBCOMMANDS.includes(value);
+}
+function issueLine(issue) {
+    const where = issue.nodeId ?? issue.edgeId ?? issue.path ?? '';
+    return `${issue.severity}: ${issue.code}${where ? ` ${where}` : ''} — ${issue.message}`;
+}
+async function graphStatusFast(root) {
+    const preflight = await contextGraphFreshnessPreflight(root);
+    return {
+        result: { ...preflight, mode: 'fast', ok: preflight.usable },
+        ok: preflight.usable,
+        lines: [
+            `Context graph: ${preflight.status} (${preflight.node_count} nodes, ${preflight.edge_count} edges, ${preflight.coverage})`,
+            ...(preflight.reasons.length ? [`Stale reasons: ${preflight.reasons.join(', ')}`] : []),
+            ...(preflight.unverified_reasons.length ? [`Not evaluated: ${preflight.unverified_reasons.join(', ')}`] : []),
+            ...(preflight.usable ? [] : [`Repair: ${preflight.repair_command}`])
+        ]
+    };
+}
+async function graphStatus(root) {
+    const status = await contextGraphStatus(root, { extractors: contextGraphExtractors() });
+    const meta = await readContextGraphMeta(root);
+    const result = {
+        schema: 'sks.triwiki-graph-status.v1',
+        ok: status.status === 'fresh',
+        status: status.status,
+        snapshot_hash: status.snapshotHash,
+        generated_at: status.generatedAt,
+        stale_reasons: status.reasons,
+        error_code: status.errorCode,
+        node_count: status.nodeCount,
+        edge_count: status.edgeCount,
+        lint: meta.status === 'ok' && meta.meta ? meta.meta.lint : null,
+        repair_command: status.repairCommand
+    };
+    const lines = [
+        `Context graph: ${status.status} (${status.nodeCount} nodes, ${status.edgeCount} edges)`,
+        ...(status.snapshotHash ? [`Snapshot: ${status.snapshotHash.slice(0, 16)}`] : []),
+        ...(status.reasons.length ? [`Stale reasons: ${status.reasons.join(', ')}`] : []),
+        ...(status.status === 'fresh' ? [] : [`Repair: ${status.repairCommand}`])
+    ];
+    return { result, ok: result.ok, lines };
+}
+async function graphLint(root) {
+    const snapshotLoad = await readContextGraphSnapshot(root);
+    if (snapshotLoad.status !== 'ok' || !snapshotLoad.snapshot) {
+        const errorCode = snapshotLoad.status === 'missing' ? 'context_graph_missing' : 'context_graph_corrupt';
+        return {
+            result: {
+                schema: 'sks.triwiki-graph-lint.v1',
+                ok: false,
+                error_code: errorCode,
+                errors: [],
+                warnings: [],
+                repair_command: CONTEXT_GRAPH_REPAIR_COMMAND
+            },
+            ok: false,
+            lines: [`Context graph lint: ${errorCode}`, `Repair: ${CONTEXT_GRAPH_REPAIR_COMMAND}`]
+        };
+    }
+    const meta = await readContextGraphMeta(root);
+    const lint = runContextGraphLint({
+        root,
+        snapshot: snapshotLoad.snapshot,
+        meta: meta.status === 'ok' ? meta.meta : null
+    });
+    const result = {
+        schema: 'sks.triwiki-graph-lint.v1',
+        ok: lint.ok,
+        snapshot_hash: snapshotLoad.snapshot.snapshotHash,
+        error_count: lint.errorCount,
+        warning_count: lint.warningCount,
+        errors: lint.errors.map(issueLine),
+        warnings: lint.warnings.slice(0, 40).map(issueLine),
+        repair_command: CONTEXT_GRAPH_REPAIR_COMMAND
+    };
+    return {
+        result,
+        ok: lint.ok,
+        lines: [
+            `Context graph lint: ${lint.ok ? 'ok' : 'blocked'} (${lint.errorCount} errors, ${lint.warningCount} warnings)`,
+            ...lint.errors.slice(0, 20).map((issue) => `- ${issueLine(issue)}`)
+        ]
+    };
+}
+async function graphQuery(root, args) {
+    const query = args.find((arg) => !arg.startsWith('-')) ?? '';
+    const profile = contextGraphQueryProfile(readOption(args, '--profile', 'implementation')).name;
+    const budgetRaw = readOption(args, '--token-budget', '');
+    const parsedBudget = budgetRaw ? Number.parseInt(String(budgetRaw), 10) : Number.NaN;
+    if (!query) {
+        return {
+            result: { schema: 'sks.triwiki-graph-query.v1', ok: false, errors: ['missing_query'] },
+            ok: false,
+            lines: ['Usage: sks triwiki graph-query "<query>" [--profile implementation|review|planning|answer] [--json]']
+        };
+    }
+    const answer = await queryContextGraph({
+        root,
+        query,
+        profile,
+        ...(Number.isFinite(parsedBudget) ? { tokenBudget: parsedBudget } : {})
+    });
+    const result = {
+        schema: 'sks.triwiki-graph-query.v1',
+        ok: answer.ok,
+        profile: answer.profile,
+        snapshot_hash: answer.snapshotHash,
+        snapshot_freshness: answer.snapshotFreshness,
+        seed_count: answer.seedCount,
+        visited_nodes: answer.visitedNodes,
+        selected: answer.selected.map((node) => ({
+            id: node.nodeId,
+            kind: node.kind,
+            path: node.path ?? null,
+            score: node.score,
+            trust: node.trust,
+            freshness: node.freshness,
+            token_cost: node.tokenCost,
+            reason_path: node.reasonPath,
+            provenance: node.provenance
+        })),
+        provenance_coverage: answer.provenanceCoverage,
+        stale_excluded: answer.staleExcluded,
+        invalidated_excluded: answer.invalidatedExcluded,
+        token_cost: answer.tokenCost,
+        token_budget: answer.tokenBudget,
+        truncated: answer.truncated,
+        timeout: answer.timeout,
+        omission_reasons: answer.omissionReasons,
+        warnings: answer.warnings,
+        errors: answer.errors,
+        repair_command: CONTEXT_GRAPH_REPAIR_COMMAND
+    };
+    const lines = answer.ok
+        ? [
+            `Context graph query (${answer.profile}): ${answer.selected.length} nodes, ${answer.tokenCost}/${answer.tokenBudget} tokens`,
+            ...answer.selected.slice(0, 12).map((node) => `- ${node.nodeId}  [${node.reasonPath.join(' ')}]`)
+        ]
+        : [`Context graph query blocked: ${answer.errors.join(', ')}`, `Repair: ${CONTEXT_GRAPH_REPAIR_COMMAND}`];
+    return { result, ok: answer.ok, lines };
+}
+export async function triwikiGraphCommand(root, sub, args) {
+    if (sub === 'graph-status')
+        return flag(args, '--fast') ? graphStatusFast(root) : graphStatus(root);
+    if (sub === 'graph-lint')
+        return graphLint(root);
+    return graphQuery(root, args.filter((arg) => arg !== 'graph-query' && !flag([arg], '--json')));
+}

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

@@ -20,8 +20,15 @@ import { wrongnessContextForRoute } from '../triwiki-wrongness/wrongness-retriev
 import { readCombinedWrongnessRecords } from '../triwiki-wrongness/wrongness-ledger.js';
 import { recordImageWrongnessFromValidation } from '../triwiki-wrongness/image-wrongness.js';
 import { publishSharedMemory, rebuildSharedIndexes, sharedMemorySummary, validateSharedMemory } from '../git-hygiene/shared-memory-publish.js';
-import { scanCodebaseIndex } from '../triwiki/code-index-scanner.js';
-import { buildCodePack, validateCodePack, writeCodePackAtomic } from '../triwiki/code-pack.js';
+import { codePackPath, isCodePackProjectionBoundToSnapshot, validateCodePack, writeCodePackAtomic } from '../triwiki/code-pack.js';
+import { repairTriWikiProofIndex } from '../triwiki/triwiki-proof-bank-index.js';
+import { runContextGraphLint } from '../triwiki/context-graph/lint/index.js';
+import { contextGraphStatus } from '../triwiki/context-graph/store/graph-status.js';
+import { readContextGraphMeta, readContextGraphSnapshot } from '../triwiki/context-graph/store/snapshot-store.js';
+import { compileContextGraph } from '../triwiki/context-graph/compiler/index.js';
+import { contextGraphExtractors } from '../triwiki/context-graph/extractors/index.js';
+import { buildWorkspaceCodePack } from '../triwiki/context-graph/projections/code-pack-workspace.js';
+import { CONTEXT_GRAPH_REPAIR_COMMAND } from '../triwiki/context-graph/contracts.js';
 import { inspectCodePackHeadFreshness } from '../triwiki/code-pack-head-freshness.js';
 import { sealTriWikiContextPack, validateTriWikiContextPackProvenance } from '../triwiki-provenance.js';
 import { flag, positionalArgs, readFlagValue, readOption, resolveMissionId } from './command-utils.js';
@@ -205,46 +212,119 @@ export async function wikiCommand(sub, args = []) {
         const pack = await readJson(path.resolve(target));
         const { result, trustAnchors } = wikiValidationResult(pack, root);
         const codePack = await codePackFreshness(root);
-        process.exitCode = result.ok ? 0 : 2;
-        if (flag(args, '--json'))
-            return console.log(JSON.stringify({ ...result, code_pack: codePack }, null, 2));
+        const graph = await wikiValidateContextGraph(root);
+        const ok = result.ok && graph.ok;
+        process.exitCode = ok ? 0 : 2;
+        if (flag(args, '--json')) {
+            return console.log(JSON.stringify({ ...result, ok, code_pack: codePack, context_graph: graph }, null, 2));
+        }
         console.log(`Wiki coordinate index: ${result.ok ? 'ok' : 'failed'}`);
         console.log(`Anchors checked: ${result.checked}`);
         console.log(`Trust anchors: ${trustAnchors}/${result.checked}`);
         for (const issue of result.issues)
             console.log(`- ${issue.severity}: ${issue.id}${issue.anchor ? ` ${issue.anchor}` : ''}`);
-        console.log(`Code pack: ${codePack.status}${codePack.status === 'stale' ? ' — run `sks wiki refresh --code`' : ''}`);
+        console.log(`Code pack: ${codePack.status}${codePack.status === 'stale' ? ` — run \`${CONTEXT_GRAPH_REPAIR_COMMAND}\`` : ''}`);
+        console.log(`Context graph: ${graph.status}${graph.ok ? '' : ` — run \`${CONTEXT_GRAPH_REPAIR_COMMAND}\``}`);
+        for (const issue of graph.issues)
+            console.log(`- ${issue}`);
         return;
     }
     console.error('Usage: sks wiki coords|pack|refresh|publish|rebuild-index|rebuild-summary|validate|validate-shared|wrongness|image-ingest|anchor-add|relation-add|image-validate|image-summary');
     process.exitCode = 1;
 }
+async function wikiValidateContextGraph(root) {
+    const status = await contextGraphStatus(root, { extractors: contextGraphExtractors() });
+    if (status.status !== 'fresh') {
+        return {
+            ok: false,
+            status: status.status,
+            snapshot_hash: status.snapshotHash,
+            issues: [status.errorCode ?? 'context_graph_not_fresh', ...status.reasons]
+        };
+    }
+    const snapshotLoad = await readContextGraphSnapshot(root);
+    const metaLoad = await readContextGraphMeta(root);
+    if (snapshotLoad.status !== 'ok' || !snapshotLoad.snapshot || metaLoad.status !== 'ok' || !metaLoad.meta) {
+        return { ok: false, status: 'corrupt', snapshot_hash: status.snapshotHash, issues: ['context_graph_snapshot_meta_unreadable'] };
+    }
+    const lint = runContextGraphLint({ root, snapshot: snapshotLoad.snapshot, meta: metaLoad.meta });
+    const issues = lint.errors.slice(0, 20).map((issue) => `${issue.code}: ${issue.message}`);
+    const pack = await readJson(codePackPath(root), null).catch(() => null);
+    const digest = typeof pack?.index_digest === 'string' ? pack.index_digest : '';
+    const boundToSnapshot = Boolean(pack
+        && Array.isArray(pack.entries)
+        && isCodePackProjectionBoundToSnapshot(snapshotLoad.snapshot.snapshotHash, pack));
+    if (digest && !boundToSnapshot)
+        issues.push('code_pack_not_bound_to_current_snapshot');
+    return {
+        ok: lint.ok && (!digest || boundToSnapshot),
+        status: 'fresh',
+        snapshot_hash: snapshotLoad.snapshot.snapshotHash,
+        issues
+    };
+}
 async function wikiRefreshCode(args = []) {
     const root = await sksRoot();
-    const index = await scanCodebaseIndex(root);
     const tokenBudgetRaw = readFlagValue(args, '--token-budget', null);
-    const tokenBudget = tokenBudgetRaw ? Number.parseInt(String(tokenBudgetRaw), 10) : undefined;
-    const pack = tokenBudget && Number.isFinite(tokenBudget) ? buildCodePack(root, index, tokenBudget) : buildCodePack(root, index);
-    const validation = await validateCodePack(pack, root);
-    const written = validation.ok ? await writeCodePackAtomic(root, pack) : null;
+    const parsedBudget = tokenBudgetRaw ? Number.parseInt(String(tokenBudgetRaw), 10) : Number.NaN;
+    const tokenBudget = Number.isFinite(parsedBudget) ? parsedBudget : undefined;
+    const proofIndex = repairTriWikiProofIndex(root);
+    const compiled = await compileContextGraph({
+        root,
+        extractors: contextGraphExtractors(),
+        useFragmentCache: false
+    });
+    const lintErrors = compiled.issues.filter((issue) => issue.severity === 'error');
+    if (!compiled.ok || !compiled.snapshot) {
+        const blocked = {
+            schema: 'sks.wiki-refresh-code.v1',
+            ok: false,
+            reason: compiled.reason ?? 'context_graph_compile_failed',
+            blockers: compiled.blockers ?? [],
+            issues: lintErrors.slice(0, 20).map((issue) => `${issue.code}: ${issue.message}`),
+            repair_command: CONTEXT_GRAPH_REPAIR_COMMAND,
+            written: null
+        };
+        process.exitCode = 2;
+        process.stderr.write(`wiki-refresh-code: root=${root} graph=blocked reason=${blocked.reason} blockers=${JSON.stringify(blocked.blockers)}\n`);
+        if (flag(args, '--json'))
+            return console.log(JSON.stringify(blocked, null, 2));
+        console.log('Sneakoscope TriWiki Context Graph Refresh');
+        console.log(`Context graph: blocked (${blocked.reason})`);
+        for (const issue of blocked.issues)
+            console.log(`- ${issue}`);
+        return;
+    }
+    const projected = await buildWorkspaceCodePack(root, {
+        ...(tokenBudget === undefined ? {} : { tokenBudget }),
+        status: { status: 'fresh', snapshotHash: compiled.snapshotHash }
+    });
+    const pack = projected.pack;
+    const validation = pack ? await validateCodePack(pack, root) : { ok: false, issues: projected.errors };
+    const written = pack && validation.ok ? await writeCodePackAtomic(root, pack) : null;
     const result = {
         schema: 'sks.wiki-refresh-code.v1',
         ok: validation.ok,
         issues: validation.issues,
-        modules: index.modules.length,
-        truncated: index.truncated,
-        scanned_file_count: index.scanned_file_count,
-        entries: pack.entries.length,
-        token_cost: pack.total_token_cost,
-        token_budget: pack.token_budget,
+        snapshot_hash: compiled.snapshotHash,
+        nodes: compiled.snapshot.nodeCount,
+        edges: compiled.snapshot.edgeCount,
+        graph_warnings: compiled.issues.filter((issue) => issue.severity === 'warning').length,
+        incremental: Boolean(compiled.incremental),
+        proof_index: { ok: proofIndex.ok, indexed: proofIndex.indexed_count, previous_status: proofIndex.previous_status },
+        compile_ms: compiled.durationMs,
+        entries: pack ? pack.entries.length : 0,
+        token_cost: pack ? pack.total_token_cost : 0,
+        token_budget: pack ? pack.token_budget : 0,
         written: written ? written.path : null
     };
     process.exitCode = validation.ok ? 0 : 2;
-    process.stderr.write(`wiki-refresh-code: root=${root} modules=${index.modules.length} entries=${pack.entries.length} token_cost=${pack.total_token_cost}/${pack.token_budget} issues=${JSON.stringify(validation.issues)}\n`);
+    process.stderr.write(`wiki-refresh-code: root=${root} nodes=${result.nodes} edges=${result.edges} entries=${result.entries} token_cost=${result.token_cost}/${result.token_budget} issues=${JSON.stringify(validation.issues)}\n`);
     if (flag(args, '--json'))
         return console.log(JSON.stringify(result, null, 2));
-    console.log('Sneakoscope TriWiki Code Pack Refresh');
-    console.log(`Code pack refresh: ${validation.ok ? 'ok' : 'blocked'} (${pack.entries.length} entries from ${index.modules.length} modules${index.truncated ? ', truncated' : ''})`);
+    console.log('Sneakoscope TriWiki Context Graph Refresh');
+    console.log(`Context graph: ok (${result.nodes} nodes, ${result.edges} edges, snapshot ${String(result.snapshot_hash).slice(0, 12)})`);
+    console.log(`Code pack projection: ${validation.ok ? 'ok' : 'blocked'} (${result.entries} entries, ${result.token_cost}/${result.token_budget} tokens)`);
     for (const issue of validation.issues)
         console.log(`- ${issue}`);
 }

package/dist/core/errors/message.js

@@ -1,3 +1,6 @@
 export function messageOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
+export function errorCodeOf(error) {
+    return error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
+}

package/dist/core/feature-registry.js

@@ -735,8 +735,8 @@ function imagegenWiringFeatures() {
                 cli_command_names: ['image-ux-review'],
                 handler_keys: ['image-ux-review', 'ux-review'],
                 dollar_commands: ['$Image-UX-Review', '$UX-Review'],
-                app_skill_aliases: ['$image-ux-review', '$ux-review'],
-                skills: ['image-ux-review', 'ux-review', 'imagegen']
+                app_skill_aliases: ['$image-ux-review'],
+                skills: ['image-ux-review', 'imagegen']
             }
         }),
         baseFeature({

package/dist/core/fsx.js

@@ -227,18 +227,22 @@ export async function writeReceiptRotated(p, data, opts = {}) {
         .slice(keep);
     await Promise.all(removable.map((row) => fsp.rm(row.file, { force: true }).catch(() => undefined)));
 }
-export async function writeBinaryAtomic(p, data) {
+export async function writeBinaryAtomic(p, data, options = {}) {
     await ensureDir(path.dirname(p));
     try {
-        if ((await fsp.readFile(p)).equals(data))
+        if (options.mode === undefined && (await fsp.readFile(p)).equals(data))
             return;
     }
     catch { }
     const tmp = `${p}.${process.pid}.${randomId(6)}.tmp`;
     try {
-        const handle = await fsp.open(tmp, 'w');
+        const handle = options.mode === undefined
+            ? await fsp.open(tmp, 'w')
+            : await fsp.open(tmp, 'w', options.mode);
         try {
             await handle.writeFile(data);
+            if (options.mode !== undefined)
+                await handle.chmod(options.mode);
             await handle.sync().catch(() => { });
         }
         finally {

package/dist/core/hooks-runtime/codex-commit-hooks-selftest.js

@@ -0,0 +1,82 @@
+import path from 'node:path';
+import { packageRoot, runProcess, tmpdir } from '../fsx.js';
+export async function selftestCodexCommitHooks() {
+    const root = tmpdir();
+    const hookBin = path.join(packageRoot(), 'dist', 'bin', 'sks.js');
+    const env = { SKS_DISABLE_UPDATE_CHECK: '1' };
+    const setup = await runProcess(process.execPath, [hookBin, 'setup', '--install-scope', 'project'], { cwd: root, env, timeoutMs: 15000, maxOutputBytes: 128 * 1024 });
+    if (setup.code !== 0)
+        throw new Error(`selftest failed: commit setup ${setup.code}: ${setup.stderr}`);
+    const runHook = (name, payload) => runProcess(process.execPath, [hookBin, 'hook', name], { cwd: root, input: JSON.stringify({ cwd: root, ...payload }), env, timeoutMs: 15000, maxOutputBytes: 128 * 1024 });
+    const id = 'commit-selftest';
+    const hook = await runHook('user-prompt-submit', { conversation_id: id, action: 'codex_git_commit', prompt: 'Generate a git commit message for the staged diff.' });
+    if (hook.code !== 0)
+        throw new Error(`selftest failed: commit hook ${hook.code}: ${hook.stderr}`);
+    const hookJson = JSON.parse(hook.stdout);
+    if (hookJson.decision === 'block' || hookJson.hookSpecificOutput?.additionalContext || !String(hookJson.systemMessage || '').includes('git action'))
+        throw new Error('selftest failed: commit route bypass');
+    const stop = await runHook('stop', { conversation_id: id, last_assistant_message: 'Fix Codex App commit message hook bypass' });
+    if (stop.code !== 0)
+        throw new Error(`selftest failed: commit stop ${stop.code}: ${stop.stderr}`);
+    const stopJson = JSON.parse(stop.stdout);
+    if (stopJson.decision === 'block' || !String(stopJson.systemMessage || '').includes('accepted without route finalization'))
+        throw new Error('selftest failed: commit stop bypass');
+    const commitPushId = 'commit-push-selftest';
+    const appCommitPushHook = await runHook('user-prompt-submit', { conversation_id: commitPushId, action: 'Codex App Git Actions Commit and Push', prompt: 'Commit and push changes.' });
+    if (appCommitPushHook.code !== 0)
+        throw new Error(`selftest failed: app commit-push hook ${appCommitPushHook.code}: ${appCommitPushHook.stderr}`);
+    const appCommitPushJson = JSON.parse(appCommitPushHook.stdout);
+    if (appCommitPushJson.decision === 'block' || appCommitPushJson.hookSpecificOutput?.additionalContext || !String(appCommitPushJson.systemMessage || '').includes('git action'))
+        throw new Error('selftest failed: app commit-push route bypass');
+    const appCommitPushStop = await runHook('stop', { conversation_id: commitPushId, last_assistant_message: 'Commit and push complete.' });
+    if (appCommitPushStop.code !== 0)
+        throw new Error(`selftest failed: app commit-push stop ${appCommitPushStop.code}: ${appCommitPushStop.stderr}`);
+    if (JSON.parse(appCommitPushStop.stdout).decision === 'block')
+        throw new Error('selftest failed: app commit-push stop bypass');
+    const appPushId = 'app-push-selftest';
+    const appPushHook = await runHook('user-prompt-submit', { conversation_id: appPushId, metadata: { source: 'codex_app', action: 'Git Actions Push' }, prompt: 'Push changes.' });
+    if (appPushHook.code !== 0)
+        throw new Error(`selftest failed: app push hook ${appPushHook.code}: ${appPushHook.stderr}`);
+    const appPushJson = JSON.parse(appPushHook.stdout);
+    if (appPushJson.decision === 'block' || appPushJson.hookSpecificOutput?.additionalContext || !String(appPushJson.systemMessage || '').includes('git action'))
+        throw new Error('selftest failed: app push metadata route bypass');
+    const appPushStop = await runHook('stop', { conversation_id: appPushId, metadata: { source: 'codex_app', action: 'Git Actions Push' }, last_assistant_message: 'Done.' });
+    if (appPushStop.code !== 0)
+        throw new Error(`selftest failed: app push stop ${appPushStop.code}: ${appPushStop.stderr}`);
+    if (JSON.parse(appPushStop.stdout).decision === 'block')
+        throw new Error('selftest failed: app push metadata stop bypass');
+    const metadataLightId = 'metadata-light-commit-push-selftest';
+    const metadataLightHook = await runHook('user-prompt-submit', { conversation_id: metadataLightId, prompt: 'Commit and push changes.' });
+    if (metadataLightHook.code !== 0)
+        throw new Error(`selftest failed: metadata-light commit-push hook ${metadataLightHook.code}: ${metadataLightHook.stderr}`);
+    const metadataLightJson = JSON.parse(metadataLightHook.stdout);
+    if (metadataLightJson.decision === 'block' || metadataLightJson.hookSpecificOutput?.additionalContext || !String(metadataLightJson.systemMessage || '').includes('git action'))
+        throw new Error('selftest failed: metadata-light app commit-push route bypass');
+    const metadataLightStop = await runHook('stop', { conversation_id: metadataLightId, last_assistant_message: 'Commit and push complete.' });
+    if (metadataLightStop.code !== 0)
+        throw new Error(`selftest failed: metadata-light commit-push stop ${metadataLightStop.code}: ${metadataLightStop.stderr}`);
+    if (JSON.parse(metadataLightStop.stdout).decision === 'block')
+        throw new Error('selftest failed: metadata-light commit-push stop bypass');
+    const settingsHook = await runHook('user-prompt-submit', { model: 'future-codex-catalog-model', metadata: { source: 'codex_app_settings', feature: 'speed profile' } });
+    if (settingsHook.code !== 0)
+        throw new Error(`selftest failed: settings hook ${settingsHook.code}: ${settingsHook.stderr}`);
+    const settingsJson = JSON.parse(settingsHook.stdout);
+    if (settingsJson.decision === 'block' || settingsJson.hookSpecificOutput?.additionalContext || !String(settingsJson.systemMessage || '').includes('settings/profile event ignored'))
+        throw new Error('selftest failed: settings/profile event should not route or block');
+    const userHook = await runHook('user-prompt-submit', { prompt: '[커밋 메시지를 생성하지 못했습니다.] 코덱스 앱에서 이 버그 수정해줘' });
+    if (userHook.code !== 0)
+        throw new Error(`selftest failed: user commit hook ${userHook.code}: ${userHook.stderr}`);
+    if (!JSON.parse(userHook.stdout).hookSpecificOutput?.additionalContext?.includes('$Naruto route prepared'))
+        throw new Error('selftest failed: user prompt route');
+    const userCommitPushHook = await runHook('user-prompt-submit', { prompt: '배포하게 커밋하고 푸쉬해줘' });
+    if (userCommitPushHook.code !== 0)
+        throw new Error(`selftest failed: user commit-push hook ${userCommitPushHook.code}: ${userCommitPushHook.stderr}`);
+    const userCommitPushJson = JSON.parse(userCommitPushHook.stdout);
+    if (userCommitPushJson.decision === 'block' || userCommitPushJson.hookSpecificOutput?.additionalContext || !String(userCommitPushJson.systemMessage || '').includes('git action'))
+        throw new Error('selftest failed: user commit-push prompt should bypass route');
+    const userCommitPushStop = await runHook('stop', { last_assistant_message: 'Commit and push complete.' });
+    if (userCommitPushStop.code !== 0)
+        throw new Error(`selftest failed: user commit-push stop ${userCommitPushStop.code}: ${userCommitPushStop.stderr}`);
+    if (JSON.parse(userCommitPushStop.stdout).decision === 'block')
+        throw new Error('selftest failed: user commit-push stop bypass');
+}

package/dist/core/hooks-runtime/context-graph-freshness-preflight.js

@@ -0,0 +1,113 @@
+import { CONTEXT_GRAPH_REPAIR_COMMAND } from '../triwiki/context-graph/contracts.js';
+import { contextGraphCacheKey } from '../triwiki/context-graph/compiler/cache-key.js';
+import { contextGraphStatus } from '../triwiki/context-graph/store/graph-status.js';
+import { readContextGraphMeta } from '../triwiki/context-graph/store/snapshot-store.js';
+import { contextGraphExtractors } from '../triwiki/context-graph/extractors/index.js';
+export const CONTEXT_GRAPH_FRESHNESS_PREFLIGHT_SCHEMA = 'sks.context-graph-freshness-preflight.v1';
+const CACHE_KEY_DERIVED_REASONS = [
+    'head_changed',
+    'dirty_fingerprint_changed',
+    'schema_revision_changed',
+    'tsconfig_changed',
+    'command_manifest_changed',
+    'gate_manifest_changed',
+    'proof_index_changed',
+    'wiki_context_changed',
+    'git_state_unknown',
+    'cache_key_changed'
+];
+const PLACEHOLDER_CACHE_KEY_PARTS = {
+    workspaceIdentity: 'unevaluated',
+    head: null,
+    gitState: 'unknown',
+    trackedDirtyFingerprint: 'unevaluated',
+    untrackedFingerprint: 'unevaluated',
+    schemaRevision: 'unevaluated',
+    tsconfigHash: 'unevaluated',
+    commandManifestHash: 'unevaluated',
+    gateManifestHash: 'unevaluated',
+    proofIndexHash: 'unevaluated',
+    wikiContextHash: 'unevaluated'
+};
+export async function contextGraphFreshnessPreflight(root, options = {}) {
+    const verifySources = options.verifySources !== false;
+    const extractors = options.extractors ?? contextGraphExtractors();
+    const supplied = options.cacheKey ?? null;
+    const metaLoad = await readContextGraphMeta(root);
+    const meta = metaLoad.status === 'ok' ? metaLoad.meta : null;
+    const cacheKey = supplied ?? neutralCacheKey(meta?.cacheKeyParts ?? PLACEHOLDER_CACHE_KEY_PARTS);
+    const recordedSources = meta ? Object.keys(meta.inputHashes ?? {}).length : 0;
+    const status = await contextGraphStatus(root, {
+        extractors,
+        cacheKey,
+        verifySources,
+        ...(options.maxVerifiedSources === undefined ? {} : { maxVerifiedSources: options.maxVerifiedSources })
+    });
+    const sourcesVerified = verifySources
+        && (options.maxVerifiedSources === undefined || options.maxVerifiedSources >= recordedSources);
+    const unverified = collectUnverifiedReasons(status.reasons, Boolean(supplied), sourcesVerified);
+    return {
+        schema: CONTEXT_GRAPH_FRESHNESS_PREFLIGHT_SCHEMA,
+        usable: status.status === 'fresh',
+        status: status.status,
+        reasons: status.reasons,
+        unverified_reasons: unverified,
+        coverage: supplied ? 'full' : sourcesVerified ? 'artifacts_and_sources' : 'artifacts_only',
+        snapshot_hash: status.snapshotHash,
+        generated_at: status.generatedAt,
+        node_count: status.nodeCount,
+        edge_count: status.edgeCount,
+        error_code: status.errorCode,
+        repair_command: CONTEXT_GRAPH_REPAIR_COMMAND
+    };
+}
+export async function contextGraphFreshnessNote(root, options = {}) {
+    const budgetMs = Math.max(1, options.budgetMs ?? 750);
+    const preflight = await raceWithTimeout(contextGraphFreshnessPreflight(root, options), budgetMs).catch(() => null);
+    if (!preflight)
+        return null;
+    return contextGraphFreshnessNoteFor(preflight);
+}
+export function contextGraphFreshnessNoteFor(preflight) {
+    if (preflight.status === 'fresh')
+        return null;
+    if (preflight.status === 'missing') {
+        return `SKS note: the codebase context graph has not been built (${preflight.error_code}). Run \`${preflight.repair_command}\` before relying on graph-cited context.`;
+    }
+    if (preflight.status === 'corrupt') {
+        return `SKS note: the codebase context graph is unusable (${preflight.error_code}). Run \`${preflight.repair_command}\` to rebuild it; no older generation is substituted.`;
+    }
+    const reasons = preflight.reasons.join(', ');
+    return `SKS note: the codebase context graph is stale (${preflight.error_code}: ${reasons}). Run \`${preflight.repair_command}\` to refresh graph-cited context.`;
+}
+function neutralCacheKey(parts) {
+    return { key: contextGraphCacheKey(parts), parts, reusable: true, reasons: [], dirtyPaths: [] };
+}
+function collectUnverifiedReasons(fired, cacheKeySupplied, sourcesVerified) {
+    const firedSet = new Set(fired);
+    const out = [];
+    if (!cacheKeySupplied) {
+        for (const reason of CACHE_KEY_DERIVED_REASONS) {
+            if (!firedSet.has(reason))
+                out.push(reason);
+        }
+    }
+    if (!sourcesVerified && !firedSet.has('source_hash_mismatch'))
+        out.push('source_hash_mismatch');
+    return out;
+}
+async function raceWithTimeout(work, ms) {
+    let timer = null;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(null), ms);
+        if (timer.unref)
+            timer.unref();
+    });
+    try {
+        return await Promise.race([work, timeout]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}

package/dist/core/hooks-runtime/official-subagent-lifecycle.js

@@ -350,7 +350,7 @@ async function rebuildHostCapabilityEvidenceForFinalization(input) {
         blockers: bound.blockers
     };
 }
-function completeNarutoTerminalBundle(input) {
+export function completeNarutoTerminalBundle(input) {
     const runId = String(input.workflowRunId || '').trim();
     const parent = normalizeSubagentParentSummary(input.parentSummary);
     return Boolean(runId

package/dist/core/hooks-runtime/tool-output-quarantine.js

@@ -87,6 +87,6 @@ export function interruptedToolOutputRecoveryBlockReason(input = {}) {
         `SKS blocked same-thread continuation because custom tool call ${callId} has no correlated output (active mission: ${missionId}).`,
         'The current Codex conversation state may be structurally invalid, so additional context cannot repair the pending Responses request.',
         'Treat the call result as unknown and do not replay a possibly mutating action.',
-        'Upgrade the selected codex-lb to 1.21.0-beta.3 or later, or explicitly switch with `sks codex-lb use-oauth`, then open a fresh Codex thread and continue the persisted mission after inspecting side effects.'
+        'Upgrade the selected codex-lb to the official latest stable release (`sks codex-lb status --json` reports whether the deployment satisfies tool-heavy continuation), or explicitly switch with `sks codex-lb use-oauth`, then open a fresh Codex thread and continue the persisted mission after inspecting side effects.'
     ].join(' ');
 }