sneakoscope 2.0.13 → 2.0.15

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

@@ -1,27 +0,0 @@
-#!/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, makeNonGitFixture } from './lib/git-worktree-fixture.js';
-const capabilityMod = await importDist('core/git/git-worktree-capability.js');
-const nonGit = makeNonGitFixture('worktree-capability-non-git');
-process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-capability-'));
-delete process.env.SKS_ALLOW_IN_REPO_WORKTREES;
-const nonGitCapability = await capabilityMod.evaluateGitWorktreeCapability({ root: nonGit, missionId: 'M-non-git' });
-assertGate(nonGitCapability.mode === 'patch-envelope-only', 'non-Git projects must degrade to patch-envelope-only', nonGitCapability);
-assertGate(nonGitCapability.worktree_probe_attempted === false, 'non-Git projects must not probe git worktree', nonGitCapability);
-const repo = makeGitFixture('worktree-capability-git');
-const gitCapability = await capabilityMod.evaluateGitWorktreeCapability({ root: repo, missionId: 'M-git' });
-assertGate(gitCapability.ok === true && gitCapability.mode === 'git-worktree', 'Git fixture must support worktree mode', gitCapability);
-assertGate(gitCapability.root_resolution?.in_repo === false, 'default worktree root must be outside main repo', gitCapability.root_resolution);
-process.env.SKS_WORKTREE_ROOT = path.join(repo, '.sneakoscope', 'worktrees');
-const blocked = await capabilityMod.evaluateGitWorktreeCapability({ root: repo, missionId: 'M-in-repo' });
-assertGate(blocked.ok === false && blocked.blockers.includes('git_worktree_root_inside_repo_blocked'), 'in-repo worktree root must be blocked by default', blocked);
-emitGate('git:worktree-capability', {
-    non_git_mode: nonGitCapability.mode,
-    git_mode: gitCapability.mode,
-    in_repo_blocked: true
-});
-//# sourceMappingURL=git-worktree-capability-check.js.map

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

@@ -1,20 +0,0 @@
-#!/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 { checkpointWorkerWorktree } from '../core/git/git-worktree-checkpoint.js';
-import { runGitCommand } from '../core/git/git-worktree-runner.js';
-const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-worktree-checkpoint-'));
-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, 'a.txt'), 'a\n');
-await runGitCommand(root, ['add', 'a.txt']);
-await runGitCommand(root, ['commit', '-m', 'base']);
-fs.writeFileSync(path.join(root, 'a.txt'), 'a2\n');
-fs.writeFileSync(path.join(root, 'b.txt'), 'b\n');
-const report = await checkpointWorkerWorktree({ worktreePath: root, repoRoot: root, workerId: 'W1', taskId: 'T1', mode: 'auto' });
-assertGate(report.ok && report.mode_applied === 'checkpoint-commit' && Boolean(report.commit_hash), 'Git worktree checkpoint must create checkpoint commits for multi-file changes', report);
-emitGate('git:worktree-checkpoint', report);
-//# sourceMappingURL=git-worktree-checkpoint-check.js.map

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

@@ -1,27 +0,0 @@
-#!/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

@@ -1,39 +0,0 @@
-#!/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 root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-worktree-cross-rebase-'));
-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(root, '..', `worker-${process.pid}`);
-const dirtyWorkerPath = path.join(root, '..', `worker-dirty-${process.pid}`);
-const runningWorkerPath = path.join(root, '..', `worker-running-${process.pid}`);
-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

@@ -1,17 +0,0 @@
-#!/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

@@ -1,43 +0,0 @@
-#!/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

@@ -1,17 +0,0 @@
-#!/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

@@ -1,14 +0,0 @@
-#!/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

@@ -1,24 +0,0 @@
-#!/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

@@ -1,20 +0,0 @@
-#!/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

@@ -1,37 +0,0 @@
-#!/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

@@ -1,18 +0,0 @@
-#!/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

@@ -1,31 +0,0 @@
-#!/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

@@ -1,20 +0,0 @@
-#!/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-untracked-diff-check.js

@@ -1,18 +0,0 @@
-#!/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-mode-official-default-check.js

@@ -1,12 +0,0 @@
-#!/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

@@ -1,63 +0,0 @@
-#!/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

@@ -1,36 +0,0 @@
-#!/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

@@ -1,35 +0,0 @@
-#!/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

@@ -1,20 +0,0 @@
-#!/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

@@ -1,17 +0,0 @@
-#!/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

@@ -1,21 +0,0 @@
-#!/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