sneakoscope 2.0.6 → 2.0.8

package/dist/core/agents/native-cli-session-swarm.js

@@ -26,6 +26,8 @@ class NativeCliSessionSwarmRecorder {
         await this.persist();
     }
     async launchWorker(ctx) {
+        const worktree = normalizeWorkerWorktree(ctx.agent?.worktree || ctx.slice?.worktree || ctx.opts?.worktree || null);
+        const workerCwd = worktree?.path || ctx.opts.cwd || packageRoot();
         const workerDirRel = path.join(ctx.agent.session_artifact_dir || path.join('sessions', ctx.agent.id), 'worker');
         const workerDir = path.join(this.root, workerDirRel);
         await ensureDir(workerDir);
@@ -45,6 +47,9 @@ class NativeCliSessionSwarmRecorder {
             backend_explicit: this.input.backendExplicit === true,
             no_ollama: this.input.noOllama === true || ctx.opts.noOllama === true,
             agent_root: this.root,
+            main_repo_root: worktree?.main_repo_root || ctx.opts.cwd || packageRoot(),
+            cwd: workerCwd,
+            worktree,
             agent: ctx.agent,
             slice: ctx.slice,
             worker_artifact_dir: workerDirRel,
@@ -89,13 +94,18 @@ class NativeCliSessionSwarmRecorder {
             patch_envelope_path: patchRel,
             fast_mode: this.input.fastModePolicy.fast_mode,
             service_tier: this.input.fastModePolicy.service_tier,
+            cwd: workerCwd,
             status: 'launching',
             exit_code: null,
             blockers: []
         };
         const stdout = fs.createWriteStream(path.join(this.root, stdoutRel), { flags: 'a' });
         const stderr = fs.createWriteStream(path.join(this.root, stderrRel), { flags: 'a' });
-        if (this.input.backend === 'zellij' && ctx.opts.real === true && ctx.opts.zellijPaneWorker !== false) {
+        const placement = String(ctx.opts.workerPlacement || this.input.workerPlacement || (this.input.backend === 'zellij' ? 'zellij-pane' : 'process'));
+        const useZellijPane = placement === 'zellij-pane'
+            && ctx.opts.zellijPaneWorker !== false
+            && (ctx.opts.zellijSessionName || this.input.missionId);
+        if (useZellijPane) {
             stdout.end();
             stderr.end();
             return this.launchWorkerInZellijPane({
@@ -110,7 +120,7 @@ class NativeCliSessionSwarmRecorder {
             });
         }
         const child = spawn(process.execPath, args, {
-            cwd: ctx.opts.cwd || packageRoot(),
+            cwd: workerCwd,
             env: {
                 ...process.env,
                 ...(ctx.opts.env || {}),
@@ -179,6 +189,8 @@ class NativeCliSessionSwarmRecorder {
     async launchWorkerInZellijPane(input) {
         const sessionName = String(input.ctx.opts.zellijSessionName || (this.input.missionId ? `sks-${this.input.missionId}` : 'sks-agent-runtime'));
         const slotId = String(input.ctx.agent.slot_id || input.ctx.agent.id || 'slot-001');
+        const worktree = normalizeWorkerWorktree(input.ctx.agent?.worktree || input.ctx.slice?.worktree || input.ctx.opts?.worktree || null);
+        const workerCwd = worktree?.path || input.ctx.opts.cwd || packageRoot();
         const activeToken = this.nextPaneToken--;
         this.active.add(activeToken);
         this.maxObserved = Math.max(this.maxObserved, this.active.size);
@@ -222,9 +234,11 @@ class NativeCliSessionSwarmRecorder {
             patchEnvelopePath: input.record.patch_envelope_path,
             stdoutLog: input.stdoutRel,
             stderrLog: input.stderrRel,
-            cwd: input.ctx.opts.cwd || packageRoot(),
+            cwd: workerCwd,
             providerContext,
-            serviceTier: this.input.fastModePolicy.service_tier
+            serviceTier: this.input.fastModePolicy.service_tier,
+            worktree: worktree ? { id: worktree.id, path: worktree.path, branch: worktree.branch } : null,
+            backend: this.input.backend
         });
         const launchBlockers = paneRecord.blockers || [];
         input.record.command_line = ['zellij', '--session', sessionName, 'action', 'new-pane', '--direction', paneRecord.direction_applied, '--name', paneRecord.pane_name, '--', 'sh', '-lc', '<native-cli-worker-command>'];
@@ -239,6 +253,7 @@ class NativeCliSessionSwarmRecorder {
         input.record.provider = paneRecord.provider;
         input.record.service_tier = paneRecord.service_tier;
         input.record.provider_context = paneRecord.provider_context;
+        input.record.worktree = worktree;
         input.record.status = launchBlockers.length ? 'failed' : 'running';
         input.record.blockers = launchBlockers;
         await this.record(input.record);
@@ -323,7 +338,7 @@ class NativeCliSessionSwarmRecorder {
         paneRecord = await closeWorkerPane({
             root: this.root,
             paneRecord,
-            cwd: input.ctx.opts.cwd || packageRoot(),
+            cwd: workerCwd,
             status: input.record.status === 'closed' ? 'closed' : 'failed',
             blockers: input.record.blockers,
             sdkThreadId,
@@ -462,4 +477,15 @@ function redactWorkerArgs(args) {
 function shellQuote(value) {
     return `'${String(value).replace(/'/g, `'\\''`)}'`;
 }
+function normalizeWorkerWorktree(value) {
+    const pathValue = value?.path || value?.worktree_path;
+    if (!pathValue)
+        return null;
+    return {
+        id: String(value?.id || value?.worktree_id || value?.slot_id || 'worktree'),
+        path: String(pathValue),
+        branch: String(value?.branch || 'unknown'),
+        main_repo_root: value?.main_repo_root == null ? null : String(value.main_repo_root)
+    };
+}
 //# sourceMappingURL=native-cli-session-swarm.js.map

package/dist/core/agents/native-cli-worker.js

@@ -27,6 +27,8 @@ export async function runNativeCliWorker(input = {}) {
     };
     const slice = intake.slice || {};
     const backend = String(input.backend || intake.backend || 'fake');
+    const workerCwd = path.resolve(String(input.cwd || intake.cwd || process.cwd()));
+    const worktree = normalizeWorkerWorktree(input.worktree || intake.worktree || null);
     const policy = resolveFastModePolicy({
         fastMode: intake.fast_mode ?? input.fastMode,
         serviceTier: intake.service_tier ?? input.serviceTier
@@ -37,6 +39,10 @@ export async function runNativeCliWorker(input = {}) {
     const heartbeatRel = String(input.heartbeatPath || intake.heartbeat_path || path.join(workerDirRel, 'worker-heartbeat.jsonl'));
     const patchRel = String(input.patchEnvelopePath || intake.patch_envelope_path || path.join(workerDirRel, 'worker-patch-envelope.json'));
     await ensureDir(workerDir);
+    try {
+        process.chdir(workerCwd);
+    }
+    catch { }
     const recursion = scanAgentTextForRecursion(JSON.stringify({ agent, slice, backend }));
     const guard = {
         schema: 'sks.native-cli-worker-recursion-guard.v1',
@@ -56,6 +62,9 @@ export async function runNativeCliWorker(input = {}) {
         persona_id: String(agent.persona_id || input.personaId || ''),
         lease_id: String(intake.lease_id || input.leaseId || ''),
         agent_root: agentRoot,
+        main_repo_root: String(input.mainRepoRoot || intake.main_repo_root || worktree?.main_repo_root || agentRoot),
+        cwd: workerCwd,
+        worktree,
         worker_artifact_dir: workerDirRel,
         result_path: resultRel,
         heartbeat_path: heartbeatRel,
@@ -65,7 +74,9 @@ export async function runNativeCliWorker(input = {}) {
             backend: backend === 'zellij' ? 'codex-sdk' : backend,
             output_schema_id: 'sks.agent-worker-result.v1',
             sandbox_policy: Array.isArray(slice.write_paths) && slice.write_paths.length > 0 ? 'workspace-write' : 'read-only',
-            thread_policy: 'new_thread_per_generation'
+            thread_policy: 'new_thread_per_generation',
+            worktree,
+            cwd: workerCwd
         },
         service_tier: policy.service_tier,
         fast_mode: policy.fast_mode,
@@ -143,6 +154,8 @@ export async function runNativeCliWorker(input = {}) {
         generated_at: nowIso(),
         ok: guard.ok,
         backend,
+        cwd: workerCwd,
+        worktree,
         agent_id: agent.id,
         session_id: agent.session_id,
         slot_id: agent.slot_id || null,
@@ -221,6 +234,9 @@ export async function runNativeCliWorker(input = {}) {
         slot_id: agent.slot_id || null,
         generation_index: agent.generation_index || null,
         process_id: process.pid,
+        main_repo_root: String(input.mainRepoRoot || intake.main_repo_root || worktree?.main_repo_root || agentRoot),
+        cwd: workerCwd,
+        worktree,
         artifact_dir: workerDirRel,
         patch_envelope: patchEnvelopes.length ? patchRel : null,
         no_patch_reason: patchEnvelopes.length ? null : path.join(workerDirRel, 'worker-no-patch-reason.json'),
@@ -290,4 +306,15 @@ function redactCommandLine(argv) {
         return part;
     });
 }
+function normalizeWorkerWorktree(value) {
+    const pathValue = value?.path || value?.worktree_path;
+    if (!pathValue)
+        return null;
+    return {
+        id: String(value?.id || value?.worktree_id || value?.slot_id || 'worktree'),
+        path: String(pathValue),
+        branch: String(value?.branch || 'unknown'),
+        main_repo_root: value?.main_repo_root == null ? null : String(value.main_repo_root)
+    };
+}
 //# sourceMappingURL=native-cli-worker.js.map

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/mad-sks-command.js

@@ -7,6 +7,7 @@ import { createMission, setCurrent } from '../mission.js';
 import { buildMadHighLaunchProfileNoWrite, madHighProfileName } from '../auto-review.js';
 import { permissionGateSummary } from '../permission-gates.js';
 import { attachZellijSessionInteractive, launchMadZellijUi, sanitizeZellijSessionName } from '../zellij/zellij-launcher.js';
+import { openZellijDashboardPane } from '../zellij/zellij-dashboard-pane.js';
 import { createMadSksAuthorizationManifest, validateMadSksAuthorizationManifest } from '../mad-sks/authorization-manifest.js';
 import { createMadSksAuditLedger, madSksAuditAction, writeMadSksAuditLedger } from '../mad-sks/audit-ledger.js';
 import { compareProtectedCoreSnapshots, evaluateMadSksWrite, resolveProtectedCore, snapshotProtectedCore } from '../mad-sks/immutable-harness-guard.js';
@@ -113,6 +114,30 @@ export async function madHighCommand(args = [], deps = {}) {
         console.log(`MAD Zellij action: ${formatMadZellijAction(launch)}`);
         return launch;
     }
+    launch.dashboard_pane = await openZellijDashboardPane({
+        root: madLaunch.root,
+        missionId: madLaunch.mission_id,
+        sessionName: launch.session_name,
+        cwd: process.cwd(),
+        snapshot: {
+            mode: 'mad-sks',
+            backend_counts: { zellij: 1 },
+            placement_counts: { 'zellij-pane': 1, headless: 0 },
+            active_workers: 1,
+            visible_panes: 1,
+            headless_workers: 0,
+            queue_depth: 0,
+            worktrees: { active: 0, completed: 0, retained: 0 },
+            local_llm: { tps: 0, queue: 0 },
+            gpt_final_status: 'pending',
+            gate_progress: 'mad-sks:session-open'
+        }
+    }).catch((err) => ({
+        ok: false,
+        pane_kind: 'dashboard',
+        worker_pane: false,
+        blockers: [`zellij_dashboard_exception:${err?.message || String(err)}`]
+    }));
     const madNativeSwarm = await startMadNativeSwarm(madLaunch.root, madLaunch, args, profile, {
         env: {
             ...madSksEnv,

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

@@ -10,11 +10,13 @@ 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 { openZellijDashboardPane } from '../zellij/zellij-dashboard-pane.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).
@@ -61,6 +63,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.
@@ -74,7 +95,8 @@ async function narutoRun(parsed) {
         readonly: parsed.readonly,
         writeCapable,
         leaseBasePath: patchEnvelopeBasePath,
-        maxActiveWorkers: parsed.concurrency || safe.cap
+        maxActiveWorkers: parsed.concurrency || safe.cap,
+        worktreePolicy
     });
     const roleDistribution = buildNarutoRoleDistribution(workGraph.work_items, { readonly: parsed.readonly });
     const governor = decideNarutoConcurrency({
@@ -86,22 +108,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,
@@ -109,9 +133,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) {
@@ -125,6 +150,34 @@ async function narutoRun(parsed) {
             attach: false
         });
         if (liveZellij?.ok && liveZellij.capability?.status === 'ok') {
+            liveZellij.dashboard_pane = await openZellijDashboardPane({
+                root,
+                missionId: mission.id,
+                sessionName: liveZellij.session_name,
+                cwd: root,
+                snapshot: {
+                    mode: 'naruto',
+                    backend_counts: { [schedulerBackend]: activeSlots },
+                    placement_counts: { 'zellij-pane': zellijVisiblePanes, headless: Math.max(0, activeSlots - zellijVisiblePanes) },
+                    active_workers: activeSlots,
+                    visible_panes: zellijVisiblePanes,
+                    headless_workers: Math.max(0, activeSlots - zellijVisiblePanes),
+                    queue_depth: Math.max(0, workGraph.total_work_items - activeSlots),
+                    worktrees: {
+                        active: worktreePolicy.mode === 'git-worktree' ? activeSlots : 0,
+                        completed: 0,
+                        retained: 0
+                    },
+                    local_llm: { tps: 0, queue: localWorker.auto_select_eligible ? Math.max(0, activeSlots - zellijVisiblePanes) : 0 },
+                    gpt_final_status: 'pending',
+                    gate_progress: 'naruto:pre-orchestrator'
+                }
+            }).catch((err) => ({
+                ok: false,
+                pane_kind: 'dashboard',
+                worker_pane: false,
+                blockers: [`zellij_dashboard_exception:${err?.message || String(err)}`]
+            }));
             console.log('Zellij: prepared ' + zellijVisiblePanes + ' visible active clone lane(s) in ' + liveZellij.session_name + ' with ' + Math.max(0, activeSlots - zellijVisiblePanes) + ' headless active worker(s). Attach with: ' + (liveZellij.attach_command_with_env || liveZellij.attach_command));
             if (parsed.attach)
                 attachZellijSessionInteractive(liveZellij.session_name, { cwd: process.cwd(), configPath: liveZellij.clipboard_config_path });
@@ -165,6 +218,7 @@ async function narutoRun(parsed) {
         serviceTier: 'fast',
         noFast: false,
         writeMode: writeCapable ? parsed.writeMode || 'parallel' : 'off',
+        gitWorktreePolicy: worktreePolicy,
         json: parsed.json
     });
     const clones = result.roster?.agent_count ?? roster.agent_count;
@@ -188,8 +242,10 @@ async function narutoRun(parsed) {
             write_allowed_count: workGraph.write_allowed_count,
             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
+            ok: workGraph.ok,
+            worktree_policy: workGraph.worktree_policy
         },
+        git_worktree: gitWorktreeCapability,
         role_distribution: roleDistribution,
         concurrency_governor: governor,
         active_pool: {
@@ -328,6 +384,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.6';
+export const PACKAGE_VERSION = '2.0.8';
 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,79 @@
+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']);
+    const status = await runGitCommand(cwd, ['status', '--porcelain=v1', '--untracked-files=all']);
+    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));
+    if (!status.ok)
+        blockers.push(gitBlocker('git_status_unresolved', status));
+    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,
+        main_worktree_dirty: status.ok && status.stdout.trim().length > 0,
+        status_porcelain: status.stdout || '',
+        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,
+        main_worktree_dirty: false,
+        status_porcelain: '',
+        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