sneakoscope 4.6.3 → 4.6.4

package/README.md

@@ -49,7 +49,7 @@ sks seo-geo-optimizer apply latest --mode seo --apply --json
 sks seo-geo-optimizer audit --mode geo --target package --offline --json
 ```
 
-> 📋 **Current release: `v4.6.3`** — full release history lives in [CHANGELOG.md](CHANGELOG.md). This README documents how Sneakoscope works today, not its version-by-version changes. Release readiness is tracked in [docs/release-readiness.md](docs/release-readiness.md).
+> 📋 **Current release: `v4.6.4`** — full release history lives in [CHANGELOG.md](CHANGELOG.md). This README documents how Sneakoscope works today, not its version-by-version changes. Release readiness is tracked in [docs/release-readiness.md](docs/release-readiness.md).
 
 ## 🍥 Parallelism, UX, And Integrations
 

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "4.6.3"
+version = "4.6.4"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "4.6.3"
+version = "4.6.4"
 edition = "2021"
 
 [dependencies]

package/crates/sks-core/src/main.rs

@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek, SeekFrom};
 fn main() {
     let mut args = std::env::args().skip(1);
     match args.next().as_deref() {
-        Some("--version") => println!("sks-rs 4.6.3"),
+        Some("--version") => println!("sks-rs 4.6.4"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '4.6.3';
+const FAST_PACKAGE_VERSION = '4.6.4';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

package/dist/cli/install-helpers.js

@@ -92,6 +92,11 @@ export async function postinstall({ bootstrap, args = [] }) {
             console.log('SKS update migration: global Doctor ran; project receipt will be finalized on first normal command.');
         else
             console.log(`SKS update migration: global Doctor did not complete; first normal command will retry. ${(postinstallDoctor.blockers || []).join(', ')}`.trim());
+        const postinstallRetention = await runPostinstallProjectRetentionCleanup(installRoot);
+        if (postinstallRetention.status === 'completed' && postinstallRetention.action_count > 0)
+            console.log(`SKS mission cleanup: removed ${postinstallRetention.action_count} disposable runtime artifact(s) from closed missions.`);
+        else if (postinstallRetention.status === 'failed')
+            console.log(`SKS mission cleanup: skipped (${postinstallRetention.error || 'cleanup failed'}).`);
         // Terminating a third-party app's processes during `npm i` is unsafe by default; opt-in only.
         const appProcessRepair = process.env.SKS_POSTINSTALL_RECONCILE_APP_PROCESSES === '1'
             ? await reconcileCodexAppUpgradeProcesses()
@@ -150,6 +155,36 @@ export async function postinstall({ bootstrap, args = [] }) {
         await reportPostinstallCodexLbAuth().catch(() => { });
     }
 }
+async function runPostinstallProjectRetentionCleanup(root) {
+    const projectRoot = path.resolve(root || process.cwd());
+    if (process.env.SKS_POSTINSTALL_RETENTION_CLEANUP === '0') {
+        return { status: 'skipped', reason: 'disabled_by_env', action_count: 0 };
+    }
+    if (!(await exists(path.join(projectRoot, '.sneakoscope', 'missions')))) {
+        return { status: 'skipped', reason: 'missions_missing', action_count: 0 };
+    }
+    try {
+        const { enforceRetention } = await import('../core/retention.js');
+        const result = await enforceRetention(projectRoot, {
+            mode: 'postinstall_update',
+            pruneReportLogs: true,
+            policy: { max_tmp_age_hours: 0 }
+        });
+        return {
+            status: 'completed',
+            root: projectRoot,
+            action_count: Array.isArray(result.actions) ? result.actions.length : 0
+        };
+    }
+    catch (err) {
+        return {
+            status: 'failed',
+            root: projectRoot,
+            action_count: 0,
+            error: err?.message || String(err)
+        };
+    }
+}
 async function reportPostinstallCodexLbAuth() {
     const codexLbAuth = await ensureCodexLbAuthDuringInstall();
     if (codexLbAuth.legacy_auth_migrated)

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '4.6.3';
+export const PACKAGE_VERSION = '4.6.4';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/retention.js

@@ -14,6 +14,7 @@ export const DEFAULT_RETENTION_POLICY = Object.freeze({
     run_gc_after_each_cycle: true,
     compact_oversize_missions: false,
     compact_closed_mission_workdirs: true,
+    compact_terminal_session_runtime_homes: true,
     prune_disposable_report_logs: false,
     max_wiki_artifacts: 40,
     max_wiki_artifact_age_days: 30,
@@ -46,7 +47,11 @@ const DISPOSABLE_MISSION_DIRS = Object.freeze([
     'tmp',
     'cycles',
     'arenas',
+    'sessions',
+    'codex-sdk-workers',
     'agents/lanes',
+    'agents/sessions',
+    'agents/codex-sdk-workers',
     'agents/tmp',
     'agents/worktrees',
     'research/cycles',
@@ -56,6 +61,10 @@ const DISPOSABLE_MISSION_FILES = Object.freeze([
     'agents/agent-intelligent-work-graph.json',
     'agents/agent-intelligent-work-graph-v2.json'
 ]);
+const DISPOSABLE_RUNTIME_HOME_DIR_NAMES = Object.freeze([
+    'codex-sdk-home',
+    'codex-sdk-workers'
+]);
 const MISSION_CLOSE_GATES = Object.freeze([
     'team-gate.json',
     'reflection-gate.json',
@@ -175,6 +184,15 @@ function proofClosed(proof) {
         return false;
     return ['verified', 'verified_partial', 'pass', 'passed'].includes(status);
 }
+function sessionsTerminal(cleanup) {
+    if (!cleanup || typeof cleanup !== 'object')
+        return false;
+    if (cleanup.all_sessions_terminal === true || cleanup.all_sessions_closed === true)
+        return true;
+    const terminal = Number(cleanup.terminal_session_count);
+    const total = Number(cleanup.total_sessions);
+    return Number.isFinite(terminal) && Number.isFinite(total) && total > 0 && terminal >= total;
+}
 async function missionClosed(mission, opts = {}) {
     const proof = await readJson(path.join(mission.path, 'completion-proof.json'), null).catch(() => null);
     if (opts.completedMissionId && mission.id === opts.completedMissionId)
@@ -195,6 +213,19 @@ async function missionClosed(mission, opts = {}) {
     }
     return false;
 }
+async function missionSessionsTerminal(mission) {
+    const cleanupFiles = [
+        'agents/agent-session-cleanup.json',
+        'team-session-cleanup.json',
+        'agent-session-cleanup.json'
+    ];
+    for (const rel of cleanupFiles) {
+        const cleanup = await readJson(path.join(mission.path, rel), null).catch(() => null);
+        if (sessionsTerminal(cleanup))
+            return true;
+    }
+    return false;
+}
 async function removePath(action, target, dryRun, actions, extra = {}) {
     const st = await fs.stat(target).catch(() => null);
     if (!st)
@@ -208,20 +239,58 @@ async function removePath(action, target, dryRun, actions, extra = {}) {
 function missionRelative(mission, file) {
     return path.relative(mission.path, file).split(path.sep).join('/');
 }
-function isPreservedSessionPath(rel) {
-    return rel.startsWith('sessions/') || rel.startsWith('agents/sessions/');
-}
 async function pruneMissionDisposableLogs(mission, dryRun, actions) {
     const files = await listFilesRecursive(mission.path, { ignore: [], maxFiles: 10000, maxDepth: 8 }).catch(() => []);
     for (const file of files) {
         const rel = missionRelative(mission, file);
-        if (isPreservedSessionPath(rel))
-            continue;
         if (!DISPOSABLE_LOG_RE.test(rel))
             continue;
         await removePath('remove_closed_mission_raw_log', file, dryRun, actions, { mission: mission.id, reason: 'closed_mission_disposable_log' });
     }
 }
+async function collectRuntimeHomeDirs(dir, depth = 10) {
+    if (depth < 0 || !(await exists(dir)))
+        return [];
+    const out = [];
+    const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const child = path.join(dir, entry.name);
+        if (DISPOSABLE_RUNTIME_HOME_DIR_NAMES.includes(entry.name)) {
+            out.push(child);
+            continue;
+        }
+        out.push(...await collectRuntimeHomeDirs(child, depth - 1));
+    }
+    return out;
+}
+async function pruneMissionRuntimeHomeDirs(mission, action, dryRun, actions, reason) {
+    const dirs = await collectRuntimeHomeDirs(mission.path);
+    for (const dir of dirs) {
+        await removePath(action, dir, dryRun, actions, { mission: mission.id, rel: missionRelative(mission, dir), reason });
+    }
+}
+async function pruneTerminalSessionRuntimeHomes(root, policy, dryRun, actions, opts = {}) {
+    if (policy.compact_terminal_session_runtime_homes === false && opts.compactTerminalSessionRuntimeHomes !== true)
+        return;
+    const activeId = await activeMissionId(root);
+    const targetOnly = Boolean(opts.afterRoute && opts.completedMissionId && opts.sweepClosedMissions !== true);
+    const missions = targetOnly
+        ? [await missionDirById(root, opts.completedMissionId)]
+        : await listMissionDirs(root);
+    for (const mission of missions.filter(Boolean)) {
+        if (await missionClosed(mission, opts))
+            continue;
+        const active = activeId && mission.id === activeId;
+        const activeRouteTarget = Boolean(opts.afterRoute && opts.completedMissionId === mission.id);
+        if (active && !activeRouteTarget && opts.allowActiveMissionCleanup !== true)
+            continue;
+        if (!(await missionSessionsTerminal(mission)))
+            continue;
+        await pruneMissionRuntimeHomeDirs(mission, 'remove_terminal_session_runtime_home', dryRun, actions, 'terminal_agent_session_runtime_home');
+    }
+}
 async function compactClosedMissionWorkdirs(root, policy, dryRun, actions, opts = {}) {
     if (policy.compact_closed_mission_workdirs === false || opts.compactClosedMissionWorkdirs === false)
         return;
@@ -539,6 +608,8 @@ export async function enforceRetention(root, opts = {}) {
     }
     if (shouldCompactClosedMissions)
         await compactClosedMissionWorkdirs(root, policy, dryRun, actions, opts);
+    if (fullMissionSweep || opts.compactTerminalSessionRuntimeHomes === true || Boolean(opts.afterRoute && opts.completedMissionId))
+        await pruneTerminalSessionRuntimeHomes(root, policy, dryRun, actions, opts);
     if (fullMissionSweep || opts.rotateLargeJsonl === true)
         await rotateLargeJsonl(root, policy, dryRun, actions);
     await pruneDisposableReportLogs(root, policy, dryRun, actions, opts);
@@ -556,6 +627,7 @@ export async function enforceRetention(root, opts = {}) {
         protected_durable_context: DURABLE_RETENTION_CLASSES,
         disposable_mission_dirs: DISPOSABLE_MISSION_DIRS,
         disposable_mission_files: DISPOSABLE_MISSION_FILES,
+        disposable_runtime_home_dir_names: DISPOSABLE_RUNTIME_HOME_DIR_NAMES,
         prune_report_logs: Boolean(opts.pruneReportLogs || policy.prune_disposable_report_logs),
         completed_mission_id: opts.completedMissionId || null,
         actions

package/dist/core/update/update-migration-state.js

@@ -2,6 +2,7 @@ import fsp from 'node:fs/promises';
 import path from 'node:path';
 import { ensureDir, exists, globalSksRoot, nowIso, packageRoot, PACKAGE_VERSION, projectRoot, readJson, runProcess, sha256, which, writeJsonAtomic } from '../fsx.js';
 import { MANAGED_ASSET_VERSION } from '../managed-assets/managed-assets-manifest.js';
+import { enforceRetention } from '../retention.js';
 export const UPDATE_MIGRATION_SCHEMA = 'sks.project-migration-receipt.v2';
 export const INSTALLATION_EPOCH_SCHEMA = 'sks.installation-epoch.v1';
 const ALLOWLIST_COMMANDS = new Set([
@@ -98,6 +99,7 @@ export async function clearPendingUpdateMigration() {
 export async function writeProjectUpdateMigrationReceipt(input) {
     const receiptPath = projectUpdateMigrationReceiptPath(input.root);
     const epoch = await ensureInstallationEpoch(input.source);
+    const retentionCleanup = await runUpdateRetentionCleanup(input.root, input.source);
     const requiredBlockers = input.blockers || [];
     const optionalWarnings = input.warnings || [];
     const receipt = {
@@ -113,6 +115,7 @@ export async function writeProjectUpdateMigrationReceipt(input) {
         pending_marker_path: installationEpochPath(),
         installation_epoch_path: installationEpochPath(),
         doctor: input.doctor || null,
+        retention_cleanup: retentionCleanup,
         update_stages: input.updateStages || [],
         required_blockers: requiredBlockers,
         optional_warnings: optionalWarnings,
@@ -122,6 +125,71 @@ export async function writeProjectUpdateMigrationReceipt(input) {
     await writeJsonAtomic(receiptPath, receipt);
     return receipt;
 }
+export async function runUpdateRetentionCleanup(root, source = 'update-migration') {
+    const missionsPath = path.join(root, '.sneakoscope', 'missions');
+    const cleanupPath = path.join(root, '.sneakoscope', 'reports', 'retention-cleanup.json');
+    const storagePath = path.join(root, '.sneakoscope', 'reports', 'storage.json');
+    if (process.env.SKS_UPDATE_RETENTION_CLEANUP === '0') {
+        return {
+            schema: 'sks.update-retention-cleanup.v1',
+            ok: true,
+            status: 'skipped',
+            root,
+            source,
+            generated_at: nowIso(),
+            action_count: 0,
+            cleanup_report_path: null,
+            storage_report_path: null,
+            reason: 'disabled_by_env'
+        };
+    }
+    if (!(await exists(missionsPath))) {
+        return {
+            schema: 'sks.update-retention-cleanup.v1',
+            ok: true,
+            status: 'skipped',
+            root,
+            source,
+            generated_at: nowIso(),
+            action_count: 0,
+            cleanup_report_path: null,
+            storage_report_path: null,
+            reason: 'missions_missing'
+        };
+    }
+    try {
+        const result = await enforceRetention(root, {
+            mode: 'update_migration',
+            pruneReportLogs: true,
+            policy: { max_tmp_age_hours: 0 }
+        });
+        return {
+            schema: 'sks.update-retention-cleanup.v1',
+            ok: true,
+            status: 'completed',
+            root,
+            source,
+            generated_at: nowIso(),
+            action_count: Array.isArray(result.actions) ? result.actions.length : 0,
+            cleanup_report_path: cleanupPath,
+            storage_report_path: storagePath
+        };
+    }
+    catch (err) {
+        return {
+            schema: 'sks.update-retention-cleanup.v1',
+            ok: false,
+            status: 'failed',
+            root,
+            source,
+            generated_at: nowIso(),
+            action_count: 0,
+            cleanup_report_path: null,
+            storage_report_path: null,
+            error: err?.message || String(err)
+        };
+    }
+}
 export async function ensureCurrentMigrationBeforeCommand(input) {
     const env = input.env || process.env;
     const command = input.command;

package/dist/core/version.js

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

package/dist/scripts/postinstall-safe-side-effects-check.js

@@ -11,6 +11,7 @@ const helpers = readText('src/cli/install-helpers.ts');
 assertGate(helpers.includes('SKS_POSTINSTALL_AUTO_INSTALL_CLI_TOOLS'), 'postinstall cli tool install must be gated behind SKS_POSTINSTALL_AUTO_INSTALL_CLI_TOOLS');
 // Killing a third-party app's processes is opt-in only.
 assertGate(helpers.includes("SKS_POSTINSTALL_RECONCILE_APP_PROCESSES === '1'"), 'postinstall process reconciliation must be gated behind SKS_POSTINSTALL_RECONCILE_APP_PROCESSES');
+assertGate(helpers.includes('runPostinstallProjectRetentionCleanup') && helpers.includes('SKS_POSTINSTALL_RETENTION_CLEANUP'), 'postinstall mission retention cleanup must be project-scoped and disableable');
 // Config writes are gated (unparseable preserved / unsafe rewrite skipped) and backed up.
 assertGate(helpers.includes('unparseable_config_preserved'), 'postinstall must preserve unparseable config');
 assertGate(helpers.includes('skipped_unsafe_rewrite'), 'postinstall must skip unsafe config rewrites');

package/dist/scripts/retention-cleanup-safety-check.js

@@ -38,11 +38,12 @@ try {
         '.sneakoscope/missions/M-old/completion-proof.json',
         '.sneakoscope/missions/M-old/trust-report.json',
         '.sneakoscope/missions/M-old/reflection.md',
-        '.sneakoscope/missions/M-done/sessions/terminal-transcript.log',
-        '.sneakoscope/missions/M-done/agents/sessions/session-1/terminal-transcript.log',
         '.sneakoscope/missions/M-active/team-inbox/active.md',
+        '.sneakoscope/missions/M-active/agents/sessions/session-1/gen-1/worker/codex-sdk-home/codex/cache.bin',
         '.sneakoscope/missions/M-blocked/team-inbox/blocked.md',
-        '.sneakoscope/missions/M-blocked/scout.stderr.log'
+        '.sneakoscope/missions/M-blocked/scout.stderr.log',
+        '.sneakoscope/missions/M-blocked-terminal/team-inbox/blocked.md',
+        '.sneakoscope/missions/M-blocked-terminal/agents/sessions/session-1/gen-1/worker/worker-result.json'
     ]) {
         assertGate(exists(path.join(applyRoot, rel)), `durable or active artifact was removed: ${rel}`, { rel, actions: applied.actions });
     }
@@ -51,10 +52,15 @@ try {
         '.sneakoscope/missions/M-done/team-inbox/worker.md',
         '.sneakoscope/missions/M-done/bus/event.jsonl',
         '.sneakoscope/missions/M-done/agents/lanes/lane-1.json',
+        '.sneakoscope/missions/M-done/sessions/terminal-transcript.log',
+        '.sneakoscope/missions/M-done/agents/sessions/session-1/terminal-transcript.log',
+        '.sneakoscope/missions/M-done/agents/sessions/session-1/gen-1/worker/codex-sdk-home/codex/cache.bin',
         '.sneakoscope/missions/M-done/scout.stdout.log',
         '.sneakoscope/missions/M-done/scout.stderr.log',
         '.sneakoscope/missions/M-old/team-inbox/worker.md',
+        '.sneakoscope/missions/M-old/agents/sessions/session-1/gen-1/worker/codex-sdk-home/codex/cache.bin',
         '.sneakoscope/missions/M-old/scout.stdout.log',
+        '.sneakoscope/missions/M-blocked-terminal/agents/sessions/session-1/gen-1/worker/codex-sdk-home/codex/cache.bin',
         '.sneakoscope/reports/release-parallel-logs/build.stdout.log'
     ]) {
         assertGate(!exists(path.join(applyRoot, rel)), `disposable artifact survived cleanup: ${rel}`, { rel, actions: applied.actions });
@@ -64,6 +70,7 @@ try {
     for (const kind of ['remove_tmp', 'remove_closed_mission_raw_log', 'remove_disposable_report_log_dir']) {
         assertGate(actionKinds.has(kind), `retention cleanup did not report action kind: ${kind}`, { actions: applied.actions });
     }
+    assertGate(actionKinds.has('remove_terminal_session_runtime_home'), 'retention cleanup did not remove terminal session runtime homes', { actions: applied.actions });
     assertGate(actionKinds.has('remove_closed_mission_workdir') || actionKinds.has('remove_old_mission_workdir'), 'retention cleanup did not report mission workdir cleanup', { actions: applied.actions });
     assertGate(actionKinds.has('retain_mission_durable_context'), 'retention cleanup did not preserve old durable mission context', { actions: applied.actions });
     assertGate(dry.actions.length >= applied.actions.length, 'dry-run should plan cleanup actions without deleting files', { applied: applied.actions.length, dry: dry.actions.length });
@@ -95,6 +102,7 @@ async function writeFixture(projectRoot) {
     await writeMission(projectRoot, 'M-active', false);
     await writeOldDurableMission(projectRoot);
     await writeBlockedMission(projectRoot);
+    await writeTerminalBlockedMission(projectRoot);
     await writeText(path.join(projectRoot, '.sneakoscope', 'reports', 'release-parallel-logs', 'build.stdout.log'), 'summarized release log\n');
 }
 async function writeMission(projectRoot, missionId, closed) {
@@ -110,14 +118,16 @@ async function writeMission(projectRoot, missionId, closed) {
         await write(path.join(dir, 'team-gate.json'), { passed: true });
         await write(path.join(dir, 'team-session-cleanup.json'), { passed: true, all_sessions_closed: true });
         await write(path.join(dir, 'agents', 'agent-proof-evidence.json'), { ok: true, all_sessions_closed: true });
-        await writeText(path.join(dir, 'sessions', 'terminal-transcript.log'), 'transcript stays\n');
-        await writeText(path.join(dir, 'agents', 'sessions', 'session-1', 'terminal-transcript.log'), 'agent transcript stays\n');
+        await writeText(path.join(dir, 'sessions', 'terminal-transcript.log'), 'transcript is disposable after close\n');
+        await writeText(path.join(dir, 'agents', 'sessions', 'session-1', 'terminal-transcript.log'), 'agent transcript is disposable after close\n');
+        await writeText(path.join(dir, 'agents', 'sessions', 'session-1', 'gen-1', 'worker', 'codex-sdk-home', 'codex', 'cache.bin'), 'large sdk cache\n');
         await writeText(path.join(dir, 'scout.stdout.log'), 'raw stdout\n');
         await writeText(path.join(dir, 'scout.stderr.log'), 'raw stderr\n');
         await writeText(path.join(dir, 'team-inbox', 'worker.md'), 'temporary inbox\n');
     }
     else {
         await writeText(path.join(dir, 'team-inbox', 'active.md'), 'active mission scratch stays\n');
+        await writeText(path.join(dir, 'agents', 'sessions', 'session-1', 'gen-1', 'worker', 'codex-sdk-home', 'codex', 'cache.bin'), 'active sdk cache stays\n');
     }
     await writeText(path.join(dir, 'bus', 'event.jsonl'), '{"event":"temporary"}\n');
     await writeText(path.join(dir, 'agents', 'lanes', 'lane-1.json'), '{"lane":"temporary"}\n');
@@ -129,6 +139,7 @@ async function writeOldDurableMission(projectRoot) {
     await write(path.join(dir, 'evidence-index.json'), { evidence: [] });
     await writeText(path.join(dir, 'reflection.md'), '# old retained reflection\n');
     await writeText(path.join(dir, 'team-inbox', 'worker.md'), 'old scratch\n');
+    await writeText(path.join(dir, 'agents', 'sessions', 'session-1', 'gen-1', 'worker', 'codex-sdk-home', 'codex', 'cache.bin'), 'old sdk cache\n');
     await writeText(path.join(dir, 'scout.stdout.log'), 'old raw log\n');
     await old(dir);
 }
@@ -138,6 +149,14 @@ async function writeBlockedMission(projectRoot) {
     await writeText(path.join(dir, 'team-inbox', 'blocked.md'), 'diagnostic scratch\n');
     await writeText(path.join(dir, 'scout.stderr.log'), 'diagnostic raw log\n');
 }
+async function writeTerminalBlockedMission(projectRoot) {
+    const dir = path.join(projectRoot, '.sneakoscope', 'missions', 'M-blocked-terminal');
+    await write(path.join(dir, 'completion-proof.json'), { schema: 'sks.completion-proof.v1', status: 'blocked', blockers: ['fixture_blocker'] });
+    await write(path.join(dir, 'agents', 'agent-session-cleanup.json'), { all_sessions_terminal: true, terminal_session_count: 1, total_sessions: 1 });
+    await writeText(path.join(dir, 'team-inbox', 'blocked.md'), 'diagnostic scratch\n');
+    await writeText(path.join(dir, 'agents', 'sessions', 'session-1', 'gen-1', 'worker', 'worker-result.json'), '{"status":"blocked"}\n');
+    await writeText(path.join(dir, 'agents', 'sessions', 'session-1', 'gen-1', 'worker', 'codex-sdk-home', 'codex', 'cache.bin'), 'terminal sdk cache\n');
+}
 async function write(file, data) {
     await writeText(file, `${JSON.stringify(data, null, 2)}\n`);
 }

package/dist/scripts/update-first-command-migration-check.js

@@ -8,6 +8,7 @@ assertGate(helper.includes('INSTALLATION_EPOCH_SCHEMA') && helper.includes('inst
 assertGate(helper.includes('projectUpdateMigrationReceiptPath'), 'migration helper must keep a project receipt');
 assertGate(helper.includes("'--profile', 'migration'") && helper.includes("'--machine-only'") && helper.includes("'--report-file'"), 'first normal command must repair through package-local migration Doctor machine report before continuing');
 assertGate(helper.includes('isProjectReceiptCurrentForEpoch'), 'project receipts must be compared against the current installation epoch');
+assertGate(helper.includes('runUpdateRetentionCleanup') && helper.includes('retention_cleanup'), 'project update migration receipt must run mission retention cleanup and record its receipt');
 assertGate(helper.includes('clearPendingUpdateMigration') && helper.includes('one project must not consume global migration state'), 'legacy clear helper must preserve the persistent epoch contract');
 assertGate(scriptContains('update:first-command-migration', 'update-first-command-migration-check.js'), 'package script must expose first command migration gate');
 emitGate('update:first-command-migration');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "4.6.3",
+  "version": "4.6.4",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",