sneakoscope 6.1.2 → 6.2.0

package/dist/core/subagents/triwiki-attention.js

@@ -2,41 +2,42 @@ import path from 'node:path';
 import { readJson } from '../fsx.js';
 export const BOUNDED_TRIWIKI_ATTENTION_SCHEMA = 'sks.subagent-triwiki-attention.v1';
 export const DEFAULT_TRIWIKI_ATTENTION_ANCHOR_LIMIT = 8;
-export async function readBoundedTriwikiAttention(root, limit = DEFAULT_TRIWIKI_ATTENTION_ANCHOR_LIMIT) {
+export async function readBoundedTriwikiAttention(root, limit = DEFAULT_TRIWIKI_ATTENTION_ANCHOR_LIMIT, query = '') {
     const pack = await readJson(path.join(root, '.sneakoscope', 'wiki', 'context-pack.json'), null);
-    return extractBoundedTriwikiAttention(pack, limit);
+    return extractBoundedTriwikiAttention(pack, limit, query);
 }
-export function extractBoundedTriwikiAttention(value, limit = DEFAULT_TRIWIKI_ATTENTION_ANCHOR_LIMIT) {
+export function extractBoundedTriwikiAttention(value, limit = DEFAULT_TRIWIKI_ATTENTION_ANCHOR_LIMIT, query = '') {
     const pack = asRecord(value);
     const attention = asRecord(pack.attention);
     const anchorLimit = normalizeLimit(limit);
     const hydrateHints = new Map();
-    for (const row of Array.isArray(attention.hydrate_first) ? attention.hydrate_first : []) {
+    const hydrateOrder = new Map();
+    for (const [index, row] of (Array.isArray(attention.hydrate_first) ? attention.hydrate_first : []).entries()) {
         if (!Array.isArray(row))
             continue;
         const id = text(row[0]);
         const hint = text(row[1]);
-        if (id && hint)
+        if (id && hint) {
             hydrateHints.set(id, hint.slice(0, 240));
+            hydrateOrder.set(id, index);
+        }
     }
-    const anchors = [];
-    const seen = new Set();
-    for (const row of Array.isArray(attention.use_first) ? attention.use_first : []) {
+    const useFirst = [];
+    for (const [index, row] of (Array.isArray(attention.use_first) ? attention.use_first : []).entries()) {
         if (!Array.isArray(row))
             continue;
         const id = text(row[0]);
-        if (!id || seen.has(id))
+        if (!id || useFirst.some((anchor) => anchor.id === id))
             continue;
-        seen.add(id);
-        anchors.push({
+        useFirst.push({
             id,
             claim_hash: text(row[1]) || null,
             source_hash: text(row[2]) || null,
-            hydrate_hint: hydrateHints.get(id) || null
+            hydrate_hint: hydrateHints.get(id) || null,
+            order: index
         });
-        if (anchors.length >= anchorLimit)
-            break;
     }
+    const anchors = selectAnchors(useFirst, hydrateHints, hydrateOrder, anchorLimit, query);
     return {
         schema: BOUNDED_TRIWIKI_ATTENTION_SCHEMA,
         source: '.sneakoscope/wiki/context-pack.json',
@@ -48,6 +49,108 @@ export function extractBoundedTriwikiAttention(value, limit = DEFAULT_TRIWIKI_AT
         full_pack_injected: false
     };
 }
+function selectAnchors(useFirst, hydrateHints, hydrateOrder, limit, query) {
+    const tokens = attentionQueryTokens(query);
+    if (!tokens.length)
+        return useFirst.slice(0, limit).map(stripOrder);
+    const selected = [];
+    const seen = new Set();
+    // Keep the leading high-trust policy anchors, then spend the remaining
+    // budget on query-relevant use_first or hydrate-first candidates. Hydrate-
+    // only rows stay hints: workers must open the cited source before relying on
+    // them, so relevance improves without treating lower-trust summaries as fact.
+    for (const anchor of useFirst.slice(0, Math.min(3, limit))) {
+        selected.push(stripOrder(anchor));
+        seen.add(anchor.id);
+    }
+    const candidates = [];
+    for (const anchor of useFirst) {
+        if (seen.has(anchor.id))
+            continue;
+        candidates.push({
+            ...stripOrder(anchor),
+            score: attentionRelevance(anchor.id, anchor.hydrate_hint, tokens),
+            order: anchor.order,
+            priority: 0
+        });
+    }
+    for (const [id, hint] of hydrateHints.entries()) {
+        if (seen.has(id) || useFirst.some((anchor) => anchor.id === id))
+            continue;
+        const score = attentionRelevance(id, hint, tokens);
+        if (score <= 0)
+            continue;
+        candidates.push({
+            id,
+            claim_hash: null,
+            source_hash: null,
+            hydrate_hint: hint,
+            score,
+            order: hydrateOrder.get(id) ?? Number.MAX_SAFE_INTEGER,
+            priority: 1
+        });
+    }
+    candidates.sort((left, right) => right.score - left.score || left.priority - right.priority || left.order - right.order);
+    for (const candidate of candidates) {
+        if (selected.length >= limit)
+            break;
+        if (candidate.score <= 0 || seen.has(candidate.id))
+            continue;
+        selected.push(stripRank(candidate));
+        seen.add(candidate.id);
+    }
+    for (const anchor of useFirst) {
+        if (selected.length >= limit)
+            break;
+        if (seen.has(anchor.id))
+            continue;
+        selected.push(stripOrder(anchor));
+        seen.add(anchor.id);
+    }
+    return selected;
+}
+function attentionQueryTokens(value) {
+    const stop = new Set([
+        'and', 'the', 'for', 'with', 'from', 'into', 'this', 'that', 'sks', 'src', 'core',
+        '작업', '구현', '개선', '추가', '변경', '기능', '모든', '최대한'
+    ]);
+    return [...new Set(String(value || '')
+            .normalize('NFKC')
+            .toLowerCase()
+            .replace(/[^\p{L}\p{N}]+/gu, ' ')
+            .split(/\s+/)
+            .map((token) => token.trim())
+            .filter((token) => token.length >= 2 && !stop.has(token)))]
+        .slice(0, 64);
+}
+function attentionRelevance(id, hint, tokens) {
+    const haystack = `${id} ${hint || ''}`
+        .normalize('NFKC')
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}]+/gu, ' ');
+    const compact = haystack.replace(/\s+/g, '');
+    return tokens.reduce((score, token) => {
+        if (haystack.includes(token))
+            return score + (token.length >= 5 ? 4 : 3);
+        return compact.includes(token) ? score + 2 : score;
+    }, 0);
+}
+function stripOrder(anchor) {
+    return {
+        id: anchor.id,
+        claim_hash: anchor.claim_hash,
+        source_hash: anchor.source_hash,
+        hydrate_hint: anchor.hydrate_hint
+    };
+}
+function stripRank(anchor) {
+    return {
+        id: anchor.id,
+        claim_hash: anchor.claim_hash,
+        source_hash: anchor.source_hash,
+        hydrate_hint: anchor.hydrate_hint
+    };
+}
 function normalizeLimit(value) {
     const parsed = Number(value);
     if (!Number.isFinite(parsed))

package/dist/core/triwiki/code-pack-head-freshness.js

@@ -0,0 +1,291 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { readJson, runProcess, writeJsonAtomic } from '../fsx.js';
+const CODE_PACK_METADATA_PATHS = new Set([
+    '.sneakoscope/wiki/code-pack.json',
+    '.sneakoscope/wiki/code-pack.prev.json'
+]);
+const COMMIT_MARKER = '@SKS-CODE-PACK';
+const ADVISORY_CACHE_SCHEMA = 'sks.code-pack-head-freshness-cache.v1';
+const ADVISORY_CACHE_PATH = path.join('.sneakoscope', 'cache', 'code-pack-head-freshness.json');
+export async function inspectCodePackHeadFreshness(root, packShaInput, opts = {}) {
+    const timeoutMs = Math.max(1, Math.floor(opts.timeoutMs ?? 5_000));
+    const startedAt = Date.now();
+    const packSha = normalizeGitSha(packShaInput);
+    const fastHead = await readGitHeadFromAdminFiles(root);
+    if (!packSha)
+        return staleWithCurrentHead(root, null, timeoutMs, fastHead, false, 'invalid_pack_sha');
+    if (fastHead === packSha)
+        return freshness(true, true, 'exact_head', fastHead, packSha, false, []);
+    // Only the non-blocking hook consumes this cache. Authoritative wiki
+    // validation always replays Git history and never trusts advisory state.
+    if (opts.advisoryCache && fastHead) {
+        const cached = await readAdvisoryCache(root, packSha, fastHead);
+        if (cached)
+            return cached;
+    }
+    // One common-path Git process returns HEAD plus every committed path after
+    // the pack was generated. Excluding all parents of packSha keeps packSha in
+    // the walk (including a root commit), so its presence proves ancestry. We
+    // keep scanning after the pack marker because a later merge can introduce
+    // sibling-branch commits that Git orders after packSha. `-m` exposes merge
+    // resolution paths and `--no-renames` makes touched paths auditable.
+    const history = await runProcess('git', [
+        '-c',
+        'core.quotepath=true',
+        'log',
+        '--topo-order',
+        '-m',
+        '--no-ext-diff',
+        `--format=${COMMIT_MARKER}%x09%H`,
+        '--name-status',
+        '--no-renames',
+        'HEAD',
+        '--not',
+        `${packSha}^@`,
+        '--'
+    ], {
+        cwd: root,
+        timeoutMs,
+        maxOutputBytes: 64 * 1024,
+        env: gitEnvironment({
+            GIT_NO_REPLACE_OBJECTS: '1',
+            GIT_OPTIONAL_LOCKS: '0',
+            LC_ALL: 'C'
+        })
+    }).catch(() => null);
+    if (!history || history.code !== 0 || history.timedOut) {
+        return staleWithCurrentHead(root, packSha, remainingMs(startedAt, timeoutMs), fastHead, false, history?.timedOut ? 'git_timeout' : 'git_failed');
+    }
+    const parsed = parseHistory(history.stdout, packSha);
+    if (history.truncated || !parsed.currentSha || parsed.invalid) {
+        const currentSha = parsed.currentSha
+            || fastHead
+            || await readCurrentHead(root, remainingMs(startedAt, timeoutMs));
+        return freshness(false, false, history.truncated ? 'history_truncated' : 'history_parse_invalid', currentSha, packSha, false, parsed.changedPaths);
+    }
+    if (!parsed.sawPack) {
+        return freshness(false, true, 'pack_not_ancestor', parsed.currentSha, packSha, false, parsed.changedPaths);
+    }
+    const metadataOnly = parsed.changedPaths.every((value) => CODE_PACK_METADATA_PATHS.has(value));
+    const exactHead = parsed.currentSha === packSha;
+    const result = freshness(metadataOnly, true, metadataOnly ? 'metadata_only_history' : 'source_change_history', parsed.currentSha, packSha, metadataOnly && !exactHead, parsed.changedPaths);
+    if (opts.advisoryCache && fastHead === parsed.currentSha) {
+        await writeAdvisoryCache(root, result).catch(() => undefined);
+    }
+    return result;
+}
+function parseHistory(stdout, packSha) {
+    let currentSha = null;
+    let activeCommit = null;
+    let sawPack = false;
+    let invalid = false;
+    const changedPaths = [];
+    const seenPaths = new Set();
+    for (const line of String(stdout || '').split(/\r?\n/)) {
+        if (line === '')
+            continue;
+        const marker = line.match(/^@SKS-CODE-PACK\t([0-9a-f]{40,64})$/i);
+        if (marker) {
+            activeCommit = String(marker[1]).toLowerCase();
+            currentSha ||= activeCommit;
+            if (activeCommit === packSha)
+                sawPack = true;
+            continue;
+        }
+        if (!activeCommit) {
+            invalid = true;
+            break;
+        }
+        const separator = line.indexOf('\t');
+        const status = separator > 0 ? line.slice(0, separator) : '';
+        const pathText = separator > 0 ? line.slice(separator + 1) : '';
+        if (!/^[A-Z][0-9]*$/.test(status) || !pathText) {
+            invalid = true;
+            break;
+        }
+        if (activeCommit === packSha)
+            continue;
+        // Do not trim Git paths: leading/trailing whitespace is meaningful and
+        // must never be normalized into an allowlisted metadata path.
+        for (const changedPath of pathText.split('\t')) {
+            if (!changedPath || seenPaths.has(changedPath))
+                continue;
+            seenPaths.add(changedPath);
+            changedPaths.push(changedPath);
+        }
+    }
+    return { currentSha, sawPack, invalid, changedPaths };
+}
+async function readAdvisoryCache(root, packSha, currentSha) {
+    const cached = await readJson(path.join(root, ADVISORY_CACHE_PATH), null).catch(() => null);
+    if (cached?.schema !== ADVISORY_CACHE_SCHEMA)
+        return null;
+    if (normalizeGitSha(cached.pack_sha) !== packSha || normalizeGitSha(cached.current_sha) !== currentSha)
+        return null;
+    const changedPaths = Array.isArray(cached.changed_paths)
+        ? cached.changed_paths.filter((value) => typeof value === 'string').slice(0, 64)
+        : [];
+    const fresh = cached.fresh === true;
+    if (fresh && (cached.metadata_only_drift !== true || changedPaths.some((value) => !CODE_PACK_METADATA_PATHS.has(value)))) {
+        return null;
+    }
+    return freshness(fresh, true, 'advisory_cache', currentSha, packSha, fresh, changedPaths);
+}
+async function writeAdvisoryCache(root, result) {
+    if (!result.pack_sha || !result.current_sha)
+        return;
+    await writeJsonAtomic(path.join(root, ADVISORY_CACHE_PATH), {
+        schema: ADVISORY_CACHE_SCHEMA,
+        pack_sha: result.pack_sha,
+        current_sha: result.current_sha,
+        fresh: result.fresh,
+        reason: result.reason,
+        metadata_only_drift: result.metadata_only_drift,
+        changed_paths: result.changed_paths.slice(0, 64),
+        checked_at: new Date().toISOString()
+    });
+}
+async function staleWithCurrentHead(root, packSha, timeoutMs, knownCurrentSha = null, conclusive = true, reason = 'git_failed') {
+    const currentSha = knownCurrentSha || await readCurrentHead(root, timeoutMs);
+    return freshness(false, conclusive, reason, currentSha, packSha, false, []);
+}
+async function readCurrentHead(root, timeoutMs) {
+    if (timeoutMs <= 0)
+        return null;
+    const head = await runProcess('git', ['rev-parse', 'HEAD'], {
+        cwd: root,
+        timeoutMs,
+        maxOutputBytes: 4 * 1024,
+        env: gitEnvironment({
+            GIT_NO_REPLACE_OBJECTS: '1',
+            GIT_OPTIONAL_LOCKS: '0',
+            LC_ALL: 'C'
+        })
+    }).catch(() => null);
+    return head && head.code === 0 && !head.truncated ? normalizeGitSha(head.stdout) : null;
+}
+async function readGitHeadFromAdminFiles(root) {
+    const gitDir = await resolveGitDir(root);
+    if (!gitDir)
+        return null;
+    const headText = await readSmallText(path.join(gitDir, 'HEAD'), 4 * 1024);
+    if (!headText)
+        return null;
+    const detached = normalizeGitSha(headText);
+    if (detached)
+        return detached;
+    const symbolic = headText.match(/^ref:\s*(refs\/[^\r\n]+)\s*$/);
+    const ref = symbolic ? String(symbolic[1]) : '';
+    if (!safeGitRef(ref))
+        return null;
+    const commonDir = await resolveCommonDir(gitDir);
+    for (const base of [...new Set([gitDir, commonDir])]) {
+        const loose = await readLooseRef(base, ref);
+        if (loose)
+            return loose;
+    }
+    return readPackedRef(commonDir, ref);
+}
+async function resolveGitDir(root) {
+    const dotGit = path.join(root, '.git');
+    const stat = await fsp.stat(dotGit).catch(() => null);
+    if (!stat)
+        return null;
+    if (stat.isDirectory())
+        return dotGit;
+    if (!stat.isFile())
+        return null;
+    const text = await readSmallText(dotGit, 4 * 1024);
+    const match = text?.match(/^gitdir:\s*(.+?)\s*$/m);
+    return match ? path.resolve(path.dirname(dotGit), String(match[1])) : null;
+}
+async function resolveCommonDir(gitDir) {
+    const text = await readSmallText(path.join(gitDir, 'commondir'), 4 * 1024);
+    return text?.trim() ? path.resolve(gitDir, text.trim()) : gitDir;
+}
+async function readLooseRef(base, ref) {
+    const file = safeRefPath(base, ref);
+    if (!file)
+        return null;
+    return normalizeGitSha(await readSmallText(file, 4 * 1024));
+}
+async function readPackedRef(commonDir, ref) {
+    const text = await readSmallText(path.join(commonDir, 'packed-refs'), 4 * 1024 * 1024);
+    if (!text)
+        return null;
+    for (const line of text.split(/\r?\n/)) {
+        if (!line || line.startsWith('#') || line.startsWith('^'))
+            continue;
+        const separator = line.indexOf(' ');
+        if (separator <= 0 || line.slice(separator + 1) !== ref)
+            continue;
+        return normalizeGitSha(line.slice(0, separator));
+    }
+    return null;
+}
+async function readSmallText(file, maxBytes) {
+    const stat = await fsp.stat(file).catch(() => null);
+    if (!stat?.isFile() || stat.size > maxBytes)
+        return null;
+    return fsp.readFile(file, 'utf8').catch(() => null);
+}
+function safeGitRef(ref) {
+    return /^refs\/[A-Za-z0-9._/-]+$/.test(ref)
+        && !ref.includes('..')
+        && !ref.includes('//')
+        && !ref.includes('@{')
+        && !ref.endsWith('/')
+        && !ref.endsWith('.')
+        && !ref.endsWith('.lock');
+}
+function safeRefPath(base, ref) {
+    if (!safeGitRef(ref))
+        return null;
+    const candidate = path.resolve(base, ...ref.split('/'));
+    const relative = path.relative(path.resolve(base), candidate);
+    return relative && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative) ? candidate : null;
+}
+function remainingMs(startedAt, timeoutMs) {
+    return Math.max(0, timeoutMs - (Date.now() - startedAt));
+}
+function gitEnvironment(extra = {}) {
+    return {
+        GIT_ALTERNATE_OBJECT_DIRECTORIES: undefined,
+        GIT_COMMON_DIR: undefined,
+        GIT_CONFIG: undefined,
+        GIT_CONFIG_COUNT: '0',
+        GIT_CONFIG_GLOBAL: undefined,
+        GIT_CONFIG_NOSYSTEM: undefined,
+        GIT_CONFIG_PARAMETERS: undefined,
+        GIT_CONFIG_SYSTEM: undefined,
+        GIT_DIR: undefined,
+        GIT_DISCOVERY_ACROSS_FILESYSTEM: undefined,
+        GIT_EXTERNAL_DIFF: undefined,
+        GIT_GRAFT_FILE: undefined,
+        GIT_INDEX_FILE: undefined,
+        GIT_NAMESPACE: undefined,
+        GIT_OBJECT_DIRECTORY: undefined,
+        GIT_QUARANTINE_PATH: undefined,
+        GIT_REPLACE_REF_BASE: undefined,
+        GIT_SHALLOW_FILE: undefined,
+        GIT_WORK_TREE: undefined,
+        ...extra
+    };
+}
+function freshness(fresh, conclusive, reason, currentSha, packSha, metadataOnlyDrift, changedPaths) {
+    return {
+        fresh,
+        conclusive,
+        reason,
+        current_sha: currentSha,
+        pack_sha: packSha,
+        metadata_only_drift: metadataOnlyDrift,
+        changed_paths: changedPaths
+    };
+}
+function normalizeGitSha(value) {
+    const text = String(value || '').trim();
+    return /^[0-9a-f]{40,64}$/i.test(text) && !/^0+$/.test(text) ? text.toLowerCase() : null;
+}
+//# sourceMappingURL=code-pack-head-freshness.js.map

package/dist/core/version.js

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

package/dist/core/zellij/zellij-launcher.js

@@ -29,7 +29,8 @@ export async function launchZellijLayout(opts = {}) {
     if (opts.codexBin)
         layoutInput.codexBin = opts.codexBin;
     const layout = await writeZellijLayout(root, layoutInput);
-    const capability = await checkZellijCapability({ root, require: opts.requireZellij === true });
+    const capability = reusableZellijCapability(opts.zellijCapability, opts.requireZellij === true)
+        || await checkZellijCapability({ root, require: opts.requireZellij === true });
     // Configure the clipboard pipeline so selections inside the session reach the OS
     // clipboard (Zellij's default OSC-52 copy is dropped by Terminal.app etc.). The
     // copy option flags are appended AFTER `--default-layout <path>` so the launch
@@ -46,6 +47,7 @@ export async function launchZellijLayout(opts = {}) {
             root: opts.cwd || root,
             env: launchProcessEnv,
             cliArgs: layout.codex_args,
+            ...(opts.verifiedCodexLbToolOutputRecovery ? { verifiedProbe: opts.verifiedCodexLbToolOutputRecovery } : {}),
             ...(typeof opts.recoveryFetch === 'function' ? { fetchImpl: opts.recoveryFetch } : {}),
             ...(opts.recoveryTimeoutMs === undefined ? {} : { timeoutMs: opts.recoveryTimeoutMs }),
             ...(opts.recoveryAllowUnverified === true ? { allowUnverified: true } : {})
@@ -75,7 +77,8 @@ export async function launchZellijLayout(opts = {}) {
         ledgerRoot: path.join(root, '.sneakoscope', 'missions', missionId),
         sessionName,
         expectedLaneCount: 0,
-        expectedCwd: opts.cwd || root
+        expectedCwd: opts.cwd || root,
+        zellijCapability: capability
     };
     if (layout.main_pane_kind === 'codex_interactive')
         paneProofOpts.expectedMainCommandIncludes = 'codex';
@@ -169,6 +172,13 @@ export async function launchZellijLayout(opts = {}) {
     ]);
     return report;
 }
+function reusableZellijCapability(value, requireZellij) {
+    if (!value || value.schema !== 'sks.zellij-capability.v1')
+        return null;
+    if (requireZellij && value.status !== 'ok')
+        return null;
+    return value;
+}
 function launchRecoveryEnv(launchEnv) {
     const env = { ...process.env };
     for (const [key, value] of Object.entries(launchEnv || {})) {

package/dist/core/zellij/zellij-pane-proof.js

@@ -9,7 +9,8 @@ export async function writeZellijPaneProof(root, opts = {}) {
     const session = await readJson(path.join(outRoot, 'zellij-session.json'), null);
     const sessionName = opts.sessionName || session?.session_name || null;
     const expectedMainCommand = opts.expectedMainCommandIncludes || (session?.codex_pane?.enabled === true ? String(session.codex_pane.bin || 'codex') : '');
-    const capability = await checkZellijCapability({ root, require: opts.require === true, writeReport: true });
+    const capability = reusableZellijCapability(opts.zellijCapability, opts.require === true)
+        || await checkZellijCapability({ root, require: opts.require === true, writeReport: true });
     const command = sessionName
         ? ['--session', sessionName, 'action', 'list-panes', '--json', '--all']
         : ['action', 'list-panes', '--json', '--all'];
@@ -93,6 +94,13 @@ export async function writeZellijPaneProof(root, opts = {}) {
     await writeJsonAtomic(path.join(outRoot, 'zellij-pane-proof.json'), report);
     return report;
 }
+function reusableZellijCapability(value, requireZellij) {
+    if (!value || value.schema !== 'sks.zellij-capability.v1')
+        return null;
+    if (requireZellij && value.status !== 'ok')
+        return null;
+    return value;
+}
 export async function readZellijPaneProof(root) {
     return readJson(path.join(root, 'zellij-pane-proof.json'), null);
 }

package/dist/core/zellij/zellij-update.js

@@ -206,6 +206,7 @@ export async function upgradeZellijToLatest(input = {}) {
 export async function maybePromptZellijUpdateForLaunch(args = [], opts = {}) {
     const env = opts.env || process.env;
     const list = (args || []).map((arg) => String(arg));
+    const autoYes = list.includes('--yes') || list.includes('-y');
     const mode = resolveZellijUpdatePromptMode({
         env,
         skipFlag: list.includes('--json') || list.includes('--skip-cli-tools') || list.includes('--skip-zellij-update'),
@@ -215,6 +216,19 @@ export async function maybePromptZellijUpdateForLaunch(args = [], opts = {}) {
     if (mode === 'skip') {
         return { status: 'skipped', current: null, latest: null, command: null };
     }
+    if (opts.deferUpdateCheck === true && !autoYes) {
+        const localCapability = await checkZellijCapability({ require: false, writeReport: false, env }).catch(() => null);
+        if (localCapability?.status === 'ok') {
+            return {
+                status: 'current',
+                current: localCapability.version,
+                latest: null,
+                command: null,
+                deferred: true,
+                capability: localCapability
+            };
+        }
+    }
     const noticeInput = { env };
     if (opts.missionDir !== undefined)
         noticeInput.missionDir = opts.missionDir;
@@ -264,7 +278,6 @@ export async function maybePromptZellijUpdateForLaunch(args = [], opts = {}) {
         return { status: 'current', current: notice.current_version, latest: notice.latest_version, command: null, error: notice.error || null };
     }
     const label = opts.label || 'Zellij launch';
-    const autoYes = list.includes('--yes') || list.includes('-y');
     if (mode === 'nonblocking-notice') {
         console.log(`Zellij update available: ${notice.current_version} -> ${notice.latest_version}. Run: ${notice.upgrade_command}`);
         return { status: 'available', current: notice.current_version, latest: notice.latest_version, command: notice.upgrade_command };

package/dist/scripts/canonical-test-runner.js

@@ -2,7 +2,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
-import { tmpdir } from '../core/fsx.js';
+import { SKS_TEMP_LEASE_FILE, tmpdir, writeJsonAtomic } from '../core/fsx.js';
 const root = process.cwd();
 const compiled = discover(path.join(root, 'dist'), (file) => file.endsWith('.test.js') && file.includes(`${path.sep}__tests__${path.sep}`));
 const unit = discover(path.join(root, 'test', 'unit'), (file) => file.endsWith('.test.mjs'));
@@ -60,6 +60,12 @@ process.once('exit', () => {
     if (error)
         console.error(`canonical test cleanup failed during exit: ${error.message}`);
 });
+await writeJsonAtomic(path.join(scratch, SKS_TEMP_LEASE_FILE), {
+    schema: 'sks.temp-lease.v1',
+    kind: 'canonical-test-runner',
+    pid: process.pid,
+    created_at: new Date().toISOString()
+});
 const isolatedProcessGroup = process.platform !== 'win32';
 const child = spawn(process.execPath, ['--test', '--test-concurrency=1', ...files, ...process.argv.slice(2)], {
     cwd: root,

package/dist/scripts/codex-lb-fast-mode-truth-check.js

@@ -3,6 +3,7 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { run } from '../commands/codex-lb.js';
+import { CODEX_LB_TOOL_OUTPUT_RECOVERY_MIN_VERSION } from '../core/codex-lb/codex-lb-tool-output-recovery.js';
 const calls = [];
 const home = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-codex-lb-fast-truth-'));
 await fs.mkdir(path.join(home, '.codex'), { recursive: true });
@@ -58,7 +59,16 @@ async function runFastCheck(env) {
     try {
         Object.assign(process.env, env);
         process.exitCode = 0;
-        globalThis.fetch = async (_url, init) => {
+        globalThis.fetch = async (url, init = {}) => {
+            if (new URL(String(url)).pathname === '/health') {
+                return new Response('{}', {
+                    status: 200,
+                    headers: {
+                        'content-type': 'application/json',
+                        'x-app-version': CODEX_LB_TOOL_OUTPUT_RECOVERY_MIN_VERSION
+                    }
+                });
+            }
             const body = JSON.parse(String(init.body || '{}'));
             calls.push({ body });
             const id = calls.length % 2 === 1 ? 'resp_fast_1' : 'resp_fast_2';

package/dist/scripts/codex-lb-fast-ui-preservation-check.js

@@ -41,8 +41,15 @@ await fs.writeFile(configPath, [
 ].join('\n'));
 await fs.writeFile(envPath, 'export CODEX_LB_BASE_URL="https://lb.example.test/backend-api/codex"\nexport CODEX_LB_API_KEY="sk-test-fast-ui"\n');
 await fs.writeFile(authPath, `${oauthAuth}\n`);
+const toolOutputRecoveryFetch = async () => new Response('{}', {
+    status: 200,
+    headers: {
+        'content-type': 'application/json',
+        'x-app-version': '1.21.0-beta.3'
+    }
+});
 const install = await ensureGlobalCodexFastModeDuringInstall({ home, configPath, forceFastMode: true });
-const firstRepair = await repairCodexLbAuth({ home, configPath, envPath, forceCodexLbApiKeyAuth: true, forceFastMode: true, authMode: 'codex-lb' });
+const firstRepair = await repairCodexLbAuth({ home, configPath, envPath, forceCodexLbApiKeyAuth: true, forceFastMode: true, authMode: 'codex-lb', toolOutputRecoveryFetch });
 const firstConfig = await fs.readFile(configPath, 'utf8');
 const firstAssert = assertConfig(firstConfig, 'first_use_codex_lb');
 const release = await releaseCodexLbAuthHold({ home, configPath, authPath, backupPath: oauthBackupPath });
@@ -55,7 +62,7 @@ const releaseAssert = {
         ...(hasLegacyFastModeTables(releasedConfig) ? ['legacy_fast_mode_tables_survived_use_oauth'] : [])
     ]
 };
-const secondRepair = await repairCodexLbAuth({ home, configPath, envPath, forceCodexLbApiKeyAuth: true, forceFastMode: true, authMode: 'codex-lb' });
+const secondRepair = await repairCodexLbAuth({ home, configPath, envPath, forceCodexLbApiKeyAuth: true, forceFastMode: true, authMode: 'codex-lb', toolOutputRecoveryFetch });
 const secondConfig = await fs.readFile(configPath, 'utf8');
 const secondAssert = assertConfig(secondConfig, 'second_use_codex_lb');
 const report = {