sneakoscope 3.0.1 → 3.0.3

package/dist/core/release/release-cache-key.js

@@ -0,0 +1,128 @@
+export function classifyReleaseCacheInputChange(input) {
+    if (input.before === input.after) {
+        return { neutralizable: true, reason: 'unchanged', behavior_affecting: false };
+    }
+    const before = normalizeReleaseCacheInputForBehavior(input.file, input.before);
+    const after = normalizeReleaseCacheInputForBehavior(input.file, input.after);
+    if (before === after) {
+        return {
+            neutralizable: true,
+            reason: neutralReason(input.file),
+            behavior_affecting: false
+        };
+    }
+    return {
+        neutralizable: false,
+        reason: behaviorReason(input.file, input.before, input.after),
+        behavior_affecting: true
+    };
+}
+export function normalizeReleaseCacheInputForBehavior(file, text) {
+    const rel = normalizeRel(file);
+    if (rel === 'package.json')
+        return normalizePackageJson(text);
+    if (rel === 'package-lock.json')
+        return normalizePackageLock(text);
+    if (rel === 'src/core/version.ts' || rel === 'src/core/fsx.ts') {
+        return text.replace(/(PACKAGE_VERSION\s*=\s*['"])([^'"]+)(['"])/, '$1__SKS_RELEASE_VERSION__$3');
+    }
+    if (rel === 'src/bin/sks.ts') {
+        return text.replace(/(FAST_PACKAGE_VERSION\s*=\s*['"])([^'"]+)(['"])/, '$1__SKS_RELEASE_VERSION__$3');
+    }
+    if (rel === 'dist/build-manifest.json')
+        return normalizeBuildManifest(text);
+    return text;
+}
+function normalizePackageJson(text) {
+    return normalizeJson(text, (value) => {
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            value.version = '__SKS_RELEASE_VERSION__';
+        }
+        return value;
+    });
+}
+function normalizePackageLock(text) {
+    return normalizeJson(text, (value) => {
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            value.version = '__SKS_RELEASE_VERSION__';
+            if (value.packages?.[''] && typeof value.packages[''] === 'object') {
+                value.packages[''].version = '__SKS_RELEASE_VERSION__';
+            }
+        }
+        return value;
+    });
+}
+function normalizeBuildManifest(text) {
+    return normalizeJson(text, (value) => {
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            if ('version' in value)
+                value.version = '__SKS_RELEASE_VERSION__';
+            if ('package_version' in value)
+                value.package_version = '__SKS_RELEASE_VERSION__';
+        }
+        return value;
+    });
+}
+function normalizeJson(text, mutate) {
+    try {
+        const parsed = JSON.parse(text);
+        return stableJson(mutate(parsed));
+    }
+    catch {
+        return text;
+    }
+}
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(',')}]`;
+    if (value && typeof value === 'object') {
+        return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+function neutralReason(file) {
+    const rel = normalizeRel(file);
+    if (rel === 'package.json')
+        return 'package_json_version_only';
+    if (rel === 'package-lock.json')
+        return 'package_lock_root_version_only';
+    if (rel === 'src/bin/sks.ts')
+        return 'fast_package_version_only';
+    if (rel === 'src/core/version.ts' || rel === 'src/core/fsx.ts')
+        return 'package_version_constant_only';
+    if (rel === 'dist/build-manifest.json')
+        return 'build_manifest_version_only';
+    return 'version_surface_only';
+}
+function behaviorReason(file, before, after) {
+    const rel = normalizeRel(file);
+    if (rel === 'package.json') {
+        const changed = changedTopLevelJsonKeys(before, after);
+        const behaviorKeys = changed.filter((key) => ['scripts', 'dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies', 'files', 'engines', 'publishConfig'].includes(key));
+        return behaviorKeys.length ? `package_json_behavior_keys:${behaviorKeys.join(',')}` : `package_json_non_version_keys:${changed.join(',') || 'unknown'}`;
+    }
+    if (rel === 'package-lock.json')
+        return 'package_lock_dependency_graph_changed';
+    if (rel === 'dist/build-manifest.json')
+        return 'build_manifest_artifact_hash_or_behavior_changed';
+    if (rel.startsWith('src/'))
+        return 'source_behavior_changed';
+    if (rel.startsWith('schemas/'))
+        return 'schema_behavior_changed';
+    return 'release_cache_input_behavior_changed';
+}
+function changedTopLevelJsonKeys(before, after) {
+    try {
+        const left = JSON.parse(before);
+        const right = JSON.parse(after);
+        const keys = [...new Set([...Object.keys(left || {}), ...Object.keys(right || {})])];
+        return keys.filter((key) => stableJson(left?.[key]) !== stableJson(right?.[key])).sort();
+    }
+    catch {
+        return [];
+    }
+}
+function normalizeRel(file) {
+    return String(file || '').replace(/\\/g, '/').replace(/^\.?\//, '');
+}
+//# sourceMappingURL=release-cache-key.js.map

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

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
+import { normalizeReleaseCacheInputForBehavior } from './release-cache-key.js';
 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');
@@ -21,7 +22,8 @@ const VERSION_NEUTRAL_CACHE_FILES = new Set([
     'package-lock.json',
     'src/core/version.ts',
     'src/core/fsx.ts',
-    'src/bin/sks.ts'
+    'src/bin/sks.ts',
+    'dist/build-manifest.json'
 ]);
 export function releaseGateCacheKey(root, gate) {
     const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
@@ -54,14 +56,14 @@ export function releaseGateCacheKey(root, gate) {
             const rel = path.relative(root, file);
             hash.update(rel);
             if (!versionSensitive && VERSION_NEUTRAL_CACHE_FILES.has(rel))
-                hashVersionNeutralFile(hash, file, releaseVersion);
+                hashVersionNeutralFile(hash, rel, file, releaseVersion);
             else
                 hashFileIfPresent(hash, file);
         }
     }
     return hash.digest('hex');
 }
-function hashVersionNeutralFile(hash, file, releaseVersion) {
+function hashVersionNeutralFile(hash, rel, file, releaseVersion) {
     if (!fs.existsSync(file) || !fs.statSync(file).isFile())
         return;
     const text = fs.readFileSync(file, 'utf8');
@@ -69,10 +71,7 @@ function hashVersionNeutralFile(hash, file, 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__'));
+    hash.update(normalizeReleaseCacheInputForBehavior(rel, text));
 }
 export function expandGlob(root, input) {
     const absolute = path.join(root, input);

package/dist/core/release/release-proof-truth.js

@@ -0,0 +1,63 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { nowIso, readJson, runProcess, sha256, writeJsonAtomic } from '../fsx.js';
+export async function buildReleaseProofTruth(root) {
+    const pkg = await readJson(path.join(root, 'package.json'));
+    const gitCommit = await gitOutput(root, ['rev-parse', 'HEAD']);
+    const gitBranch = await gitOutput(root, ['rev-parse', '--abbrev-ref', 'HEAD']);
+    const gitStatus = await gitOutput(root, ['status', '--porcelain']);
+    const packlist = await readNpmPacklist(root);
+    return {
+        schema: 'sks.release-proof-truth.v1',
+        generated_at: nowIso(),
+        package_version: String(pkg.version || ''),
+        git_commit_sha: gitCommit || null,
+        git_branch: gitBranch || null,
+        git_status_clean: gitStatus === '',
+        package_json_sha256: await shaFile(root, 'package.json'),
+        package_lock_sha256: await shaFile(root, 'package-lock.json'),
+        version_ts_sha256: await shaFile(root, 'src/core/version.ts'),
+        changelog_sha256: await shaFile(root, 'CHANGELOG.md'),
+        release_gates_sha256: await shaFile(root, 'release-gates.v2.json'),
+        ...(packlist ? {
+            npm_packlist_count: packlist.count,
+            npm_packlist_bytes: packlist.bytes
+        } : {})
+    };
+}
+export async function writeReleaseProofTruth(root) {
+    const truth = await buildReleaseProofTruth(root);
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'release-proof-truth.json'), truth);
+    await writeJsonAtomic(path.join(root, 'dist', 'release-proof-truth.json'), truth);
+    return truth;
+}
+async function shaFile(root, rel) {
+    return sha256(await fs.readFile(path.join(root, rel)));
+}
+async function gitOutput(root, args) {
+    const result = await runProcess('git', args, { cwd: root, timeoutMs: 10000, maxOutputBytes: 64 * 1024 }).catch(() => null);
+    if (!result || result.code !== 0)
+        return null;
+    return String(result.stdout || '').trim();
+}
+async function readNpmPacklist(root) {
+    const result = await runProcess('npm', ['pack', '--dry-run', '--json', '--ignore-scripts'], {
+        cwd: root,
+        timeoutMs: 60000,
+        maxOutputBytes: 1024 * 1024
+    }).catch(() => null);
+    if (!result || result.code !== 0)
+        return null;
+    try {
+        const parsed = JSON.parse(String(result.stdout || '[]'));
+        const files = Array.isArray(parsed?.[0]?.files) ? parsed[0].files : [];
+        return {
+            count: files.length,
+            bytes: files.reduce((sum, file) => sum + Number(file.size || 0), 0)
+        };
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=release-proof-truth.js.map

package/dist/core/safety/side-effect-runtime-report.js

@@ -34,10 +34,18 @@ export async function buildSideEffectRuntimeReport(root) {
 async function discoverLedgerPaths(root) {
     const found = new Set();
     await addIfExists(found, mutationLedgerPath(root));
-    await walkForLedgers(path.join(root, '.sneakoscope', 'missions'), found);
+    await walkForLedgers(path.join(root, '.sneakoscope', 'missions'), found, {
+        depth: 0,
+        maxDepth: positiveInt(process.env.SKS_SIDE_EFFECT_LEDGER_SCAN_MAX_DEPTH, 6),
+        visitedDirs: 0,
+        maxDirs: positiveInt(process.env.SKS_SIDE_EFFECT_LEDGER_SCAN_MAX_DIRS, 20000)
+    });
     return [...found].sort();
 }
-async function walkForLedgers(dir, found) {
+async function walkForLedgers(dir, found, budget) {
+    if (budget.depth > budget.maxDepth || budget.visitedDirs >= budget.maxDirs)
+        return;
+    budget.visitedDirs += 1;
     let entries;
     try {
         entries = await fsp.readdir(dir, { withFileTypes: true });
@@ -47,12 +55,19 @@ async function walkForLedgers(dir, found) {
     }
     for (const entry of entries) {
         const file = path.join(dir, entry.name);
-        if (entry.isDirectory())
-            await walkForLedgers(file, found);
+        if (entry.isDirectory() && !shouldSkipLedgerScanDir(entry.name))
+            await walkForLedgers(file, found, { ...budget, depth: budget.depth + 1 });
         else if (entry.isFile() && entry.name === 'mutation-ledger.jsonl')
             found.add(file);
     }
 }
+function shouldSkipLedgerScanDir(name) {
+    return new Set(['node_modules', '.git', 'dist', 'vendor', '.next', 'coverage']).has(name);
+}
+function positiveInt(value, fallback) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
 async function addIfExists(found, file) {
     try {
         await fsp.access(file);

package/dist/core/version.js

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

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

@@ -3,6 +3,47 @@ import { nowIso, writeJsonAtomic } from '../fsx.js';
 import { compareVersionLike, parseZellijVersionText, runZellij } from './zellij-command.js';
 export const ZELLIJ_CAPABILITY_SCHEMA = 'sks.zellij-capability.v1';
 export const ZELLIJ_MIN_VERSION = '0.41.0';
+export const ZELLIJ_STACKED_PANE_CAPABILITY_SCHEMA = 'sks.zellij-stacked-pane-capability.v1';
+export const ZELLIJ_STACKED_PANE_MIN_VERSION = '0.43.0';
+export function zellijSupportsStackedPanes(version) {
+    const parsed = parseZellijVersionText(version);
+    return Boolean(parsed && compareVersionLike(parsed, ZELLIJ_STACKED_PANE_MIN_VERSION) >= 0);
+}
+export function resolveZellijStackedPaneCapability(input = {}) {
+    const versionText = input.versionText == null ? null : String(input.versionText);
+    const parsedVersion = parseZellijVersionText(versionText);
+    const supports = zellijSupportsStackedPanes(parsedVersion);
+    const blockers = [...(input.blockers || [])].map(String);
+    const zellijMissing = blockers.includes('zellij_missing') || blockers.includes('zellij_missing_required');
+    if (!parsedVersion && !zellijMissing && input.ok === false)
+        blockers.push('zellij_version_unparsed');
+    return {
+        schema: ZELLIJ_STACKED_PANE_CAPABILITY_SCHEMA,
+        ok: blockers.length === 0 && supports,
+        zellij_bin: input.zellijBin === undefined ? 'zellij' : input.zellijBin,
+        version_text: versionText,
+        parsed_version: parsedVersion,
+        supports_stacked_panes: supports,
+        requires_update: Boolean(parsedVersion && !supports),
+        fallback_mode: supports ? 'native-stacked' : zellijMissing ? 'headless-only' : 'down-split-stack-emulation',
+        blockers
+    };
+}
+export async function checkZellijStackedPaneCapability(opts = {}) {
+    const versionRun = await runZellij(['--version'], { optional: true, timeoutMs: 5000 });
+    const versionText = `${versionRun.stdout_tail}\n${versionRun.stderr_tail}`.trim();
+    const report = resolveZellijStackedPaneCapability({
+        ok: versionRun.ok,
+        zellijBin: 'zellij',
+        versionText,
+        blockers: versionRun.ok ? [] : versionRun.blockers
+    });
+    if (opts.writeReport !== false) {
+        const root = opts.root || process.cwd();
+        await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'zellij-stacked-pane-capability.json'), report);
+    }
+    return report;
+}
 export async function checkZellijCapability(opts = {}) {
     const requireZellij = opts.require === true || process.env.SKS_REQUIRE_ZELLIJ === '1';
     const versionRun = await runZellij(['--version'], { optional: !requireZellij, timeoutMs: 5000 });

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

@@ -1,6 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { runProcess } from '../fsx.js';
+import { runFakeZellij } from './zellij-fake-adapter.js';
 export const ZELLIJ_UNIX_SOCKET_PATH_LIMIT = 103;
 export async function runZellij(args = [], opts = {}) {
     const started = Date.now();
@@ -16,7 +17,17 @@ export async function runZellij(args = [], opts = {}) {
         runOpts.stdoutFile = opts.stdoutFile;
     if (opts.stderrFile !== undefined)
         runOpts.stderrFile = opts.stderrFile;
-    const result = await runProcess('zellij', args, runOpts);
+    const fakeOpts = {
+        cwd: runOpts.cwd || process.cwd(),
+        env: preparedEnv.env
+    };
+    if (runOpts.timeoutMs !== undefined)
+        fakeOpts.timeoutMs = runOpts.timeoutMs;
+    if (runOpts.maxOutputBytes !== undefined)
+        fakeOpts.maxOutputBytes = runOpts.maxOutputBytes;
+    const result = process.env.SKS_ZELLIJ_FAKE_ADAPTER === '1' || preparedEnv.env.SKS_ZELLIJ_FAKE_ADAPTER === '1'
+        ? await runFakeZellij(args, fakeOpts)
+        : await runProcess('zellij', args, runOpts);
     const ok = result.code === 0;
     const stderr = String(result.stderr || '');
     const missing = result.code === -1 && /ENOENT|not found|spawn zellij/i.test(stderr);
@@ -88,9 +99,10 @@ export function isZellijSocketPathTooLong(text) {
     return /IPC socket path is too long|socket path is too long/i.test(String(text || ''));
 }
 export function parseZellijVersionText(text) {
-    const match = String(text || '').match(/\b(\d+\.\d+\.\d+)(?:[-+][0-9A-Za-z.-]+)?\b/);
+    const match = String(text || '').match(/(?:^|[^0-9A-Za-z])v?(\d+\.\d+\.\d+)(?:[-+][0-9A-Za-z.-]+)?(?:$|[^0-9A-Za-z])/i);
     return match?.[1] ?? null;
 }
+export const parseZellijVersion = parseZellijVersionText;
 export function compareVersionLike(a, b) {
     const pa = versionParts(a);
     const pb = versionParts(b);

package/dist/core/zellij/zellij-fake-adapter.js

@@ -0,0 +1,163 @@
+import path from 'node:path';
+import { appendJsonl, ensureDir, nowIso } from '../fsx.js';
+const sessions = new Map();
+export async function runFakeZellij(args = [], opts = {}) {
+    const env = { ...process.env, ...(opts.env || {}) };
+    const root = path.resolve(String(env.SKS_ZELLIJ_FAKE_ROOT || opts.cwd || process.cwd()));
+    const version = String(env.SKS_ZELLIJ_FAKE_VERSION || '0.43.1');
+    const delayMs = Math.max(0, Number(env.SKS_ZELLIJ_FAKE_DELAY_MS || 0) || 0);
+    const sessionName = sessionFromArgs(args);
+    const startedAt = Date.now();
+    let result;
+    if (args.length === 1 && args[0] === '--version') {
+        result = ok(`zellij ${version}\n`);
+    }
+    else if (args[0] === 'attach' && args[1] === '--create-background') {
+        getSession(String(args[2] || 'default'));
+        result = ok('');
+    }
+    else if (args.includes('new-pane')) {
+        if (args.includes('--stacked') && !supportsStacked(version)) {
+            result = fail('unknown option --stacked');
+        }
+        else {
+            if (delayMs > 0)
+                await sleep(delayMs);
+            const session = getSession(sessionName);
+            const name = optionValue(args, '--name') || `pane-${session.next_id}`;
+            const paneId = `terminal_${session.next_id++}`;
+            const command = commandAfter(args, '--') || '';
+            const pane = { pane_id: paneId, title: name, name, terminal_command: command, exited: false };
+            session.panes.push(pane);
+            session.focused_pane_id = paneId;
+            result = ok(`${JSON.stringify({ pane_id: paneId })}\n`);
+        }
+    }
+    else if (args.includes('focus-pane-id')) {
+        const paneId = String(args[args.indexOf('focus-pane-id') + 1] || '');
+        const session = getSession(sessionName);
+        const pane = findPane(session, paneId);
+        if (!pane)
+            result = fail(`Pane ${paneId} not found`);
+        else {
+            session.focused_pane_id = pane.pane_id;
+            result = ok('');
+        }
+    }
+    else if (args.includes('list-panes')) {
+        const session = getSession(sessionName);
+        result = ok(`${JSON.stringify(session.panes)}\n`);
+    }
+    else if (args.includes('dump-screen')) {
+        const session = getSession(sessionName);
+        result = ok(session.panes.map((pane) => pane.title).join('\n') + '\n');
+    }
+    else if (args.includes('rename-pane')) {
+        const session = getSession(sessionName);
+        const paneId = optionValue(args, '--pane-id');
+        const name = String(args[args.length - 1] || '');
+        const pane = paneId ? findPane(session, paneId) : session.panes.find((row) => row.pane_id === session.focused_pane_id);
+        if (!pane)
+            result = fail(`Pane ${paneId || 'focused'} not found`);
+        else {
+            pane.title = name;
+            pane.name = name;
+            result = ok('');
+        }
+    }
+    else if (args.includes('close-pane')) {
+        const session = getSession(sessionName);
+        const paneId = optionValue(args, '--pane-id');
+        const pane = paneId ? findPane(session, paneId) : session.panes.find((row) => row.pane_id === session.focused_pane_id);
+        if (!pane)
+            result = fail(`Pane ${paneId || 'focused'} not found`);
+        else {
+            pane.exited = true;
+            result = ok('');
+        }
+    }
+    else {
+        result = ok('');
+    }
+    await recordFakeZellijCall(root, args, {
+        session_name: sessionName,
+        version,
+        exit_code: result.code,
+        duration_ms: Date.now() - startedAt
+    });
+    return result;
+}
+async function recordFakeZellijCall(root, args, meta) {
+    const file = path.join(root, '.sneakoscope', 'fake-zellij-calls.jsonl');
+    await ensureDir(path.dirname(file));
+    await appendJsonl(file, {
+        schema: 'sks.fake-zellij-call.v1',
+        ts: nowIso(),
+        args: [...args],
+        ...meta
+    });
+}
+function getSession(name) {
+    const key = String(name || 'default');
+    const existing = sessions.get(key);
+    if (existing)
+        return existing;
+    const next = { next_id: 1, focused_pane_id: null, panes: [] };
+    sessions.set(key, next);
+    return next;
+}
+function sessionFromArgs(args) {
+    const explicit = optionValue(args, '--session');
+    if (explicit)
+        return explicit;
+    if (args[0] === 'attach' && args[1] === '--create-background')
+        return String(args[2] || 'default');
+    return 'default';
+}
+function optionValue(args, flag) {
+    const index = args.indexOf(flag);
+    if (index < 0)
+        return null;
+    const value = args[index + 1];
+    return value == null ? null : String(value);
+}
+function commandAfter(args, marker) {
+    const index = args.indexOf(marker);
+    if (index < 0)
+        return null;
+    return args.slice(index + 1).map(String).join(' ');
+}
+function findPane(session, id) {
+    const normalized = String(id || '').replace(/^terminal_/, '');
+    return session.panes.find((pane) => pane.pane_id === id || pane.pane_id.replace(/^terminal_/, '') === normalized) || null;
+}
+function supportsStacked(version) {
+    const parts = String(version || '0.0.0').match(/(\d+)\.(\d+)\.(\d+)/)?.slice(1).map((part) => Number.parseInt(part, 10) || 0) || [0, 0, 0];
+    return parts[0] > 0 || parts[1] > 43 || (parts[1] === 43 && parts[2] >= 0);
+}
+function ok(stdout) {
+    return {
+        code: 0,
+        stdout,
+        stderr: '',
+        stdoutBytes: Buffer.byteLength(stdout),
+        stderrBytes: 0,
+        truncated: false,
+        timedOut: false
+    };
+}
+function fail(stderr) {
+    return {
+        code: 1,
+        stdout: '',
+        stderr,
+        stdoutBytes: 0,
+        stderrBytes: Buffer.byteLength(stderr),
+        truncated: false,
+        timedOut: false
+    };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=zellij-fake-adapter.js.map

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

@@ -8,6 +8,18 @@ import { createRequestedScopeContract } from '../safety/requested-scope-contract
 import { checkZellijCapability } from './zellij-capability.js';
 import { compareVersionLike, parseZellijVersionText } from './zellij-command.js';
 export const ZELLIJ_UPDATE_NOTICE_SCHEMA = 'sks.zellij-update-notice.v1';
+export function resolveZellijUpdatePromptMode(input) {
+    const env = input.env || process.env;
+    if (input.skipFlag === true || env.SKS_SKIP_ZELLIJ_UPDATE === '1')
+        return 'skip';
+    if (input.ci === true || env.CI === '1' || /^true$/i.test(String(env.CI || '')))
+        return 'nonblocking-notice';
+    if (input.noQuestion === true || env.SKS_NO_QUESTION === '1' || /^true$/i.test(String(env.SKS_NO_QUESTION || '')))
+        return 'nonblocking-notice';
+    if (input.headless === true)
+        return 'nonblocking-notice';
+    return 'interactive-prompt';
+}
 const ZELLIJ_RELEASES_API_PATH = '/repos/zellij-org/zellij/releases/latest';
 export function zellijUpgradeCommandHint(missing = false) {
     if (process.platform === 'darwin')
@@ -194,10 +206,19 @@ export async function upgradeZellijToLatest(input = {}) {
 export async function maybePromptZellijUpdateForLaunch(args = [], opts = {}) {
     const env = opts.env || process.env;
     const list = (args || []).map((arg) => String(arg));
-    if (list.includes('--json') || list.includes('--skip-cli-tools') || list.includes('--skip-zellij-update') || env.SKS_SKIP_ZELLIJ_UPDATE === '1') {
+    const mode = resolveZellijUpdatePromptMode({
+        env,
+        skipFlag: list.includes('--json') || list.includes('--skip-cli-tools') || list.includes('--skip-zellij-update'),
+        noQuestion: list.includes('--no-question') || list.includes('--no-questions'),
+        headless: !(process.stdin.isTTY && process.stdout.isTTY)
+    });
+    if (mode === 'skip') {
         return { status: 'skipped', current: null, latest: null, command: null };
     }
-    const notice = await checkZellijUpdateNotice({ env }).catch(() => null);
+    const noticeInput = { env };
+    if (opts.missionDir !== undefined)
+        noticeInput.missionDir = opts.missionDir;
+    const notice = await checkZellijUpdateNotice(noticeInput).catch(() => null);
     if (!notice)
         return { status: 'skipped', current: null, latest: null, command: null };
     if (notice.zellij_missing) {
@@ -211,6 +232,10 @@ export async function maybePromptZellijUpdateForLaunch(args = [], opts = {}) {
     }
     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 };
+    }
     if (!autoYes && !canAskYesNo(env)) {
         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 };
@@ -284,7 +309,7 @@ function githubLatestTag(timeoutMs) {
     });
 }
 function canAskYesNo(env) {
-    return Boolean(process.stdin.isTTY && process.stdout.isTTY && env.CI !== 'true');
+    return resolveZellijUpdatePromptMode({ env, headless: !(process.stdin.isTTY && process.stdout.isTTY) }) === 'interactive-prompt';
 }
 async function askYesNoDefaultYes(question) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });