sneakoscope 7.3.0 → 7.6.0

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/hook-context.js

@@ -5,6 +5,7 @@ import { routePrompt } from '../pipeline.js';
 import { allowlistedManagedRouteSkillNames, dollarCommand, INVALID_EXPLICIT_MANAGED_SKILL_NAME, managedSkillNamesForPrompt, routeRequiresSubagents, stripVisibleDecisionAnswerBlocks } from '../routes.js';
 import { inspectConfinedPath } from '../managed-path-safety.js';
 import { renderAuthoritativeSksSkillContext, resolveAuthoritativeSksSkillSources } from '../codex-native/sks-skill-paths.js';
+import { healStaleGlobalManagedSkillGeneration, managedSkillResolutionIsHealable } from './managed-skill-generation-heal.js';
 import { looksLikeActiveContinuationPrompt } from './naruto-decision-gate.js';
 import { extractUserPrompt, looksLikeCodexGitAction, looksLikeCodexUiSettingsEvent } from './payload-signals.js';
 const STANDALONE_PARENT_BASE_SKILLS = [
@@ -100,7 +101,7 @@ async function readStandaloneParentRouteContext(root, missionId) {
     }
 }
 export async function authoritativeSksSkillAdmission(root, skillNames) {
-    const resolution = await resolveAuthoritativeSksSkillSources({ root, skillNames }).catch(() => null);
+    let resolution = await resolveAuthoritativeSksSkillSources({ root, skillNames }).catch(() => null);
     if (!resolution) {
         return {
             resolution: null,
@@ -111,16 +112,28 @@ export async function authoritativeSksSkillAdmission(root, skillNames) {
             }
         };
     }
+    let healedGeneration = null;
+    if (managedSkillResolutionIsHealable(resolution)) {
+        healedGeneration = await healStaleGlobalManagedSkillGeneration().catch(() => null);
+        if (healedGeneration) {
+            const rechecked = await resolveAuthoritativeSksSkillSources({ root, skillNames }).catch(() => null);
+            if (rechecked)
+                resolution = rechecked;
+        }
+    }
     if (resolution.unresolved.length || resolution.blockers.length) {
         const details = [
             resolution.unresolved.length ? `unavailable=${resolution.unresolved.join(',')}` : '',
             resolution.blockers.length ? `rejected=${resolution.blockers.join(',')}` : ''
         ].filter(Boolean).join('; ');
+        const repair = healedGeneration
+            ? `Global managed skills were regenerated from sneakoscope ${healedGeneration.installed_version} to ${healedGeneration.runtime_version} and still do not match this runtime, so \`sks doctor --fix\` cannot clear it. Ask the user to install the sneakoscope build that matches this runtime (${healedGeneration.runtime_version}) and retry.`
+            : 'Ask the user to run `sks doctor --fix` (do not run it yourself), then retry.';
         return {
             resolution,
             blocked: {
                 decision: 'block',
-                reason: `SKS managed skill availability check failed (${details}). Ask the user to run \`sks doctor --fix\` (do not run it yourself), then retry.`,
+                reason: `SKS managed skill availability check failed (${details}). ${repair}`,
                 systemMessage: 'SKS: managed skill availability check blocked this turn.'
             }
         };

package/dist/core/hooks-runtime/managed-skill-generation-heal.js

@@ -0,0 +1,46 @@
+import os from 'node:os';
+import path from 'node:path';
+import { PACKAGE_VERSION, readJson } from '../fsx.js';
+const HEALABLE_BLOCKER_STATUSES = new Set([
+    'content_digest_mismatch',
+    'canonical_name_mismatch',
+    'not_sks_managed'
+]);
+const healedGenerations = new Map();
+export function managedSkillResolutionIsHealable(resolution) {
+    if (!resolution)
+        return false;
+    const blockers = resolution.blockers || [];
+    if (blockers.some((blocker) => !HEALABLE_BLOCKER_STATUSES.has(String(blocker).split(':')[0] || '')))
+        return false;
+    return Boolean(resolution.unresolved.length || blockers.length);
+}
+export async function staleGlobalManagedSkillGeneration(home) {
+    const resolvedHome = path.resolve(home || process.env.HOME || os.homedir());
+    const marker = await readJson(path.join(resolvedHome, '.agents', 'skills', '.sks-generated.json'), null);
+    if (String(marker?.generated_by || '') !== 'sneakoscope')
+        return null;
+    const installedVersion = String(marker?.version || '').trim();
+    if (!installedVersion || installedVersion === PACKAGE_VERSION)
+        return null;
+    return { home: resolvedHome, installed_version: installedVersion, runtime_version: PACKAGE_VERSION };
+}
+export async function healStaleGlobalManagedSkillGeneration(home) {
+    const stale = await staleGlobalManagedSkillGeneration(home);
+    if (!stale)
+        return null;
+    const cached = healedGenerations.get(stale.home);
+    if (cached)
+        return cached;
+    const work = (async () => {
+        const { reconcileSkills } = await import('../init/skills.js');
+        const report = await reconcileSkills({
+            targetDir: path.join(stale.home, '.agents', 'skills'),
+            scope: 'global',
+            fix: true
+        }).catch(() => null);
+        return report?.ok === true ? stale : null;
+    })();
+    healedGenerations.set(stale.home, work);
+    return work;
+}

package/dist/core/hooks-runtime/naruto-terminal-finalization.js

@@ -160,6 +160,7 @@ async function resolveStaleOfficialSubagentComplianceBlocker(input) {
     await appendJsonl(path.join(input.dir, 'events.jsonl'), {
         ts: nowIso(),
         type: 'pipeline.compliance_loop_guard.resolved',
+        proof_invalidating: false,
         gate: 'official-subagent-evidence',
         workflow_run_id: input.workflowRunId,
         resolution_artifact: RESOLVED_HARD_BLOCKER_ARTIFACT

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 disable only codex-lb routing with `sks codex-lb disable`, then open a fresh Codex thread and continue the persisted mission after inspecting side effects. ChatGPT OAuth is not replaced by either action.'
     ].join(' ');
 }

package/dist/core/hooks-runtime.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { projectRoot, readJson, writeJsonAtomic, appendJsonl, nowIso, runProcess, sha256, packageRoot, tmpdir } from './fsx.js';
+import { projectRoot, readJson, writeJsonAtomic, appendJsonl, nowIso, sha256, packageRoot } from './fsx.js';
 import { looksInteractiveCommand, interactiveCommandReason } from './no-question-guard.js';
 import { loadStateForSession, missionDir, sessionStateKey, setCurrent, stateFileForSession } from './mission.js';
 import { checkDbOperation, dbBlockReason, handleMadSksUserConfirmation } from './db-safety.js';
@@ -42,6 +42,7 @@ import { activeAuthoritativeSksSkillRefresh, activeGoalOverlayContext, attachAut
 import { sealedSubagentRoutingContext, subagentRouteContext } from './hooks-runtime/subagent-context.js';
 export { loadHookPayload, normalizeHookResult };
 export { refreshOfficialSubagentCompletionArtifacts };
+export { selftestCodexCommitHooks } from './hooks-runtime/codex-commit-hooks-selftest.js';
 async function loadState(root, payload = {}) {
     const sessionKey = conversationId(payload);
     if (!explicitConversationId(payload))
@@ -863,8 +864,9 @@ async function hookStop(root, state, payload, noQuestion, sessionKey = null) {
         await refreshOfficialSubagentCompletionArtifacts(root, state, last, sessionKey).catch(() => null);
     }
     const routeDecision = await evaluateStop(root, state, payload, { noQuestion });
-    if (routeDecision)
+    if (routeDecision && !successfulAppNarutoStopNeedsVisibleSummary(state, routeDecision)) {
         return routeDecision;
+    }
     if (!noQuestion) {
         const languageBasis = state?.prompt || state?.task || extractUserPrompt(payload) || last;
         if (!hasHonestMode(last)) {
@@ -892,13 +894,23 @@ async function hookStop(root, state, payload, noQuestion, sessionKey = null) {
         }
         if (state?.honest_loop_required)
             await resolveHonestModeLoopback(root, state, sessionKey);
-        return { continue: true };
+        return routeDecision || { continue: true };
     }
     return {
         decision: 'block',
         reason: 'SKS no-question run is not done. Continue autonomously, fix failing checks, update the active gate file, and do not ask the user.'
     };
 }
+function successfulAppNarutoStopNeedsVisibleSummary(state = {}, routeDecision = {}) {
+    const route = String(state?.route || state?.route_command || state?.mode || '')
+        .replace(/^\$/, '')
+        .replace(/[-_]/g, '')
+        .toUpperCase();
+    return route === 'NARUTO'
+        && Boolean(state?.session_scope)
+        && routeDecision?.continue === true
+        && !['hard_blocked', 'route_closed'].includes(String(routeDecision?.action || ''));
+}
 async function consumeLightRouteStop(root, payload = {}) {
     const file = path.join(root, '.sneakoscope', 'state', LIGHT_ROUTE_STOP_ARTIFACT);
     const record = await readJson(file, null).catch(() => null);
@@ -982,12 +994,22 @@ function hasHonestModeUnresolvedGap(text) {
 }
 export function honestModeGapLines(text) {
     const issue = /(gap|remaining|unverified|not verified|not run|not complete|incomplete|failed|blocked|blocker|could not|couldn't|missing|미완료|미검증|미실행|실패|차단|누락|못했|못 했|안 했|안함|아직|남은)/i;
-    return String(text || '')
+    const lines = String(text || '')
         .split(/\n/)
-        .map((line) => line.trim())
-        .filter((line) => issue.test(line) && !honestGapLineResolved(line))
+        .map((line) => line.trim());
+    return lines
+        .filter((line, index) => issue.test(line)
+        && !honestGapLineResolved(line)
+        && !honestGapHeadingResolved(line, lines.slice(index + 1).find((candidate) => candidate.length > 0)))
         .slice(0, 12);
 }
+function honestGapHeadingResolved(line, nextLine) {
+    const heading = String(line || '').replace(/^#{1,6}\s*/, '').replace(/\s*[:：]\s*$/, '').trim();
+    if (!/^(?:remaining|unresolved)\s+(?:gaps?|issues?)$|^(?:남은|미해결)\s*(?:문제|항목|갭|gap)$/i.test(heading)) {
+        return false;
+    }
+    return /^(?:없음|없습니다|없다|none|no(?:ne)?|0|0개)[.!。]?$/i.test(String(nextLine || '').trim());
+}
 function honestGapLineResolved(line) {
     if (/(?:unverified|미검증)\s*:\s*\[\s*\]/i.test(line) && /blockers?\s*:\s*\[\s*\]/i.test(line))
         return true;
@@ -1003,7 +1025,9 @@ function honestGapLineResolved(line) {
         return true;
     if (/no\s+active\s+blocking\s+route\s+gate\s+detected/i.test(line))
         return true;
-    if (/(non[-\s]?blocker|non[-\s]?blocking|not\s+(?:a\s+)?blocker|no\s+blocker|does\s+not\s+block|not\s+blocking|blocker\s*(?:는|가)?\s*(?:아님|아닙니다|없음)|차단(?:하지|하진|하지는)\s*않|막(?:지|지는)\s*않)/i.test(line))
+    if (/(?:blockers?|차단(?:\s*(?:항목|요소|건))?)\s*(?:[:=]\s*)?0(?:건|개)?\b/i.test(line))
+        return true;
+    if (/(non[-\s]?blocker|non[-\s]?blocking|not\s+(?:a\s+)?blocker|no\s+blocker|does\s+not\s+block|not\s+blocking|비\s*차단|blocker\s*(?:는|가)?\s*(?:아님|아닙니다|없음)|차단(?:하지|하진|하지는)\s*않|막(?:지|지는)\s*않)/i.test(line))
         return true;
     if (/(요약\s*(?:없으면|없는\s*경우).*(?:차단|block).*(?:요약\s*(?:있으면|있는\s*경우)|통과|pass)|(?:missing|without)\s+summary.*(?:block|blocked).*(?:with\s+summary|pass|accepted))/i.test(line))
         return true;
@@ -1050,7 +1074,7 @@ async function recordHonestModeLoopback(root, state = {}, lastMessage = '', sess
     };
     const file = path.join(dir, 'honest-loopback.json');
     await writeJsonAtomic(file, artifact);
-    await appendJsonl(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'pipeline.honest_mode.loopback', previous_phase: previousPhase, phase, attempt, issues: artifact.issue_lines });
+    await appendJsonl(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'pipeline.honest_mode.loopback', proof_invalidating: false, previous_phase: previousPhase, phase, attempt, issues: artifact.issue_lines });
     await setCurrent(root, {
         phase,
         honest_loop_required: true,
@@ -1068,7 +1092,7 @@ async function resolveHonestModeLoopback(root, state = {}, sessionKey = null) {
     const id = state.mission_id;
     const mode = String(state.mode || state.route || 'SKS').toUpperCase();
     if (id)
-        await appendJsonl(path.join(missionDir(root, id), 'events.jsonl'), { ts: nowIso(), type: 'pipeline.honest_mode.loopback_resolved', previous_phase: state.phase || null });
+        await appendJsonl(path.join(missionDir(root, id), 'events.jsonl'), { ts: nowIso(), type: 'pipeline.honest_mode.loopback_resolved', proof_invalidating: false, previous_phase: state.phase || null });
     await setCurrent(root, {
         phase: `${mode}_HONEST_COMPLETE`,
         honest_loop_required: false,
@@ -1080,83 +1104,3 @@ export async function emitHook(name) {
     const result = await hookMain(name);
     process.stdout.write(`${JSON.stringify(normalizeHookResult(name, result))}\n`);
 }
-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/image-ux-review/callout-extraction.js

@@ -27,12 +27,18 @@ export function buildIssueLedgerFromGeneratedCallouts(generatedReviewLedger = {}
         blockers.push('ux_review_text_only_fallback');
     if (generated.length && !issues.length)
         blockers.push(generated.some((image) => image.callout_extraction_status === 'pending') ? 'callout_extraction_pending' : 'callout_extraction_schema_failed');
+    const primaryGenerated = generated.find((image) => image.id === existing?.generated_image_id)
+        || generated.find((image) => image.id === issues[0]?.generated_review_image_id)
+        || generated[0]
+        || null;
     return {
         schema: 'sks.image-ux-issue-ledger.v3',
         schema_version: 3,
         extraction_source: 'image-ux-generated-review-ledger.json',
         extraction_method: 'codex_exec_resume_output_schema_preferred',
         extraction_schema: 'schemas/codex/image-ux-issue-ledger.schema.json',
+        generated_image_id: primaryGenerated?.id || existing?.generated_image_id || issues[0]?.generated_review_image_id || null,
+        generated_image_sha256: primaryGenerated?.sha256 || existing?.generated_image_sha256 || issues[0]?.generated_image_sha256 || null,
         extracted_from_generated_callout: issues.length > 0,
         issues,
         blocking_issue_count: issues.filter((issue) => ['P0', 'P1'].includes(issue.severity) && !['fixed', 'accepted_not_applicable'].includes(issue.status)).length,