sneakoscope 2.0.18 → 3.0.0

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.0';
 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/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 = [

package/dist/core/release/release-gate-cache-v2.js

@@ -5,19 +5,44 @@ export const RELEASE_GATE_CACHE_V2_SCHEMA = 'sks.release-gate-cache.v2';
 export function releaseGateCacheFile(root) {
     return path.join(root, '.sneakoscope', 'reports', 'release-gates', 'cache-v2.json');
 }
+// Files whose only release-to-release difference is the version literal.
+// Hashing them version-neutrally keeps a pure `sks versioning bump` from
+// invalidating every behavior gate: bumping the version rewrites
+// package.json, package-lock.json, and the three PACKAGE_VERSION constant
+// sources, which are inputs of ~280 gates (via `package.json` and `src/**`).
+// Before this normalization every publish re-ran the entire DAG from zero
+// (test:blackbox alone is ~11 minutes) even when no behavior changed.
+// Version-CORRECTNESS gates (release:version-truth, release:metadata, ...)
+// are declared with `cache.enabled: false`, so they always re-run and still
+// catch version drift. Set SKS_RELEASE_CACHE_VERSION_SENSITIVE=1 to restore
+// the old fully version-sensitive hashing.
+const VERSION_NEUTRAL_CACHE_FILES = new Set([
+    'package.json',
+    'package-lock.json',
+    'src/core/version.ts',
+    'src/core/fsx.ts',
+    'src/bin/sks.ts'
+]);
 export function releaseGateCacheKey(root, gate) {
     const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+    const releaseVersion = String(pkg.version || '');
+    const versionSensitive = process.env.SKS_RELEASE_CACHE_VERSION_SENSITIVE === '1';
     const hash = crypto.createHash('sha256');
     hash.update(gate.id);
     hash.update(gate.command);
-    hash.update(String(pkg.version || ''));
+    if (versionSensitive)
+        hash.update(releaseVersion);
     hash.update(process.version);
     hash.update(String(process.env.npm_config_user_agent || ''));
     hash.update(JSON.stringify(gate.resource || []));
     hash.update(JSON.stringify(gate.preset || []));
     hashFileIfPresent(hash, path.join(root, 'release-gates.v2.json'));
-    hashFileIfPresent(hash, path.join(root, 'package.json'));
-    hashFileIfPresent(hash, path.join(root, 'dist', 'build-manifest.json'));
+    if (versionSensitive || !gate.cache.inputs.length) {
+        // No declared inputs (or explicitly version-sensitive mode): fall back to
+        // the conservative global digests so such a gate cannot cache-hit forever.
+        hashFileIfPresent(hash, path.join(root, 'package.json'));
+        hashFileIfPresent(hash, path.join(root, 'dist', 'build-manifest.json'));
+    }
     for (const input of gate.cache.inputs) {
         const expanded = expandGlob(root, input);
         hash.update(`input:${input}`);
@@ -26,12 +51,29 @@ export function releaseGateCacheKey(root, gate) {
             continue;
         }
         for (const file of expanded) {
-            hash.update(path.relative(root, file));
-            hashFileIfPresent(hash, file);
+            const rel = path.relative(root, file);
+            hash.update(rel);
+            if (!versionSensitive && VERSION_NEUTRAL_CACHE_FILES.has(rel))
+                hashVersionNeutralFile(hash, file, releaseVersion);
+            else
+                hashFileIfPresent(hash, file);
         }
     }
     return hash.digest('hex');
 }
+function hashVersionNeutralFile(hash, file, releaseVersion) {
+    if (!fs.existsSync(file) || !fs.statSync(file).isFile())
+        return;
+    const text = fs.readFileSync(file, 'utf8');
+    if (!releaseVersion) {
+        hash.update(text);
+        return;
+    }
+    // Replace exact occurrences of the current release version literal so a
+    // version-only bump hashes identically. Any other content change in these
+    // files still alters the key.
+    hash.update(text.split(releaseVersion).join('__SKS_RELEASE_VERSION__'));
+}
 export function expandGlob(root, input) {
     const absolute = path.join(root, input);
     if (!/[*!?[\]{}]/.test(input)) {

package/dist/core/usage/codex-account-usage.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
-import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { findCodexBinary } from '../codex-adapter.js';
+import { nowIso, runProcess, writeJsonAtomic } from '../fsx.js';
 export async function collectCodexAccountUsage() {
     if (process.env.SKS_CODEX_ACCOUNT_USAGE_FAKE === '1') {
         return {
@@ -15,22 +16,42 @@ export async function collectCodexAccountUsage() {
                 reset_at: null
             },
             usage_limit_tokens: 100000,
+            attempted_sources: ['fake'],
             blockers: []
         };
     }
-    const url = String(process.env.SKS_CODEX_APP_SERVER_USAGE_URL || process.env.CODEX_APP_SERVER_USAGE_URL || '').trim();
-    if (!url)
-        return unavailable(['codex_app_server_usage_endpoint_unavailable']);
-    try {
-        const response = await fetch(url, { signal: AbortSignal.timeout(5000) });
-        if (!response.ok)
-            return unavailable([`codex_app_server_usage_http_${response.status}`]);
-        const payload = await response.json();
-        return normalizeUsagePayload(payload, 'app-server');
-    }
-    catch (err) {
-        return unavailable([`codex_app_server_usage_fetch_failed:${err?.message || String(err)}`]);
+    const attemptedSources = [];
+    const urls = [
+        ['CODEX_APP_SERVER_USAGE_URL', process.env.CODEX_APP_SERVER_USAGE_URL],
+        ['SKS_CODEX_APP_SERVER_USAGE_URL', process.env.SKS_CODEX_APP_SERVER_USAGE_URL],
+        ...localWellKnownUsageUrls().map((url) => [`local:${url}`, url])
+    ];
+    const blockers = [];
+    for (const [label, rawUrl] of urls) {
+        const url = String(rawUrl || '').trim();
+        if (!url)
+            continue;
+        attemptedSources.push(label);
+        try {
+            const response = await fetch(url, { signal: AbortSignal.timeout(label.startsWith('local:') ? 800 : 5000) });
+            if (!response.ok) {
+                blockers.push(`codex_app_server_usage_http_${response.status}:${label}`);
+                continue;
+            }
+            const payload = await response.json();
+            return normalizeUsagePayload(payload, 'app-server', attemptedSources);
+        }
+        catch (err) {
+            blockers.push(`codex_app_server_usage_fetch_failed:${label}:${err?.message || String(err)}`);
+        }
     }
+    const cli = await collectUsageFromCodexCli(attemptedSources).catch((err) => {
+        blockers.push(`codex_cli_usage_probe_failed:${err?.message || String(err)}`);
+        return null;
+    });
+    if (cli)
+        return cli;
+    return unavailable(attemptedSources.length ? blockers : ['codex_app_server_usage_endpoint_unavailable'], attemptedSources);
 }
 export async function writeCodexAccountUsageArtifacts(root, input = {}) {
     const snapshot = await collectCodexAccountUsage();
@@ -43,7 +64,7 @@ export async function writeCodexAccountUsageArtifacts(root, input = {}) {
     }
     return { snapshot, root_artifact: rootArtifact, mission_artifact: missionArtifact };
 }
-function normalizeUsagePayload(payload, source) {
+function normalizeUsagePayload(payload, source, attemptedSources) {
     const usage = payload?.token_usage || payload?.usage || payload;
     const input = Number(usage?.input_tokens || usage?.inputTokens || 0);
     const output = Number(usage?.output_tokens || usage?.outputTokens || 0);
@@ -61,18 +82,58 @@ function normalizeUsagePayload(payload, source) {
             reset_at: usage?.reset_at || usage?.resetAt || null
         },
         usage_limit_tokens: Number.isFinite(Number(payload?.usage_limit_tokens || payload?.usageLimitTokens)) ? Number(payload?.usage_limit_tokens || payload?.usageLimitTokens) : null,
+        attempted_sources: attemptedSources,
         blockers: []
     };
 }
-function unavailable(blockers) {
+function unavailable(blockers, attemptedSources = []) {
     return {
         schema: 'sks.codex-account-usage.v1',
         generated_at: nowIso(),
-        ok: true,
+        ok: false,
         source: 'unavailable',
         token_usage: null,
         usage_limit_tokens: null,
+        attempted_sources: attemptedSources,
         blockers
     };
 }
+function localWellKnownUsageUrls() {
+    const ports = [
+        process.env.CODEX_APP_SERVER_PORT,
+        process.env.SKS_CODEX_APP_SERVER_PORT,
+        1455,
+        1456,
+        3000
+    ].map((value) => Number(value)).filter((value, index, rows) => Number.isFinite(value) && value > 0 && rows.indexOf(value) === index);
+    return ports.flatMap((port) => [
+        `http://127.0.0.1:${port}/usage`,
+        `http://127.0.0.1:${port}/api/usage`,
+        `http://127.0.0.1:${port}/.well-known/codex/usage`
+    ]);
+}
+async function collectUsageFromCodexCli(attemptedSources) {
+    const bin = await findCodexBinary();
+    if (!bin)
+        return null;
+    const commands = [
+        ['account', 'usage', '--json'],
+        ['usage', '--json'],
+        ['app-server', 'status', '--json']
+    ];
+    for (const args of commands) {
+        const label = `codex-cli:${args.join(' ')}`;
+        attemptedSources.push(label);
+        const result = await runProcess(bin, args, { timeoutMs: 3000, maxOutputBytes: 64 * 1024 }).catch(() => null);
+        if (!result || result.code !== 0)
+            continue;
+        try {
+            const payload = JSON.parse(`${result.stdout || ''}${result.stderr || ''}`.trim() || '{}');
+            const normalized = normalizeUsagePayload(payload, 'app-server', attemptedSources);
+            return { ...normalized, source: 'app-server' };
+        }
+        catch { }
+    }
+    return null;
+}
 //# sourceMappingURL=codex-account-usage.js.map

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '2.0.18';
+export const PACKAGE_VERSION = '3.0.0';
 //# sourceMappingURL=version.js.map