sneakoscope 2.0.6 → 2.0.8

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

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const policyMod = await importDist('core/git/git-worktree-cache-policy.js');
+const now = Date.now();
+const entries = Array.from({ length: 1000 }, (_, index) => ({
+    path: `/tmp/wt-${index}`,
+    updated_at_ms: now - index * 60000,
+    bytes: 1024 * (index + 1),
+    dirty: index % 137 === 0
+}));
+const start = Date.now();
+const plan = policyMod.planGitWorktreeCachePolicy({ entries, nowMs: now, maxEntries: 120, maxBytes: 40 * 1024 * 1024, ttlMs: 2 * 60 * 60 * 1000 });
+const elapsed = Date.now() - start;
+assertGate(plan.ok === true, 'cache policy plan must pass', plan);
+assertGate(plan.keep.length <= 120 || plan.dirty_retained.length > 0, 'cache policy must bound retained clean entries', plan);
+assertGate(plan.dirty_retained.length > 0, 'dirty entries must be retained by cache policy', plan);
+assertGate(elapsed < 250, 'cache policy must stay fast on 1000 entries', { elapsed });
+emitGate('git:worktree-cache-performance', {
+    elapsed_ms: elapsed,
+    keep: plan.keep.length,
+    prune: plan.prune.length,
+    dirty_retained: plan.dirty_retained.length
+});
+//# sourceMappingURL=git-worktree-cache-performance-check.js.map

package/dist/scripts/git-worktree-capability-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, 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-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-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,22 @@
+#!/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] });
+assertGate(report.ok === true && report.applied_count === 1, 'git-worktree-diff must apply through merge queue', report);
+emitGate('git:worktree-integration-primary', { applied_count: report.applied_count });
+//# sourceMappingURL=git-worktree-integration-primary-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,30 @@
+#!/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(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-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/lib/git-worktree-fixture.js

@@ -0,0 +1,33 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+export function makeGitFixture(name) {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), `sks-${name}-`));
+    run('git', ['init'], root);
+    run('git', ['config', 'user.email', 'sks@example.invalid'], root);
+    run('git', ['config', 'user.name', 'SKS Test'], root);
+    fs.writeFileSync(path.join(root, 'a.txt'), 'alpha\n');
+    fs.writeFileSync(path.join(root, 'b.txt'), 'bravo\n');
+    run('git', ['add', 'a.txt', 'b.txt'], root);
+    run('git', ['commit', '-m', 'fixture'], root);
+    return root;
+}
+export function makeNonGitFixture(name) {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), `sks-${name}-`));
+    fs.writeFileSync(path.join(root, 'plain.txt'), 'not git\n');
+    return root;
+}
+export function run(command, args, cwd, input) {
+    const result = spawnSync(command, args, {
+        cwd,
+        input,
+        encoding: 'utf8',
+        stdio: input === undefined ? ['ignore', 'pipe', 'pipe'] : ['pipe', 'pipe', 'pipe']
+    });
+    if (result.status !== 0) {
+        throw new Error(`${command} ${args.join(' ')} failed in ${cwd}: ${result.stderr || result.stdout}`);
+    }
+    return result.stdout || '';
+}
+//# sourceMappingURL=git-worktree-fixture.js.map

package/dist/scripts/naruto-shadow-clone-swarm-check.js

@@ -6,6 +6,7 @@
 // schedules >20 concurrent clone sessions to completion with proof.
 import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { assertGate, emitGate, importDist, root, exists } from './sks-1-18-gate-lib.js';
 const schema = await importDist('core/agents/agent-schema.js');
@@ -71,8 +72,10 @@ assertGate(bigMemoryHost.cap >= 64, 'a 64 GB host must allow >= 64 parallel code
 //    concurrency is throttled to the host-safe cap (never the full 24 unless the host allows).
 const proofClones = 24;
 const cli = path.join(root, 'dist', 'bin', 'sks.js');
+const isolatedWorktreeRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-naruto-shadow-wt-'));
+const childEnv = { ...process.env, SKS_WORKTREE_ROOT: isolatedWorktreeRoot };
 assertGate(exists('dist/bin/sks.js'), 'dist/bin/sks.js missing (build first)');
-const helpRun = spawnSync(process.execPath, [cli, 'naruto', '--help', '--json'], { cwd: root, encoding: 'utf8', timeout: 30000, maxBuffer: 1024 * 1024 });
+const helpRun = spawnSync(process.execPath, [cli, 'naruto', '--help', '--json'], { cwd: root, env: childEnv, encoding: 'utf8', timeout: 30000, maxBuffer: 1024 * 1024 });
 const helpParsed = parseJson(helpRun.stdout);
 assertGate(helpRun.status === 0 && helpParsed?.action === 'help', 'sks naruto --help must emit help instead of launching a run', { status: helpRun.status, stdout: tail(helpRun.stdout), stderr: tail(helpRun.stderr) });
 const run = spawnSync(process.execPath, [
@@ -81,7 +84,7 @@ const run = spawnSync(process.execPath, [
     '--backend', 'fake',
     '--work-items', String(proofClones),
     '--json'
-], { cwd: root, encoding: 'utf8', timeout: 240000, maxBuffer: 8 * 1024 * 1024 });
+], { cwd: root, env: childEnv, encoding: 'utf8', timeout: 240000, maxBuffer: 8 * 1024 * 1024 });
 assertGate(run.status === 0, 'sks naruto run must exit 0', { status: run.status, stderr: tail(run.stderr) });
 const parsed = parseJson(run.stdout);
 assertGate(parsed !== null, 'sks naruto run must emit JSON', { stdout: tail(run.stdout) });
@@ -109,11 +112,11 @@ assertGate(new Set(writePaths).size > 1, 'naruto command default patch-envelope
 assertGate(commandGraph.active_waves.some((wave) => wave.write_paths.length > 1), 'naruto command graph must contain a parallel write wave when route-local patch envelopes do not overlap', { waves: commandGraph.active_waves.slice(0, 3) });
 const state = parsed.run?.scheduler?.state || parsed.run?.scheduler || {};
 assertGate(Number(state.completed_count) === proofClones, 'all clone work items must complete despite throttling', { completed_count: state.completed_count });
-const explicitConcurrency = spawnSync(process.execPath, [cli, 'naruto', 'run', 'explicit concurrency', '--clones', '6', '--backend', 'fake', '--work-items', '6', '--concurrency', '6', '--json'], { cwd: root, encoding: 'utf8', timeout: 120000, maxBuffer: 4 * 1024 * 1024 });
+const explicitConcurrency = spawnSync(process.execPath, [cli, 'naruto', 'run', 'explicit concurrency', '--clones', '6', '--backend', 'fake', '--work-items', '6', '--concurrency', '6', '--json'], { cwd: root, env: childEnv, encoding: 'utf8', timeout: 120000, maxBuffer: 4 * 1024 * 1024 });
 const explicitParsed = parseJson(explicitConcurrency.stdout);
 assertGate(explicitConcurrency.status === 0 && explicitParsed?.target_active_slots === 6, 'explicit --concurrency must let Naruto use the requested parallel slot count', { status: explicitConcurrency.status, target_active_slots: explicitParsed?.target_active_slots });
 // 7) A small request is NOT throttled below what was asked (cap only ever reduces, never inflates).
-const small = spawnSync(process.execPath, [cli, 'naruto', 'run', 'tiny', '--clones', '2', '--backend', 'fake', '--work-items', '2', '--json'], { cwd: root, encoding: 'utf8', timeout: 120000, maxBuffer: 4 * 1024 * 1024 });
+const small = spawnSync(process.execPath, [cli, 'naruto', 'run', 'tiny', '--clones', '2', '--backend', 'fake', '--work-items', '2', '--json'], { cwd: root, env: childEnv, encoding: 'utf8', timeout: 120000, maxBuffer: 4 * 1024 * 1024 });
 const smallParsed = parseJson(small.stdout);
 assertGate(small.status === 0 && smallParsed?.target_active_slots === 2, 'a 2-clone run must run 2 concurrently (no over-throttle)', { status: small.status, target_active_slots: smallParsed?.target_active_slots });
 emitGate('naruto:shadow-clone-swarm', {
@@ -128,7 +131,8 @@ emitGate('naruto:shadow-clone-swarm', {
     low_free_capable_cap: lowFreeButCapable.cap,
     cores: heavySafe.cores,
     completed_count: state.completed_count,
-    mission_id: parsed.mission_id
+    mission_id: parsed.mission_id,
+    isolated_worktree_root: isolatedWorktreeRoot
 });
 function parseJson(text) {
     try {

package/dist/scripts/naruto-worktree-coding-blackbox.js

@@ -0,0 +1,29 @@
+#!/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 mergeMod = await importDist('core/git/git-worktree-merge-queue.js');
+const repo = makeGitFixture('naruto-worktree-blackbox');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-naruto-blackbox-'));
+const allocations = [];
+for (const file of ['a.txt', 'b.txt']) {
+    const allocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-naruto-blackbox', workerId: file.replace('.txt', ''), slotId: file.replace('.txt', '') });
+    fs.writeFileSync(path.join(allocation.worktree_path, file), `${file}\nworker-change\n`);
+    allocations.push(allocation);
+}
+assertGate(run('git', ['status', '--porcelain=v1'], repo).trim() === '', 'main worktree must remain unchanged before integration');
+const diffs = [];
+for (const allocation of allocations) {
+    diffs.push(await diffMod.exportGitWorktreeDiff({ mainRepoRoot: repo, worktreePath: allocation.worktree_path, missionId: 'M-naruto-blackbox', workerId: allocation.worker_id }));
+}
+const integration = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-naruto-blackbox', workerId: 'integration', slotId: 'integration' });
+const report = await mergeMod.applyGitWorktreeMergeQueue({ integrationWorktreePath: integration.worktree_path, diffs });
+assertGate(report.ok === true && report.applied_count === 2, 'integration worktree merge report must apply worker diffs', report);
+assertGate(run('git', ['status', '--porcelain=v1'], repo).trim() === '', 'main worktree must remain unchanged after integration queue');
+emitGate('naruto:worktree-coding:blackbox', { allocations: allocations.length, applied_count: report.applied_count });
+//# sourceMappingURL=naruto-worktree-coding-blackbox.js.map

package/dist/scripts/naruto-worktree-coding-check.js

@@ -0,0 +1,44 @@
+#!/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 workGraphMod = await importDist('core/naruto/naruto-work-graph.js');
+const activePoolMod = await importDist('core/naruto/naruto-active-pool.js');
+const governorMod = await importDist('core/naruto/naruto-concurrency-governor.js');
+const repo = makeGitFixture('naruto-worktree-coding');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-naruto-wt-'));
+const capability = await capabilityMod.evaluateGitWorktreeCapability({ root: repo, missionId: 'M-naruto-wt', requireGitWorktree: process.argv.includes('--require-real') });
+const policy = {
+    mode: capability.mode,
+    required: capability.mode === 'git-worktree',
+    main_repo_root: capability.detection.root,
+    worktree_root: capability.root_resolution?.root || null,
+    fallback_reason: capability.mode === 'git-worktree' ? null : capability.blockers.join(';')
+};
+const graph = workGraphMod.buildNarutoWorkGraph({
+    requestedClones: 8,
+    totalWorkItems: 12,
+    writeCapable: true,
+    targetPaths: Array.from({ length: 12 }, (_, index) => `src/wt-${index}.ts`),
+    maxActiveWorkers: 4,
+    worktreePolicy: policy
+});
+const governor = governorMod.decideNarutoConcurrency({ requestedClones: 8, totalWorkItems: 12, pendingWorkQueueSize: 12, backend: 'fake' });
+const pool = await activePoolMod.runNarutoActivePool({ graph, governor: { ...governor, safe_active_workers: 4 } });
+assertGate(capability.ok === true && capability.mode === 'git-worktree', 'Git Naruto coding fixture must use git-worktree mode', capability);
+assertGate(graph.worktree_policy.mode === 'git-worktree', 'Naruto work graph must carry git-worktree policy', graph.worktree_policy);
+assertGate(graph.work_items.filter((item) => item.write_allowed).every((item) => item.worktree?.allocation_required === true), 'write-capable work items must require worktree allocation', graph.work_items);
+assertGate(pool.worktree_allocation_required_count > 0, 'active pool must plan worktree allocations for write work', pool);
+const nonGit = makeNonGitFixture('naruto-worktree-non-git');
+const nonGitCapability = await capabilityMod.evaluateGitWorktreeCapability({ root: nonGit, missionId: 'M-naruto-non-git' });
+assertGate(nonGitCapability.mode === 'patch-envelope-only' && nonGitCapability.worktree_probe_attempted === false, 'non-Git Naruto must degrade without worktree probe', nonGitCapability);
+emitGate('naruto:worktree-coding', {
+    worktree_mode: graph.worktree_policy.mode,
+    allocation_required_count: pool.worktree_allocation_required_count,
+    non_git_mode: nonGitCapability.mode
+});
+//# sourceMappingURL=naruto-worktree-coding-check.js.map

package/dist/scripts/naruto-worktree-gpt-final-check.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const workGraphMod = await importDist('core/naruto/naruto-work-graph.js');
+const rolesMod = await importDist('core/naruto/naruto-role-policy.js');
+const packMod = await importDist('core/naruto/naruto-gpt-final-pack.js');
+const policy = {
+    mode: 'git-worktree',
+    required: true,
+    main_repo_root: '/repo',
+    worktree_root: '/cache/sks/worktrees/repo/M-final',
+    fallback_reason: null
+};
+const graph = workGraphMod.buildNarutoWorkGraph({ requestedClones: 6, totalWorkItems: 8, writeCapable: true, worktreePolicy: policy });
+const roleDistribution = rolesMod.buildNarutoRoleDistribution(graph.work_items);
+const worktreeDiff = {
+    schema: 'sks.git-worktree-diff.v1',
+    ok: true,
+    mission_id: 'M-final',
+    worker_id: 'worker-1',
+    main_repo_root: '/repo',
+    worktree_path: '/cache/wt/worker-1',
+    branch: 'sks/M/worker-1',
+    changed_files: ['src/a.ts'],
+    diff: 'diff --git a/src/a.ts b/src/a.ts\n',
+    diff_bytes: 37
+};
+const pack = packMod.buildNarutoGptFinalPack({
+    missionId: 'M-final',
+    graph,
+    roleDistribution,
+    changedFiles: ['src/a.ts'],
+    worktreePolicy: policy,
+    worktreeDiffs: [worktreeDiff],
+    localLlmMetrics: { participated: true, final_status: 'draft_until_gpt_final' }
+});
+assertGate(pack.worktree_policy.mode === 'git-worktree', 'GPT final pack must include worktree policy', pack.worktree_policy);
+assertGate(pack.worktree_diffs.length === 1, 'GPT final pack must include bounded worktree diffs', pack);
+assertGate(pack.local_llm_metrics.final_status === 'draft_until_gpt_final', 'local LLM output must remain draft until GPT final', pack.local_llm_metrics);
+assertGate(pack.bounded === true && pack.secrets_redacted === true, 'GPT final pack must stay bounded/redacted', pack);
+emitGate('naruto:worktree-gpt-final', {
+    worktree_mode: pack.worktree_policy.mode,
+    worktree_diffs: pack.worktree_diffs.length
+});
+//# sourceMappingURL=naruto-worktree-gpt-final-check.js.map

package/dist/scripts/naruto-worktree-zellij-ui-check.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const dashboardMod = await importDist('core/zellij/zellij-naruto-dashboard.js');
+const plan = dashboardMod.planNarutoZellijDashboard({
+    targetActiveWorkers: 10,
+    visiblePaneCap: 6,
+    roles: ['implementer', 'verifier'],
+    backend: 'codex-sdk',
+    worktreePolicy: {
+        mode: 'git-worktree',
+        required: true,
+        main_repo_root: '/repo',
+        worktree_root: '/cache/sks/worktrees/repo/M',
+        fallback_reason: null
+    }
+});
+assertGate(plan.ok === true, 'Naruto worktree Zellij dashboard must pass', plan);
+assertGate(plan.worktree_mode === 'git-worktree', 'dashboard must carry worktree mode', plan);
+assertGate(plan.worktree_labels.length === plan.visible_worker_panes, 'visible panes must have worktree labels', plan);
+assertGate(plan.pane_titles.every((title) => title.includes('WT:') && title.includes('branch:')), 'pane titles must include worktree id and branch', plan.pane_titles);
+assertGate(plan.headless_workers === 4, 'dashboard must still expose headless worker count', plan);
+emitGate('naruto:worktree-zellij-ui', {
+    visible_worker_panes: plan.visible_worker_panes,
+    headless_workers: plan.headless_workers,
+    sample_title: plan.pane_titles[0]
+});
+//# sourceMappingURL=naruto-worktree-zellij-ui-check.js.map

package/dist/scripts/release-gate-dag-runner-check.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readJson, readText } from './sks-1-18-gate-lib.js';
+const pkg = readJson('package.json');
+const manifest = readJson('release-gates.v2.json');
+const runner = readText('src/core/release/release-gate-dag.ts');
+const scheduler = readText('src/core/release/release-gate-scheduler.ts');
+const cache = readText('src/core/release/release-gate-cache-v2.ts');
+assertGate(pkg.scripts['release:check'].includes('release-gate-dag-runner.js'), 'release:check must execute DAG runner', pkg.scripts['release:check']);
+assertGate(!/&&\s*npm run\s+\w/.test(pkg.scripts['release:check'].replace('npm run build --silent &&', '')), 'release:check must not be a giant npm-run chain', pkg.scripts['release:check']);
+assertGate(pkg.scripts['release:check:legacy'], 'release:check:legacy must exist for explicit debugging');
+assertGate(manifest.schema === 'sks.release-gates.v2' && manifest.gates.length >= 10, 'release-gates.v2 manifest must exist with nodes', manifest);
+assertGate(runner.includes('Promise.race') && scheduler.includes('pickLaunchableReleaseGates'), 'DAG runner must schedule independent gates concurrently');
+assertGate(runner.includes('readReleaseGateCacheHit') && cache.includes('RELEASE_GATE_CACHE_V2_SCHEMA'), 'DAG runner must use release gate cache v2 module');
+assertGate(runner.includes('cpu_time_saved_ms') && runner.includes('peak_running') && runner.includes('budget_snapshot'), 'DAG summary must include CPU time saved, peak running gates, and resource budget proof');
+emitGate('release:dag-runner', { gates: manifest.gates.length, default_script: pkg.scripts['release:check'] });
+//# sourceMappingURL=release-gate-dag-runner-check.js.map