sneakoscope 5.7.0 → 5.9.0

package/dist/core/agents/agent-orchestrator.js

@@ -146,7 +146,8 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         writeCapable,
         visualRequired,
         appshotsOk: sourceIntelligence.appshots?.ok === true,
-        sourceIntelligenceOk: sourceIntelligence.ok
+        sourceIntelligenceOk: sourceIntelligence.ok,
+        sourceIntelligenceRequired: sourceIntelligenceRequiredForWriteGate(sourceIntelligence, route)
     });
     await writeStrategyGateArtifact(dir, strategyGate);
     const strategyRef = {
@@ -499,7 +500,9 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         minActiveWorkers: Math.min(targetActiveSlots, desiredWorkItemCount),
         ...(backend === 'codex-sdk' && opts.real === true ? { minSpeedupRatio: 3 } : {}),
         proofMode: opts.mock === true ? 'mock-process' : 'production',
-        requireWorkerPids: opts.nativeCliSwarm !== false && targetActiveSlots >= 16
+        requireWorkerPids: opts.nativeCliSwarm !== false && targetActiveSlots >= 16,
+        requireChangedFiles: writeCapable && effectiveWriteMode === 'parallel',
+        minChangedFiles: Math.min(2, desiredWorkItemCount)
     });
     let results = scheduler.results;
     const tournamentSelection = await selectSolutionTournamentWinners(root, ledgerRoot, results);
@@ -687,6 +690,21 @@ function normalizeMissionHardTimeoutMs(opts = {}, route = '') {
         return Math.max(1000, Math.min(Math.floor(raw), 24 * 60 * 60 * 1000));
     return String(route || '').replace(/^\$/, '').toUpperCase() === 'NARUTO' ? 10 * 60 * 1000 : 30 * 60 * 1000;
 }
+function sourceIntelligenceRequiredForWriteGate(sourceIntelligence, route) {
+    const policy = sourceIntelligence?.policy || {};
+    const mode = String(sourceIntelligence?.mode || policy.mode || '');
+    if (String(route || '').replace(/^\$/, '').toLowerCase() === 'super-search')
+        return true;
+    if (policy.context7?.required === true)
+        return true;
+    if (policy.requirements?.official_sources === true)
+        return true;
+    if (policy.requirements?.social_recency === true)
+        return true;
+    if (policy.requirements?.code_execution_verification === true && mode !== 'offline_cache')
+        return true;
+    return mode !== 'offline_cache';
+}
 function withFinalGptPatchEnvelopes(results, patchEnvelopes = []) {
     const byAgent = new Map();
     for (const envelope of patchEnvelopes) {

package/dist/core/agents/agent-wrongness.js

@@ -11,7 +11,7 @@ const WRONGNESS_MAP = [
     ['missing_follow_up_schema', /follow_up_work_item|follow_up_work_items|schema_invalid:.*follow_up/],
     ['session_generation_missing', /session_generation_open|terminal_close_report_missing|source_intelligence_missing_for_generation|goal_mode_missing_for_generation/],
     ['schema_invalid_output', /^schema_invalid:/],
-    ['ultra_search_provider_independent_proof_missing', /ultra_search_provider_independent_proof_missing/],
+    ['super_search_provider_independent_proof_missing', /super_search_provider_independent_proof_missing/],
     ['codex_web_search_missing', /codex_web_search_missing/],
     ['context7_missing', /context7_missing|docs_context_missing/],
     ['stale_heartbeat', /stale_heartbeat/],

package/dist/core/agents/native-cli-session-swarm.js

@@ -274,6 +274,7 @@ class NativeCliSessionSwarmRecorder {
             status: result.status === 'done' ? 'completed' : 'failed',
             artifacts: result.artifacts || [],
             blockers: result.blockers || [],
+            changedFiles: changedFilesFromWorkerResult(result),
             logTail: result.summary || ''
         });
         await this.record(record);
@@ -649,6 +650,7 @@ class NativeCliSessionSwarmRecorder {
             status: parsed.status === 'done' ? 'completed' : 'failed',
             artifacts: [...new Set([...(Array.isArray(parsed.artifacts) ? parsed.artifacts : []), input.stdoutRel, input.stderrRel, path.join(input.workerDirRel, 'zellij-worker-pane.json')])],
             blockers: input.record.blockers,
+            changedFiles: changedFilesFromWorkerResult(parsed),
             logTail: parsed.summary || ''
         });
         return validateAgentWorkerResult({
@@ -752,6 +754,7 @@ class NativeCliSessionSwarmRecorder {
                 meta: {
                     status: input.status,
                     artifacts: input.artifacts || [],
+                    changed_files: input.changedFiles || [],
                     blockers: input.blockers || []
                 }
             }).catch(() => undefined);
@@ -956,9 +959,19 @@ function mapTelemetryToParallelEvent(eventType) {
         return 'worker_failed';
     return null;
 }
+function changedFilesFromWorkerResult(result) {
+    const direct = Array.isArray(result?.changed_files) ? result.changed_files : [];
+    const envelopeFiles = (Array.isArray(result?.patch_envelopes) ? result.patch_envelopes : [])
+        .flatMap((envelope) => [
+        ...(Array.isArray(envelope?.changed_files) ? envelope.changed_files : []),
+        ...(Array.isArray(envelope?.allowed_paths) ? envelope.allowed_paths : []),
+        ...(Array.isArray(envelope?.operations) ? envelope.operations.map((operation) => operation?.path) : [])
+    ]);
+    return [...new Set([...direct, ...envelopeFiles].map((file) => String(file || '').replace(/\\/g, '/').replace(/^\.\/+/, '')).filter(Boolean))];
+}
 function normalizeParallelPlacement(value) {
     const text = String(value || '');
-    if (text === 'zellij-pane' || text === 'process' || text === 'headless')
+    if (text === 'zellij-pane' || text === 'process' || text === 'headless' || text === 'headless_by_design_viewport_ui')
         return text;
     return 'unknown';
 }

package/dist/core/agents/parallel-runtime-proof.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { appendJsonlBounded, ensureDir, nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
 export const PARALLEL_RUNTIME_EVENT_SCHEMA = 'sks.parallel-runtime-event.v1';
-export const PARALLEL_RUNTIME_PROOF_SCHEMA = 'sks.parallel-runtime-proof.v1';
+export const PARALLEL_RUNTIME_PROOF_SCHEMA = 'sks.parallel-runtime-proof.v2';
 export function parallelRuntimeEventPath(root, missionId) {
     return path.join(inferAgentsDir(root, missionId), 'parallel-runtime.events.jsonl');
 }
@@ -100,7 +100,7 @@ export async function buildParallelRuntimeProof(root, missionId, opts = {}) {
         ? workerDurations.reduce((sum, value) => sum + value, 0)
         : requestedWorkers * positiveInt(opts.expectedWorkerRuntimeMs, 4000);
     const visiblePanes = nonNegativeInt(opts.visiblePanes, sorted.filter((event) => event.placement === 'zellij-pane').length ? new Set(sorted.filter((event) => event.placement === 'zellij-pane').map((event) => event.slot_id || event.session_id || '')).size : 0);
-    const observedHeadlessWorkers = sorted.filter((event) => event.placement === 'headless' && (event.event_type === 'worker_launch_invoked' || event.event_type === 'worker_process_spawned')).length;
+    const observedHeadlessWorkers = sorted.filter((event) => (event.placement === 'headless' || event.placement === 'headless_by_design_viewport_ui') && (event.event_type === 'worker_launch_invoked' || event.event_type === 'worker_process_spawned')).length;
     const headlessWorkers = Math.max(observedHeadlessWorkers, Math.max(0, targetActiveSlots - visiblePanes));
     const minActiveWorkers = opts.minActiveWorkers === undefined
         ? Math.min(targetActiveSlots, requestedWorkers)
@@ -112,6 +112,7 @@ export async function buildParallelRuntimeProof(root, missionId, opts = {}) {
     const firstBatchLimit = positiveInt(opts.firstBatchLaunchSpanLimitMs, requestedWorkers >= 16 ? 2500 : 30000);
     const schedulerState = await readJson(path.join(root, 'agent-scheduler-state.json'), null).catch(() => null);
     const coalescedOverlapWindows = coalesceOverlapWindows(overlapWindows);
+    const workerEvidence = buildWorkerRuntimeEvidence(sorted, firstMs, lastMs);
     const utilizationProofConsistency = buildUtilizationProofConsistency(schedulerState, {
         proofMaxActive: maxWorkers,
         proofWallMs: wallMs,
@@ -130,15 +131,27 @@ export async function buildParallelRuntimeProof(root, missionId, opts = {}) {
         blockers.push('speedup_ratio_below_target');
     if (firstBatchLaunchSpanMs > firstBatchLimit)
         blockers.push('first_batch_launch_span_above_limit');
+    if (minActiveWorkers > 1 && workerEvidence.unique_worker_ids.length < Math.min(minActiveWorkers, 2))
+        blockers.push('worker_id_diversity_below_target');
+    if (minActiveWorkers > 1 && workerEvidence.overlap_windows.length === 0)
+        blockers.push('worker_timestamp_overlap_missing');
+    if (opts.requireChangedFiles === true && workerEvidence.changed_file_count < positiveInt(opts.minChangedFiles, Math.min(2, requestedWorkers)))
+        blockers.push('parallel_write_changed_files_below_target');
+    const passed = blockers.length === 0;
     return {
         schema: PARALLEL_RUNTIME_PROOF_SCHEMA,
         mission_id: missionId,
         generated_at: nowIso(),
+        ok: passed,
         proof_mode: proofMode,
+        production_runtime: proofMode === 'production',
+        mock_only: proofMode !== 'production',
         require_worker_pids: requireWorkerPids,
         allow_missing_pids: allowMissingPids,
         requested_workers: requestedWorkers,
         target_active_slots: targetActiveSlots,
+        observed_worker_count: workerEvidence.unique_worker_ids.length,
+        unique_worker_ids: workerEvidence.unique_worker_ids,
         max_observed_active_workers: maxWorkers,
         max_observed_worker_processes: Math.max(maxProcesses, workerPids.size ? maxProcesses : maxWorkers),
         unique_worker_pids: workerPids.size,
@@ -149,11 +162,13 @@ export async function buildParallelRuntimeProof(root, missionId, opts = {}) {
         wall_ms: wallMs,
         sequential_estimate_ms: sequentialEstimateMs,
         speedup_ratio: speedupRatio,
-        overlap_windows: coalescedOverlapWindows,
+        overlap_windows: [...coalescedOverlapWindows, ...workerEvidence.overlap_windows],
+        changed_file_count: workerEvidence.changed_file_count,
+        changed_files_by_worker: workerEvidence.changed_files_by_worker,
         visible_panes: visiblePanes,
         headless_workers: headlessWorkers,
         utilization_proof_consistency: utilizationProofConsistency,
-        passed: blockers.length === 0,
+        passed,
         blockers
     };
 }
@@ -200,7 +215,7 @@ function normalizeParallelRuntimeEvent(missionId, event) {
 }
 function normalizePlacement(value) {
     const text = String(value || 'unknown');
-    if (text === 'zellij-pane' || text === 'process' || text === 'headless')
+    if (text === 'zellij-pane' || text === 'process' || text === 'headless' || text === 'headless_by_design_viewport_ui')
         return text;
     return 'unknown';
 }
@@ -253,14 +268,73 @@ function buildUtilizationProofConsistency(state, input) {
     };
 }
 function activeSlotTimeMsFromWindows(windows) {
-    return windows.reduce((sum, window) => sum + Math.max(0, window.end_ms - window.start_ms) * Math.max(0, window.active_workers), 0);
+    return windows.reduce((sum, window) => sum + Math.max(0, Number(window.end_ms || 0) - Number(window.start_ms || 0)) * Math.max(0, Number(window.active_workers || 0)), 0);
 }
 function coalesceOverlapWindows(windows) {
     return windows
-        .filter((window) => window.end_ms > window.start_ms)
-        .filter((window) => window.active_workers > 0 || window.active_model_calls > 0)
+        .filter((window) => Number(window.end_ms || 0) > Number(window.start_ms || 0))
+        .filter((window) => Number(window.active_workers || 0) > 0 || Number(window.active_model_calls || 0) > 0)
         .slice(0, 2000);
 }
+function buildWorkerRuntimeEvidence(events, firstMs, lastMs) {
+    const intervals = new Map();
+    for (const event of events) {
+        const workerId = workerRuntimeId(event);
+        if (!workerId)
+            continue;
+        if (event.event_type === 'worker_launch_invoked' || event.event_type === 'worker_process_spawned') {
+            const current = intervals.get(workerId);
+            if (current)
+                current.start = Math.min(current.start, event.ms);
+            else
+                intervals.set(workerId, { start: event.ms, end: event.ms, changedFiles: new Set() });
+        }
+        if (event.event_type === 'worker_completed' || event.event_type === 'worker_failed') {
+            const current = intervals.get(workerId) || { start: event.ms, end: event.ms, changedFiles: new Set() };
+            current.end = event.ms;
+            for (const file of eventChangedFiles(event))
+                current.changedFiles.add(file);
+            intervals.set(workerId, current);
+        }
+    }
+    const uniqueWorkerIds = [...intervals.keys()].sort();
+    const changedFilesByWorker = Object.fromEntries(uniqueWorkerIds.map((id) => [id, [...(intervals.get(id)?.changedFiles || new Set())].sort()]));
+    const changedFileCount = new Set(Object.values(changedFilesByWorker).flat()).size;
+    const overlapWindows = [];
+    for (let i = 0; i < uniqueWorkerIds.length; i++) {
+        for (let j = i + 1; j < uniqueWorkerIds.length; j++) {
+            const a = uniqueWorkerIds[i];
+            const b = uniqueWorkerIds[j];
+            const left = intervals.get(a);
+            const right = intervals.get(b);
+            const overlapMs = Math.max(0, Math.min(left.end, right.end) - Math.max(left.start, right.start));
+            if (overlapMs > 0 && Math.max(left.start, right.start) < Math.min(left.end, right.end)) {
+                overlapWindows.push({
+                    worker_a: a,
+                    worker_b: b,
+                    overlap_ms: overlapMs,
+                    start_ms: Math.max(left.start, right.start) - firstMs,
+                    end_ms: Math.min(left.end, right.end) - firstMs,
+                    active_workers: 2,
+                    active_model_calls: 0
+                });
+            }
+        }
+    }
+    return {
+        unique_worker_ids: uniqueWorkerIds,
+        changed_files_by_worker: changedFilesByWorker,
+        changed_file_count: changedFileCount,
+        overlap_windows: overlapWindows.slice(0, 2000)
+    };
+}
+function workerRuntimeId(event) {
+    return event.slot_id || event.session_id || (event.pid == null ? null : `pid:${event.pid}`);
+}
+function eventChangedFiles(event) {
+    const fromMeta = Array.isArray(event.meta?.changed_files) ? event.meta.changed_files : [];
+    return fromMeta.map((file) => String(file || '').replace(/\\/g, '/').replace(/^\.\/+/, '')).filter(Boolean);
+}
 function inferAgentsDir(root, missionId) {
     const resolved = path.resolve(root);
     if (path.basename(resolved) === 'agents' && path.basename(path.dirname(resolved)) === missionId)

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/commands/gc-command.js

@@ -1,5 +1,5 @@
 import { dirSize, formatBytes, packageRoot, projectRoot, sksRoot } from '../fsx.js';
-import { enforceRetention, storageReport } from '../retention.js';
+import { enforceRetention, lightweightStorageReport, storageReport } from '../retention.js';
 import { flag } from './command-utils.js';
 import { projectTriwikiToAgentsMd } from '../triwiki/agents-md-projector.js';
 import { compileMistakeRules } from '../verification/mistake-rule-compiler.js';
@@ -45,13 +45,19 @@ function readOption(args = [], name, fallback = null) {
 }
 export async function statsCommand(args = []) {
     const root = await sksRoot();
-    const report = await storageReport(root);
-    const pkgBytes = await dirSize(packageRoot()).catch(() => 0);
-    const out = { package: { bytes: pkgBytes, human: formatBytes(pkgBytes) }, storage: report };
+    const full = flag(args, '--full');
+    const report = full ? await storageReport(root) : await lightweightStorageReport(root);
+    const pkgBytes = full ? await dirSize(packageRoot()).catch(() => 0) : null;
+    const out = {
+        package: full
+            ? { bytes: pkgBytes, human: formatBytes(pkgBytes), full_size: true }
+            : { bytes: null, human: null, full_size: false, note: 'Run `sks stats --full --json` for recursive package sizing.' },
+        storage: report
+    };
     if (flag(args, '--json'))
         return console.log(JSON.stringify(out, null, 2));
     console.log('ㅅㅋㅅ Stats');
-    console.log(`Package: ${out.package.human}`);
-    console.log(`State:   ${report.total_human || '0 B'}`);
+    console.log(`Package: ${out.package.human || 'not scanned (use --full)'}`);
+    console.log(`State:   ${report.total_human || 'not scanned (use --full)'}`);
 }
 //# sourceMappingURL=gc-command.js.map

package/dist/core/commands/run-command.js

@@ -378,8 +378,8 @@ function runNextAction(route, id, args) {
 function safeRouteExecutionArgs(route, prompt, { auto = false } = {}) {
     if (route.command === '$DB')
         return ['db', 'check', '--sql', 'SELECT 1', '--json'];
-    if (route.command === '$Insane-Search')
-        return ultraSearchExecutionArgs(prompt);
+    if (route.command === '$Super-Search')
+        return superSearchExecutionArgs(prompt);
     if (route.command === '$SEO-GEO-OPTIMIZER')
         return ['seo-geo-optimizer', searchVisibilityActionFromPrompt(prompt), '--mode', searchVisibilityModeFromPrompt(prompt), '--target', searchVisibilityTargetFromPrompt(prompt), '--offline', '--json'];
     if (route.command === '$Wiki')
@@ -394,32 +394,34 @@ function safeRouteExecutionArgs(route, prompt, { auto = false } = {}) {
         return ['commit-and-push', '--json'];
     return ['team', prompt, '--mock', '--json', ...(auto ? ['--no-open-zellij'] : [])];
 }
-function ultraSearchExecutionArgs(prompt = '') {
-    const stripped = stripUltraSearchPrompt(prompt);
+function superSearchExecutionArgs(prompt = '') {
+    const stripped = stripSuperSearchPrompt(prompt);
     const lower = stripped.toLowerCase();
     if (!stripped || /^(?:doctor|check|status)\b/.test(lower))
-        return ['insane-search', 'doctor', '--json'];
+        return ['super-search', 'doctor', '--json'];
     if (/^(?:x|x-search|x_search)\b/.test(lower)) {
         const query = stripped.replace(/^(?:x|x-search|x_search)\b[:\s-]*/i, '').trim() || 'source intelligence fixture';
-        return ['insane-search', 'x', query, '--json'];
+        return ['super-search', 'x', query, '--json'];
     }
     const url = stripped.match(/\bhttps?:\/\/\S+/)?.[0];
-    if (/^(?:fetch|url)\b/.test(lower) || url)
-        return ['insane-search', 'fetch', url || stripped.replace(/^(?:fetch|url)\b[:\s-]*/i, '').trim() || 'https://example.com', '--json'];
+    if (/^(?:fetch|url)\b/.test(lower) || url) {
+        const fetchTarget = url || stripped.replace(/^(?:fetch|url)\b[:\s-]*/i, '').trim();
+        return fetchTarget ? ['super-search', 'fetch', fetchTarget, '--json'] : ['super-search', 'fetch', '--json'];
+    }
     const query = stripped.replace(/^run\b[:\s-]*/i, '').trim() || 'source intelligence fixture';
-    return ['insane-search', 'run', query, '--mode', 'balanced', '--json'];
+    return ['super-search', 'run', query, '--mode', 'balanced', '--json'];
 }
-function stripUltraSearchPrompt(prompt = '') {
+function stripSuperSearchPrompt(prompt = '') {
     return String(prompt || '')
         .trim()
-        .replace(/^\[\$Insane-Search\]\([^)]+\)(?:\s|:)?\s*/i, '')
-        .replace(/^\[\$InsaneSearch\]\([^)]+\)(?:\s|:)?\s*/i, '')
-        .replace(/^\[\$Ultra-Search\]\([^)]+\)(?:\s|:)?\s*/i, '')
-        .replace(/^\[\$UltraSearch\]\([^)]+\)(?:\s|:)?\s*/i, '')
-        .replace(/^\$Insane-Search(?:\s|:)?\s*/i, '')
-        .replace(/^\$InsaneSearch(?:\s|:)?\s*/i, '')
-        .replace(/^\$Ultra-Search(?:\s|:)?\s*/i, '')
-        .replace(/^\$UltraSearch(?:\s|:)?\s*/i, '')
+        .replace(/^\[\$Super-Search\]\([^)]+\)(?:\s|:)?\s*/i, '')
+        .replace(/^\[\$Super-Search\]\([^)]+\)(?:\s|:)?\s*/i, '')
+        .replace(/^\[\$Super-Search\]\([^)]+\)(?:\s|:)?\s*/i, '')
+        .replace(/^\[\$Super-Search\]\([^)]+\)(?:\s|:)?\s*/i, '')
+        .replace(/^\$Super-Search(?:\s|:)?\s*/i, '')
+        .replace(/^\$Super-Search(?:\s|:)?\s*/i, '')
+        .replace(/^\$Super-Search(?:\s|:)?\s*/i, '')
+        .replace(/^\$Super-Search(?:\s|:)?\s*/i, '')
         .trim();
 }
 function searchVisibilityActionFromPrompt(prompt = '') {