sneakoscope 4.0.13 → 4.0.15

package/dist/scripts/git-worktree-cleanup-check.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+import { makeGitFixture } from './lib/git-worktree-fixture.js';
+const managerMod = await importDist('core/git/git-worktree-manager.js');
+const cleanupMod = await importDist('core/git/git-worktree-cleanup.js');
+const repo = makeGitFixture('worktree-cleanup');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-cleanup-'));
+const cleanAllocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-cleanup', workerId: 'clean', slotId: 'slot-001' });
+const clean = await cleanupMod.cleanupGitWorktree({ repoRoot: repo, worktreePath: cleanAllocation.worktree_path, branch: cleanAllocation.branch, deleteBranch: true });
+assertGate(clean.ok === true && clean.action === 'removed', 'clean worktree must be removed by cleanup manager', clean);
+assertGate(!fs.existsSync(cleanAllocation.worktree_path), 'removed clean worktree path should be gone');
+const dirtyAllocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-cleanup', workerId: 'dirty', slotId: 'slot-002' });
+fs.writeFileSync(path.join(dirtyAllocation.worktree_path, 'a.txt'), 'dirty\n');
+const dirty = await cleanupMod.cleanupGitWorktree({ repoRoot: repo, worktreePath: dirtyAllocation.worktree_path, branch: dirtyAllocation.branch, deleteBranch: true });
+assertGate(dirty.ok === true && dirty.action === 'retained_dirty', 'dirty worktree must be retained', dirty);
+assertGate(fs.existsSync(dirtyAllocation.worktree_path), 'dirty worktree path must still exist');
+assertGate(dirty.retention_lock_path && fs.existsSync(dirty.retention_lock_path), 'dirty retention lock must be written outside the retained worktree', dirty);
+emitGate('git:worktree-cleanup', {
+    clean_action: clean.action,
+    dirty_action: dirty.action,
+    retention_lock_path: dirty.retention_lock_path
+});
+//# sourceMappingURL=git-worktree-cleanup-check.js.map

package/dist/scripts/git-worktree-cross-rebase-check.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+import { crossRebaseIdleWorktrees } from '../core/git/git-worktree-cross-rebase.js';
+import { runGitCommand, gitOutputLine } from '../core/git/git-worktree-runner.js';
+const suiteRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-worktree-cross-rebase-'));
+const root = path.join(suiteRoot, 'repo');
+fs.mkdirSync(root, { recursive: true });
+await runGitCommand(root, ['init']);
+await runGitCommand(root, ['config', 'user.email', 'sks@example.test']);
+await runGitCommand(root, ['config', 'user.name', 'SKS Test']);
+fs.writeFileSync(path.join(root, 'base.txt'), 'base\n');
+await runGitCommand(root, ['add', 'base.txt']);
+await runGitCommand(root, ['commit', '-m', 'base']);
+const workerPath = path.join(suiteRoot, 'worker');
+const dirtyWorkerPath = path.join(suiteRoot, 'worker-dirty');
+const runningWorkerPath = path.join(suiteRoot, 'worker-running');
+await runGitCommand(root, ['worktree', 'add', workerPath, 'HEAD']);
+await runGitCommand(root, ['worktree', 'add', dirtyWorkerPath, 'HEAD']);
+await runGitCommand(root, ['worktree', 'add', runningWorkerPath, 'HEAD']);
+fs.writeFileSync(path.join(dirtyWorkerPath, 'dirty.txt'), 'dirty\n');
+fs.writeFileSync(path.join(root, 'integration.txt'), 'integration\n');
+await runGitCommand(root, ['add', 'integration.txt']);
+await runGitCommand(root, ['commit', '-m', 'integration']);
+const head = gitOutputLine(await runGitCommand(root, ['rev-parse', 'HEAD']));
+const report = await crossRebaseIdleWorktrees({
+    integrationHead: head,
+    workers: [
+        { worker_id: 'W1', worktree_path: workerPath, state: 'idle' },
+        { worker_id: 'W-dirty', worktree_path: dirtyWorkerPath, state: 'idle' },
+        { worker_id: 'W-running', worktree_path: runningWorkerPath, state: 'running' }
+    ]
+});
+assertGate(report.ok && report.applied_count === 1, 'Idle worktrees must cross-rebase to the integration head', report);
+assertGate(report.skipped_count === 2, 'Dirty and running worktrees must be skipped during cross-rebase', report);
+assertGate(report.records.some((row) => row.worker_id === 'W-dirty' && row.status === 'skipped' && row.reason === 'dirty_worktree_skipped'), 'Dirty worktree must skip cross-rebase', report);
+assertGate(report.records.some((row) => row.worker_id === 'W-running' && row.status === 'skipped' && row.reason === 'worker_not_idle'), 'Running worktree must skip cross-rebase', report);
+emitGate('git:worktree-cross-rebase', report);
+//# sourceMappingURL=git-worktree-cross-rebase-check.js.map

package/dist/scripts/git-worktree-diff-envelope-check.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const envelopeMod = await importDist('core/git/git-worktree-patch-envelope.js');
+const schemaMod = await importDist('core/agents/agent-patch-schema.js');
+const envelope = envelopeMod.buildGitWorktreePatchEnvelope({
+    diff: { schema: 'sks.git-worktree-diff.v1', mission_id: 'M-env', worker_id: 'worker-1', main_repo_root: '.', worktree_path: '.', branch: null, base_head: null, worktree_head: null, changed_files: ['a.txt', 'b.txt'], diff_bytes: 12, diff: 'diff --git a/a.txt b/a.txt\n', clean: false },
+    agentId: 'agent-1',
+    sessionId: 'session-1',
+    slotId: 'slot-001',
+    generationIndex: 1
+});
+const validation = schemaMod.validateAgentPatchEnvelope(schemaMod.normalizeAgentPatchEnvelope(envelope));
+assertGate(envelope.operations.length === 1 && envelope.operations[0].op === 'git_apply_patch', 'git worktree envelope must use one git_apply_patch operation', envelope);
+assertGate(validation.ok === true, 'git_apply_patch envelope must validate', validation);
+emitGate('git:worktree-diff-envelope', { operations: envelope.operations.length, op: envelope.operations[0].op });
+//# sourceMappingURL=git-worktree-diff-envelope-check.js.map

package/dist/scripts/git-worktree-diff-export-check.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+import { makeGitFixture, run } from './lib/git-worktree-fixture.js';
+const managerMod = await importDist('core/git/git-worktree-manager.js');
+const diffMod = await importDist('core/git/git-worktree-diff.js');
+const envelopeMod = await importDist('core/git/git-worktree-patch-envelope.js');
+const schemaMod = await importDist('core/agents/agent-patch-schema.js');
+const cleanupMod = await importDist('core/git/git-worktree-cleanup.js');
+const repo = makeGitFixture('worktree-diff');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-diff-'));
+const allocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-diff', workerId: 'worker-1', slotId: 'slot-001' });
+fs.writeFileSync(path.join(allocation.worktree_path, 'a.txt'), 'alpha\nchanged\n');
+const diff = await diffMod.exportGitWorktreeDiff({
+    mainRepoRoot: repo,
+    worktreePath: allocation.worktree_path,
+    missionId: 'M-diff',
+    workerId: 'worker-1'
+});
+const envelope = envelopeMod.buildGitWorktreePatchEnvelope({
+    diff,
+    agentId: 'agent-1',
+    sessionId: 'session-1',
+    slotId: 'slot-001',
+    generationIndex: 1
+});
+const validation = schemaMod.validateAgentPatchEnvelope(schemaMod.normalizeAgentPatchEnvelope(envelope));
+assertGate(diff.ok === true && diff.clean === false, 'diff export must detect changed worktree', diff);
+assertGate(diff.changed_files.includes('a.txt'), 'diff export must include changed file', diff);
+assertGate(/index [0-9a-f]{40}\.\.[0-9a-f]{40}/.test(diff.diff), 'diff export must use full-index diff hashes', { diff: diff.diff });
+assertGate(envelope.source === 'git-worktree-diff' && validation.ok === true, 'git worktree diff patch envelope must validate', { envelope, validation });
+assertGate(run('git', ['status', '--porcelain=v1'], repo).trim() === '', 'main repo must stay clean after diff export');
+run('git', ['checkout', '--', 'a.txt'], allocation.worktree_path);
+await cleanupMod.cleanupGitWorktree({ repoRoot: repo, worktreePath: allocation.worktree_path, branch: allocation.branch, deleteBranch: true });
+emitGate('git:worktree-diff-export', {
+    changed_files: diff.changed_files,
+    diff_bytes: diff.diff_bytes,
+    envelope_source: envelope.source
+});
+//# sourceMappingURL=git-worktree-diff-export-check.js.map

package/dist/scripts/git-worktree-dirty-lock-check.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+import { makeGitFixture } from './lib/git-worktree-fixture.js';
+const managerMod = await importDist('core/git/git-worktree-manager.js');
+const cleanupMod = await importDist('core/git/git-worktree-cleanup.js');
+const repo = makeGitFixture('dirty-lock');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-lock-'));
+const allocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-lock', workerId: 'worker-1', slotId: 'slot-001' });
+fs.writeFileSync(path.join(allocation.worktree_path, 'a.txt'), 'dirty\n');
+const cleanup = await cleanupMod.cleanupGitWorktree({ repoRoot: repo, worktreePath: allocation.worktree_path, branch: allocation.branch });
+assertGate(cleanup.action === 'retained_dirty' && cleanup.git_locked === true, 'dirty retained worktree must be git locked', cleanup);
+emitGate('git:worktree-dirty-lock', { git_locked: cleanup.git_locked, unlock_command: cleanup.unlock_command });
+//# sourceMappingURL=git-worktree-dirty-lock-check.js.map

package/dist/scripts/git-worktree-dirty-main-detection-check.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+import { makeGitFixture } from './lib/git-worktree-fixture.js';
+const detectionMod = await importDist('core/git/git-repo-detection.js');
+const repo = makeGitFixture('dirty-main-detection');
+fs.writeFileSync(path.join(repo, 'dirty.txt'), 'dirty\n');
+const detection = await detectionMod.detectGitRepo(repo);
+assertGate(detection.main_worktree_dirty === true, 'dirty main worktree must be detected', detection);
+assertGate(String(detection.status_porcelain).includes('dirty.txt'), 'status_porcelain must include dirty file', detection);
+emitGate('git:worktree-dirty-main-detection', { dirty: detection.main_worktree_dirty });
+//# sourceMappingURL=git-worktree-dirty-main-detection-check.js.map

package/dist/scripts/git-worktree-integration-primary-check.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+import { makeGitFixture } from './lib/git-worktree-fixture.js';
+const managerMod = await importDist('core/git/git-worktree-manager.js');
+const diffMod = await importDist('core/git/git-worktree-diff.js');
+const mergeMod = await importDist('core/git/git-worktree-merge-queue.js');
+const repo = makeGitFixture('integration-primary');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-integration-'));
+const allocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-integrate', workerId: 'worker-1', slotId: 'slot-001' });
+fs.writeFileSync(path.join(allocation.worktree_path, 'a.txt'), 'alpha\nintegrated\n');
+const diff = await diffMod.exportGitWorktreeDiff({ mainRepoRoot: repo, worktreePath: allocation.worktree_path, missionId: 'M-integrate', workerId: 'worker-1' });
+const integrationPath = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-integration-'));
+fs.rmSync(integrationPath, { recursive: true, force: true });
+const integration = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-integrate', workerId: 'integration', slotId: 'integration' });
+const report = await mergeMod.applyGitWorktreeMergeQueue({ integrationWorktreePath: integration.worktree_path, diffs: [diff] });
+const mainReport = await mergeMod.applyGitWorktreeMergeQueue({ integrationWorktreePath: repo, diffs: [diff] });
+const mainContent = fs.readFileSync(path.join(repo, 'a.txt'), 'utf8');
+assertGate(report.ok === true && report.applied_count === 1 && mainReport.ok === true && mainReport.applied_count === 1 && mainContent.includes('integrated'), 'git-worktree-diff must prevalidate in integration worktree and apply to main repo', { report, mainReport, mainContent });
+emitGate('git:worktree-integration-primary', { applied_count: report.applied_count, main_applied_count: mainReport.applied_count });
+//# sourceMappingURL=git-worktree-integration-primary-check.js.map

package/dist/scripts/git-worktree-integration-primary-runtime-check.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
+const orchestrator = fs.readFileSync(path.join(root, 'src/core/agents/agent-orchestrator.ts'), 'utf8');
+const report = {
+    schema: 'sks.git-worktree-integration-primary-runtime-check.v1',
+    splits_worktree_entries: orchestrator.includes("entry.envelope?.source === 'git-worktree-diff'"),
+    uses_integration_worktree: orchestrator.includes('createGitIntegrationWorktree'),
+    uses_merge_queue: orchestrator.includes('applyGitWorktreeMergeQueue'),
+    applies_to_main_repo: orchestrator.includes('main_repo_apply') && orchestrator.includes('integrationWorktreePath: repoRoot'),
+    rollback_evidence: orchestrator.includes('rollback_evidence') && orchestrator.includes('captureGitWorktreeRollbackPlan') && orchestrator.includes('completeGitWorktreeRollbackPlan'),
+    bypasses_normal_apply: orchestrator.includes('const normalEntries') && orchestrator.includes('applyAgentPatchQueueEntry(root, entry') && orchestrator.includes('parallelEntries = disjointEntries'),
+    writes_report: orchestrator.includes('git-worktree-merge-queue-report.json')
+};
+const ok = report.splits_worktree_entries && report.uses_integration_worktree && report.uses_merge_queue && report.applies_to_main_repo && report.rollback_evidence && report.bypasses_normal_apply && report.writes_report;
+assertGate(ok, 'git-worktree-diff entries must use integration merge queue primary path', report);
+emitGate('git:worktree-integration-primary-runtime', report);
+//# sourceMappingURL=git-worktree-integration-primary-runtime-check.js.map

package/dist/scripts/git-worktree-manager-check.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+import { makeGitFixture, run } from './lib/git-worktree-fixture.js';
+const managerMod = await importDist('core/git/git-worktree-manager.js');
+const cleanupMod = await importDist('core/git/git-worktree-cleanup.js');
+const repo = makeGitFixture('worktree-manager');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-manager-'));
+delete process.env.SKS_ALLOW_IN_REPO_WORKTREES;
+const allocation = await managerMod.allocateWorkerWorktree({
+    repoRoot: repo,
+    missionId: 'M-manager',
+    workerId: 'worker-1',
+    slotId: 'slot-001',
+    generationIndex: 1
+});
+assertGate(allocation.ok === true, 'worker worktree allocation must pass', allocation);
+assertGate(fs.existsSync(allocation.worktree_path), 'allocated worktree path must exist', allocation);
+assertGate(!path.resolve(allocation.worktree_path).startsWith(path.resolve(repo) + path.sep), 'worktree must be outside main repo by default', allocation);
+assertGate(fs.existsSync(allocation.manifest_path), 'worktree manifest must be written', allocation);
+assertGate(run('git', ['status', '--porcelain=v1'], repo).trim() === '', 'main repo must stay clean after allocation');
+const cleanup = await cleanupMod.cleanupGitWorktree({
+    repoRoot: repo,
+    worktreePath: allocation.worktree_path,
+    branch: allocation.branch,
+    deleteBranch: true
+});
+assertGate(cleanup.ok === true && cleanup.action === 'removed', 'clean worktree cleanup must remove allocation', cleanup);
+emitGate('git:worktree-manager', {
+    worktree_outside_repo: true,
+    branch: allocation.branch,
+    cleanup: cleanup.action
+});
+//# sourceMappingURL=git-worktree-manager-check.js.map

package/dist/scripts/git-worktree-manifest-append-check.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+import { makeGitFixture } from './lib/git-worktree-fixture.js';
+const managerMod = await importDist('core/git/git-worktree-manager.js');
+const repo = makeGitFixture('worktree-manifest-append');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-manifest-'));
+const allocations = [];
+for (let index = 0; index < 4; index += 1) {
+    allocations.push(await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-manifest', workerId: `worker-${index}`, slotId: `slot-${index}` }));
+}
+const manifest = JSON.parse(fs.readFileSync(allocations[0].manifest_path, 'utf8'));
+assertGate(manifest.allocations.length >= allocations.length, 'manifest append must preserve allocations', manifest);
+emitGate('git:worktree-manifest-append', { allocations: manifest.allocations.length });
+//# sourceMappingURL=git-worktree-manifest-append-check.js.map

package/dist/scripts/git-worktree-merge-queue-check.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+import { makeGitFixture } from './lib/git-worktree-fixture.js';
+const managerMod = await importDist('core/git/git-worktree-manager.js');
+const diffMod = await importDist('core/git/git-worktree-diff.js');
+const integrationMod = await importDist('core/git/git-integration-worktree.js');
+const queueMod = await importDist('core/git/git-worktree-merge-queue.js');
+const repo = makeGitFixture('worktree-merge');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-merge-'));
+const a = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-merge', workerId: 'a', slotId: 'slot-001' });
+const b = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-merge', workerId: 'b', slotId: 'slot-002' });
+fs.writeFileSync(path.join(a.worktree_path, 'a.txt'), 'alpha\nfrom-a\n');
+fs.writeFileSync(path.join(b.worktree_path, 'b.txt'), 'bravo\nfrom-b\n');
+const diffA = await diffMod.exportGitWorktreeDiff({ mainRepoRoot: repo, worktreePath: a.worktree_path, missionId: 'M-merge', workerId: 'a' });
+const diffB = await diffMod.exportGitWorktreeDiff({ mainRepoRoot: repo, worktreePath: b.worktree_path, missionId: 'M-merge', workerId: 'b' });
+const integration = await integrationMod.createGitIntegrationWorktree({ repoRoot: repo, missionId: 'M-merge' });
+const report = await queueMod.applyGitWorktreeMergeQueue({ integrationWorktreePath: integration.worktree_path, diffs: [diffA, diffB] });
+assertGate(report.ok === true && report.applied_count === 2, 'merge queue must apply non-conflicting worktree diffs', report);
+assertGate((report.strategy_results || []).every((row) => row.strategy === 'diff-apply-3way'), 'merge queue must record the diff apply strategy for worktree diffs', report.strategy_results || []);
+assertGate(fs.readFileSync(path.join(integration.worktree_path, 'a.txt'), 'utf8').includes('from-a'), 'integration worktree must include first diff');
+assertGate(fs.readFileSync(path.join(integration.worktree_path, 'b.txt'), 'utf8').includes('from-b'), 'integration worktree must include second diff');
+assertGate(fs.readFileSync(path.join(repo, 'a.txt'), 'utf8') === 'alpha\n', 'main worktree must remain unchanged before integration commit');
+emitGate('git:worktree-merge-queue', {
+    applied_count: report.applied_count,
+    changed_files: report.changed_files
+});
+//# sourceMappingURL=git-worktree-merge-queue-check.js.map

package/dist/scripts/git-worktree-pool-performance-check.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const poolMod = await importDist('core/git/git-worktree-pool.js');
+const workerIds = Array.from({ length: 100 }, (_, index) => `worker-${index + 1}`);
+const reusable = Array.from({ length: 32 }, (_, index) => `/tmp/reuse-${index + 1}`);
+const start = Date.now();
+const plan = poolMod.planGitWorktreePool({ workerIds, reusableWorktrees: reusable });
+const elapsed = Date.now() - start;
+assertGate(plan.ok === true, 'pool plan must pass', plan);
+assertGate(plan.assignments.length === 100, 'pool must assign every requested worker', plan);
+assertGate(plan.assignments.filter((row) => row.action === 'reuse').length === 32, 'pool must reuse available worktrees first', plan);
+assertGate(plan.allocate_count === 68, 'pool must allocate only the remaining workers', plan);
+assertGate(elapsed < 100, 'pool plan must stay fast for 100 workers', { elapsed });
+emitGate('git:worktree-pool-performance', {
+    elapsed_ms: elapsed,
+    reusable: 32,
+    allocate_count: plan.allocate_count
+});
+//# sourceMappingURL=git-worktree-pool-performance-check.js.map

package/dist/scripts/git-worktree-prewarm-runtime-check.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
+const src = readText('src/core/agents/agent-orchestrator.ts');
+assertGate(src.includes('preparedWorktreeAllocations') && src.includes('prewarmed_allocations') && src.includes('allocateWorkerWorktreesBatch'), 'orchestrator must prewarm write-capable git worktrees before scheduler launch');
+emitGate('git:worktree-prewarm-runtime');
+//# sourceMappingURL=git-worktree-prewarm-runtime-check.js.map

package/dist/scripts/git-worktree-untracked-diff-check.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+import { makeGitFixture } from './lib/git-worktree-fixture.js';
+const managerMod = await importDist('core/git/git-worktree-manager.js');
+const diffMod = await importDist('core/git/git-worktree-diff.js');
+const repo = makeGitFixture('untracked-diff');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-untracked-'));
+const allocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-untracked', workerId: 'worker-1', slotId: 'slot-001' });
+fs.writeFileSync(path.join(allocation.worktree_path, 'new-file.txt'), 'new content\n');
+const diff = await diffMod.exportGitWorktreeDiff({ mainRepoRoot: repo, worktreePath: allocation.worktree_path, missionId: 'M-untracked', workerId: 'worker-1' });
+assertGate(diff.changed_files.includes('new-file.txt'), 'changed files must include untracked file', diff);
+assertGate(diff.diff.includes('new file mode') && diff.diff.includes('+new content'), 'git diff must include untracked file content', { diff: diff.diff });
+emitGate('git:worktree-untracked-diff', { changed_files: diff.changed_files });
+//# sourceMappingURL=git-worktree-untracked-diff-check.js.map

package/dist/scripts/goal-artifact-compat-check.js

@@ -0,0 +1,3 @@
+import { runLoopDirectiveCheck } from './loop-directive-check-lib.js';
+await runLoopDirectiveCheck('goal:artifact-compat');
+//# sourceMappingURL=goal-artifact-compat-check.js.map

package/dist/scripts/goal-legacy-runtime-escape-check.js

@@ -0,0 +1,3 @@
+import { runLoopDirectiveCheck } from './loop-directive-check-lib.js';
+await runLoopDirectiveCheck('goal:legacy-runtime-escape');
+//# sourceMappingURL=goal-legacy-runtime-escape-check.js.map

package/dist/scripts/goal-loop-compat-check.js

@@ -0,0 +1,3 @@
+import { runLoopDirectiveCheck } from './loop-directive-check-lib.js';
+await runLoopDirectiveCheck('goal:loop-compat');
+//# sourceMappingURL=goal-loop-compat-check.js.map

package/dist/scripts/goal-loop-runtime-default-check.js

@@ -0,0 +1,3 @@
+import { runLoopDirectiveCheck } from './loop-directive-check-lib.js';
+await runLoopDirectiveCheck('goal:loop-runtime-default');
+//# sourceMappingURL=goal-loop-runtime-default-check.js.map

package/dist/scripts/goal-mode-official-default-check.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/codex/official-goal-mode.js');
+const official = await mod.detectOfficialGoalMode({ runCommand: false, codexHelpText: 'Usage: codex /goal create', codexGoalHelpText: 'codex goal --help' });
+const featureListOfficial = await mod.detectOfficialGoalMode({ runCommand: false, codexHelpText: 'Usage: codex', codexGoalHelpText: '', codexFeaturesText: 'goals stable true\n' });
+const fallback = await mod.detectOfficialGoalMode({ runCommand: false, codexHelpText: 'Usage: codex' });
+assertGate(official.official_goal_available === true && official.default_enabled === true, 'official goal availability must default-enable goal mode', official);
+assertGate(featureListOfficial.official_goal_available === true && featureListOfficial.codex_goals_feature_enabled === true, 'Codex goals feature flag must default-enable goal mode without goal subcommand help', featureListOfficial);
+assertGate(fallback.mode === 'sks_goal_fallback', 'missing official goal must use SKS fallback', fallback);
+emitGate('goal-mode:official-default', { official: official.mode, feature_list_official: featureListOfficial.mode, fallback: fallback.mode });
+//# sourceMappingURL=goal-mode-official-default-check.js.map

package/dist/scripts/gpt-final-arbiter-check.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist, readJsonFile, root } from './lib/codex-sdk-gate-lib.js';
+const mod = await importDist('core/codex-control/gpt-final-arbiter.js');
+const old = snapshotEnv();
+process.env.NODE_ENV = 'test';
+process.env.SKS_CODEX_SDK_FAKE = '1';
+delete process.env.SKS_GPT_FINAL_ARBITER_UNAVAILABLE;
+try {
+    const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-gpt-final-arbiter-'));
+    const approved = await mod.runGptFinalArbiter(fixtureInput('approved'), { cwd: root, mutationLedgerRoot: tmp });
+    assertGate(approved.ok === true, 'GPT final arbiter fixture must approve safe candidate', approved);
+    assertGate(approved.backend === 'codex-sdk', 'GPT final arbiter backend must be codex-sdk');
+    assertGate(approved.result.status === 'approved', 'safe candidate must return approved');
+    assertGate(approved.final_gate.ok === true, 'approved arbiter result must pass final gate');
+    const artifact = await readJsonFile(path.join(tmp, 'gpt-final-arbiter.json'));
+    assertGate(artifact.result.schema === 'sks.gpt-final-arbiter-result.v1', 'arbiter artifact must contain schema-valid result');
+    const unsafeTmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-gpt-final-arbiter-unsafe-'));
+    const rejected = await mod.runGptFinalArbiter({ ...fixtureInput('unsafe'), candidate_diff: 'unsafe delete all credential patch' }, { cwd: root, mutationLedgerRoot: unsafeTmp });
+    assertGate(rejected.ok === false, 'unsafe candidate must not pass final arbiter');
+    assertGate(rejected.result.status === 'rejected', 'unsafe candidate must be rejected');
+    assertGate(rejected.blockers.includes('unsafe_candidate_patch'), 'unsafe rejection blocker must be preserved');
+    emitGate('local-collab:gpt-final-arbiter', { approved: approved.result.status, rejected: rejected.result.status });
+}
+finally {
+    restoreEnv(old);
+}
+function fixtureInput(label) {
+    return {
+        schema: 'sks.gpt-final-arbiter-input.v1',
+        route: '$Naruto',
+        mission_id: `M-${label}`,
+        local_mode: 'local-parallel-gpt-final',
+        local_outputs: [
+            { worker_id: 'slot-001/gen-1', backend: 'local-llm', summary: 'candidate patch drafted', patch_envelopes: [], proof: 'local draft' }
+        ],
+        candidate_diff: 'diff --git a/example.ts b/example.ts',
+        candidate_patch_envelopes: [],
+        verification_results: [{ ok: true, status: 'passed' }],
+        side_effect_report: { ok: true },
+        mutation_ledger: { ok: true },
+        rollback_plan: { ok: true }
+    };
+}
+function snapshotEnv() {
+    return {
+        NODE_ENV: process.env.NODE_ENV,
+        SKS_CODEX_SDK_FAKE: process.env.SKS_CODEX_SDK_FAKE,
+        SKS_GPT_FINAL_ARBITER_UNAVAILABLE: process.env.SKS_GPT_FINAL_ARBITER_UNAVAILABLE
+    };
+}
+function restoreEnv(old) {
+    for (const [key, value] of Object.entries(old)) {
+        if (value === undefined)
+            delete process.env[key];
+        else
+            process.env[key] = value;
+    }
+}
+//# sourceMappingURL=gpt-final-arbiter-check.js.map

package/dist/scripts/gpt-final-arbiter-performance-check.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './lib/codex-sdk-gate-lib.js';
+const compressor = await importDist('core/codex-control/gpt-final-context-compressor.js');
+const local_outputs = Array.from({ length: 20 }, (_, index) => ({
+    worker_id: `slot-${String(index + 1).padStart(3, '0')}/gen-1`,
+    backend: 'local-llm',
+    status: 'done',
+    summary: `worker ${index + 1} summarized a bounded shard`,
+    changed_files: [`src/example-${index + 1}.ts`],
+    blockers: []
+}));
+const candidate_patch_envelopes = local_outputs.map((output, index) => ({
+    id: `patch-${index + 1}`,
+    agent_id: output.worker_id,
+    source: 'model_authored',
+    lease_id: `lease-${index + 1}`,
+    rollback_hint: { ok: true },
+    operations: [{ op: 'replace', path: output.changed_files[0], search: 'before', replace: 'after' }]
+}));
+const report = compressor.compressGptFinalContext({
+    route: '$Naruto',
+    mission_id: 'M-20-local-workers',
+    local_mode: 'local-parallel-gpt-final',
+    local_outputs,
+    candidate_patch_envelopes,
+    verification_results: [{ ok: true, status: 'passed' }],
+    side_effect_report: { ok: true },
+    mutation_ledger: { ok: true },
+    rollback_plan: { ok: true }
+});
+assertGate(report.proof_pack.worker_count === 20, 'proof pack must include 20 worker summaries');
+assertGate(report.proof_pack.token_budget_estimate < 8000, '20-worker proof pack must stay under token budget', report.proof_pack);
+assertGate(report.latency_budget.ok === true, 'GPT final latency budget report must pass');
+emitGate('local-collab:gpt-final-performance', { workers: report.proof_pack.worker_count, token_budget_estimate: report.proof_pack.token_budget_estimate });
+//# sourceMappingURL=gpt-final-arbiter-performance-check.js.map

package/dist/scripts/gpt-image-2-request-validator-check.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { validateGptImage2Request } from '../core/imagegen/gpt-image-2-request-validator.js';
+import { writeValidPngFixture } from './lib/valid-png-fixture.js';
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-gpt-image-2-validator-'));
+const source = path.join(root, 'source.png');
+writeValidPngFixture(source);
+const good = await validateGptImage2Request({
+    provider: 'fake_imagegen_adapter',
+    endpoint: 'local hermetic fixture',
+    model: 'gpt-image-2',
+    prompt: 'Annotate the image with numbered callouts.',
+    source_image_path: source,
+    output_dir: root,
+    params: { size: 'auto' },
+    privacy: 'local-only'
+});
+const bad = await validateGptImage2Request({
+    provider: 'openai_images_api',
+    endpoint: '/v1/images/edits',
+    model: 'gpt-image-2',
+    prompt: 'Bad request.',
+    source_image_path: source,
+    output_dir: root,
+    params: { input_fidelity: 'high' },
+    privacy: 'local-only'
+});
+const ok = good.ok === true && bad.ok === false && bad.blockers.includes('input_fidelity_must_be_omitted_for_gpt_image_2');
+console.log(JSON.stringify({ schema: 'sks.gpt-image-2-request-validator-check.v1', ok, good, bad }, null, 2));
+if (!ok)
+    process.exitCode = 1;
+//# sourceMappingURL=gpt-image-2-request-validator-check.js.map

package/dist/scripts/hooks-0.134-context-parity-check.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, readText, root } from './sks-1-18-gate-lib.js';
+const hooksSchema = readText('src/core/codex-compat/codex-hook-events.ts');
+const cockpit = readText('src/core/agents/agent-orchestrator.ts');
+const report = {
+    schema: 'sks.hooks-0.134-context-parity-check.v1',
+    ok: hooksSchema.includes('SubagentStart') && hooksSchema.includes('SubagentStop') && cockpit.includes('agent_transcript_path') && cockpit.includes('permission_mode'),
+    hook_events_have_subagents: hooksSchema.includes('SubagentStart') && hooksSchema.includes('SubagentStop'),
+    agent_context_forwarded: cockpit.includes('agent_transcript_path') && cockpit.includes('permission_mode')
+};
+const out = path.join(root, '.sneakoscope', 'reports', 'hooks-0.134-context-parity.json');
+fs.mkdirSync(path.dirname(out), { recursive: true });
+fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
+assertGate(report.hook_events_have_subagents === true, 'Codex 0.134 hook event parity must include subagent events', report);
+assertGate(report.agent_context_forwarded === true, 'Codex 0.134 hook context parity must forward agent context', report);
+emitGate('hooks:0.134-context-parity', { hook_events_have_subagents: report.hook_events_have_subagents });
+//# sourceMappingURL=hooks-0.134-context-parity-check.js.map

package/dist/scripts/hooks-actual-parity-check.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { installManagedCodexHooks } from '../core/codex-hooks/codex-hook-managed-install.js';
+import { writeCodexHookOfficialParityReport } from '../core/codex-hooks/codex-hook-official-parity.js';
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-hooks-actual-parity-'));
+const install = await installManagedCodexHooks(root);
+const report = await writeCodexHookOfficialParityReport(root, {
+    outputPath: path.join(root, '.sneakoscope', 'reports', 'codex-hook-parity-1.14.1.json')
+});
+const ok = install.ok && report.ok && report.policy.managed_only_enforced === true;
+console.log(JSON.stringify({ schema: 'sks.hooks-actual-parity-check.v1', ok, install, report_path: report.path, policy: report.policy }, null, 2));
+if (!ok)
+    process.exitCode = 1;
+//# sourceMappingURL=hooks-actual-parity-check.js.map

package/dist/scripts/hooks-actual-parity-v2-check.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { installManagedCodexHooks } from '../core/codex-hooks/codex-hook-managed-install.js';
+import { writeCodexHookOfficialParityReport } from '../core/codex-hooks/codex-hook-official-parity.js';
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-hooks-actual-v2-'));
+const install = await installManagedCodexHooks(root);
+const report = await writeCodexHookOfficialParityReport(root, {
+    outputPath: path.join(root, '.sneakoscope', 'reports', 'codex-hook-parity-1.14.1.json')
+});
+const ok = install.ok
+    && report.ok
+    && report.schema === 'sks.codex-hook-official-parity.v2'
+    && report.coverage.requirements_toml === 'covered'
+    && report.unmanaged_trusted_hash_writer_enabled === false;
+console.log(JSON.stringify({ schema: 'sks.hooks-actual-parity-v2-check.v1', ok, report_path: report.path, coverage: report.coverage, policy: report.policy }, null, 2));
+if (!ok)
+    process.exitCode = 1;
+//# sourceMappingURL=hooks-actual-parity-v2-check.js.map

package/dist/scripts/hooks-latest-schema-check.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { codexSchemaSnapshotReport } from '../core/codex-compat/codex-schema-snapshot.js';
+const report = await codexSchemaSnapshotReport();
+const ok = report.ok
+    && report.supported_events_count === 10
+    && report.schema_files_count === 20
+    && report.metadata?.tag === 'latest'
+    && report.supported_events.includes('SubagentStart')
+    && report.supported_events.includes('SubagentStop');
+console.log(JSON.stringify({
+    schema: 'sks.hooks-latest-schema-check.v1',
+    ok,
+    supported_events_count: report.supported_events_count,
+    schema_files_count: report.schema_files_count,
+    release_blockers: ok ? [] : report.release_blockers
+}, null, 2));
+if (!ok)
+    process.exitCode = 1;
+//# sourceMappingURL=hooks-latest-schema-check.js.map