sneakoscope 2.0.17 → 2.0.18

package/dist/core/mad-db/mad-db-result-lifecycle.js

@@ -74,6 +74,24 @@ export async function recordMadDbToolResult(input) {
         event
     };
 }
+export async function maybeRecordMadDbToolResultFromToolUse(input) {
+    const payload = input.toolResult ?? input.toolCallPayload ?? {};
+    const hook = lifecycleHookFromUnknown(input.decision)
+        || lifecycleHookFromUnknown(input.toolCallPayload)
+        || lifecycleHookFromUnknown(input.toolResult)
+        || await readLatestPendingMadDbLifecycleHook(input.root, input.missionId, input.toolCallPayload || payload);
+    if (!hook)
+        return null;
+    const ok = !madDbToolUseFailed(payload);
+    return recordMadDbToolResult({
+        root: input.root,
+        missionId: input.missionId,
+        hook,
+        ok,
+        rowCount: extractRowCount(payload),
+        error: ok ? null : extractToolError(payload)
+    });
+}
 export function lifecycleHookFromUnknown(value) {
     const candidate = value?.ledger_result_hook || value?.mad_db?.ledger_result_hook || value;
     const missionId = stringOrNull(candidate?.mission_id || candidate?.missionId);
@@ -107,6 +125,59 @@ function hookMatchesPayload(hook, payload) {
         return true;
     return toolText.includes(String(hook.tool_name).toLowerCase()) || String(hook.tool_name).toLowerCase().includes(toolText);
 }
+function madDbToolUseFailed(payload = {}) {
+    if (payload?.isError === true || payload?.tool_response?.isError === true || payload?.toolResponse?.isError === true || payload?.result?.isError === true)
+        return true;
+    const candidates = [
+        payload.exit_code,
+        payload.exitCode,
+        payload.tool_response?.exit_code,
+        payload.toolResponse?.exitCode,
+        payload.result?.exit_code,
+        payload.result?.exitCode
+    ];
+    for (const candidate of candidates) {
+        if (candidate === undefined || candidate === null || candidate === '')
+            continue;
+        const n = Number(candidate);
+        if (Number.isFinite(n))
+            return n !== 0;
+    }
+    if (payload.success === false || payload.tool_response?.success === false || payload.toolResponse?.success === false || payload.result?.success === false)
+        return true;
+    if (payload.executed === false)
+        return true;
+    return false;
+}
+function extractRowCount(payload = {}) {
+    const candidates = [
+        payload.row_count,
+        payload.rowCount,
+        payload.tool_response?.row_count,
+        payload.tool_response?.rowCount,
+        payload.toolResponse?.rowCount,
+        payload.result?.row_count,
+        payload.result?.rowCount,
+        payload.result?.rows_affected,
+        payload.tool_response?.rows_affected
+    ];
+    for (const candidate of candidates) {
+        if (candidate === undefined || candidate === null || candidate === '')
+            continue;
+        const parsed = Number(candidate);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return null;
+}
+function extractToolError(payload = {}) {
+    if (payload?.result?.isError === true && Array.isArray(payload.result.content)) {
+        const text = payload.result.content.map((entry) => entry?.text || entry?.message || '').filter(Boolean).join('\n');
+        if (text.trim())
+            return text.trim();
+    }
+    return String(payload.error || payload.message || payload.stderr || payload.tool_response?.stderr || payload.toolResponse?.stderr || payload.result?.stderr || payload.result?.error || 'tool_failed');
+}
 async function hasTerminalLifecycleEvent(root, missionId, operationId) {
     const ledger = path.join(missionDir(root, missionId), 'mad-db-ledger.jsonl');
     const text = await readText(ledger, '').catch(() => '');

package/dist/core/mcp/mcp-plugin-inventory.js

@@ -0,0 +1,29 @@
+import path from 'node:path';
+import { buildCodexPluginInventory } from '../codex-plugins/codex-plugin-json.js';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { policyForPluginMcpServer } from './mcp-server-policy.js';
+export function buildMcpPluginServerCandidates(inventory) {
+    const candidates = inventory.plugins.flatMap((plugin) => plugin.remote_mcp_servers.map((server) => policyForPluginMcpServer({
+        pluginId: plugin.id,
+        name: server.name,
+        url: server.url,
+        authType: server.auth_type
+    })));
+    return {
+        schema: 'sks.mcp-plugin-server-candidates.v1',
+        generated_at: nowIso(),
+        candidates,
+        candidate_only: true,
+        blockers: []
+    };
+}
+export async function writeMcpPluginInventoryArtifacts(root, input = {}) {
+    const inventory = input.inventory || await buildCodexPluginInventory();
+    const candidates = buildMcpPluginServerCandidates(inventory);
+    const pluginArtifact = path.join(root, '.sneakoscope', 'codex-plugin-inventory.json');
+    const candidateArtifact = path.join(root, '.sneakoscope', 'mcp-plugin-server-candidates.json');
+    await writeJsonAtomic(pluginArtifact, inventory);
+    await writeJsonAtomic(candidateArtifact, candidates);
+    return { inventory, candidates, plugin_artifact: pluginArtifact, candidate_artifact: candidateArtifact };
+}
+//# sourceMappingURL=mcp-plugin-inventory.js.map

package/dist/core/mcp/mcp-server-policy.js

@@ -0,0 +1,24 @@
+export function policyForPluginMcpServer(input) {
+    const haystack = `${input.name} ${input.url || ''}`.toLowerCase();
+    const dbRelated = /supabase|postgres|database|sql|db\b/.test(haystack);
+    const oauth = /oauth/i.test(String(input.authType || ''));
+    return {
+        name: input.name,
+        plugin_id: input.pluginId,
+        url: input.url || null,
+        auth_type: input.authType || null,
+        candidate_only: true,
+        auto_enable: false,
+        destructive_tools_auto_enabled: false,
+        db_safety_required: dbRelated,
+        mad_db_required_for_destructive: dbRelated,
+        oauth_prerefresh_recommended: oauth,
+        policy_notes: [
+            'Remote MCP servers from plugin detail are candidate only.',
+            'Do not auto-enable destructive MCP tools.',
+            dbRelated ? 'DB MCP servers require DB safety and Mad-DB for destructive operations.' : 'Non-DB MCP candidate still requires explicit operator enablement.',
+            oauth ? 'OAuth-backed MCP should trigger pre-refresh doctor check.' : ''
+        ].filter(Boolean)
+    };
+}
+//# sourceMappingURL=mcp-server-policy.js.map

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

@@ -0,0 +1,37 @@
+import { defaultModelCallBudget } from '../codex-control/model-call-concurrency.js';
+import { codexModelEffortCapability, nextAdvertisedEffort } from '../codex-control/codex-model-capabilities.js';
+export function buildQaLoopBudgetPolicy(input = {}) {
+    const usage = input.usage || null;
+    const available = Boolean(usage?.token_usage);
+    const limit = Number(usage?.usage_limit_tokens || 0);
+    const total = Number(usage?.token_usage?.total_tokens || 0);
+    const nearLimit = Boolean(limit > 0 && total / limit >= 0.9);
+    const baseBudget = defaultModelCallBudget(String(input.provider || 'codex-sdk'));
+    return {
+        schema: 'sks.qa-loop-budget-policy.v1',
+        ok: true,
+        account_usage_source: usage?.source || 'unavailable',
+        token_usage_available: available,
+        near_limit: nearLimit,
+        remote_model_call_concurrency: nearLimit ? Math.max(1, Math.min(2, baseBudget)) : baseBudget,
+        local_llm_draft_preferred: nearLimit,
+        final_reviewer_gpt_backed: true,
+        warnings: available ? [] : ['codex_account_usage_unavailable_no_hard_block']
+    };
+}
+export function selectQaLoopEscalatedEffort(input = {}) {
+    const capability = input.capability || codexModelEffortCapability();
+    const current = input.currentEffort || capability.default_effort;
+    const failureCount = Number(input.failureCount || 0);
+    return {
+        schema: 'sks.qa-loop-effort-escalation.v1',
+        model: capability.model,
+        advertised_efforts: capability.advertised_efforts,
+        order_source: capability.order_source,
+        failure_count: failureCount,
+        current_effort: current,
+        next_effort: failureCount >= 2 ? nextAdvertisedEffort(current, capability) : current,
+        escalated: failureCount >= 2 && nextAdvertisedEffort(current, capability) !== current
+    };
+}
+//# sourceMappingURL=qa-loop-budget-policy.js.map

package/dist/core/qa-loop.js

@@ -309,6 +309,14 @@ export function defaultQaGate(contract = {}, opts = {}) {
         ui_chrome_extension_evidence: !uiRequired,
         ui_computer_use_evidence: false,
         ui_evidence_source: uiRequired ? null : 'not_required',
+        desktop_app_handoff_required: false,
+        desktop_app_handoff_status: 'not_requested',
+        desktop_app_handoff_artifact: null,
+        desktop_app_handoff_supported: false,
+        desktop_app_handoff_is_web_ui_evidence: false,
+        image_artifact_path_contract_present: false,
+        image_artifact_path_contract_artifact: null,
+        image_artifact_path_contract_blockers: [],
         api_e2e_required: apiRequired,
         unsafe_external_side_effects: false,
         corrective_loop_enabled: corrective,
@@ -374,6 +382,15 @@ export async function evaluateQaGate(dir) {
         if (evidenceMentionsForbiddenWebComputerUseEvidence({ evidence: gate.evidence, ui_evidence_source: gate.ui_evidence_source }))
             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')
+            reasons.push('desktop_app_handoff_missing');
+        if (gate.desktop_app_handoff_is_web_ui_evidence === true)
+            reasons.push('desktop_app_handoff_misused_as_web_evidence');
+    }
+    const imageBlockers = Array.isArray(gate.image_artifact_path_contract_blockers) ? gate.image_artifact_path_contract_blockers : [];
+    if (imageBlockers.includes('image_generated_file_path_missing'))
+        reasons.push('image_generated_file_path_missing');
     if (!reportFile)
         reasons.push('qa_report_file_missing');
     else if (!isQaReportFilename(reportFile))
@@ -396,8 +413,14 @@ export async function writeMockQaResult(dir, mission, contract) {
     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.'] });
     return evaluateQaGate(dir);
 }
-export function buildQaLoopPrompt({ id, mission, contract, cycle, previous, reportFile }) {
+export function buildQaLoopPrompt({ id, mission, contract, cycle, previous, reportFile, imagePathContract, appHandoff }) {
     const report = reportFile && isQaReportFilename(reportFile) ? reportFile : 'the date/version-prefixed report named by qa-gate.json.qa_report_file';
+    const imageContractText = imagePathContract
+        ? `\nIMAGE PATH CONTRACT:\n${JSON.stringify(imagePathContract, null, 2)}\nUse model_visible_path values for follow-up image edits; do not invent generated image paths.\n`
+        : '';
+    const appHandoffText = appHandoff
+        ? `\nCODEX DESKTOP /app HANDOFF:\n${JSON.stringify(appHandoff, null, 2)}\nThis is desktop-app review status only and is not web UI evidence.\n`
+        : '';
     return `SKS QA-LOOP
 MISSION: ${id}
 TASK: ${mission.prompt}
@@ -410,6 +433,7 @@ GATE: passed=false while unresolved_findings or unresolved_fixable_findings > 0,
 ARTIFACTS: update qa-ledger.json, ${report}, qa-gate.json, and qa-loop/cycle-${cycle}/.
 CONTRACT:
 ${JSON.stringify(contract, null, 2)}
+${imageContractText}${appHandoffText}
 Previous tail:
 ${String(previous || '').slice(-2500)}
 `;
@@ -417,9 +441,11 @@ ${String(previous || '').slice(-2500)}
 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 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()) };
+    return { gate, checklist_count: ledger?.checklist?.length ?? null, report_file: reportFile, report_written: Boolean(report.trim()), desktop_app_handoff: appHandoff, image_path_contract: imagePathContract };
 }
 function qaChecklist(a) {
     const cases = [

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

@@ -0,0 +1,78 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+export async function collectCodexAccountUsage() {
+    if (process.env.SKS_CODEX_ACCOUNT_USAGE_FAKE === '1') {
+        return {
+            schema: 'sks.codex-account-usage.v1',
+            generated_at: nowIso(),
+            ok: true,
+            source: 'fake',
+            account_id: 'fake-account',
+            token_usage: {
+                input_tokens: 1000,
+                output_tokens: 500,
+                total_tokens: 1500,
+                reset_at: null
+            },
+            usage_limit_tokens: 100000,
+            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)}`]);
+    }
+}
+export async function writeCodexAccountUsageArtifacts(root, input = {}) {
+    const snapshot = await collectCodexAccountUsage();
+    const rootArtifact = path.join(root, '.sneakoscope', 'codex-account-usage.json');
+    await writeJsonAtomic(rootArtifact, snapshot);
+    let missionArtifact = null;
+    if (input.missionId) {
+        missionArtifact = path.join(root, '.sneakoscope', 'missions', input.missionId, 'codex-account-usage.json');
+        await writeJsonAtomic(missionArtifact, snapshot);
+    }
+    return { snapshot, root_artifact: rootArtifact, mission_artifact: missionArtifact };
+}
+function normalizeUsagePayload(payload, source) {
+    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);
+    const total = Number(usage?.total_tokens || usage?.totalTokens || input + output);
+    return {
+        schema: 'sks.codex-account-usage.v1',
+        generated_at: nowIso(),
+        ok: true,
+        source,
+        account_id: payload?.account_id || payload?.accountId || null,
+        token_usage: {
+            input_tokens: Number.isFinite(input) ? input : 0,
+            output_tokens: Number.isFinite(output) ? output : 0,
+            total_tokens: Number.isFinite(total) ? total : 0,
+            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,
+        blockers: []
+    };
+}
+function unavailable(blockers) {
+    return {
+        schema: 'sks.codex-account-usage.v1',
+        generated_at: nowIso(),
+        ok: true,
+        source: 'unavailable',
+        token_usage: null,
+        usage_limit_tokens: null,
+        blockers
+    };
+}
+//# sourceMappingURL=codex-account-usage.js.map

package/dist/core/version.js

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

package/dist/core/zellij/zellij-slot-column-anchor.js

@@ -10,18 +10,21 @@ export function renderZellijSlotColumnAnchor(input = {}) {
     const fail = nonNegativeInt(input.failedWorkers, 0);
     const update = input.updateAvailableVersion ? ` · update ${trimInline(input.updateAvailableVersion, 18)} available` : '';
     const madDb = input.madDbActive ? ' · MAD-DB ACTIVE' : '';
+    const appHandoff = input.qaAppHandoffPending ? ' · QA /app handoff pending' : '';
     const header = done || fail
-        ? `SLOTS active ${active} · headless ${headless} · done ${done} · fail ${fail} · q ${queue}${update}${madDb}`
-        : `SLOTS active ${active}/${visible} · headless ${headless} · q ${queue}${update}${madDb}`;
+        ? `SLOTS active ${active} · headless ${headless} · done ${done} · fail ${fail} · q ${queue}${update}${madDb}${appHandoff}`
+        : `SLOTS active ${active}/${visible} · headless ${headless} · q ${queue}${update}${madDb}${appHandoff}`;
     const workers = Array.isArray(input.workerRows) ? input.workerRows : [];
+    const handoffLine = input.qaAppHandoffPending ? `QA app handoff pending · ${trimInline(input.qaAppHandoffArtifact || 'qa-loop/app-handoff.json', 64)}` : null;
     if (!workers.length)
-        return `${header}\nvisible slot panes stack below this anchor`;
+        return [header, handoffLine, 'visible slot panes stack below this anchor'].filter(Boolean).join('\n');
     const maxRows = Math.max(1, nonNegativeInt(input.maxWorkerRows, input.mode === 'full-debug' ? 24 : 12));
     const overflowRows = workers.filter((row) => row.placement === 'headless').slice(0, maxRows);
     const visibleRows = overflowRows.length ? overflowRows : workers.filter((row) => row.placement !== 'zellij-pane').slice(0, maxRows);
     const hidden = Math.max(0, workers.length - visibleRows.length);
     return [
         header,
+        handoffLine,
         `visible slot panes stack below this anchor`,
         ...visibleRows.map((row, index) => renderWorkerRow(row, index + 1)),
         ...(hidden && visibleRows.length ? [`+${hidden} worker${hidden === 1 ? '' : 's'} in dedicated panes or overflow`] : [])
@@ -33,8 +36,9 @@ export async function renderZellijSlotColumnAnchorFromArtifacts(input) {
     const telemetry = await readZellijSlotTelemetrySnapshot(root, input.missionId).catch(() => null);
     const updateNotice = await readJson(path.join(missionDir, 'update-notice.json'));
     const madDb = await readJson(path.join(missionDir, 'mad-db-capability.json'));
+    const appHandoff = await readJson(path.join(missionDir, 'qa-loop', 'app-handoff.json'));
     if (telemetry && Object.keys(telemetry.slots || {}).length) {
-        return renderTelemetryAnchor(telemetry, updateNotice, madDb);
+        return renderTelemetryAnchor(telemetry, updateNotice, madDb, appHandoff);
     }
     const snapshot = await readJson(path.join(missionDir, 'zellij-dashboard-snapshot.json'));
     const rightColumn = await readJson(path.join(missionDir, 'zellij-right-column-state.json'));
@@ -50,20 +54,25 @@ export async function renderZellijSlotColumnAnchorFromArtifacts(input) {
         anchorInput.updateAvailableVersion = String(updateNotice.latest_version);
     if (isMadDbActive(madDb))
         anchorInput.madDbActive = true;
+    if (['pending', 'blocked_for_desktop_review'].includes(String(appHandoff?.status || ''))) {
+        anchorInput.qaAppHandoffPending = true;
+        anchorInput.qaAppHandoffArtifact = appHandoff?.artifact_path || 'qa-loop/app-handoff.json';
+    }
     if (input.mode !== undefined)
         anchorInput.mode = input.mode;
     return renderZellijSlotColumnAnchor(anchorInput);
 }
-function renderTelemetryAnchor(snapshot, updateNotice = null, madDbCapability = null) {
+function renderTelemetryAnchor(snapshot, updateNotice = null, madDbCapability = null, appHandoff = null) {
     const updatedAt = Date.parse(snapshot.updated_at || '');
     const staleSeconds = Number.isFinite(updatedAt) ? Math.max(0, Math.round((Date.now() - updatedAt) / 1000)) : null;
     const counts = snapshot.counts || {};
     const active = Number(counts.running || 0) + Number(counts.verifying || 0);
     const update = updateNotice?.update_available && updateNotice?.latest_version ? ` · update ${trimInline(String(updateNotice.latest_version), 18)} available` : '';
     const madDb = isMadDbActive(madDbCapability) ? ' · MAD-DB ACTIVE' : '';
+    const qaHandoff = ['pending', 'blocked_for_desktop_review'].includes(String(appHandoff?.status || '')) ? ' · QA /app handoff pending' : '';
     if (staleSeconds != null && staleSeconds > 10)
-        return `SLOTS telemetry stale ${staleSeconds}s · active ?${update}${madDb}`;
-    return `SLOTS active ${active} · headless ${Number(counts.headless || 0)} · done ${Number(counts.completed || 0)} · fail ${Number(counts.failed || 0)} · q ${Number(counts.queued || 0)}${update}${madDb}`;
+        return `SLOTS telemetry stale ${staleSeconds}s · active ?${update}${madDb}${qaHandoff}`;
+    return `SLOTS active ${active} · headless ${Number(counts.headless || 0)} · done ${Number(counts.completed || 0)} · fail ${Number(counts.failed || 0)} · q ${Number(counts.queued || 0)}${update}${madDb}${qaHandoff}`;
 }
 function isMadDbActive(capability) {
     if (!capability || capability.enabled !== true || capability.consumed === true)

package/dist/core/zellij/zellij-slot-pane-renderer.js

@@ -24,6 +24,7 @@ export function renderZellijSlotPane(input) {
         `doing: ${task}`,
         `files: ${trimInline(files.length ? files.join(', ') : 'no changed file yet', 78)}`,
         `patch: ${trimInline(input.patchStatus || 'queued', 24)}  verify: ${trimInline(input.verifyStatus || 'queued', 24)}`,
+        input.qaAppHandoffPending ? `QA app handoff pending: ${trimInline(input.qaAppHandoffArtifact || 'qa-loop/app-handoff.json', 55)}` : null,
         ...events.map((event) => `event: ${trimInline(event, 78)}`),
         ...stdout.map((line) => `out: ${trimInline(line, 79)}`),
         ...stderr.map((line) => `err: ${trimInline(line, 79)}`)
@@ -97,6 +98,7 @@ async function renderZellijSlotPaneFromArtifactDir(input) {
         ...(Array.isArray(intake?.input_files) ? intake.input_files : [])
     ]);
     const now = Date.now();
+    const qaAppHandoff = await readQaAppHandoffNearArtifactDir(artifactDir);
     if (!result && !intake && !backendReport && !fastReport && !paneReport && !codexProof && !localProof && !heartbeatMtime && !eventRows.length)
         return null;
     return renderZellijSlotPane({
@@ -155,9 +157,25 @@ async function renderZellijSlotPaneFromArtifactDir(input) {
         eventLines: eventRows.map(formatArtifactEvent).filter(Boolean),
         stdoutTail: await readTextTailLines(path.join(artifactDir, 'worker.stdout.log'), 2),
         stderrTail: await readTextTailLines(path.join(artifactDir, 'worker.stderr.log'), 1),
+        qaAppHandoffPending: ['pending', 'blocked_for_desktop_review'].includes(String(qaAppHandoff?.status || '')),
+        qaAppHandoffArtifact: qaAppHandoff?.artifact_path || null,
         mode: input.mode || 'compact-slots'
     });
 }
+async function readQaAppHandoffNearArtifactDir(artifactDir) {
+    let current = path.resolve(artifactDir);
+    for (let i = 0; i < 8; i += 1) {
+        const candidate = path.join(current, 'qa-loop', 'app-handoff.json');
+        const json = await readJson(candidate);
+        if (json)
+            return json;
+        const next = path.dirname(current);
+        if (next === current)
+            break;
+        current = next;
+    }
+    return null;
+}
 export async function renderZellijSlotPaneStatusFromArtifacts(input) {
     const snapshot = input.missionId && input.missionId !== 'latest'
         ? await readZellijSlotTelemetrySnapshot(path.resolve(input.artifactRoot || input.artifactDir), input.missionId).catch(() => null)

package/dist/scripts/release-gate-existence-audit.js

@@ -84,7 +84,11 @@ const required = [
     'git-collaboration:e2e'
 ];
 assertGate(releaseManifest.schema === 'sks.release-gates.v2', 'release gate manifest schema mismatch', { schema: releaseManifest.schema });
-assertGate(String(scripts['release:check'] || '').includes('release-gate-dag-runner') && String(scripts['release:check'] || '').includes('--preset release'), 'release:check must use the v2 DAG release preset', { release_check: scripts['release:check'] });
+const releaseCheck = String(scripts['release:check'] || '');
+const releaseCheckTarget = releaseCheck.includes('release:check:affected')
+    ? String(scripts['release:check:affected'] || '')
+    : releaseCheck;
+assertGate(releaseCheckTarget.includes('release-gate-dag-runner') && /--preset\s+(?:release|affected)/.test(releaseCheckTarget), 'release:check must use the v2 DAG release/affected preset', { release_check: scripts['release:check'], resolved_release_check: releaseCheckTarget });
 assertGate(releaseGates.length > 0, 'release v2 manifest must include release preset gates', { gate_count: releaseGates.length });
 for (const name of required) {
     assertGate(Boolean(scripts[name]), `missing release gate script: ${name}`, { required });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "2.0.17",
+  "version": "2.0.18",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -557,6 +557,29 @@
     "release:check:dag:explain": "node ./dist/scripts/release-gate-dag-runner.js --preset release --explain",
     "release:check:dag:no-cache": "node ./dist/scripts/release-gate-dag-runner.js --preset release --no-cache",
     "release:check:dag:fail-fast": "node ./dist/scripts/release-gate-dag-runner.js --preset release --fail-fast",
+    "codex:0138-capability": "node ./dist/scripts/codex-0138-capability-check.js",
+    "codex:0138-capability-artifact": "node ./dist/scripts/codex-0138-capability-artifact-check.js",
+    "codex-sdk:version-compat": "node ./dist/scripts/codex-sdk-version-compat-check.js",
+    "codex-app:handoff": "node ./dist/scripts/codex-app-handoff-check.js",
+    "qa-loop:app-handoff": "node ./dist/scripts/qa-loop-app-handoff-check.js",
+    "qa-loop:app-handoff-capability": "node ./dist/scripts/qa-loop-app-handoff-capability-check.js",
+    "qa-loop:app-handoff-cli": "node ./dist/scripts/qa-loop-app-handoff-cli-check.js",
+    "zellij:qa-app-handoff-status": "node ./dist/scripts/zellij-qa-app-handoff-status-check.js",
+    "codex-plugin:json": "node ./dist/scripts/codex-plugin-json-check.js",
+    "codex-plugin:inventory": "node ./dist/scripts/codex-plugin-inventory-check.js",
+    "mcp:plugin-inventory": "node ./dist/scripts/mcp-plugin-inventory-check.js",
+    "codex-plugin:app-template-policy": "node ./dist/scripts/codex-plugin-app-template-policy-check.js",
+    "image:artifact-path-contract": "node ./dist/scripts/image-artifact-path-contract-check.js",
+    "qa-loop:image-path-exposure": "node ./dist/scripts/qa-loop-image-path-exposure-check.js",
+    "image:generation-path-handoff": "node ./dist/scripts/image-generation-path-handoff-check.js",
+    "image:followup-edit-path": "node ./dist/scripts/image-followup-edit-path-check.js",
+    "codex:effort-order": "node ./dist/scripts/codex-effort-order-check.js",
+    "qa-loop:effort-escalation": "node ./dist/scripts/qa-loop-effort-escalation-check.js",
+    "codex:account-usage": "node ./dist/scripts/codex-account-usage-check.js",
+    "qa-loop:budget-policy": "node ./dist/scripts/qa-loop-budget-policy-check.js",
+    "naruto:parallel-gate-consistency": "node ./dist/scripts/naruto-parallel-gate-consistency-check.js",
+    "codex:0138-doctor": "node ./dist/scripts/codex-0138-doctor-check.js",
+    "doctor:codex-0138-fix": "node ./dist/scripts/doctor-codex-0138-fix-check.js",
     "release:dag-runner": "node ./dist/scripts/release-gate-dag-runner-check.js",
     "release:parallel-speed-budget": "node ./dist/scripts/release-parallel-speed-budget-check.js",
     "release:stability-report": "node ./dist/scripts/release-stability-report-check.js",
@@ -711,7 +734,7 @@
   "license": "MIT",
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.29.0",
-    "@openai/codex-sdk": "0.137.0",
+    "@openai/codex-sdk": "^0.138.0",
     "figlet": "^1.11.0",
     "typescript": "^5.9.3"
   },

package/schemas/codex-app/codex-app-handoff.schema.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://sneakoscope.dev/schemas/codex-app/codex-app-handoff.schema.json",
+  "title": "SKS Codex App Handoff",
+  "type": "object",
+  "required": ["schema", "ok", "status", "desktop_handoff_supported", "artifact_path", "prompt_artifact_path"],
+  "properties": {
+    "schema": { "const": "sks.codex-app-handoff-result.v1" },
+    "ok": { "type": "boolean" },
+    "attempted": { "type": "boolean" },
+    "launched": { "type": "boolean" },
+    "status": { "enum": ["pending", "skipped", "blocked_for_desktop_review"] },
+    "desktop_handoff_supported": { "type": "boolean" },
+    "artifact_path": { "type": "string", "minLength": 1 },
+    "prompt_artifact_path": { "type": "string", "minLength": 1 },
+    "blockers": { "type": "array", "items": { "type": "string" } },
+    "request": { "type": "object" }
+  },
+  "additionalProperties": true
+}

package/schemas/codex-plugins/codex-plugin-inventory.schema.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://sneakoscope.dev/schemas/codex-plugins/codex-plugin-inventory.schema.json",
+  "title": "SKS Codex Plugin Inventory",
+  "type": "object",
+  "required": ["schema", "generated_at", "plugins", "marketplace_available", "blockers"],
+  "properties": {
+    "schema": { "const": "sks.codex-plugin-inventory.v1" },
+    "generated_at": { "type": "string" },
+    "marketplace_available": { "type": "boolean" },
+    "plugins": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["id", "name", "source", "installed", "enabled", "default_prompts", "remote_mcp_servers", "unavailable_app_templates"],
+        "properties": {
+          "id": { "type": "string", "minLength": 1 },
+          "name": { "type": "string" },
+          "source": { "enum": ["marketplace", "local", "remote", "unknown"] },
+          "installed": { "type": "boolean" },
+          "enabled": { "type": "boolean" },
+          "default_prompts": { "type": "array", "items": { "type": "string" } },
+          "remote_mcp_servers": { "type": "array", "items": { "type": "object" } },
+          "unavailable_app_templates": { "type": "array", "items": { "type": "string" } }
+        },
+        "additionalProperties": true
+      }
+    },
+    "blockers": { "type": "array", "items": { "type": "string" } }
+  },
+  "additionalProperties": true
+}

package/schemas/image/image-artifact-path-contract.schema.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://sneakoscope.dev/schemas/image/image-artifact-path-contract.schema.json",
+  "title": "SKS Image Artifact Path Contract",
+  "type": "object",
+  "required": ["schema", "mission_id", "generated_at", "images", "blockers"],
+  "properties": {
+    "schema": { "const": "sks.image-artifact-path-contract.v1" },
+    "mission_id": { "type": "string", "minLength": 1 },
+    "generated_at": { "type": "string" },
+    "images": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["id", "kind", "file_path", "relative_path", "exists", "model_visible_path", "followup_edit_hint"],
+        "properties": {
+          "id": { "type": "string", "minLength": 1 },
+          "kind": { "enum": ["input_attachment", "generated_image", "edited_image", "visual_qa_snapshot"] },
+          "file_path": { "type": "string", "minLength": 1 },
+          "relative_path": { "type": "string" },
+          "exists": { "type": "boolean" },
+          "mime_type": { "type": ["string", "null"] },
+          "model_visible_path": { "type": "string", "minLength": 1 },
+          "followup_edit_hint": { "type": "string", "minLength": 1 }
+        },
+        "additionalProperties": true
+      }
+    },
+    "blockers": { "type": "array", "items": { "type": "string" } }
+  },
+  "additionalProperties": true
+}

package/schemas/usage/codex-account-usage.schema.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://sneakoscope.dev/schemas/usage/codex-account-usage.schema.json",
+  "title": "SKS Codex Account Usage",
+  "type": "object",
+  "required": ["schema", "generated_at", "ok", "source", "blockers"],
+  "properties": {
+    "schema": { "const": "sks.codex-account-usage.v1" },
+    "generated_at": { "type": "string" },
+    "ok": { "type": "boolean" },
+    "source": { "enum": ["app-server", "unavailable", "fake"] },
+    "account_id": { "type": ["string", "null"] },
+    "token_usage": {
+      "type": ["object", "null"],
+      "properties": {
+        "input_tokens": { "type": "number" },
+        "output_tokens": { "type": "number" },
+        "total_tokens": { "type": "number" },
+        "reset_at": { "type": ["string", "null"] }
+      },
+      "additionalProperties": true
+    },
+    "usage_limit_tokens": { "type": ["number", "null"] },
+    "blockers": { "type": "array", "items": { "type": "string" } }
+  },
+  "additionalProperties": true
+}