sneakoscope 2.0.6 → 2.0.7

package/dist/core/git/git-worktree-patch-envelope.js

@@ -0,0 +1,35 @@
+export function buildGitWorktreePatchEnvelope(input) {
+    const changedFiles = input.diff.changed_files.length ? input.diff.changed_files : ['git-worktree.diff'];
+    return {
+        schema: 'sks.agent-patch-envelope.v1',
+        source: 'git-worktree-diff',
+        mission_id: input.diff.mission_id,
+        route: '$Naruto',
+        agent_id: input.agentId,
+        session_id: input.sessionId,
+        slot_id: input.slotId,
+        generation_index: input.generationIndex,
+        lease_id: `git-worktree:${input.diff.worker_id}`,
+        allowed_paths: changedFiles,
+        git_worktree: {
+            main_repo_root: input.diff.main_repo_root,
+            worktree_path: input.diff.worktree_path,
+            branch: input.diff.branch,
+            base_head: input.diff.base_head,
+            worktree_head: input.diff.worktree_head,
+            changed_files: changedFiles,
+            diff_bytes: input.diff.diff_bytes
+        },
+        operations: changedFiles.map((file) => ({
+            op: 'unified_diff',
+            path: file,
+            diff: input.diff.diff
+        })),
+        rationale: 'Process-generated patch envelope exported from an isolated Git worktree diff.',
+        verification_hint: {
+            command: 'git apply --3way --check <diff>',
+            notes: 'Apply inside an integration worktree based on the recorded base head.'
+        }
+    };
+}
+//# sourceMappingURL=git-worktree-patch-envelope.js.map

package/dist/core/git/git-worktree-pool.js

@@ -0,0 +1,23 @@
+import { nowIso } from '../fsx.js';
+export function planGitWorktreePool(input) {
+    const reusable = [...(input.reusableWorktrees || [])];
+    const assignments = input.workerIds.map((workerId) => {
+        const worktree = reusable.shift() || null;
+        return {
+            worker_id: workerId,
+            action: worktree ? 'reuse' : 'allocate',
+            worktree_path: worktree
+        };
+    });
+    return {
+        schema: 'sks.git-worktree-pool.v1',
+        ok: true,
+        generated_at: nowIso(),
+        requested_workers: input.workerIds.length,
+        reusable_count: (input.reusableWorktrees || []).length,
+        allocate_count: assignments.filter((row) => row.action === 'allocate').length,
+        assignments,
+        blockers: []
+    };
+}
+//# sourceMappingURL=git-worktree-pool.js.map

package/dist/core/git/git-worktree-root.js

@@ -0,0 +1,52 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { sha256 } from '../fsx.js';
+export function resolveGitWorktreeRoot(input) {
+    const env = input.env || process.env;
+    const repoRoot = path.resolve(input.repoRoot);
+    const missionId = sanitizePathPart(input.missionId || 'mission');
+    const repoHash = sha256(repoRoot).slice(0, 16);
+    const explicitRoot = env.SKS_WORKTREE_ROOT ? path.resolve(env.SKS_WORKTREE_ROOT) : null;
+    const source = explicitRoot ? 'SKS_WORKTREE_ROOT' : env.XDG_CACHE_HOME ? 'XDG_CACHE_HOME' : 'HOME_CACHE';
+    const cacheBase = explicitRoot || path.join(env.XDG_CACHE_HOME || path.join(env.HOME || os.homedir(), '.cache'), 'sks', 'worktrees');
+    const root = explicitRoot ? path.join(cacheBase, repoHash, missionId) : path.join(cacheBase, repoHash, missionId);
+    const inRepo = isPathInside(root, repoRoot);
+    const allowInRepo = env.SKS_ALLOW_IN_REPO_WORKTREES === '1';
+    const blockers = inRepo && !allowInRepo ? ['git_worktree_root_inside_repo_blocked'] : [];
+    return {
+        schema: 'sks.git-worktree-root.v1',
+        ok: blockers.length === 0,
+        repo_root: repoRoot,
+        mission_id: missionId,
+        root,
+        source,
+        repo_hash: repoHash,
+        in_repo: inRepo,
+        allow_in_repo: allowInRepo,
+        blockers
+    };
+}
+export function sanitizePathPart(value) {
+    return String(value || 'item').replace(/[^A-Za-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 80) || 'item';
+}
+export function isPathInside(candidate, parent) {
+    const canonicalParent = canonicalPath(parent);
+    const canonicalCandidate = canonicalPath(candidate);
+    const rel = path.relative(canonicalParent, canonicalCandidate);
+    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+function canonicalPath(value) {
+    const resolved = path.resolve(value);
+    try {
+        return fs.realpathSync.native(resolved);
+    }
+    catch {
+        const parent = path.dirname(resolved);
+        if (parent === resolved)
+            return resolved;
+        const base = canonicalPath(parent);
+        return path.join(base, path.basename(resolved));
+    }
+}
+//# sourceMappingURL=git-worktree-root.js.map

package/dist/core/git/git-worktree-runner.js

@@ -0,0 +1,40 @@
+import { runProcess } from '../fsx.js';
+export async function runGitCommand(cwd, args, opts = {}) {
+    const processOptions = {
+        cwd,
+        timeoutMs: opts.timeoutMs ?? 30000,
+        maxOutputBytes: 512 * 1024
+    };
+    if (opts.input !== undefined)
+        processOptions.input = opts.input;
+    const result = await runProcess('git', args, processOptions);
+    return normalizeGitResult(cwd, args, result);
+}
+export function normalizeGitResult(cwd, args, result) {
+    const stdout = result.stdout || '';
+    const stderr = result.stderr || '';
+    return {
+        ok: result.code === 0,
+        code: result.code,
+        args,
+        cwd,
+        stdout,
+        stderr,
+        stdout_tail: stdout.slice(-4000),
+        stderr_tail: stderr.slice(-4000),
+        timed_out: result.timedOut
+    };
+}
+export function gitOutputLine(result) {
+    return String(result.stdout || '').split(/\r?\n/).find((line) => line.trim())?.trim() || '';
+}
+export function gitBlocker(prefix, result) {
+    const combined = [result.stderr_tail || result.stderr, result.stdout_tail || result.stdout]
+        .map((value) => String(value || '').trim())
+        .filter(Boolean)
+        .join('\n');
+    const detail = combined.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).slice(-3).join(' | ');
+    const meta = `code=${result.code ?? 'null'} timed_out=${result.timed_out ? '1' : '0'} args=${result.args.join(' ')}`;
+    return detail ? `${prefix}:${meta}:${detail.slice(0, 320)}` : `${prefix}:${meta}`;
+}
+//# sourceMappingURL=git-worktree-runner.js.map

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

@@ -1,4 +1,39 @@
 import { createNarutoGeneration, completeNarutoGeneration } from './naruto-generation-scheduler.js';
+export async function runNarutoActivePool(input) {
+    const base = simulateNarutoActivePool(input);
+    const allocations = [];
+    for (const item of input.graph.work_items) {
+        if (!item.write_allowed)
+            continue;
+        const mode = item.worktree?.mode || input.graph.worktree_policy.mode;
+        if (mode !== 'git-worktree') {
+            allocations.push({ work_item_id: item.id, mode, allocation_status: 'skipped', blockers: [] });
+            continue;
+        }
+        if (!input.allocateWorktree) {
+            allocations.push({ work_item_id: item.id, mode, allocation_status: 'planned', blockers: [] });
+            continue;
+        }
+        const allocated = await input.allocateWorktree(item);
+        allocations.push({
+            work_item_id: item.id,
+            mode,
+            allocation_status: allocated.ok ? 'allocated' : 'planned',
+            ...(allocated.worktree_path ? { worktree_path: allocated.worktree_path } : {}),
+            ...(allocated.branch ? { branch: allocated.branch } : {}),
+            blockers: allocated.blockers || []
+        });
+    }
+    const allocationBlockers = allocations.flatMap((row) => row.blockers);
+    return {
+        ...base,
+        ok: base.ok && allocationBlockers.length === 0,
+        worktree_mode: input.graph.worktree_policy.mode,
+        worktree_allocation_required_count: allocations.filter((row) => row.mode === 'git-worktree').length,
+        worktree_allocations: allocations,
+        blockers: [...base.blockers, ...allocationBlockers]
+    };
+}
 export function simulateNarutoActivePool(input) {
     const safeActiveWorkers = Math.max(1, input.governor.safe_active_workers);
     const retryLimit = Math.max(0, Math.floor(Number(input.retryLimit ?? 1)));

package/dist/core/naruto/naruto-gpt-final-pack.js

@@ -12,6 +12,8 @@ export function buildNarutoGptFinalPack(input) {
         },
         role_distribution: input.roleDistribution,
         changed_files: [...new Set((input.changedFiles || []).map(String))],
+        worktree_policy: input.worktreePolicy || input.graph.worktree_policy,
+        worktree_diffs: (input.worktreeDiffs || []).slice(0, maxPatchEnvelopes).map(redactSecrets),
         patch_envelopes: (input.patchEnvelopes || []).slice(0, maxPatchEnvelopes).map(redactSecrets),
         verification_results: (input.verificationResults || []).slice(0, 200).map(redactSecrets),
         failed_shards: (input.failedShards || []).slice(0, 100).map(redactSecrets),

package/dist/core/naruto/naruto-work-graph.js

@@ -33,6 +33,13 @@ export function buildNarutoWorkGraph(input = {}) {
     const basePath = normalizeNarutoPath(input.leaseBasePath || '.sneakoscope/naruto/patch-envelopes');
     const targetPaths = normalizePaths(input.targetPaths || []);
     const readonlyPaths = normalizePaths(input.readonlyPaths || []);
+    const worktreePolicy = input.worktreePolicy || {
+        mode: 'patch-envelope-only',
+        required: false,
+        main_repo_root: null,
+        worktree_root: null,
+        fallback_reason: writeCapable ? 'git_capability_not_evaluated' : 'readonly_or_write_disabled'
+    };
     const workItems = [];
     for (let index = 0; index < totalWorkItems; index += 1) {
         const id = `NW-${String(index + 1).padStart(6, '0')}`;
@@ -64,7 +71,14 @@ export function buildNarutoWorkGraph(input = {}) {
                 requires_patch_envelope: writePaths.length > 0,
                 requires_verification: kind !== 'research' && kind !== 'final_review_input_pack',
                 requires_gpt_final: writePaths.length > 0 || kind === 'final_review_input_pack'
-            }
+            },
+            ...(writePaths.length > 0 ? {
+                worktree: {
+                    mode: worktreePolicy.mode,
+                    required: worktreePolicy.required,
+                    allocation_required: worktreePolicy.mode === 'git-worktree'
+                }
+            } : {})
         });
     }
     const activeWaves = planNarutoWorkWaves(workItems, Math.max(1, normalizePositiveInt(input.maxActiveWorkers, requestedClones)));
@@ -88,6 +102,7 @@ export function buildNarutoWorkGraph(input = {}) {
         active_waves: activeWaves,
         mixed_work_kinds: mixedWorkKinds,
         write_allowed_count: writeAllowedCount,
+        worktree_policy: worktreePolicy,
         ok: blockers.length === 0,
         blockers
     };

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '2.0.6';
+export const PACKAGE_VERSION = '2.0.7';
 //# sourceMappingURL=version.js.map

package/dist/core/zellij/zellij-naruto-dashboard.js

@@ -4,11 +4,18 @@ export function planNarutoZellijDashboard(input) {
     const visibleWorkerPanes = Math.min(targetActiveWorkers, visiblePaneCap);
     const headlessWorkers = Math.max(0, targetActiveWorkers - visibleWorkerPanes);
     const backend = input.backend || 'codex-sdk';
+    const worktreeMode = input.worktreePolicy?.mode || 'patch-envelope-only';
     const roles = input.roles && input.roles.length ? input.roles : ['implementer', 'modifier', 'verifier', 'test_writer'];
+    const worktreeLabels = [];
     const paneTitles = Array.from({ length: visibleWorkerPanes }, (_, index) => {
         const slot = `slot-${String(index + 1).padStart(3, '0')}`;
         const role = roles[index % roles.length] || 'worker';
-        return `${slot}/gen-1 · ${role} · ${backend} · active`;
+        if (worktreeMode !== 'git-worktree')
+            return `${slot}/gen-1 · ${role} · ${backend} · active`;
+        const wt = `WT:${slot}-gen-1`;
+        const branch = `branch:${slot}/gen-1`;
+        worktreeLabels.push(`${wt} ${branch}`);
+        return `${slot}/gen-1 · ${wt} · ${branch} · ${role} · ${backend} · active`;
     });
     const blockers = [
         ...(visibleWorkerPanes > visiblePaneCap ? ['naruto_zellij_visible_panes_exceed_cap'] : []),
@@ -29,6 +36,8 @@ export function planNarutoZellijDashboard(input) {
             backpressure: input.backpressure || 'normal'
         },
         pane_titles: paneTitles,
+        worktree_mode: worktreeMode,
+        worktree_labels: worktreeLabels,
         ok: blockers.length === 0,
         blockers
     };

package/dist/core/zellij/zellij-worker-pane-manager.js

@@ -9,10 +9,11 @@ export const ZELLIJ_WORKER_PANE_EVENT_SCHEMA = 'sks.zellij-worker-pane-event.v1'
 export function buildWorkerPaneName(slotId, generationIndex) {
     return `${slotId}/gen-${Math.max(1, Math.floor(Number(generationIndex) || 1))}`;
 }
-export function buildWorkerPaneTitle(slotId, generationIndex, context, serviceTier, backend, status) {
+export function buildWorkerPaneTitle(slotId, generationIndex, context, serviceTier, backend, status, worktree) {
     const base = buildWorkerPaneName(slotId, generationIndex);
     const normalized = normalizePaneProviderContext(context, serviceTier);
-    return `${base} · ${backend || 'codex-sdk'} · ${providerPaneLabel(normalized)} · ${status || 'launching'}`;
+    const wt = worktree ? ` · WT:${worktree.id} · branch:${worktree.branch}` : '';
+    return `${base}${wt} · ${backend || 'codex-sdk'} · ${providerPaneLabel(normalized)} · ${status || 'launching'}`;
 }
 export function isRealZellijWorkerPaneIdSource(value) {
     return value === 'zellij_worker_new_pane_stdout' || value === 'zellij_worker_list_panes';
@@ -22,7 +23,7 @@ export function buildWorkerPaneArtifact(input) {
     const paneIdSource = input.paneIdSource || 'zellij_worker_pane_launch_failed';
     const blockers = input.blockers || [];
     const providerContext = normalizePaneProviderContext(input.providerContext, input.serviceTier);
-    const paneTitle = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier, input.backend, input.status || input.statusLabel);
+    const paneTitle = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier, input.backend, input.status || input.statusLabel, input.worktree || null);
     return {
         schema: ZELLIJ_WORKER_PANE_SCHEMA,
         generated_at: now,
@@ -42,6 +43,7 @@ export function buildWorkerPaneArtifact(input) {
         provider: providerContext.provider,
         service_tier: providerContext.service_tier,
         provider_context: providerContext,
+        worktree: input.worktree || null,
         worker_artifact_dir: input.workerArtifactDir,
         worker_result_path: input.resultPath,
         heartbeat_path: input.heartbeatPath,
@@ -82,7 +84,7 @@ export async function openWorkerPane(input) {
         timeoutMs: 5000,
         optional: false
     });
-    const paneName = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier, input.backend, input.statusLabel || 'running');
+    const paneName = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier, input.backend, input.statusLabel || 'running', input.worktree || null);
     let launch = createSession.ok
         ? await runZellij(['--session', input.sessionName, 'action', 'new-pane', '--direction', 'right', '--name', paneName, '--', 'sh', '-lc', input.workerCommand], {
             cwd,

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-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-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-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/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 {