sneakoscope 2.0.5 → 2.0.7

package/dist/core/codex-control/python-codex-sdk-adapter.js

@@ -9,18 +9,24 @@ export async function detectPythonCodexSdkCapability() {
     const pyOk = parsePythonVersion(python.versionText) >= 3.10;
     const probes = [];
     let detected = null;
+    let detectedModulePath = '';
+    let detectedModuleParentPath = '';
     if (pyOk) {
         for (const candidate of PYTHON_CODEX_SDK_CANDIDATES) {
-            const importProbe = await runProcess(python.path, ['-c', `import ${candidate.importName}; print("ok")`], { timeoutMs: 5000, maxOutputBytes: 4096 })
+            const importProbe = await runProcess(python.path, ['-c', `import ${candidate.importName} as m, os; print(os.path.dirname(os.path.abspath(getattr(m, "__file__", ""))))`], { timeoutMs: 5000, maxOutputBytes: 4096 })
                 .catch((err) => ({ code: 1, stdout: '', stderr: err.message || String(err) }));
+            const modulePath = String(importProbe.stdout || '').trim().split(/\r?\n/).filter(Boolean).at(-1) || '';
             probes.push({
                 package_name: candidate.packageName,
                 import_name: candidate.importName,
                 ok: importProbe.code === 0,
+                module_path: modulePath || null,
                 stderr: String(importProbe.stderr || '').slice(-500)
             });
             if (importProbe.code === 0) {
                 detected = candidate;
+                detectedModulePath = modulePath;
+                detectedModuleParentPath = modulePath ? path.dirname(modulePath) : '';
                 break;
             }
         }
@@ -29,7 +35,7 @@ export async function detectPythonCodexSdkCapability() {
         ...(pyOk ? [] : ['python_version_below_3_10']),
         ...(detected ? [] : ['python_codex_sdk_unavailable'])
     ];
-    return capability(blockers.length === 0, python.path, python.versionText, blockers, detected, blockers.length ? setupAction(python.path) : null, probes);
+    return capability(blockers.length === 0, python.path, python.versionText, blockers, detected, blockers.length ? setupAction(python.path) : null, probes, detectedModulePath, detectedModuleParentPath);
 }
 export async function runPythonCodexSdkTask(input, opts = {}) {
     const cap = await detectPythonCodexSdkCapability();
@@ -48,7 +54,7 @@ export async function runPythonCodexSdkTask(input, opts = {}) {
         prompt: input.prompt,
         output_schema: input.outputSchema || {}
     };
-    const events = await runPythonRunner(python, request, opts.env);
+    const events = await runPythonRunner(python, request, pythonRunnerEnv(opts.env, cap.module_parent_path));
     const translatedEvents = translatePythonCodexSdkEvents(events);
     const last = [...events].reverse().find((event) => event?.event === 'turn_completed');
     const errors = events.filter((event) => event?.event === 'error').map((event) => String(event.message || 'python_codex_sdk_error'));
@@ -63,6 +69,22 @@ export async function runPythonCodexSdkTask(input, opts = {}) {
         capability: cap
     };
 }
+function pythonRunnerEnv(envOverride, moduleParentPath) {
+    const env = {};
+    for (const [key, value] of Object.entries(envOverride || process.env)) {
+        if (value !== undefined)
+            env[key] = String(value);
+    }
+    const parent = String(moduleParentPath || '').trim();
+    if (!parent)
+        return env;
+    env.PYTHONPATH = prependPath(env.PYTHONPATH, parent);
+    return env;
+}
+function prependPath(value, entry) {
+    const parts = String(value || '').split(path.delimiter).filter(Boolean);
+    return [entry, ...parts.filter((part) => part !== entry)].join(path.delimiter);
+}
 function runPythonRunner(python, request, envOverride) {
     const runner = path.join(packageRoot(), 'pytools', 'codex_sdk_runner.py');
     return new Promise((resolve, reject) => {
@@ -177,7 +199,7 @@ function setupAction(pythonBin) {
         `If your environment provides the directive package, run \`${pythonBin} -m pip install openai-codex\`.`
     ].join(' ');
 }
-function capability(ok, pythonBin, versionText, blockers, detected, setupActionValue, probes = []) {
+function capability(ok, pythonBin, versionText, blockers, detected, setupActionValue, probes = [], modulePath = '', moduleParentPath = '') {
     const selected = detected || PYTHON_CODEX_SDK_CANDIDATES[0] || { packageName: 'codex-app-server', importName: 'codex_app_server', source: 'developers.openai.com/codex/sdk' };
     return {
         schema: 'sks.python-codex-sdk-capability.v1',
@@ -189,6 +211,8 @@ function capability(ok, pythonBin, versionText, blockers, detected, setupActionV
         source: selected.source,
         supported_packages: PYTHON_CODEX_SDK_CANDIDATES.map((candidate) => candidate.packageName),
         supported_imports: PYTHON_CODEX_SDK_CANDIDATES.map((candidate) => candidate.importName),
+        module_path: modulePath || null,
+        module_parent_path: moduleParentPath || null,
         import_probes: probes,
         setup_action: setupActionValue,
         blockers

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

@@ -10,11 +10,12 @@ import { attachZellijSessionInteractive, launchZellijLayout } from '../zellij/ze
 import { buildNarutoWorkGraph } from '../naruto/naruto-work-graph.js';
 import { buildNarutoRoleDistribution } from '../naruto/naruto-role-policy.js';
 import { decideNarutoConcurrency } from '../naruto/naruto-concurrency-governor.js';
-import { simulateNarutoActivePool } from '../naruto/naruto-active-pool.js';
+import { runNarutoActivePool } from '../naruto/naruto-active-pool.js';
 import { buildNarutoVerificationDag } from '../naruto/naruto-verification-dag.js';
 import { buildNarutoGptFinalPack } from '../naruto/naruto-gpt-final-pack.js';
 import { planNarutoZellijDashboard } from '../zellij/zellij-naruto-dashboard.js';
 import { checkPromptPlaceholders } from '../prompt/prompt-placeholder-guard.js';
+import { evaluateGitWorktreeCapability } from '../git/git-worktree-capability.js';
 const NARUTO_RESULT_SCHEMA = 'sks.naruto-command-result.v1';
 const NARUTO_ROUTE = '$Naruto';
 // $Naruto — Shadow Clone Swarm (影分身 / Kage Bunshin no Jutsu).
@@ -34,10 +35,11 @@ export async function narutoCommand(commandOrArgs = 'naruto', maybeArgs = []) {
 async function narutoRun(parsed) {
     const root = await sksRoot();
     const writeCapable = parsed.readonly !== true && parsed.writeMode !== 'off';
+    const patchEnvelopeBasePath = '.sneakoscope/naruto/patch-envelopes';
     const placeholderGuard = checkPromptPlaceholders({
         prompt: parsed.prompt,
         writeCapable,
-        targetPaths: writeCapable ? ['.sneakoscope/naruto/patch-envelopes'] : []
+        targetPaths: writeCapable ? [patchEnvelopeBasePath] : []
     });
     if (!placeholderGuard.ok) {
         return emit(parsed, {
@@ -60,6 +62,25 @@ async function narutoRun(parsed) {
         readonly: parsed.readonly,
         maxAgentCount: MAX_NARUTO_AGENT_COUNT
     });
+    const mission = await createMission(root, { mode: 'naruto', prompt: parsed.prompt });
+    const gitWorktreeCapability = writeCapable
+        ? await evaluateGitWorktreeCapability({ root, missionId: mission.id })
+        : null;
+    const worktreePolicy = gitWorktreeCapability?.mode === 'git-worktree'
+        ? {
+            mode: 'git-worktree',
+            required: true,
+            main_repo_root: gitWorktreeCapability.detection.root,
+            worktree_root: gitWorktreeCapability.root_resolution?.root || null,
+            fallback_reason: null
+        }
+        : {
+            mode: 'patch-envelope-only',
+            required: false,
+            main_repo_root: gitWorktreeCapability?.detection.root || null,
+            worktree_root: null,
+            fallback_reason: writeCapable ? (gitWorktreeCapability?.blockers.join(';') || 'not_git_repo_or_worktree_unavailable') : 'readonly_or_write_disabled'
+        };
     // The clone roster is the full work fan-out; live concurrency is throttled to a
     // system-safe number so naruto never spawns the whole count at once unless an
     // explicit operator override asks for a higher target.
@@ -72,8 +93,9 @@ async function narutoRun(parsed) {
         totalWorkItems: parsed.workItems,
         readonly: parsed.readonly,
         writeCapable,
-        targetPaths: ['.sneakoscope/naruto/patch-envelopes'],
-        maxActiveWorkers: parsed.concurrency || safe.cap
+        leaseBasePath: patchEnvelopeBasePath,
+        maxActiveWorkers: parsed.concurrency || safe.cap,
+        worktreePolicy
     });
     const roleDistribution = buildNarutoRoleDistribution(workGraph.work_items, { readonly: parsed.readonly });
     const governor = decideNarutoConcurrency({
@@ -85,22 +107,24 @@ async function narutoRun(parsed) {
     const backendMinimum = schedulerBackend === 'fake' ? roster.agent_count : Math.min(roster.agent_count, 2);
     const activeSlots = Math.max(1, Math.min(roster.agent_count, parsed.concurrency || Math.max(governor.safe_active_workers, backendMinimum), safe.cap));
     const zellijVisiblePanes = Math.max(1, Math.min(activeSlots, governor.safe_zellij_visible_panes));
-    const activePool = simulateNarutoActivePool({ graph: workGraph, governor: { ...governor, safe_active_workers: activeSlots } });
+    const activePool = await runNarutoActivePool({ graph: workGraph, governor: { ...governor, safe_active_workers: activeSlots } });
     const verificationDag = buildNarutoVerificationDag(workGraph, { cwd: root });
     const gptFinalPack = buildNarutoGptFinalPack({
-        missionId: 'pending',
+        missionId: mission.id,
         graph: workGraph,
         roleDistribution,
-        localLlmMetrics: localWorker
+        localLlmMetrics: localWorker,
+        worktreePolicy,
+        worktreeDiffs: []
     });
     const zellijDashboard = planNarutoZellijDashboard({
         targetActiveWorkers: activeSlots,
         visiblePaneCap: governor.safe_zellij_visible_panes,
         backpressure: governor.backpressure,
         roles: roleDistribution.work_item_roles.map((row) => row.role),
-        backend: schedulerBackend
+        backend: schedulerBackend,
+        worktreePolicy
     });
-    const mission = await createMission(root, { mode: 'naruto', prompt: parsed.prompt });
     const ledgerRoot = path.join(mission.dir, 'agents');
     await writeNarutoArtifacts(ledgerRoot, {
         workGraph,
@@ -108,9 +132,10 @@ async function narutoRun(parsed) {
         governor,
         activePool,
         verificationDag,
-        gptFinalPack: { ...gptFinalPack, mission_id: mission.id },
+        gptFinalPack,
         zellijDashboard,
-        placeholderGuard
+        placeholderGuard,
+        gitWorktreeCapability
     });
     let liveZellij = null;
     if (!parsed.json && !parsed.mock && !parsed.noOpenZellij) {
@@ -163,7 +188,8 @@ async function narutoRun(parsed) {
         fastMode: true,
         serviceTier: 'fast',
         noFast: false,
-        ...(parsed.writeMode ? { writeMode: parsed.writeMode } : {}),
+        writeMode: writeCapable ? parsed.writeMode || 'parallel' : 'off',
+        gitWorktreePolicy: worktreePolicy,
         json: parsed.json
     });
     const clones = result.roster?.agent_count ?? roster.agent_count;
@@ -185,8 +211,12 @@ async function narutoRun(parsed) {
             total_work_items: workGraph.total_work_items,
             mixed_work_kinds: workGraph.mixed_work_kinds,
             write_allowed_count: workGraph.write_allowed_count,
-            ok: workGraph.ok
+            active_wave_count: workGraph.active_waves.length,
+            parallel_write_wave_count: workGraph.active_waves.filter((wave) => wave.write_paths.length > 1).length,
+            ok: workGraph.ok,
+            worktree_policy: workGraph.worktree_policy
         },
+        git_worktree: gitWorktreeCapability,
         role_distribution: roleDistribution,
         concurrency_governor: governor,
         active_pool: {
@@ -251,7 +281,9 @@ async function narutoStatus(parsed) {
         work_graph: workGraph ? {
             total_work_items: workGraph.total_work_items,
             mixed_work_kinds: workGraph.mixed_work_kinds,
-            write_allowed_count: workGraph.write_allowed_count
+            write_allowed_count: workGraph.write_allowed_count,
+            active_wave_count: Array.isArray(workGraph.active_waves) ? workGraph.active_waves.length : null,
+            parallel_write_wave_count: Array.isArray(workGraph.active_waves) ? workGraph.active_waves.filter((wave) => Array.isArray(wave.write_paths) && wave.write_paths.length > 1).length : null
         } : null,
         concurrency_governor: governor
     };
@@ -323,6 +355,8 @@ async function writeNarutoArtifacts(ledgerRoot, artifacts) {
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-gpt-final-pack.json'), artifacts.gptFinalPack);
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-zellij-dashboard.json'), artifacts.zellijDashboard);
     await writeJsonAtomic(path.join(ledgerRoot, 'prompt-placeholder-guard.json'), artifacts.placeholderGuard);
+    if (artifacts.gitWorktreeCapability)
+        await writeJsonAtomic(path.join(ledgerRoot, 'git-worktree-capability.json'), artifacts.gitWorktreeCapability);
 }
 function clampClones(value) {
     if (!Number.isFinite(value) || value < 1)

package/dist/core/feature-registry.js

@@ -786,6 +786,8 @@ function isExternalPromptCommandMention(mention) {
         '$SKS_CODEX_APP_IMAGEGEN_OUTPUT',
         '$SKS_CODEX_APP_IMAGEGEN_OUTPUT_ID',
         '$SKS_CODEX_APP_IMAGEGEN_CREATED_AT',
+        '$SKS_WORKTREE_ROOT',
+        '$XDG_CACHE_HOME',
         '$IMAGEGEN'
     ].includes(normalized);
 }

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '2.0.5';
+export const PACKAGE_VERSION = '2.0.7';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

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

@@ -0,0 +1,15 @@
+import { allocateWorkerWorktree } from './git-worktree-manager.js';
+export async function createGitIntegrationWorktree(input) {
+    const allocationInput = {
+        repoRoot: input.repoRoot,
+        missionId: input.missionId,
+        workerId: 'integration',
+        slotId: 'integration',
+        generationIndex: 1,
+        branchPrefix: 'sks-integration'
+    };
+    if (input.baseRef !== undefined)
+        allocationInput.baseRef = input.baseRef;
+    return allocateWorkerWorktree(allocationInput);
+}
+//# sourceMappingURL=git-integration-worktree.js.map

package/dist/core/git/git-repo-detection.js

@@ -0,0 +1,72 @@
+import path from 'node:path';
+import { which } from '../fsx.js';
+import { gitBlocker, gitOutputLine, runGitCommand } from './git-worktree-runner.js';
+export async function detectGitRepo(root = process.cwd()) {
+    const cwd = path.resolve(root);
+    const gitBinary = await which('git');
+    const blockers = [];
+    if (!gitBinary) {
+        return baseDetection(cwd, null, false, ['git_binary_missing']);
+    }
+    const inside = await runGitCommand(cwd, ['rev-parse', '--is-inside-work-tree']);
+    if (!inside.ok || gitOutputLine(inside) !== 'true') {
+        return baseDetection(cwd, gitBinary, true, []);
+    }
+    const top = await runGitCommand(cwd, ['rev-parse', '--show-toplevel']);
+    const gitDir = await runGitCommand(cwd, ['rev-parse', '--git-dir']);
+    const commonDir = await runGitCommand(cwd, ['rev-parse', '--git-common-dir']);
+    const bare = await runGitCommand(cwd, ['rev-parse', '--is-bare-repository']);
+    const branch = await runGitCommand(cwd, ['branch', '--show-current']);
+    const head = await runGitCommand(cwd, ['rev-parse', 'HEAD']);
+    if (!top.ok)
+        blockers.push(gitBlocker('git_root_unresolved', top));
+    if (!gitDir.ok)
+        blockers.push(gitBlocker('git_dir_unresolved', gitDir));
+    if (!commonDir.ok)
+        blockers.push(gitBlocker('git_common_dir_unresolved', commonDir));
+    if (!head.ok)
+        blockers.push(gitBlocker('git_head_unresolved', head));
+    const repoRoot = top.ok ? path.resolve(gitOutputLine(top)) : null;
+    const resolvedGitDir = gitDir.ok ? absolutizeGitPath(cwd, gitOutputLine(gitDir)) : null;
+    const resolvedCommonDir = commonDir.ok ? absolutizeGitPath(cwd, gitOutputLine(commonDir)) : null;
+    return {
+        schema: 'sks.git-repo-detection.v1',
+        ok: blockers.length === 0,
+        cwd,
+        git_binary: gitBinary,
+        is_git_repo: true,
+        inside_work_tree: true,
+        bare: gitOutputLine(bare) === 'true',
+        root: repoRoot,
+        git_dir: resolvedGitDir,
+        common_dir: resolvedCommonDir,
+        worktree_git_dir: resolvedGitDir && resolvedCommonDir && resolvedGitDir !== resolvedCommonDir ? resolvedGitDir : null,
+        branch: gitOutputLine(branch) || null,
+        head: gitOutputLine(head) || null,
+        blockers
+    };
+}
+function baseDetection(cwd, gitBinary, gitAvailable, blockers) {
+    return {
+        schema: 'sks.git-repo-detection.v1',
+        ok: gitAvailable || blockers.length === 0,
+        cwd,
+        git_binary: gitBinary,
+        is_git_repo: false,
+        inside_work_tree: false,
+        bare: false,
+        root: null,
+        git_dir: null,
+        common_dir: null,
+        worktree_git_dir: null,
+        branch: null,
+        head: null,
+        blockers
+    };
+}
+function absolutizeGitPath(cwd, value) {
+    if (!value)
+        return null;
+    return path.isAbsolute(value) ? path.resolve(value) : path.resolve(cwd, value);
+}
+//# sourceMappingURL=git-repo-detection.js.map

package/dist/core/git/git-worktree-cache-policy.js

@@ -0,0 +1,36 @@
+import { nowIso } from '../fsx.js';
+export function planGitWorktreeCachePolicy(input) {
+    const nowMs = Math.max(0, Math.floor(Number(input.nowMs ?? Date.now())));
+    const maxEntries = Math.max(1, Math.floor(Number(input.maxEntries ?? 50)));
+    const maxBytes = Math.max(1024 * 1024, Math.floor(Number(input.maxBytes ?? 8 * 1024 * 1024 * 1024)));
+    const ttlMs = Math.max(60000, Math.floor(Number(input.ttlMs ?? 7 * 24 * 60 * 60 * 1000)));
+    const sorted = [...input.entries].sort((a, b) => a.updated_at_ms - b.updated_at_ms);
+    const prune = new Set();
+    let totalBytes = sorted.reduce((sum, entry) => sum + Math.max(0, entry.bytes), 0);
+    for (const entry of sorted) {
+        if (entry.dirty)
+            continue;
+        if (nowMs - entry.updated_at_ms > ttlMs)
+            prune.add(entry.path);
+    }
+    for (const entry of sorted) {
+        if (sorted.length - prune.size <= maxEntries && totalBytes <= maxBytes)
+            break;
+        if (entry.dirty || prune.has(entry.path))
+            continue;
+        prune.add(entry.path);
+        totalBytes -= Math.max(0, entry.bytes);
+    }
+    return {
+        schema: 'sks.git-worktree-cache-policy.v1',
+        ok: true,
+        generated_at: nowIso(),
+        max_entries: maxEntries,
+        max_bytes: maxBytes,
+        ttl_ms: ttlMs,
+        keep: sorted.filter((entry) => !prune.has(entry.path)).map((entry) => entry.path),
+        prune: sorted.filter((entry) => prune.has(entry.path)).map((entry) => entry.path),
+        dirty_retained: sorted.filter((entry) => entry.dirty === true).map((entry) => entry.path)
+    };
+}
+//# sourceMappingURL=git-worktree-cache-policy.js.map

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

@@ -0,0 +1,54 @@
+import { ensureDir } from '../fsx.js';
+import { detectGitRepo } from './git-repo-detection.js';
+import { gitBlocker, runGitCommand } from './git-worktree-runner.js';
+import { resolveGitWorktreeRoot } from './git-worktree-root.js';
+export async function evaluateGitWorktreeCapability(input = {}) {
+    const requireGitWorktree = input.requireGitWorktree === true || process.env.SKS_REQUIRE_GIT_WORKTREE === '1';
+    const detection = await detectGitRepo(input.root || process.cwd());
+    const blockers = [...detection.blockers];
+    const gitAvailable = Boolean(detection.git_binary);
+    if (!detection.is_git_repo || !detection.root) {
+        if (requireGitWorktree)
+            blockers.push('git_worktree_required_but_not_git_repo');
+        return {
+            schema: 'sks.git-worktree-capability.v1',
+            ok: blockers.length === 0,
+            mode: 'patch-envelope-only',
+            require_git_worktree: requireGitWorktree,
+            git_available: gitAvailable,
+            is_git_repo: false,
+            worktree_supported: false,
+            worktree_probe_attempted: false,
+            detection,
+            root_resolution: null,
+            blockers
+        };
+    }
+    const rootResolution = resolveGitWorktreeRoot({
+        repoRoot: detection.root,
+        missionId: input.missionId || 'capability'
+    });
+    blockers.push(...rootResolution.blockers);
+    if (rootResolution.ok)
+        await ensureDir(rootResolution.root);
+    const list = await runGitCommand(detection.root, ['worktree', 'list', '--porcelain']);
+    const worktreeSupported = list.ok;
+    if (!worktreeSupported)
+        blockers.push(gitBlocker('git_worktree_list_failed', list));
+    if (requireGitWorktree && !worktreeSupported)
+        blockers.push('git_worktree_required_but_unsupported');
+    return {
+        schema: 'sks.git-worktree-capability.v1',
+        ok: blockers.length === 0,
+        mode: blockers.length === 0 && worktreeSupported ? 'git-worktree' : 'patch-envelope-only',
+        require_git_worktree: requireGitWorktree,
+        git_available: gitAvailable,
+        is_git_repo: true,
+        worktree_supported: worktreeSupported,
+        worktree_probe_attempted: true,
+        detection,
+        root_resolution: rootResolution,
+        blockers: [...new Set(blockers)]
+    };
+}
+//# sourceMappingURL=git-worktree-capability.js.map

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

@@ -0,0 +1,51 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { runGitCommand } from './git-worktree-runner.js';
+export async function cleanupGitWorktree(input) {
+    const repoRoot = path.resolve(input.repoRoot);
+    const worktreePath = path.resolve(input.worktreePath);
+    const status = await runGitCommand(worktreePath, ['status', '--porcelain=v1', '--untracked-files=all']);
+    const clean = status.ok && status.stdout.trim().length === 0;
+    if (!clean) {
+        const lockPath = `${worktreePath}.retained.json`;
+        await writeJsonAtomic(lockPath, {
+            schema: 'sks.git-worktree-retention-lock.v1',
+            generated_at: nowIso(),
+            repo_root: repoRoot,
+            worktree_path: worktreePath,
+            branch: input.branch || null,
+            reason: status.ok ? 'dirty_worktree_retained' : 'status_failed_retained',
+            status_porcelain: status.stdout || null
+        });
+        return {
+            schema: 'sks.git-worktree-cleanup.v1',
+            ok: true,
+            generated_at: nowIso(),
+            repo_root: repoRoot,
+            worktree_path: worktreePath,
+            branch: input.branch || null,
+            clean: false,
+            action: 'retained_dirty',
+            retention_lock_path: lockPath,
+            blockers: []
+        };
+    }
+    const remove = await runGitCommand(repoRoot, ['worktree', 'remove', worktreePath]);
+    const blockers = remove.ok ? [] : ['git_worktree_remove_failed'];
+    if (remove.ok && input.deleteBranch === true && input.branch) {
+        await runGitCommand(repoRoot, ['branch', '-D', input.branch]);
+    }
+    return {
+        schema: 'sks.git-worktree-cleanup.v1',
+        ok: blockers.length === 0,
+        generated_at: nowIso(),
+        repo_root: repoRoot,
+        worktree_path: worktreePath,
+        branch: input.branch || null,
+        clean: true,
+        action: remove.ok ? 'removed' : 'remove_failed',
+        retention_lock_path: null,
+        blockers
+    };
+}
+//# sourceMappingURL=git-worktree-cleanup.js.map

package/dist/core/git/git-worktree-conflict-resolver.js

@@ -0,0 +1,13 @@
+export function summarizeGitWorktreeConflict(input) {
+    const stderr = String(input.stderr || '');
+    return {
+        schema: 'sks.git-worktree-conflict.v1',
+        ok: false,
+        worker_id: input.workerId,
+        changed_files: input.changedFiles,
+        stderr_tail: stderr.slice(-4000),
+        conflict_markers_possible: /conflict|patch failed|does not apply/i.test(stderr),
+        blockers: ['git_worktree_diff_apply_failed']
+    };
+}
+//# sourceMappingURL=git-worktree-conflict-resolver.js.map

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

@@ -0,0 +1,50 @@
+import path from 'node:path';
+import { nowIso } from '../fsx.js';
+import { gitOutputLine, runGitCommand } from './git-worktree-runner.js';
+export async function exportGitWorktreeDiff(input) {
+    const worktreePath = path.resolve(input.worktreePath);
+    const blockers = [];
+    const branch = await runGitCommand(worktreePath, ['branch', '--show-current']);
+    const head = await runGitCommand(worktreePath, ['rev-parse', 'HEAD']);
+    const status = await runGitCommand(worktreePath, ['status', '--porcelain=v1', '--untracked-files=all']);
+    const diff = await runGitCommand(worktreePath, ['diff', '--binary', '--full-index', 'HEAD']);
+    const names = await runGitCommand(worktreePath, ['diff', '--name-only', 'HEAD']);
+    const untracked = await runGitCommand(worktreePath, ['ls-files', '--others', '--exclude-standard']);
+    if (!status.ok)
+        blockers.push('git_worktree_status_failed');
+    if (!diff.ok)
+        blockers.push('git_worktree_diff_failed');
+    const untrackedFiles = lines(untracked.stdout);
+    const trackedChanged = lines(names.stdout);
+    const changedFiles = [...new Set([...trackedChanged, ...untrackedFiles, ...statusFiles(status.stdout)])];
+    return {
+        schema: 'sks.git-worktree-diff.v1',
+        ok: blockers.length === 0,
+        generated_at: nowIso(),
+        mission_id: input.missionId,
+        worker_id: input.workerId,
+        main_repo_root: path.resolve(input.mainRepoRoot),
+        worktree_path: worktreePath,
+        branch: gitOutputLine(branch) || null,
+        base_head: null,
+        worktree_head: gitOutputLine(head) || null,
+        status_porcelain: status.stdout,
+        changed_files: changedFiles,
+        untracked_files: untrackedFiles,
+        diff: diff.stdout,
+        diff_bytes: Buffer.byteLength(diff.stdout),
+        clean: changedFiles.length === 0 && status.stdout.trim().length === 0,
+        blockers
+    };
+}
+function lines(text) {
+    return String(text || '').split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+}
+function statusFiles(text) {
+    return lines(text).map((line) => {
+        const match = line.match(/^.{2}\s+(.*)$/) || line.match(/^\S+\s+(.*)$/);
+        const file = (match?.[1] || line).trim();
+        return file.includes(' -> ') ? file.split(' -> ').pop()?.trim() || file : file;
+    }).filter(Boolean);
+}
+//# sourceMappingURL=git-worktree-diff.js.map

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

@@ -0,0 +1,86 @@
+import path from 'node:path';
+import fsp from 'node:fs/promises';
+import { ensureDir, nowIso, writeJsonAtomic } from '../fsx.js';
+import { evaluateGitWorktreeCapability } from './git-worktree-capability.js';
+import { gitBlocker, gitOutputLine, runGitCommand } from './git-worktree-runner.js';
+import { sanitizePathPart } from './git-worktree-root.js';
+export async function allocateWorkerWorktree(input) {
+    const capability = await evaluateGitWorktreeCapability({
+        root: input.repoRoot || process.cwd(),
+        missionId: input.missionId,
+        requireGitWorktree: true
+    });
+    const repoRoot = capability.detection.root || path.resolve(input.repoRoot || process.cwd());
+    const root = capability.root_resolution?.root || path.join(repoRoot, '.sneakoscope', 'blocked-worktrees');
+    const workerId = sanitizePathPart(input.workerId);
+    const slotId = sanitizePathPart(input.slotId || workerId);
+    const generationIndex = Math.max(1, Math.floor(Number(input.generationIndex || 1)));
+    const baseRef = input.baseRef || capability.detection.head || 'HEAD';
+    const branchPrefix = sanitizeBranchPart(input.branchPrefix || 'sks');
+    const branch = `${branchPrefix}/${sanitizeBranchPart(input.missionId)}/${sanitizeBranchPart(slotId)}-gen-${generationIndex}-${workerId}`;
+    const worktreePath = path.join(root, `${slotId}-gen-${generationIndex}-${workerId}`);
+    const blockers = [...capability.blockers];
+    let baseHead = capability.detection.head;
+    if (capability.ok) {
+        await ensureDir(root);
+        let add = null;
+        for (let attempt = 1; attempt <= 3; attempt += 1) {
+            if (attempt > 1) {
+                await sleep(250 * attempt);
+                await runGitCommand(repoRoot, ['worktree', 'prune'], { timeoutMs: 30000 }).catch(() => null);
+                await fsp.rm(worktreePath, { recursive: true, force: true }).catch(() => null);
+            }
+            const existingBranch = await runGitCommand(repoRoot, ['show-ref', '--verify', '--quiet', `refs/heads/${branch}`]);
+            const args = existingBranch.ok
+                ? ['worktree', 'add', worktreePath, branch]
+                : ['worktree', 'add', '-b', branch, worktreePath, baseRef];
+            add = await runGitCommand(repoRoot, args, { timeoutMs: 120000 });
+            if (add.ok)
+                break;
+        }
+        if (!add?.ok)
+            blockers.push(gitBlocker('git_worktree_add_failed', add));
+        if (add?.ok) {
+            const head = await runGitCommand(worktreePath, ['rev-parse', 'HEAD']);
+            baseHead = head.ok ? gitOutputLine(head) : baseHead;
+        }
+    }
+    const allocation = {
+        schema: 'sks.git-worktree-allocation.v1',
+        ok: blockers.length === 0,
+        created_at: nowIso(),
+        mission_id: input.missionId,
+        worker_id: workerId,
+        slot_id: slotId,
+        generation_index: generationIndex,
+        repo_root: repoRoot,
+        main_repo_root: repoRoot,
+        worktree_path: worktreePath,
+        branch,
+        base_ref: baseRef,
+        base_head: baseHead,
+        manifest_path: path.join(root, 'git-worktree-manifest.json'),
+        capability,
+        blockers: [...new Set(blockers)]
+    };
+    await appendWorktreeManifest(allocation);
+    return allocation;
+}
+async function appendWorktreeManifest(allocation) {
+    const manifest = {
+        schema: 'sks.git-worktree-manifest.v1',
+        updated_at: nowIso(),
+        mission_id: allocation.mission_id,
+        repo_root: allocation.repo_root,
+        root: path.dirname(allocation.worktree_path),
+        allocations: [allocation]
+    };
+    await writeJsonAtomic(allocation.manifest_path, manifest);
+}
+function sanitizeBranchPart(value) {
+    return sanitizePathPart(value).replace(/\./g, '-').slice(0, 48) || 'item';
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=git-worktree-manager.js.map