sneakoscope 2.0.18 → 3.0.1

package/dist/core/codex-plugins/codex-plugin-json.js

@@ -19,14 +19,18 @@ export async function runCodexPluginDetailJson(pluginId) {
     return runCodexJson(bin, ['plugin', 'detail', pluginId, '--json']);
 }
 export async function buildCodexPluginInventory() {
+    const started = Date.now();
     const capability = await detectCodex0138Capability();
     const listJson = await runCodexPluginListJson();
     const summaries = normalizePluginList(listJson);
-    const plugins = [];
-    for (const summary of summaries) {
+    const concurrency = Math.max(1, Number(process.env.SKS_CODEX_PLUGIN_DETAIL_CONCURRENCY || 6) || 6);
+    let failed = 0;
+    const plugins = await mapWithConcurrency(summaries, concurrency, async (summary) => {
         const detail = await runCodexPluginDetailJson(summary.id || summary.name).catch((err) => ({ error: err?.message || String(err) }));
-        plugins.push(normalizePlugin(summary, detail));
-    }
+        if (detail?.error || normalizeList(detail?.blockers).length > 0)
+            failed += 1;
+        return normalizePlugin(summary, detail);
+    });
     const blockers = [
         ...(capability.supports_plugin_json ? [] : ['codex_0_138_plugin_json_unavailable']),
         ...normalizeList(listJson?.blockers)
@@ -35,11 +39,29 @@ export async function buildCodexPluginInventory() {
         schema: 'sks.codex-plugin-inventory.v1',
         generated_at: nowIso(),
         codex_0138_capability: capability,
+        fetch_concurrency: concurrency,
+        detail_fetch_count: summaries.length,
+        detail_fetch_failed_count: failed,
+        duration_ms: Date.now() - started,
         plugins,
         marketplace_available: plugins.some((plugin) => plugin.source === 'marketplace' || plugin.source === 'remote') || Boolean(listJson?.marketplace_available || listJson?.marketplaceAvailable),
         blockers
     };
 }
+export async function mapWithConcurrency(items, concurrency, fn) {
+    const limit = Math.max(1, Math.floor(concurrency || 1));
+    const results = new Array(items.length);
+    let next = 0;
+    async function worker() {
+        while (next < items.length) {
+            const index = next;
+            next += 1;
+            results[index] = await fn(items[index]);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(limit, items.length || 1) }, () => worker()));
+    return results;
+}
 export async function writeCodexPluginInventoryArtifacts(root, inventory = null) {
     const report = inventory || await buildCodexPluginInventory();
     const artifact = path.join(root, '.sneakoscope', 'codex-plugin-inventory.json');
@@ -126,15 +148,17 @@ function boolish(value, fallback = false) {
     return fallback;
 }
 function fakePluginList() {
+    const count = Math.max(1, Number(process.env.SKS_CODEX_PLUGIN_JSON_FAKE_COUNT || 1) || 1);
     return {
         marketplace_available: true,
-        plugins: [{
-                id: 'fixture-plugin',
-                name: 'Fixture Plugin',
-                source: 'marketplace',
-                installed: true,
-                enabled: true
-            }]
+        plugins: Array.from({ length: count }, (_, index) => ({
+            id: 'fixture-plugin',
+            name: index === 0 ? 'Fixture Plugin' : `Fixture Plugin ${index + 1}`,
+            ...(index === 0 ? {} : { id: `fixture-plugin-${index + 1}` }),
+            source: 'marketplace',
+            installed: true,
+            enabled: true
+        }))
     };
 }
 function fakePluginDetail(pluginId) {

package/dist/core/commands/mad-sks-command.js

@@ -21,6 +21,7 @@ import { diffCodexAppUiSnapshots, writeCodexAppUiSnapshot } from '../codex-app/c
 import { checkSksUpdateNotice } from '../update/update-notice.js';
 import { createMadDbCapability, MAD_DB_ACK } from '../mad-db/mad-db-capability.js';
 import { writeCodex0138CapabilityArtifacts } from '../codex-control/codex-0138-capability.js';
+import { writeCodex0139CapabilityArtifacts } from '../codex-control/codex-0139-capability.js';
 export async function madHighCommand(args = [], deps = {}) {
     const subcommand = firstSubcommand(args);
     if (subcommand)
@@ -37,6 +38,10 @@ export async function madHighCommand(args = [], deps = {}) {
         process.exitCode = 1;
         return;
     }
+    // Zellij is checked the same way Codex is, but it stays NON-blocking: a
+    // failed or skipped zellij upgrade never prevents the MAD launch.
+    const zellijUpdate = deps.maybePromptZellijUpdateForLaunch ? await deps.maybePromptZellijUpdateForLaunch(args, { label: 'MAD launch' }).catch(() => ({ status: 'error' })) : { status: 'skipped' };
+    void zellijUpdate;
     const depStatus = deps.ensureMadLaunchDependencies ? await deps.ensureMadLaunchDependencies(args) : { ready: true, actions: [] };
     if (!depStatus.ready) {
         console.error('SKS MAD launch blocked by missing dependencies.');
@@ -381,6 +386,7 @@ async function activateMadZellijPermissionState(cwd = process.cwd(), args = [])
     const dbWriteAllowed = has('db_write');
     const { id, dir } = await createMission(root, { mode: 'mad-sks', prompt: 'sks --mad Zellij scoped high-power maintenance session' });
     await writeCodex0138CapabilityArtifacts(root, { missionId: id }).catch(() => null);
+    await writeCodex0139CapabilityArtifacts(root, { missionId: id }).catch(() => null);
     const protectedCore = resolveProtectedCore({ packageRoot: packageRoot(), targetRoot: cwd });
     // The interactive launch 'before' snapshot is only persisted (env + policy json)
     // and is never compared against an 'after' snapshot during the session, so the
@@ -567,6 +573,7 @@ function codexLbImmediateLaunchOpts(args = [], lb = {}, opts = {}) {
 export async function madSksFixture(root) {
     const { id, dir } = await createMission(root, { mode: 'mad-sks', prompt: '$MAD-SKS fixture permission gate' });
     await writeCodex0138CapabilityArtifacts(root, { missionId: id }).catch(() => null);
+    await writeCodex0139CapabilityArtifacts(root, { missionId: id }).catch(() => null);
     const gate = { schema_version: 1, passed: true, mad_sks_permission_active: true, permissions_deactivated: true, catastrophic_safety_guard_active: true, permission_profile: permissionGateSummary(), fixture: true };
     await writeJsonAtomic(path.join(dir, 'mad-sks-gate.json'), gate);
     return { mission_id: id, dir, gate };
@@ -742,6 +749,7 @@ async function materializeMadSksRun(root, targetRoot, permission, userIntent, js
         await initProject(root, {});
     const { id, dir } = await createMission(root, { mode: 'mad-sks', prompt: userIntent });
     await writeCodex0138CapabilityArtifacts(root, { missionId: id }).catch(() => null);
+    await writeCodex0139CapabilityArtifacts(root, { missionId: id }).catch(() => null);
     const before = await snapshotProtectedCore(packageRoot(), 'before');
     const authorization = opts.authorizationManifest || createMadSksAuthorizationManifest({ permission, userIntent });
     const authorizationPath = opts.authorizationManifestPath || path.join(dir, 'mad-sks-authorization.json');

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

@@ -7,6 +7,7 @@ import { buildNarutoCloneRoster, systemSafeNarutoConcurrency } from '../agents/a
 import { DEFAULT_NARUTO_CLONES, MAX_NARUTO_AGENT_COUNT } from '../agents/agent-schema.js';
 import { resolveOllamaWorkerConfig } from '../agents/ollama-worker-config.js';
 import { attachZellijSessionInteractive, launchZellijLayout } from '../zellij/zellij-launcher.js';
+import { maybePromptZellijUpdateForLaunch } from '../zellij/zellij-update.js';
 import { buildNarutoWorkGraph } from '../naruto/naruto-work-graph.js';
 import { buildNarutoRoleDistribution } from '../naruto/naruto-role-policy.js';
 import { decideNarutoConcurrency } from '../naruto/naruto-concurrency-governor.js';
@@ -15,12 +16,14 @@ import { collectActualNarutoWorker, spawnActualNarutoWorker } from '../naruto/na
 import { allocateNarutoTasksToWorkers } from '../naruto/naruto-allocation-policy.js';
 import { rebalanceNarutoReadyWork } from '../naruto/naruto-rebalance-policy.js';
 import { buildNarutoVerificationDag } from '../naruto/naruto-verification-dag.js';
+import { evaluateNarutoFinalizer } from '../naruto/naruto-finalizer.js';
 import { buildNarutoGptFinalPack } from '../naruto/naruto-gpt-final-pack.js';
 import { planNarutoZellijDashboard } from '../zellij/zellij-naruto-dashboard.js';
 import { checkPromptPlaceholders } from '../prompt/prompt-placeholder-guard.js';
 import { evaluateGitWorktreeCapability } from '../git/git-worktree-capability.js';
 import { buildRuntimeProofSummary, renderRuntimeProofSummary } from '../agents/runtime-proof-summary.js';
 import { writeCodex0138CapabilityArtifacts } from '../codex-control/codex-0138-capability.js';
+import { writeCodex0139CapabilityArtifacts } from '../codex-control/codex-0139-capability.js';
 const NARUTO_RESULT_SCHEMA = 'sks.naruto-command-result.v1';
 const NARUTO_ROUTE = '$Naruto';
 // $Naruto — Shadow Clone Swarm (影分身 / Kage Bunshin no Jutsu).
@@ -41,6 +44,12 @@ export async function narutoCommand(commandOrArgs = 'naruto', maybeArgs = []) {
         return narutoWorkers(parsed);
     if (parsed.action === 'proof')
         return narutoProof(parsed);
+    // Like the Codex CLI update prompt: check the installed zellij version and
+    // offer an upgrade to the latest stable release before the live session
+    // opens. Never blocks the run.
+    if (!parsed.json && !parsed.mock && !parsed.noOpenZellij) {
+        await maybePromptZellijUpdateForLaunch(args, { label: '$Naruto launch' }).catch(() => undefined);
+    }
     return narutoRun(parsed);
 }
 async function narutoRun(parsed) {
@@ -75,6 +84,7 @@ async function narutoRun(parsed) {
     });
     const mission = await createMission(root, { mode: 'naruto', prompt: parsed.prompt });
     await writeCodex0138CapabilityArtifacts(root, { missionId: mission.id }).catch(() => null);
+    await writeCodex0139CapabilityArtifacts(root, { missionId: mission.id }).catch(() => null);
     const gitWorktreeCapability = writeCapable
         ? await evaluateGitWorktreeCapability({ root, missionId: mission.id })
         : null;
@@ -299,6 +309,10 @@ async function narutoRun(parsed) {
         console.log('  parallelism mode: ' + parsed.parallelism);
         if (activeSlots < roster.agent_count)
             console.log('  cap reasons: ' + (governor.reasons.join(', ') || 'host safety cap'));
+        // Backpressure used to throttle silently (50% when throttled, 25% when
+        // saturated); always tell the operator when host pressure reduced workers.
+        if (governor.backpressure !== 'normal')
+            console.log('  backpressure: ' + governor.backpressure + ' — host resource pressure reduced active workers (memory/cpu/fd/disk thresholds)');
         if (parsed.parallelism !== 'safe' && activeSlots < 10)
             console.log('  warning: active workers below 10 in non-safe mode');
     }
@@ -418,6 +432,18 @@ async function narutoRun(parsed) {
     });
     const clones = result.roster?.agent_count ?? roster.agent_count;
     const localWorkerSummary = summarizeNarutoLocalWorkerResult(localWorker, result);
+    // Finalizer policy: when local LLM workers contributed patches, the GPT
+    // final arbiter must have accepted before patches are considered final.
+    const finalizer = evaluateNarutoFinalizer({
+        localParticipated: Number(localWorkerSummary?.selected_worker_count || 0) > 0,
+        gptFinalStatus: result.proof?.gpt_final_status || null,
+        applyPatches: writeCapable
+    });
+    await writeJsonAtomic(path.join(mission.dir, 'naruto-finalizer.json'), {
+        ...finalizer,
+        generated_at: nowIso(),
+        mission_id: mission.id
+    });
     const summary = {
         schema: NARUTO_RESULT_SCHEMA,
         ok: result.ok === true,
@@ -477,6 +503,7 @@ async function narutoRun(parsed) {
             passed: parallelRuntime.passed
         } : null,
         local_worker: localWorkerSummary,
+        finalizer,
         proof: result.proof?.status || 'missing',
         run: compactNarutoRunResult(result),
         zellij: null
@@ -489,6 +516,8 @@ async function narutoRun(parsed) {
         console.log('Backend: ' + result.backend);
         console.log('Roles: ' + roleDistribution.entries.map((entry) => `${entry.role}:${entry.count}`).join(', '));
         console.log('Proof: ' + summary.proof);
+        if (!finalizer.ok)
+            console.log('Finalizer: blocked — ' + finalizer.blockers.join(', '));
         if (summary.parallel_runtime) {
             console.log('$Naruto parallel proof:');
             console.log('  max active workers: ' + summary.parallel_runtime.max_observed_active_workers);

package/dist/core/commands/qa-loop-command.js

@@ -17,11 +17,13 @@ import { runCodexAppHandoff, qaLoopShouldRequestAppHandoff } from '../codex-app/
 import { writeCodex0138CapabilityArtifacts } from '../codex-control/codex-0138-capability.js';
 import { writeCodexAccountUsageArtifacts } from '../usage/codex-account-usage.js';
 import { buildQaLoopBudgetPolicy, selectQaLoopEscalatedEffort } from '../qa-loop/qa-loop-budget-policy.js';
+import { writeCodexModelEffortCapabilityArtifact } from '../codex-control/codex-model-capabilities.js';
 import { discoverImageArtifactsInDir, writeImageArtifactPathContract } from '../image/image-artifact-path-contract.js';
 import { pluginAppTemplatePolicy } from '../codex-plugins/codex-plugin-json.js';
+import { confirmQaLoopAppHandoff } from '../qa-loop/qa-loop-app-handoff-confirmation.js';
 import fsp from 'node:fs/promises';
 export async function qaLoopCommand(sub, args = []) {
-    const known = new Set(['prepare', 'answer', 'run', 'status', 'help', '--help', '-h']);
+    const known = new Set(['prepare', 'answer', 'run', 'status', 'app-confirm', 'help', '--help', '-h']);
     const action = known.has(sub) ? sub : 'prepare';
     const actionArgs = action === 'prepare' && sub && !known.has(sub) ? [sub, ...args] : args;
     if (action === 'prepare')
@@ -32,12 +34,15 @@ export async function qaLoopCommand(sub, args = []) {
         return qaLoopRun(actionArgs);
     if (action === 'status')
         return qaLoopStatus(actionArgs);
+    if (action === 'app-confirm')
+        return qaLoopAppConfirm(actionArgs);
     console.log(`SKS QA-LOOP
 
 Usage:
   sks qa-loop prepare "target"
   sks qa-loop answer <mission-id|latest> <answers.json>
-  sks qa-loop run <mission-id|latest> [--mock] [--max-cycles N] [--app-handoff] [--app-handoff-required]
+  sks qa-loop run <mission-id|latest> [--mock] [--max-cycles N] [--app-handoff] [--app-handoff-required] [--app-handoff-launch] [--app-handoff-artifact-only]
+  sks qa-loop app-confirm <mission-id|latest> --verdict pass|fail --notes "..."
   sks qa-loop status <mission-id|latest> [--desktop]
 `);
 }
@@ -146,9 +151,11 @@ async function qaLoopRun(args) {
     const usageArtifact = await writeCodexAccountUsageArtifacts(root, { missionId: id }).catch((err) => ({ error: err?.message || String(err), snapshot: null }));
     const budgetPolicy = buildQaLoopBudgetPolicy({ usage: usageArtifact?.snapshot || null, provider: 'codex-sdk' });
     await writeJsonAtomic(path.join(dir, 'qa-loop', 'qa-loop-budget-policy.json'), budgetPolicy);
+    const effortCapabilityArtifact = await writeCodexModelEffortCapabilityArtifact(root, { missionId: id }).catch((err) => ({ error: err?.message || String(err), capability: null }));
     const effortEscalation = selectQaLoopEscalatedEffort({
         failureCount: Number(qaGate.safe_fix_attempts || qaGate.failure_count || 0),
-        currentEffort: String(profile || 'high').replace(/^sks-(?:logic|agent)-/, '').replace(/-fast$/, '') || 'high'
+        currentEffort: String(profile || 'high').replace(/^sks-(?:logic|agent)-/, '').replace(/-fast$/, '') || 'high',
+        capability: effortCapabilityArtifact?.capability || undefined
     });
     await writeJsonAtomic(path.join(dir, 'qa-loop', 'qa-loop-effort-escalation.json'), effortEscalation);
     const discoveredImages = await discoverImageArtifactsInDir(dir).catch(() => []);
@@ -158,6 +165,9 @@ async function qaLoopRun(args) {
     const pluginInventory = await readJson(path.join(root, '.sneakoscope', 'codex-plugin-inventory.json'), null);
     const pluginPolicy = pluginInventory?.schema === 'sks.codex-plugin-inventory.v1' ? pluginAppTemplatePolicy(pluginInventory) : null;
     const appHandoffRequired = flag(args, '--app-handoff-required') || process.env.SKS_QA_LOOP_APP_HANDOFF_REQUIRED === '1';
+    const launchMode = flag(args, '--app-handoff-launch') || process.env.SKS_QA_LOOP_APP_HANDOFF_LAUNCH === '1'
+        ? 'attempt-launch'
+        : 'artifact-only';
     const appHandoffRequested = qaLoopShouldRequestAppHandoff({
         args,
         uiRequired,
@@ -183,13 +193,15 @@ async function qaLoopRun(args) {
             ].filter(Boolean),
             prompt: mission.prompt || 'QA-LOOP desktop handoff',
             require_desktop: appHandoffRequired,
-            capability_required: 'codex-0.138'
+            capability_required: 'codex-0.138',
+            launch_mode: flag(args, '--app-handoff-artifact-only') ? 'artifact-only' : launchMode
         }).catch((err) => ({
             ok: false,
             status: 'blocked_for_desktop_review',
             artifact_path: path.join(dir, 'qa-loop', 'app-handoff.json'),
             blockers: [`codex_app_handoff_failed:${err?.message || String(err)}`],
-            desktop_handoff_supported: false
+            desktop_handoff_supported: false,
+            launch_attempt: null
         }))
         : null;
     if (appHandoff || imagePathContract) {
@@ -200,6 +212,9 @@ async function qaLoopRun(args) {
             desktop_app_handoff_status: appHandoff ? appHandoff.status : 'not_requested',
             desktop_app_handoff_artifact: appHandoff ? path.relative(dir, appHandoff.artifact_path) : null,
             desktop_app_handoff_supported: appHandoff ? appHandoff.desktop_handoff_supported === true : false,
+            desktop_app_handoff_confirmed: latestGate.desktop_app_handoff_confirmed === true,
+            desktop_app_handoff_verdict: latestGate.desktop_app_handoff_verdict || null,
+            desktop_app_handoff_launch_attempt: appHandoff ? appHandoff.launch_attempt || null : null,
             desktop_app_handoff_is_web_ui_evidence: false,
             image_artifact_path_contract_present: Boolean(imagePathContract),
             image_artifact_path_contract_artifact: imagePathContract ? 'qa-loop/image-artifact-path-contract.json' : null,
@@ -207,6 +222,7 @@ async function qaLoopRun(args) {
             blockers: Array.from(new Set([
                 ...(latestGate.blockers || []),
                 ...(appHandoffRequired && appHandoff && appHandoff.ok !== true ? ['blocked_for_desktop_review'] : []),
+                ...(appHandoffRequired && latestGate.desktop_app_handoff_confirmed !== true ? ['desktop_app_handoff_confirmation_missing'] : []),
                 ...(imagePathContract?.contract?.blockers || [])
             ])),
             notes: [
@@ -367,8 +383,10 @@ async function qaLoopStatus(args) {
     const nativeAgentPlan = await readJson(path.join(dir, 'qa-agent-plan.json'), null);
     const agentSessions = await readJson(path.join(dir, 'agents', 'agent-sessions.json'), null);
     const desktop = await readJson(path.join(dir, 'qa-loop', 'app-handoff.json'), null);
+    const desktopConfirmation = await readJson(path.join(dir, 'qa-loop', 'app-handoff-confirmation.json'), null);
+    const desktopReviewComplete = desktopConfirmation?.verdict === 'pass';
     if (flag(args, '--json'))
-        return console.log(JSON.stringify({ mission, state, qa: status, desktop_app_handoff: desktop, native_agent_plan: nativeAgentPlan, agent_sessions: agentSessions?.sessions || null }, null, 2));
+        return console.log(JSON.stringify({ mission, state, qa: status, desktop_app_handoff: desktop, desktop_app_confirmation: desktopConfirmation, desktop_review_complete: desktopReviewComplete, native_agent_plan: nativeAgentPlan, agent_sessions: agentSessions?.sessions || null }, null, 2));
     console.log('SKS QA-LOOP Status\n');
     console.log(`Mission:   ${id}`);
     console.log(`Phase:     ${state.phase || mission.phase}`);
@@ -380,11 +398,28 @@ async function qaLoopStatus(args) {
     if (flag(args, '--desktop')) {
         console.log('Desktop:');
         console.log(`  /app handoff: ${desktop?.status || 'not_requested'}`);
+        console.log(`  launch:       ${desktop?.launch_attempt?.attempted ? desktop?.launch_attempt?.launched ? 'launched' : 'attempted_fallback' : 'not_attempted'}`);
+        console.log(`  confirmation: ${desktopConfirmation?.verdict || 'missing'}`);
+        console.log(`  complete:     ${desktopReviewComplete ? 'yes' : 'no'}`);
         if (desktop?.operator_instruction?.prompt_artifact)
             console.log(`  prompt:       ${desktop.operator_instruction.prompt_artifact}`);
         console.log('  web evidence: not a substitute for Codex Chrome Extension web UI verification');
     }
 }
+async function qaLoopAppConfirm(args) {
+    const root = await sksRoot();
+    const id = await resolveMissionId(root, args[0]);
+    const verdict = String(readFlagValue(args, '--verdict', '') || '').trim();
+    const notes = String(readFlagValue(args, '--notes', '') || '');
+    if (!id || !['pass', 'fail'].includes(verdict))
+        throw new Error('Usage: sks qa-loop app-confirm <mission-id|latest> --verdict pass|fail --notes "..."');
+    const result = await confirmQaLoopAppHandoff(root, { missionId: id, verdict: verdict, notes });
+    const evaluated = await evaluateQaGate(path.join(root, '.sneakoscope', 'missions', id));
+    if (flag(args, '--json'))
+        return console.log(JSON.stringify({ schema: 'sks.qa-loop-app-confirm.v1', ok: verdict === 'pass', mission_id: id, confirmation: result.confirmation, artifact_path: result.artifact_path, gate: result.gate, evaluated }, null, 2));
+    console.log(`QA-LOOP Desktop app handoff confirmation recorded: ${id} (${verdict})`);
+    console.log(path.relative(root, result.artifact_path));
+}
 async function writeQaLoopImagePathContract(root, dir, missionId, images) {
     const primary = await writeImageArtifactPathContract(root, {
         missionId,

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '2.0.18';
+export const PACKAGE_VERSION = '3.0.1';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/image/image-artifact-path-contract.js

@@ -16,6 +16,8 @@ export async function buildImageArtifactPathContract(root, input) {
             kind: image.kind,
             file_path: filePath,
             relative_path: path.relative(root, filePath),
+            route: image.route || null,
+            stage: image.stage || null,
             exists,
             mime_type: mimeForPath(filePath),
             width: dims?.width ?? null,

package/dist/core/image/image-artifact-registry.js

@@ -0,0 +1,33 @@
+import path from 'node:path';
+import { readJson, writeJsonAtomic } from '../fsx.js';
+import { buildImageArtifactPathContract } from './image-artifact-path-contract.js';
+export async function registerImageArtifact(root, input) {
+    const artifactPath = imageArtifactRegistryPath(root, input.missionId);
+    const existing = await readJson(artifactPath, null);
+    const id = input.id || path.basename(input.filePath).replace(/[^0-9A-Za-z._-]/g, '_');
+    const rows = [
+        ...(existing?.images || [])
+            .filter((image) => image.id !== id)
+            .map((image) => ({
+            id: image.id,
+            kind: image.kind,
+            filePath: image.file_path,
+            route: image.route || null,
+            stage: image.stage || null
+        })),
+        {
+            id,
+            kind: input.kind,
+            filePath: input.filePath,
+            route: input.route,
+            stage: input.stage
+        }
+    ];
+    const contract = await buildImageArtifactPathContract(root, { missionId: input.missionId, images: rows });
+    await writeJsonAtomic(artifactPath, contract);
+    return contract;
+}
+export function imageArtifactRegistryPath(root, missionId) {
+    return path.join(root, '.sneakoscope', 'missions', missionId, 'image-artifact-path-contract.json');
+}
+//# sourceMappingURL=image-artifact-registry.js.map

package/dist/core/image-ux-review/imagegen-adapter.js

@@ -1,13 +1,14 @@
 import path from 'node:path';
 import fsp from 'node:fs/promises';
 import { parseShellEnvValue } from '../codex-lb/codex-lb-env.js';
-import { ensureDir, exists, nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
+import { ensureDir, exists, nowIso, projectRoot, readJson, readText, writeJsonAtomic } from '../fsx.js';
 import { sha256File, imageDimensions } from '../wiki-image/image-hash.js';
 import { detectImagegenCapability } from '../imagegen/imagegen-capability.js';
 import { validateGptImage2Request } from '../imagegen/gpt-image-2-request-validator.js';
 import { withResponsesRetry } from '../responses-retry-policy.js';
 import { discoverCodexAppGeneratedImage } from './codex-app-generated-image-discovery.js';
 import { writeImageArtifactPathContract } from '../image/image-artifact-path-contract.js';
+import { registerImageArtifact } from '../image/image-artifact-registry.js';
 const DEFAULT_OPENAI_IMAGE_EDITS_ENDPOINT = 'https://api.openai.com/v1/images/edits';
 export function buildCalloutPrompt(sourceScreenId, context = {}) {
     return [
@@ -479,16 +480,36 @@ export function createOpenAIImagesApiAdapter(opts = {}) {
     };
 }
 async function writeGeneratedImagePathContract(input, outputPath, provider) {
-    return writeImageArtifactPathContract(process.cwd(), {
+    const root = await resolveImageArtifactRoot(input);
+    if (input.mission_id) {
+        await registerImageArtifact(root, {
+            missionId: input.mission_id,
+            id: `${provider}-${input.source_screen_id || 'screen'}`,
+            kind: 'generated_image',
+            filePath: outputPath,
+            route: '$Image-UX-Review',
+            stage: provider
+        });
+    }
+    return writeImageArtifactPathContract(root, {
         missionId: input.mission_id || 'unassigned',
         images: [{
                 id: `${provider}-${input.source_screen_id || 'screen'}`,
                 kind: 'generated_image',
-                filePath: outputPath
+                filePath: outputPath,
+                route: '$Image-UX-Review',
+                stage: provider
             }],
         artifactPath: path.join(input.output_dir, 'image-artifact-path-contract.json')
     });
 }
+async function resolveImageArtifactRoot(input) {
+    const cwdRoot = await projectRoot(process.cwd()).catch(() => process.cwd());
+    const resolvedCwd = path.resolve(process.cwd());
+    if (path.resolve(cwdRoot) !== resolvedCwd)
+        return cwdRoot;
+    return projectRoot(input.output_dir || process.cwd()).catch(() => cwdRoot);
+}
 export async function generateGptImage2CalloutReview(input, opts = {}) {
     if (opts.fake === true || process.env.SKS_TEST_FAKE_IMAGEGEN === '1') {
         return createFakeImagegenAdapter(opts.fakeAdapter || {}).generateCalloutReview(input);
@@ -500,21 +521,11 @@ export async function generateGptImage2CalloutReview(input, opts = {}) {
     // allowApiFallback:false or SKS_IMAGEGEN_ALLOW_API_FALLBACK=0.
     const openAiKeyPresent = Boolean(opts.openai?.apiKey || process.env.OPENAI_API_KEY);
     const explicitDisableApiFallback = opts.allowApiFallback === false || process.env.SKS_IMAGEGEN_ALLOW_API_FALLBACK === '0';
-    // codex-lb imagegen routes gpt-image-2 through the same Codex /responses
-    // backend the LB already proxies (base_url ends in /backend-api/codex, so the
-    // image_generation tool call is just another Responses request). When codex-lb
-    // is the active, fully-configured auth (selected provider + key + base_url) and
-    // there is no direct OPENAI_API_KEY, enable it BY DEFAULT so image generation
-    // works for users authenticated only through codex-lb — that is the common case
-    // and a hard block here is the bug the user hit. It still never overrides a real
-    // OpenAI key, and SKS_IMAGEGEN_ALLOW_CODEX_LB_API_FALLBACK=0 (or
-    // allowCodexLbApiFallback:false) opts out for callers that require Codex App
-    // built-in evidence only.
-    const codexLbAuthActive = capability?.codex_lb?.available === true;
+    // codex-lb imagegen is a direct API fallback, not Codex App imagegen evidence.
+    // It must be explicitly enabled by the caller or environment.
     const explicitDisableCodexLbFallback = opts.allowCodexLbApiFallback === false || process.env.SKS_IMAGEGEN_ALLOW_CODEX_LB_API_FALLBACK === '0';
     const allowCodexLbApiFallback = !explicitDisableCodexLbFallback && (opts.allowCodexLbApiFallback === true
-        || process.env.SKS_IMAGEGEN_ALLOW_CODEX_LB_API_FALLBACK === '1'
-        || (codexLbAuthActive && !openAiKeyPresent));
+        || process.env.SKS_IMAGEGEN_ALLOW_CODEX_LB_API_FALLBACK === '1');
     const allowApiFallback = !explicitDisableApiFallback && (opts.allowApiFallback === true
         || process.env.SKS_IMAGEGEN_ALLOW_API_FALLBACK === '1'
         || openAiKeyPresent

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

@@ -1249,13 +1249,15 @@ function subagentToolName(payload) {
 }
 function subagentStage(payload) {
     const hay = JSON.stringify(payload || {});
-    if (!/(spawn_agent|send_input|wait_agent|close_agent|subagent|worker|explorer)/i.test(hay))
+    // Codex 0.139 renamed multi-agent v2 `close_agent` to `interrupt_agent`;
+    // accept both so cockpit evidence keeps classifying on newer CLIs.
+    if (!/(spawn_agent|send_input|wait_agent|close_agent|interrupt_agent|subagent|worker|explorer)/i.test(hay))
         return null;
     if (/subagent[_ -]?unavailable|subagents unavailable|unsafe to split|unsplittable|cannot safely split/i.test(hay))
         return 'exception';
     if (/spawn_agent/i.test(hay))
         return 'spawn_agent';
-    if (/wait_agent|close_agent|completed|final/i.test(hay))
+    if (/wait_agent|close_agent|interrupt_agent|completed|final/i.test(hay))
         return 'result';
     return 'subagent';
 }

package/dist/core/qa-loop/qa-loop-app-handoff-confirmation.js

@@ -0,0 +1,51 @@
+import path from 'node:path';
+import { nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+export async function confirmQaLoopAppHandoff(root, input) {
+    const missionDir = path.join(root, '.sneakoscope', 'missions', input.missionId);
+    const qaLoopDir = path.join(missionDir, 'qa-loop');
+    const handoffArtifact = path.join(qaLoopDir, 'app-handoff.json');
+    const confirmationArtifact = path.join(qaLoopDir, 'app-handoff-confirmation.json');
+    const handoff = await readJson(handoffArtifact, null);
+    if (handoff?.schema !== 'sks.codex-app-handoff-result.v1') {
+        throw new Error(`Cannot confirm Desktop app handoff before app-handoff.json exists for mission ${input.missionId}`);
+    }
+    if (input.verdict === 'pass' && handoff.status === 'blocked_for_desktop_review') {
+        throw new Error(`Cannot pass-confirm blocked Desktop app handoff for mission ${input.missionId}`);
+    }
+    const confirmation = {
+        schema: 'sks.qa-loop-app-handoff-confirmation.v1',
+        mission_id: input.missionId,
+        confirmed_at: nowIso(),
+        verdict: input.verdict,
+        notes: String(input.notes || ''),
+        operator: input.operator || process.env.USER || null,
+        related_handoff_artifact: path.relative(missionDir, handoffArtifact).split(path.sep).join('/')
+    };
+    await writeJsonAtomic(confirmationArtifact, confirmation);
+    const gatePath = path.join(missionDir, 'qa-gate.json');
+    const previousGate = await readJson(gatePath, {});
+    const previousBlockers = Array.isArray(previousGate.blockers) ? previousGate.blockers : [];
+    const failedBlocker = 'desktop_app_handoff_failed';
+    const blockers = input.verdict === 'pass'
+        ? previousBlockers.filter((blocker) => blocker !== failedBlocker && blocker !== 'desktop_app_handoff_confirmation_missing')
+        : Array.from(new Set([...previousBlockers, failedBlocker]));
+    const gate = {
+        ...previousGate,
+        desktop_app_handoff_required: previousGate.desktop_app_handoff_required === true,
+        desktop_app_handoff_status: input.verdict === 'pass' ? 'completed' : previousGate.desktop_app_handoff_status || 'pending',
+        desktop_app_handoff_confirmed: input.verdict === 'pass',
+        desktop_app_handoff_verdict: input.verdict,
+        desktop_app_handoff_confirmation_artifact: path.relative(missionDir, confirmationArtifact).split(path.sep).join('/'),
+        desktop_app_handoff_confirmation_notes: confirmation.notes,
+        blockers,
+        notes: Array.from(new Set([
+            ...(Array.isArray(previousGate.notes) ? previousGate.notes : []),
+            input.verdict === 'pass'
+                ? 'Codex Desktop /app review was explicitly confirmed by operator artifact.'
+                : 'Codex Desktop /app review failed and remains a QA blocker.'
+        ]))
+    };
+    await writeJsonAtomic(gatePath, gate);
+    return { confirmation, artifact_path: confirmationArtifact, gate };
+}
+//# sourceMappingURL=qa-loop-app-handoff-confirmation.js.map

package/dist/core/qa-loop/qa-loop-budget-policy.js

@@ -9,7 +9,7 @@ export function buildQaLoopBudgetPolicy(input = {}) {
     const baseBudget = defaultModelCallBudget(String(input.provider || 'codex-sdk'));
     return {
         schema: 'sks.qa-loop-budget-policy.v1',
-        ok: true,
+        ok: available,
         account_usage_source: usage?.source || 'unavailable',
         token_usage_available: available,
         near_limit: nearLimit,

package/dist/core/qa-loop.js

@@ -313,6 +313,9 @@ export function defaultQaGate(contract = {}, opts = {}) {
         desktop_app_handoff_status: 'not_requested',
         desktop_app_handoff_artifact: null,
         desktop_app_handoff_supported: false,
+        desktop_app_handoff_confirmed: false,
+        desktop_app_handoff_verdict: null,
+        desktop_app_handoff_confirmation_artifact: null,
         desktop_app_handoff_is_web_ui_evidence: false,
         image_artifact_path_contract_present: false,
         image_artifact_path_contract_artifact: null,
@@ -383,8 +386,14 @@ export async function evaluateQaGate(dir) {
             reasons.push('computer_use_web_evidence_forbidden');
     }
     if (gate.desktop_app_handoff_required === true) {
-        if (gate.desktop_app_handoff_status !== 'pending' && gate.desktop_app_handoff_status !== 'completed')
+        if (!['pending', 'launched_pending_confirmation', 'completed'].includes(String(gate.desktop_app_handoff_status || '')))
             reasons.push('desktop_app_handoff_missing');
+        if (gate.desktop_app_handoff_confirmed !== true)
+            reasons.push('desktop_app_handoff_confirmation_missing');
+        if (gate.desktop_app_handoff_verdict !== 'pass')
+            reasons.push('desktop_app_handoff_verdict_not_pass');
+        if (gate.desktop_app_handoff_status !== 'completed')
+            reasons.push('desktop_app_handoff_not_completed');
         if (gate.desktop_app_handoff_is_web_ui_evidence === true)
             reasons.push('desktop_app_handoff_misused_as_web_evidence');
     }
@@ -410,7 +419,38 @@ export async function writeMockQaResult(dir, mission, contract) {
     const reportFile = isQaReportFilename(previousReportFile) ? previousReportFile : qaReportFilename();
     const uiRequired = qaUiRequired(contract.answers || {});
     await writeTextAtomic(path.join(dir, reportFile), `# QA-LOOP Report\n\nMission: ${mission.id}\nMode: mock verification\n\nMock QA-LOOP completed. No live UI/API actions were executed.\n\n## Honest Mode\n\nThis is a mock smoke run for command verification, not production QA evidence.\n`);
-    await writeJsonAtomic(path.join(dir, 'qa-gate.json'), { ...defaultQaGate(contract, { reportFile }), passed: !uiRequired, qa_report_written: true, qa_ledger_complete: true, checklist_completed: true, safety_reviewed: true, credentials_not_persisted: true, chrome_extension_preflight_passed: !uiRequired, ui_chrome_extension_evidence: !uiRequired, ui_computer_use_evidence: false, ui_evidence_source: uiRequired ? null : 'not_required', unresolved_findings: 0, unresolved_fixable_findings: 0, unsafe_or_deferred_findings: 0, post_fix_verification_complete: true, honest_mode_complete: true, evidence: ['mock QA-LOOP smoke completed'], notes: ['No live UI/API verification was claimed.'] });
+    await writeJsonAtomic(path.join(dir, 'qa-gate.json'), {
+        ...defaultQaGate(contract, { reportFile }),
+        desktop_app_handoff_required: previousGate.desktop_app_handoff_required === true,
+        desktop_app_handoff_status: previousGate.desktop_app_handoff_status || 'not_requested',
+        desktop_app_handoff_artifact: previousGate.desktop_app_handoff_artifact || null,
+        desktop_app_handoff_supported: previousGate.desktop_app_handoff_supported === true,
+        desktop_app_handoff_confirmed: previousGate.desktop_app_handoff_confirmed === true,
+        desktop_app_handoff_verdict: previousGate.desktop_app_handoff_verdict || null,
+        desktop_app_handoff_confirmation_artifact: previousGate.desktop_app_handoff_confirmation_artifact || null,
+        desktop_app_handoff_is_web_ui_evidence: false,
+        image_artifact_path_contract_present: previousGate.image_artifact_path_contract_present === true,
+        image_artifact_path_contract_artifact: previousGate.image_artifact_path_contract_artifact || null,
+        image_artifact_path_contract_blockers: previousGate.image_artifact_path_contract_blockers || [],
+        blockers: previousGate.blockers || [],
+        passed: !uiRequired,
+        qa_report_written: true,
+        qa_ledger_complete: true,
+        checklist_completed: true,
+        safety_reviewed: true,
+        credentials_not_persisted: true,
+        chrome_extension_preflight_passed: !uiRequired,
+        ui_chrome_extension_evidence: !uiRequired,
+        ui_computer_use_evidence: false,
+        ui_evidence_source: uiRequired ? null : 'not_required',
+        unresolved_findings: 0,
+        unresolved_fixable_findings: 0,
+        unsafe_or_deferred_findings: 0,
+        post_fix_verification_complete: true,
+        honest_mode_complete: true,
+        evidence: ['mock QA-LOOP smoke completed'],
+        notes: ['No live UI/API verification was claimed.']
+    });
     return evaluateQaGate(dir);
 }
 export function buildQaLoopPrompt({ id, mission, contract, cycle, previous, reportFile, imagePathContract, appHandoff }) {
@@ -442,10 +482,11 @@ export async function qaStatus(dir) {
     const gate = await readJson(path.join(dir, 'qa-gate.evaluated.json'), await readJson(path.join(dir, 'qa-gate.json'), null));
     const ledger = await readJson(path.join(dir, 'qa-ledger.json'), null);
     const appHandoff = await readJson(path.join(dir, 'qa-loop', 'app-handoff.json'), null);
+    const appConfirmation = await readJson(path.join(dir, 'qa-loop', 'app-handoff-confirmation.json'), null);
     const imagePathContract = await readJson(path.join(dir, 'qa-loop', 'image-artifact-path-contract.json'), null);
     const reportFile = qaReportFileFromGate(gate?.gate || gate || {}) || ledger?.qa_report_file || null;
     const report = reportFile && isQaReportFilename(reportFile) ? await readText(path.join(dir, reportFile), '') : '';
-    return { gate, checklist_count: ledger?.checklist?.length ?? null, report_file: reportFile, report_written: Boolean(report.trim()), desktop_app_handoff: appHandoff, image_path_contract: imagePathContract };
+    return { gate, checklist_count: ledger?.checklist?.length ?? null, report_file: reportFile, report_written: Boolean(report.trim()), desktop_app_handoff: appHandoff, desktop_app_confirmation: appConfirmation, desktop_review_complete: appConfirmation?.verdict === 'pass', image_path_contract: imagePathContract };
 }
 function qaChecklist(a) {
     const cases = [