sneakoscope 5.8.0 → 5.9.0

package/dist/core/agents/parallel-write-fixture.js

@@ -0,0 +1,301 @@
+import { execFile } from 'node:child_process';
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+export const PARALLEL_PRODUCTION_SMOKE_SCHEMA = 'sks.parallel-production-smoke.v1';
+export async function runParallelProductionSmoke(options = {}) {
+    const tmpRoot = await fsp.mkdtemp(path.join(os.tmpdir(), 'sks-parallel-production-smoke-'));
+    const repoRoot = path.join(tmpRoot, 'tmp-repo');
+    const worktreesRoot = path.join(tmpRoot, 'worktrees');
+    const blockers = [];
+    let cleanup = null;
+    try {
+        await createFixtureRepo(repoRoot);
+        await fsp.mkdir(worktreesRoot, { recursive: true });
+        const workerSpecs = buildWorkerSpecs(options.injectFailure === true);
+        await Promise.all(workerSpecs.map((worker) => setupWorkerWorktree(repoRoot, worktreesRoot, worker)));
+        const workerResults = await Promise.all(workerSpecs.map((worker) => runWorker(worker, path.join(worktreesRoot, worker.id))));
+        const successfulWorkers = workerResults.filter((result) => result.ok);
+        const failedWorkers = workerResults.filter((result) => !result.ok);
+        const targetFiles = ['src/a.ts', 'src/b.ts', 'src/c.ts'];
+        await mergeWorkerOutputs(repoRoot, successfulWorkers);
+        const typecheck = await runTypecheck(repoRoot);
+        const sharedUntouched = await fileEquals(path.join(repoRoot, 'src', 'shared.ts'), "export const sharedValue = 'stable-shared-contract'\n");
+        const statusAfterMerge = (await runCommand(['git', 'status', '--short'], repoRoot)).stdout_tail.trim();
+        const parentMergeArtifact = {
+            schema: 'sks.parallel-production-parent-merge.v1',
+            ok: successfulWorkers.length >= 3 && targetFiles.every((file) => successfulWorkers.some((worker) => worker.changed_files.includes(file))) && sharedUntouched,
+            merged_files: Array.from(new Set(successfulWorkers.flatMap((worker) => worker.changed_files))).sort(),
+            shared_untouched: sharedUntouched,
+            git_status_after_merge: statusAfterMerge
+        };
+        if (parentMergeArtifact.ok) {
+            await runCommand(['git', 'add', ...parentMergeArtifact.merged_files], repoRoot, true);
+            await runCommand(['git', 'commit', '-m', 'parent merge parallel worker outputs'], repoRoot, true);
+        }
+        const changedFilesByWorker = Object.fromEntries(successfulWorkers.map((worker) => [worker.worker_id, worker.changed_files]));
+        const changedFiles = Array.from(new Set(successfulWorkers.flatMap((worker) => worker.changed_files))).sort();
+        const overlapWindows = buildOverlapWindows(workerResults);
+        const cleanupBefore = await runCommand(['git', 'worktree', 'list', '--porcelain'], repoRoot);
+        cleanup = await cleanupWorktreesAndBranches(repoRoot, tmpRoot, workerSpecs, cleanupBefore.stdout_tail, options.keepTmp === true);
+        if (workerSpecs.filter((worker) => !worker.fail).length < 3)
+            blockers.push('parallel_write_worker_target_below_three');
+        if (successfulWorkers.length < 3)
+            blockers.push('parallel_write_successful_workers_below_target');
+        if (changedFiles.length < 3)
+            blockers.push('parallel_write_changed_files_below_target');
+        if (!targetFiles.every((file) => changedFiles.includes(file)))
+            blockers.push('parallel_write_target_files_missing');
+        if (new Set(Object.entries(changedFilesByWorker).filter(([, files]) => files.some((file) => targetFiles.includes(file))).map(([workerId]) => workerId)).size < 2)
+            blockers.push('parallel_write_files_not_distributed');
+        if (overlapWindows.length === 0)
+            blockers.push('worker_timestamp_overlap_missing');
+        if (successfulWorkers.filter((worker) => worker.patch.trim()).length < 3)
+            blockers.push('patch_envelope_count_below_target');
+        if (!parentMergeArtifact.ok)
+            blockers.push('parent_merge_artifact_missing_or_invalid');
+        if (!typecheck.ok)
+            blockers.push('typecheck_failed');
+        if (!cleanup.ok)
+            blockers.push('worktree_cleanup_failed');
+        if (failedWorkers.length > 0 && successfulWorkers.length === 0)
+            blockers.push('failure_injection_killed_scheduler');
+        return {
+            schema: PARALLEL_PRODUCTION_SMOKE_SCHEMA,
+            ok: blockers.length === 0,
+            status: blockers.length === 0 ? 'passed' : 'blocked',
+            proof_level: blockers.length === 0 ? 'production_git_worktree_fixture' : 'blocked',
+            tmp_root: tmpRoot,
+            repo_root: repoRoot,
+            worker_count: successfulWorkers.length,
+            worker_ids: successfulWorkers.map((worker) => worker.worker_id).sort(),
+            changed_files: changedFiles,
+            changed_files_by_worker: changedFilesByWorker,
+            distributed_across_workers: new Set(Object.keys(changedFilesByWorker)).size >= 2,
+            timestamp_overlap: overlapWindows.length > 0,
+            overlap_windows: overlapWindows,
+            patch_envelope_count: successfulWorkers.filter((worker) => worker.patch.trim()).length,
+            parent_merge_artifact: parentMergeArtifact,
+            typecheck,
+            worktree_cleanup: cleanup,
+            failure_injection: {
+                requested: options.injectFailure === true,
+                worker_failure_seen: failedWorkers.length > 0,
+                reassignment_attempted: failedWorkers.length > 0,
+                survived_worker_failure: failedWorkers.length > 0 ? successfulWorkers.length >= 3 : true,
+                failed_worker_id: failedWorkers[0]?.worker_id ?? null,
+                failed_worker_ids: failedWorkers.map((worker) => worker.worker_id).sort(),
+                recovered_work_item_ids: failedWorkers.length > 0 ? successfulWorkers.flatMap((worker) => worker.changed_files).sort() : [],
+                scheduler_survived: successfulWorkers.length >= 3,
+                successful_workers: successfulWorkers.map((worker) => worker.worker_id).sort(),
+                failed_workers: failedWorkers.map((worker) => worker.worker_id).sort()
+            },
+            mock_only: false,
+            blockers
+        };
+    }
+    catch (error) {
+        blockers.push(error instanceof Error ? `unexpected_error:${error.message}` : 'unexpected_error');
+        cleanup ??= await bestEffortCleanup(repoRoot, tmpRoot, options.keepTmp === true);
+        return blockedReport(tmpRoot, repoRoot, cleanup, blockers);
+    }
+}
+async function createFixtureRepo(repoRoot) {
+    await fsp.mkdir(path.join(repoRoot, 'src'), { recursive: true });
+    await fsp.writeFile(path.join(repoRoot, 'package.json'), `${JSON.stringify({ type: 'module', scripts: { typecheck: 'tsc -p tsconfig.json --noEmit' }, devDependencies: {} }, null, 2)}\n`);
+    await fsp.writeFile(path.join(repoRoot, 'tsconfig.json'), `${JSON.stringify({ compilerOptions: { target: 'ES2022', module: 'NodeNext', moduleResolution: 'NodeNext', strict: true, noEmit: true }, include: ['src/**/*.ts'] }, null, 2)}\n`);
+    await fsp.writeFile(path.join(repoRoot, 'src', 'shared.ts'), "export const sharedValue = 'stable-shared-contract'\n");
+    await fsp.writeFile(path.join(repoRoot, 'src', 'a.ts'), "import { sharedValue } from './shared.js'\nexport const aValue = `a:${sharedValue}`\n");
+    await fsp.writeFile(path.join(repoRoot, 'src', 'b.ts'), "import { sharedValue } from './shared.js'\nexport const bValue = `b:${sharedValue}`\n");
+    await fsp.writeFile(path.join(repoRoot, 'src', 'c.ts'), "import { sharedValue } from './shared.js'\nexport const cValue = `c:${sharedValue}`\n");
+    await runCommand(['git', 'init', '--initial-branch', 'main'], repoRoot, true);
+    await runCommand(['git', 'config', 'user.email', 'parallel-smoke@example.invalid'], repoRoot, true);
+    await runCommand(['git', 'config', 'user.name', 'Parallel Smoke'], repoRoot, true);
+    await runCommand(['git', 'add', '.'], repoRoot, true);
+    await runCommand(['git', 'commit', '-m', 'initial fixture'], repoRoot, true);
+}
+function buildWorkerSpecs(injectFailure) {
+    const workers = [
+        { id: 'worker-a', branch: 'worker/parallel-a', file: 'src/a.ts', exportName: 'workerADeterministic', returnValue: 'alpha' },
+        { id: 'worker-b', branch: 'worker/parallel-b', file: 'src/b.ts', exportName: 'workerBDeterministic', returnValue: 'bravo' },
+        { id: 'worker-c', branch: 'worker/parallel-c', file: 'src/c.ts', exportName: 'workerCDeterministic', returnValue: 'charlie' }
+    ];
+    if (injectFailure) {
+        workers.push({ id: 'worker-fail', branch: 'worker/parallel-fail', file: 'src/shared.ts', exportName: 'shouldNotLand', returnValue: 'failed', fail: true });
+    }
+    return workers;
+}
+async function setupWorkerWorktree(repoRoot, worktreesRoot, worker) {
+    await runCommand(['git', 'worktree', 'add', '-b', worker.branch, path.join(worktreesRoot, worker.id), 'HEAD'], repoRoot, true);
+}
+async function runWorker(worker, worktree) {
+    const startedMs = Date.now();
+    await delay(25);
+    if (worker.fail) {
+        return {
+            worker_id: worker.id,
+            ok: false,
+            branch: worker.branch,
+            worktree,
+            changed_files: [],
+            patch: '',
+            started_ms: startedMs,
+            completed_ms: Date.now(),
+            blocker: 'injected_worker_failure'
+        };
+    }
+    const filePath = path.join(worktree, worker.file);
+    const original = await fsp.readFile(filePath, 'utf8');
+    await fsp.writeFile(filePath, `${original}\nexport function ${worker.exportName}(): string {\n  return '${worker.returnValue}'\n}\n`);
+    await runCommand(['git', 'add', worker.file], worktree, true);
+    await runCommand(['git', 'commit', '-m', `${worker.id} deterministic function`], worktree, true);
+    const diff = await runCommand(['git', 'diff', 'HEAD~1', 'HEAD', '--', worker.file], worktree, true);
+    return {
+        worker_id: worker.id,
+        ok: true,
+        branch: worker.branch,
+        worktree,
+        changed_files: [worker.file],
+        patch: diff.stdout_tail,
+        started_ms: startedMs,
+        completed_ms: Date.now()
+    };
+}
+async function mergeWorkerOutputs(repoRoot, workers) {
+    for (const worker of workers) {
+        for (const file of worker.changed_files) {
+            await fsp.copyFile(path.join(worker.worktree, file), path.join(repoRoot, file));
+        }
+    }
+}
+async function runTypecheck(repoRoot) {
+    const localTsc = path.join(process.cwd(), 'node_modules', '.bin', process.platform === 'win32' ? 'tsc.cmd' : 'tsc');
+    return runCommand([localTsc, '-p', 'tsconfig.json', '--noEmit'], repoRoot);
+}
+async function cleanupWorktreesAndBranches(repoRoot, tmpRoot, workers, before, keepTmp) {
+    for (const worker of workers) {
+        await runCommand(['git', 'worktree', 'remove', '--force', path.join(tmpRoot, 'worktrees', worker.id)], repoRoot);
+    }
+    await runCommand(['git', 'worktree', 'prune'], repoRoot);
+    for (const worker of workers) {
+        await runCommand(['git', 'branch', '-D', worker.branch], repoRoot);
+    }
+    const after = await runCommand(['git', 'worktree', 'list', '--porcelain'], repoRoot);
+    const status = await runCommand(['git', 'status', '--short'], repoRoot);
+    if (!keepTmp)
+        await fsp.rm(tmpRoot, { recursive: true, force: true });
+    const tmpRemoved = keepTmp ? false : !(await exists(tmpRoot));
+    return {
+        ok: workers.every((worker) => !after.stdout_tail.includes(worker.id) && !after.stdout_tail.includes(worker.branch)) && status.stdout_tail.trim().length === 0 && tmpRemoved,
+        worktree_list_before_cleanup: before,
+        worktree_list_after_cleanup: after.stdout_tail,
+        worker_worktrees_removed: workers.every((worker) => !after.stdout_tail.includes(worker.id)),
+        worker_branches_removed: workers.every((worker) => !after.stdout_tail.includes(worker.branch)),
+        parent_dirty_after_cleanup: status.stdout_tail.trim().length > 0,
+        tmp_removed: tmpRemoved
+    };
+}
+async function bestEffortCleanup(repoRoot, tmpRoot, keepTmp) {
+    const before = await runCommand(['git', 'worktree', 'list', '--porcelain'], repoRoot);
+    if (!keepTmp)
+        await fsp.rm(tmpRoot, { recursive: true, force: true });
+    return {
+        ok: !keepTmp && !(await exists(tmpRoot)),
+        worktree_list_before_cleanup: before.stdout_tail,
+        worktree_list_after_cleanup: '',
+        worker_worktrees_removed: true,
+        worker_branches_removed: false,
+        parent_dirty_after_cleanup: false,
+        tmp_removed: !keepTmp && !(await exists(tmpRoot))
+    };
+}
+function buildOverlapWindows(results) {
+    const windows = [];
+    for (let i = 0; i < results.length; i += 1) {
+        for (let j = i + 1; j < results.length; j += 1) {
+            const a = results[i];
+            const b = results[j];
+            if (!a || !b)
+                continue;
+            const overlap = Math.min(a.completed_ms, b.completed_ms) - Math.max(a.started_ms, b.started_ms);
+            if (overlap > 0)
+                windows.push({ worker_a: a.worker_id, worker_b: b.worker_id, overlap_ms: overlap });
+        }
+    }
+    return windows;
+}
+async function runCommand(command, cwd, throwOnFailure = false) {
+    try {
+        const { stdout, stderr } = await execFileAsync(command[0] ?? '', command.slice(1), { cwd, encoding: 'utf8', maxBuffer: 1024 * 1024 * 8 });
+        return { ok: true, command, cwd, exit_code: 0, stdout_tail: tail(stdout), stderr_tail: tail(stderr) };
+    }
+    catch (error) {
+        const record = {
+            ok: false,
+            command,
+            cwd,
+            exit_code: typeof error.code === 'number' ? error.code : null,
+            stdout_tail: tail(typeof error.stdout === 'string' ? error.stdout : ''),
+            stderr_tail: tail(typeof error.stderr === 'string' ? error.stderr : error instanceof Error ? error.message : String(error))
+        };
+        if (throwOnFailure)
+            throw new Error(`${command.join(' ')} failed: ${record.stderr_tail || record.stdout_tail}`);
+        return record;
+    }
+}
+function blockedReport(tmpRoot, repoRoot, cleanup, blockers) {
+    return {
+        schema: PARALLEL_PRODUCTION_SMOKE_SCHEMA,
+        ok: false,
+        status: 'blocked',
+        proof_level: 'blocked',
+        tmp_root: tmpRoot,
+        repo_root: repoRoot,
+        worker_count: 0,
+        worker_ids: [],
+        changed_files: [],
+        changed_files_by_worker: {},
+        distributed_across_workers: false,
+        timestamp_overlap: false,
+        overlap_windows: [],
+        patch_envelope_count: 0,
+        parent_merge_artifact: { schema: 'sks.parallel-production-parent-merge.v1', ok: false, merged_files: [], shared_untouched: false, git_status_after_merge: '' },
+        typecheck: { ok: false, command: [], cwd: repoRoot, exit_code: null, stdout_tail: '', stderr_tail: '' },
+        worktree_cleanup: cleanup,
+        failure_injection: {
+            requested: false,
+            worker_failure_seen: false,
+            reassignment_attempted: false,
+            survived_worker_failure: false,
+            failed_worker_id: null,
+            failed_worker_ids: [],
+            recovered_work_item_ids: [],
+            scheduler_survived: false,
+            successful_workers: [],
+            failed_workers: []
+        },
+        mock_only: false,
+        blockers
+    };
+}
+async function fileEquals(file, expected) {
+    return (await fsp.readFile(file, 'utf8')) === expected;
+}
+async function exists(file) {
+    try {
+        await fsp.access(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function tail(text, max = 4000) {
+    return text.length > max ? text.slice(-max) : text;
+}
+//# sourceMappingURL=parallel-write-fixture.js.map

package/dist/core/doctor/doctor-idempotence.js

@@ -0,0 +1,93 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { runProcess, tmpdir, writeJsonAtomic } from '../fsx.js';
+export async function runDoctorIdempotence(root) {
+    const tmp = tmpdir('sks-doctor-idempotence-');
+    const home = path.join(tmp, 'home');
+    const codexHome = path.join(tmp, 'codex');
+    await Promise.all([home, codexHome].map((dir) => fs.mkdir(dir, { recursive: true })));
+    const first = await runDoctor(root, home, codexHome);
+    const second = await runDoctor(root, home, codexHome);
+    const rollbackManifestExists = await hasRollbackManifest(home, codexHome, root);
+    const changedFilesSecond = extractChangedFiles(second);
+    const blockers = [];
+    if (first.exit_code !== 0)
+        blockers.push(`first_doctor_exit_${first.exit_code}`);
+    if (second.exit_code !== 0)
+        blockers.push(`second_doctor_exit_${second.exit_code}`);
+    if (changedFilesSecond.length > 0)
+        blockers.push('second_doctor_not_noop');
+    const report = {
+        schema: 'sks.doctor-idempotence.v1',
+        ok: blockers.length === 0,
+        generated_at: new Date().toISOString(),
+        temp_dir: tmp,
+        first,
+        second,
+        rollback_manifest_exists: rollbackManifestExists,
+        changed_files_second: changedFilesSecond,
+        blockers: [...new Set(blockers)]
+    };
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'doctor-idempotence.json'), report);
+    return report;
+}
+async function runDoctor(root, home, codexHome) {
+    const started = Date.now();
+    const res = await runProcess(process.execPath, ['./dist/bin/sks.js', 'doctor', '--fix', '--yes', '--json'], {
+        cwd: root,
+        timeoutMs: 180_000,
+        maxOutputBytes: 1024 * 1024,
+        env: {
+            HOME: home,
+            CODEX_HOME: codexHome,
+            SKS_TEST_ISOLATION: '1',
+            SKS_DISABLE_NETWORK: '1',
+            SKS_DISABLE_UPDATE_CHECK: '1'
+        }
+    });
+    let parsed = null;
+    try {
+        parsed = JSON.parse(res.stdout);
+    }
+    catch { }
+    const blockers = Array.isArray(parsed?.blockers) ? parsed.blockers.map(String) : [];
+    return {
+        exit_code: res.code,
+        duration_ms: Date.now() - started,
+        stdout_json: parsed != null,
+        ok: res.code === 0 && parsed?.ok !== false,
+        blockers,
+        parsed
+    };
+}
+function extractChangedFiles(run) {
+    const repair = run.parsed?.repair || {};
+    const candidates = [
+        repair.doctor_transaction?.changed_files,
+        run.parsed?.doctor_fix_transaction?.changed_files,
+        run.parsed?.changed_files
+    ];
+    return [...new Set(candidates.flatMap((value) => Array.isArray(value) ? value.map(String) : []))];
+}
+async function hasRollbackManifest(...roots) {
+    for (const dir of roots) {
+        const found = await findFileContaining(dir, /rollback|transaction|manifest/i, 4);
+        if (found)
+            return true;
+    }
+    return false;
+}
+async function findFileContaining(dir, pattern, depth) {
+    if (depth < 0)
+        return false;
+    const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+        const child = path.join(dir, entry.name);
+        if (entry.isFile() && pattern.test(entry.name))
+            return true;
+        if (entry.isDirectory() && await findFileContaining(child, pattern, depth - 1))
+            return true;
+    }
+    return false;
+}
+//# sourceMappingURL=doctor-idempotence.js.map

package/dist/core/errors/blocker-humanizer.js

@@ -0,0 +1,13 @@
+import { diagnosticForBlocker } from './next-action-map.js';
+export function humanizeBlockers(blockers = [], evidencePaths = []) {
+    const uniqueBlockers = [...new Set(blockers.filter(Boolean))];
+    const diagnostics = uniqueBlockers.map((blocker) => diagnosticForBlocker(blocker));
+    return {
+        human_summary: diagnostics.length
+            ? diagnostics.map((diagnostic) => diagnostic.human_summary).join(' ')
+            : 'No blockers were recorded.',
+        next_actions: [...new Set(diagnostics.flatMap((diagnostic) => diagnostic.next_actions))],
+        evidence_paths: [...new Set(evidencePaths.filter(Boolean))]
+    };
+}
+//# sourceMappingURL=blocker-humanizer.js.map

package/dist/core/errors/next-action-map.js

@@ -0,0 +1,56 @@
+const NEXT_ACTIONS = {
+    source_acquisition_unavailable: {
+        human_summary: 'Super-Search has no live source acquisition path available for this request.',
+        next_actions: ['sks super-search doctor --json']
+    },
+    parallel_runtime_events_missing: {
+        human_summary: 'Parallel worker runtime events were not recorded.',
+        next_actions: ['sks naruto proof latest --json']
+    },
+    worker_timestamp_overlap_missing: {
+        human_summary: 'There is no evidence that workers actually overlapped in time.',
+        next_actions: ['cat .sneakoscope/missions/latest/parallel-runtime-proof.json']
+    },
+    production_proof_mock_only: {
+        human_summary: 'A production gate received mock-only proof.',
+        next_actions: ['Inspect whether a mock backend path is connected to production proof.']
+    },
+    direct_url_fetch_adapter_unavailable: {
+        human_summary: 'Direct URL fetch is unavailable in this Node runtime.',
+        next_actions: ['node -e "console.log(typeof fetch)"']
+    },
+    direct_url_fetch_failed: {
+        human_summary: 'Direct URL fetch failed before verified content could be captured.',
+        next_actions: ['sks super-search doctor --json']
+    },
+    direct_url_fetch_timeout: {
+        human_summary: 'Direct URL fetch timed out before verified content could be captured.',
+        next_actions: ['Retry the fetch or inspect local network access.']
+    },
+    direct_url_fetch_empty_content: {
+        human_summary: 'Direct URL fetch returned no readable content.',
+        next_actions: ['Open the URL manually and check whether it requires authentication or JavaScript rendering.']
+    }
+};
+export function diagnosticForBlocker(blocker) {
+    const exact = NEXT_ACTIONS[blocker];
+    if (exact)
+        return exact;
+    if (/^direct_url_fetch_http_\d+$/.test(blocker)) {
+        return {
+            human_summary: `Direct URL fetch returned HTTP ${blocker.replace('direct_url_fetch_http_', '')}.`,
+            next_actions: ['Open the URL manually and verify whether it is public and reachable.']
+        };
+    }
+    if (blocker.startsWith('super_search_mission_artifact_missing:')) {
+        return {
+            human_summary: 'A required Super-Search evidence artifact is missing.',
+            next_actions: [`cat ${blocker.slice('super_search_mission_artifact_missing:'.length)}`]
+        };
+    }
+    return {
+        human_summary: `Gate blocked on machine reason: ${blocker}.`,
+        next_actions: ['Inspect the gate JSON and referenced evidence paths.']
+    };
+}
+//# sourceMappingURL=next-action-map.js.map

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 = '5.8.0';
+export const PACKAGE_VERSION = '5.9.0';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/install/installed-package-smoke.js

@@ -0,0 +1,121 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { runProcess, writeJsonAtomic } from '../fsx.js';
+export async function runInstalledPackageSmoke(root) {
+    const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-installed-smoke-'));
+    const home = path.join(tmp, 'home');
+    const codexHome = path.join(tmp, 'codex-home');
+    const npmCache = path.join(tmp, 'npm-cache');
+    await Promise.all([home, codexHome, npmCache].map((dir) => fs.mkdir(dir, { recursive: true })));
+    const blockers = [];
+    const commands = [];
+    let tarball = null;
+    let installedVersion = null;
+    let packedVersion = null;
+    const pack = await runJsonCommand(root, ['npm', 'pack', '--json', '--ignore-scripts'], { npmCache });
+    commands.push(pack.command);
+    if (pack.exit_code !== 0)
+        blockers.push('npm_pack_failed');
+    const packInfo = packJsonObject(pack.json);
+    if (packInfo?.filename)
+        tarball = path.join(root, String(packInfo.filename));
+    if (packInfo?.version)
+        packedVersion = String(packInfo.version);
+    if (!tarball)
+        blockers.push('npm_pack_tarball_missing');
+    await fs.writeFile(path.join(tmp, 'package.json'), JSON.stringify({ private: true, type: 'module' }, null, 2));
+    if (tarball) {
+        const install = await runJsonCommand(tmp, ['npm', 'install', tarball, '--ignore-scripts'], { home, codexHome, npmCache });
+        commands.push(install.command);
+        if (install.exit_code !== 0)
+            blockers.push('npm_install_tarball_failed');
+    }
+    const bin = path.join(tmp, 'node_modules', '.bin', 'sks');
+    const smokeCommands = [
+        [bin, '--version'],
+        [bin, 'commands', '--json'],
+        [bin, 'bootstrap', '--json'],
+        [bin, 'doctor', '--json'],
+        [bin, 'super-search', 'doctor', '--json'],
+        [bin, 'selftest', '--mock']
+    ];
+    for (const argv of smokeCommands) {
+        const result = await runJsonCommand(tmp, argv, { home, codexHome, npmCache });
+        commands.push(result.command);
+        if (result.exit_code !== 0)
+            blockers.push(`installed_command_failed:${argv.slice(1).join('_') || 'version'}`);
+        if (argv.includes('--version')) {
+            const match = String(result.stdout || '').match(/([0-9]+\.[0-9]+\.[0-9]+)/);
+            if (match)
+                installedVersion = match[1] || null;
+        }
+    }
+    const forbiddenFindings = [];
+    if (process.env.HOME && home === process.env.HOME)
+        forbiddenFindings.push('host_home_reused');
+    if (process.env.CODEX_HOME && codexHome === process.env.CODEX_HOME)
+        forbiddenFindings.push('host_codex_home_reused');
+    if (packedVersion && installedVersion && packedVersion !== installedVersion)
+        blockers.push(`installed_version_mismatch:${installedVersion}:expected_${packedVersion}`);
+    blockers.push(...forbiddenFindings.map((item) => `forbidden:${item}`));
+    const report = {
+        schema: 'sks.installed-package-smoke.v1',
+        ok: blockers.length === 0,
+        generated_at: new Date().toISOString(),
+        tarball,
+        installed_version: installedVersion,
+        temp_dir: tmp,
+        commands,
+        forbidden_findings: forbiddenFindings,
+        blockers: [...new Set(blockers)]
+    };
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'installed-package-smoke.json'), report);
+    return report;
+}
+async function runJsonCommand(cwd, argv, opts) {
+    const started = Date.now();
+    const [command, ...args] = argv;
+    const env = {
+        SKS_TEST_ISOLATION: '1',
+        SKS_DISABLE_NETWORK: '1',
+        SKS_DISABLE_UPDATE_CHECK: '1'
+    };
+    if (opts.home !== undefined)
+        env.HOME = opts.home;
+    if (opts.codexHome !== undefined)
+        env.CODEX_HOME = opts.codexHome;
+    if (opts.npmCache !== undefined) {
+        env.npm_config_cache = opts.npmCache;
+        env.NPM_CONFIG_CACHE = opts.npmCache;
+    }
+    const res = await runProcess(command || 'node', args, {
+        cwd,
+        timeoutMs: 120_000,
+        maxOutputBytes: 1024 * 1024,
+        env
+    });
+    let parsed = null;
+    try {
+        parsed = JSON.parse(res.stdout);
+    }
+    catch { }
+    return {
+        exit_code: res.code,
+        stdout: res.stdout,
+        json: parsed,
+        command: {
+            argv,
+            exit_code: res.code,
+            stdout_json: parsed != null,
+            duration_ms: Date.now() - started,
+            stdout_tail: res.stdout.slice(-1200),
+            stderr_tail: res.stderr.slice(-1200)
+        }
+    };
+}
+function packJsonObject(value) {
+    const row = Array.isArray(value) ? value[0] : value;
+    return row && typeof row === 'object' ? row : null;
+}
+//# sourceMappingURL=installed-package-smoke.js.map

package/dist/core/naruto/naruto-active-pool.js

@@ -51,8 +51,12 @@ export async function runNarutoRealActivePool(input) {
         maxObserved = Math.max(maxObserved, active.size);
         timeline.push({ tick, active: active.size, pending: pending.length, completed: completed.size, event: launched ? 'refill' : 'wait' });
         const done = await nextCollectableWorkers(active, input.hardTimeoutMs);
-        if (!done.length)
-            break;
+        if (!done.length) {
+            tick += 1;
+            if (tick > input.graph.work_items.length * 4 + 20)
+                break;
+            continue;
+        }
         for (const handle of done) {
             active.delete(handle.id);
             if (handle.placement.placement === 'zellij-pane')