sneakoscope 2.0.17 → 3.0.0

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

@@ -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: available,
+        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,17 @@ 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_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,
+        image_artifact_path_contract_blockers: [],
         api_e2e_required: apiRequired,
         unsafe_external_side_effects: false,
         corrective_loop_enabled: corrective,
@@ -374,6 +385,21 @@ 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 (!['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');
+    }
+    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))
@@ -393,11 +419,48 @@ 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 }) {
+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 +473,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 +481,12 @@ ${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 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()) };
+    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

@@ -0,0 +1,139 @@
+import path from 'node:path';
+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 {
+            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,
+            attempted_sources: ['fake'],
+            blockers: []
+        };
+    }
+    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();
+    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, 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);
+    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,
+        attempted_sources: attemptedSources,
+        blockers: []
+    };
+}
+function unavailable(blockers, attemptedSources = []) {
+    return {
+        schema: 'sks.codex-account-usage.v1',
+        generated_at: nowIso(),
+        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.17';
+export const PACKAGE_VERSION = '3.0.0';
 //# 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)
@@ -197,7 +215,10 @@ async function tryRenderTelemetrySlotPane(input) {
         return null;
     const staleRows = staleTelemetryRows(telemetryStatus(snapshot).telemetry_age_ms);
     const fallbackRows = artifactFallbackRows(input.artifactRender);
-    const liveRows = staleRows.length || !slot.progress ? fallbackRows : [];
+    // Always surface the live artifact rows (current file, tool events, stdout
+    // tail). Telemetry freshness only tells us the worker is alive — the user
+    // still needs to see WHAT the worker is doing right now.
+    const liveRows = fallbackRows;
     if (slot.status === 'failed') {
         return [
             `${slot.slot_id} gen-${slot.generation_index} · FAILED`,
@@ -236,7 +257,7 @@ function artifactFallbackRows(text) {
         .map((line) => line.replace(/^\|\s?/, '').replace(/\s?\|$/, '').trim())
         .filter((line) => /^(heartbeat|doing|files|event|out|err):\s+/i.test(line))
         .filter((line) => !/unknown|waiting for worker intake|no changed file yet/i.test(line))
-        .slice(-4)
+        .slice(-7)
         .map((line) => `live: ${trimInline(line, 72)}`);
 }
 function findTelemetrySlot(snapshot, slotId, generationIndex) {