sneakoscope 2.0.6 → 2.0.7

package/README.md

@@ -16,10 +16,15 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## Current Release
 
-SKS **2.0.6** wires Codex App Product Design into the design pipeline and hardens Naruto read-only routing on top of the 2.0 execution layer. Design routes can now discover, install, verify, and prefer the remote `product-design@openai-curated-remote` plugin, while read-only native worker runs keep write mode off and avoid treating pre-existing dirty files as generated patches.
+SKS **2.0.7** adds Git worktree parallel coding foundations for Naruto/MAD-SKS-style high-throughput work. Write-capable Git missions can now declare `git-worktree` mode, allocate worker worktrees outside the main checkout by default, export full-index diffs into patch envelopes, apply them through an integration worktree queue, and retain dirty worktrees instead of deleting evidence. Non-Git projects degrade to patch-envelope-only without calling `git worktree`.
 
 What changed:
 
+- Git capability checks detect repo roots, Git dirs, worktree support, and safe cache roots while blocking in-repo worktree roots unless `SKS_ALLOW_IN_REPO_WORKTREES=1` is explicit.
+- Worker worktree allocation creates isolated branches/paths under `$SKS_WORKTREE_ROOT`, `$XDG_CACHE_HOME/sks/worktrees`, or `~/.cache/sks/worktrees`; main checkouts stay untouched until integration.
+- Worktree diff export records status, changed files, full-index binary diffs, and `git-worktree-diff` patch envelopes for parent-owned integration.
+- Integration worktrees apply worker diffs with `git apply --3way`, while cleanup removes only clean worktrees and retains dirty ones with a lock artifact.
+- Naruto work graphs, active-pool artifacts, Zellij dashboard titles, native worker intake, and GPT Final packs now carry worktree policy and WT/branch context.
 - Product Design plugin readiness now checks both local and remote Codex App catalogs, auto-installs the remote plugin when needed, and records the installed/enabled skill surface.
 - UI/design/PPT runtime routes prefer Product Design for research, ideation, audit, design QA, prototype, URL-to-code, image-to-code, share, and user-context steps.
 - Naruto read-only runs force write mode off, propagate no-patch reasons through worker proof, and skip changed-file lease checks when no write-capable patch envelope exists.

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "2.0.6"
+version = "2.0.7"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "2.0.6"
+version = "2.0.7"
 edition = "2021"
 
 [dependencies]

package/crates/sks-core/src/main.rs

@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek, SeekFrom};
 fn main() {
     let mut args = std::env::args().skip(1);
     match args.next().as_deref() {
-        Some("--version") => println!("sks-rs 2.0.6"),
+        Some("--version") => println!("sks-rs 2.0.7"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/.sks-build-stamp.json

@@ -1,8 +1,8 @@
 {
   "schema": "sks.dist-build-stamp.v1",
   "package_name": "sneakoscope",
-  "package_version": "2.0.6",
-  "source_digest": "3947e39c47a565506e9ffd37568ae889bc7943f6dc342b5c357976b840770f94",
-  "source_file_count": 1953,
-  "built_at_source_time": 1780662014263
+  "package_version": "2.0.7",
+  "source_digest": "fd9b0bc3d9a5a09bcd2b90988719b11e844448de39f28cf27e98c1b4cae82a0f",
+  "source_file_count": 1979,
+  "built_at_source_time": 1780686416915
 }

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '2.0.6';
+const FAST_PACKAGE_VERSION = '2.0.7';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

package/dist/build-manifest.json

@@ -1,16 +1,16 @@
 {
   "schema": "sks.dist-build.v2",
-  "version": "2.0.6",
-  "package_version": "2.0.6",
+  "version": "2.0.7",
+  "package_version": "2.0.7",
   "typescript": true,
   "mjs_runtime_files": 0,
-  "compiled_file_count": 1019,
-  "compiled_js_count": 1019,
+  "compiled_file_count": 1043,
+  "compiled_js_count": 1043,
   "compiled_dts_count": 0,
-  "source_digest": "3947e39c47a565506e9ffd37568ae889bc7943f6dc342b5c357976b840770f94",
-  "source_file_count": 1953,
-  "source_files_hash": "5d6f0e4186fc37279e1cf6de0c6b3c7230123c4a588966f8fda2a9324eb75192",
-  "source_list_hash": "5d6f0e4186fc37279e1cf6de0c6b3c7230123c4a588966f8fda2a9324eb75192",
+  "source_digest": "fd9b0bc3d9a5a09bcd2b90988719b11e844448de39f28cf27e98c1b4cae82a0f",
+  "source_file_count": 1979,
+  "source_files_hash": "319ce7cd86fb58c825b14eb717a1d7b9c85be197206852aee9646fbfd5d356c6",
+  "source_list_hash": "319ce7cd86fb58c825b14eb717a1d7b9c85be197206852aee9646fbfd5d356c6",
   "src_mjs_runtime_files": 0,
   "dist_stamp_schema": "sks.dist-build-stamp.v1",
   "files": [
@@ -342,6 +342,19 @@
     "core/git-hygiene/shared-memory-security.js",
     "core/git-hygiene/validators.js",
     "core/git-simple.js",
+    "core/git/git-integration-worktree.js",
+    "core/git/git-repo-detection.js",
+    "core/git/git-worktree-cache-policy.js",
+    "core/git/git-worktree-capability.js",
+    "core/git/git-worktree-cleanup.js",
+    "core/git/git-worktree-conflict-resolver.js",
+    "core/git/git-worktree-diff.js",
+    "core/git/git-worktree-manager.js",
+    "core/git/git-worktree-merge-queue.js",
+    "core/git/git-worktree-patch-envelope.js",
+    "core/git/git-worktree-pool.js",
+    "core/git/git-worktree-root.js",
+    "core/git/git-worktree-runner.js",
     "core/goal-workflow.js",
     "core/gx-renderer.js",
     "core/harness-conflicts.js",
@@ -814,6 +827,13 @@
     "scripts/flagship-proof-graph-v3-check.js",
     "scripts/flagship-proof-graph-v4-check.js",
     "scripts/git-precommit-fixture-check.js",
+    "scripts/git-worktree-cache-performance-check.js",
+    "scripts/git-worktree-capability-check.js",
+    "scripts/git-worktree-cleanup-check.js",
+    "scripts/git-worktree-diff-export-check.js",
+    "scripts/git-worktree-manager-check.js",
+    "scripts/git-worktree-merge-queue-check.js",
+    "scripts/git-worktree-pool-performance-check.js",
     "scripts/goal-mode-official-default-check.js",
     "scripts/gpt-final-arbiter-check.js",
     "scripts/gpt-final-arbiter-performance-check.js",
@@ -841,6 +861,7 @@
     "scripts/legacy-upgrade-matrix-check.js",
     "scripts/lib/codex-sdk-gate-lib.js",
     "scripts/lib/ensure-dist-fresh.js",
+    "scripts/lib/git-worktree-fixture.js",
     "scripts/lib/mad-sks-actual-executor-check-lib.js",
     "scripts/lib/native-cli-session-swarm-check-lib.js",
     "scripts/lib/real-codex-parallel-gate.js",
@@ -894,6 +915,9 @@
     "scripts/naruto-shadow-clone-swarm-check.js",
     "scripts/naruto-verification-pool-check.js",
     "scripts/naruto-work-graph-check.js",
+    "scripts/naruto-worktree-coding-check.js",
+    "scripts/naruto-worktree-gpt-final-check.js",
+    "scripts/naruto-worktree-zellij-ui-check.js",
     "scripts/naruto-zellij-massive-ui-check.js",
     "scripts/non-recursive-pipeline-check.js",
     "scripts/npm-publish-performance-check.js",

package/dist/core/agents/agent-orchestrator.js

@@ -52,6 +52,10 @@ import { CODEX_AGENT_WORKER_RESULT_SCHEMA_ID, codexAgentWorkerResultSchema } fro
 import { resolveLocalCollaborationPolicy, localCollaborationParticipated } from '../local-llm/local-collaboration-policy.js';
 import { runFinalGptReviewStage } from '../pipeline/final-gpt-review-stage.js';
 import { selectFinalGptPatchSource } from '../pipeline/final-gpt-patch-stage.js';
+import { allocateWorkerWorktree } from '../git/git-worktree-manager.js';
+import { exportGitWorktreeDiff } from '../git/git-worktree-diff.js';
+import { buildGitWorktreePatchEnvelope } from '../git/git-worktree-patch-envelope.js';
+import { cleanupGitWorktree } from '../git/git-worktree-cleanup.js';
 export async function runNativeAgentOrchestrator(opts = {}) {
     const root = path.resolve(opts.root || process.cwd());
     const prompt = String(opts.prompt || 'Native agent run');
@@ -253,6 +257,21 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         strategy_gate: strategyRef
     };
     await writeJsonAtomic(path.join(ledgerRoot, 'agent-parallel-write-policy.json'), parallelWritePolicy);
+    const gitWorktreePolicy = opts.gitWorktreePolicy || null;
+    const gitWorktreeRuntime = {
+        schema: 'sks.agent-git-worktree-runtime.v1',
+        generated_at: nowIso(),
+        ok: true,
+        mode: gitWorktreePolicy?.mode || 'patch-envelope-only',
+        required: gitWorktreePolicy?.required === true,
+        main_repo_root: gitWorktreePolicy?.main_repo_root || root,
+        worktree_root: gitWorktreePolicy?.worktree_root || null,
+        allocations: [],
+        diffs: [],
+        cleanup: [],
+        blockers: []
+    };
+    await writeJsonAtomic(path.join(ledgerRoot, 'agent-git-worktree-runtime.json'), gitWorktreeRuntime);
     const nativeCliSwarm = createNativeCliSessionSwarmRecorder(ledgerRoot, {
         missionId,
         requestedAgents: Number(opts.agents || roster.agent_count || targetActiveSlots),
@@ -280,6 +299,17 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         goalModeRef,
         launchSession: async ({ agent, workItem }) => {
             const slice = workItem.slice || { id: workItem.id, description: workItem.description || prompt };
+            const workerWorktree = await prepareWorkerGitWorktree({
+                root,
+                ledgerRoot,
+                missionId,
+                agent,
+                slice,
+                policy: gitWorktreePolicy,
+                runtime: gitWorktreeRuntime
+            });
+            const runtimeAgent = workerWorktree ? { ...agent, worktree: workerWorktree.context } : agent;
+            const runtimeSlice = workerWorktree ? { ...slice, worktree: workerWorktree.context } : slice;
             await openAgentSession(ledgerRoot, agent);
             await heartbeatAgentSession(ledgerRoot, agent);
             await appendAgentCodexCockpitHookEvent(dir, {
@@ -303,10 +333,21 @@ export async function runNativeAgentOrchestrator(opts = {}) {
                 generationIndex: agent.generation_index,
                 requireGeneration: true
             });
-            const backendOpts = { ...opts, missionId, agentRoot: ledgerRoot, cwd: root, route, prompt, fastMode: fastModePolicy.fast_mode, serviceTier: fastModePolicy.service_tier };
+            const backendOpts = { ...opts, missionId, agentRoot: ledgerRoot, cwd: workerWorktree?.context.path || root, route, prompt, fastMode: fastModePolicy.fast_mode, serviceTier: fastModePolicy.service_tier, ...(workerWorktree ? { worktree: workerWorktree.context } : {}) };
             const result = opts.nativeCliSwarm === false
-                ? await runAgentByBackend(backend, agent, slice, backendOpts)
-                : await nativeCliSwarm.launchWorker({ agent, slice, opts: backendOpts });
+                ? await runAgentByBackend(backend, runtimeAgent, runtimeSlice, backendOpts)
+                : await nativeCliSwarm.launchWorker({ agent: runtimeAgent, slice: runtimeSlice, opts: backendOpts });
+            if (workerWorktree)
+                await finalizeWorkerGitWorktree({
+                    root,
+                    ledgerRoot,
+                    missionId,
+                    agent: runtimeAgent,
+                    slice: runtimeSlice,
+                    result,
+                    workerWorktree,
+                    runtime: gitWorktreeRuntime
+                });
             const terminalClose = await closeAgentTerminalSession(ledgerRoot, agent, {
                 exitCode: result.status === 'done' ? 0 : 1,
                 status: result.status,
@@ -444,6 +485,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         ...(nativeCliSessionProof.ok ? [] : nativeCliSessionProof.blockers),
         ...(noSubagentScalingPolicy.ok ? [] : noSubagentScalingPolicy.blockers),
         ...(fastModePropagation.ok ? [] : fastModePropagation.blockers),
+        ...(gitWorktreeRuntime.required === true && gitWorktreeRuntime.ok === false ? gitWorktreeRuntime.blockers || ['git_worktree_runtime_not_ok'] : []),
         ...(localParticipated && gptFinalArbiter?.ok !== true ? gptFinalArbiter?.blockers || ['gpt_final_arbiter_not_ok'] : []),
         ...(localParticipated && finalGptPatchStage?.ok === false ? finalGptPatchStage.blockers || ['final_gpt_patch_stage_not_ok'] : []),
         ...(patchSwarm.ok ? [] : patchSwarm.blockers),
@@ -480,6 +522,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         noSubagentScalingPolicy,
         fastModePolicy,
         fastModePropagation,
+        gitWorktreeRuntime,
         triwikiContext,
         selectedCoreSkill,
         localCollaborationPolicy,
@@ -524,6 +567,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         no_subagent_scaling_policy: noSubagentScalingPolicy,
         fast_mode_policy: fastModePolicy,
         fast_mode_propagation: fastModePropagation,
+        git_worktree_runtime: gitWorktreeRuntime,
         local_collaboration_policy: localCollaborationPolicy,
         gpt_final_arbiter: gptFinalArbiter,
         final_gpt_patch_stage: finalGptPatchStage,
@@ -548,6 +592,97 @@ function withFinalGptPatchEnvelopes(results, patchEnvelopes = []) {
         next[0] = { ...next[0], patch_envelopes: patchEnvelopes };
     return next;
 }
+async function prepareWorkerGitWorktree(input) {
+    if (input.policy?.mode !== 'git-worktree')
+        return null;
+    const sliceHasWritePaths = Array.isArray(input.slice.write_paths) && input.slice.write_paths.length > 0;
+    const agentWriteCapable = input.agent.write_allowed === true || /write|lease|required/i.test(String(input.agent.write_policy || ''));
+    if (!sliceHasWritePaths && !agentWriteCapable)
+        return null;
+    const generationIndex = Math.max(1, Math.floor(Number(input.agent.generation_index || 1)));
+    const allocation = await allocateWorkerWorktree({
+        repoRoot: input.policy.main_repo_root || input.root,
+        missionId: input.missionId,
+        workerId: String(input.agent.id || input.slice.id || 'worker'),
+        slotId: String(input.agent.slot_id || input.agent.id || 'slot-001'),
+        generationIndex
+    });
+    const artifactDir = path.join(input.ledgerRoot, input.agent.session_artifact_dir || path.join('sessions', input.agent.id || input.slice.id || 'worker'), 'worker');
+    await writeJsonAtomic(path.join(artifactDir, 'git-worktree-allocation.json'), allocation);
+    input.runtime.allocations.push({
+        agent_id: input.agent.id,
+        slice_id: input.slice.id,
+        ok: allocation.ok,
+        worktree_path: allocation.worktree_path,
+        branch: allocation.branch,
+        blockers: allocation.blockers
+    });
+    input.runtime.blockers.push(...allocation.blockers);
+    input.runtime.ok = input.runtime.blockers.length === 0;
+    await writeJsonAtomic(path.join(input.ledgerRoot, 'agent-git-worktree-runtime.json'), input.runtime);
+    if (!allocation.ok)
+        return null;
+    return {
+        allocation,
+        artifactDir,
+        context: {
+            id: `${allocation.slot_id}-gen-${allocation.generation_index}`,
+            path: allocation.worktree_path,
+            branch: allocation.branch,
+            main_repo_root: allocation.main_repo_root
+        }
+    };
+}
+async function finalizeWorkerGitWorktree(input) {
+    const allocation = input.workerWorktree.allocation;
+    const diff = await exportGitWorktreeDiff({
+        mainRepoRoot: allocation.main_repo_root || input.root,
+        worktreePath: allocation.worktree_path,
+        missionId: input.missionId,
+        workerId: String(input.agent.id || input.slice.id || 'worker')
+    });
+    await writeJsonAtomic(path.join(input.workerWorktree.artifactDir, 'git-worktree-diff.json'), diff);
+    input.runtime.diffs.push({
+        agent_id: input.agent.id,
+        slice_id: input.slice.id,
+        ok: diff.ok,
+        clean: diff.clean,
+        changed_files: diff.changed_files,
+        diff_bytes: diff.diff_bytes,
+        blockers: diff.blockers
+    });
+    if (!diff.clean && diff.ok) {
+        const envelope = buildGitWorktreePatchEnvelope({
+            diff,
+            agentId: String(input.agent.id || 'agent'),
+            sessionId: String(input.agent.session_id || ''),
+            slotId: String(input.agent.slot_id || ''),
+            generationIndex: Math.max(1, Math.floor(Number(input.agent.generation_index || 1)))
+        });
+        input.result.patch_envelopes = [...(Array.isArray(input.result.patch_envelopes) ? input.result.patch_envelopes : []), envelope];
+        input.result.changed_files = [...new Set([...(input.result.changed_files || []), ...diff.changed_files])];
+        input.result.artifacts = [...new Set([...(input.result.artifacts || []), path.relative(input.ledgerRoot, path.join(input.workerWorktree.artifactDir, 'git-worktree-diff.json'))])];
+        input.result.git_worktree_diff = diff;
+    }
+    const cleanup = await cleanupGitWorktree({
+        repoRoot: allocation.main_repo_root || input.root,
+        worktreePath: allocation.worktree_path,
+        branch: allocation.branch,
+        deleteBranch: diff.clean
+    });
+    await writeJsonAtomic(path.join(input.workerWorktree.artifactDir, 'git-worktree-cleanup.json'), cleanup);
+    input.runtime.cleanup.push({
+        agent_id: input.agent.id,
+        slice_id: input.slice.id,
+        action: cleanup.action,
+        clean: cleanup.clean,
+        retention_lock_path: cleanup.retention_lock_path,
+        blockers: cleanup.blockers
+    });
+    input.runtime.blockers.push(...diff.blockers, ...cleanup.blockers);
+    input.runtime.ok = input.runtime.blockers.length === 0;
+    await writeJsonAtomic(path.join(input.ledgerRoot, 'agent-git-worktree-runtime.json'), input.runtime);
+}
 async function legacyCodexExecBlockedRun(input) {
     const blockers = ['legacy_codex_exec_runtime_removed'];
     const ledgerRoot = path.join(input.dir, 'agents');

package/dist/core/agents/agent-patch-schema.js

@@ -27,6 +27,7 @@ export function normalizeAgentPatchEnvelope(input) {
         ...(input?.verification_node_id === undefined ? {} : { verification_node_id: String(input.verification_node_id) }),
         ...(input?.rollback_node_id === undefined ? {} : { rollback_node_id: String(input.rollback_node_id) }),
         ...(input?.lease_proof ? { lease_proof: normalizeLeaseProof(input.lease_proof) } : {}),
+        ...(input?.git_worktree ? { git_worktree: normalizeGitWorktreeMetadata(input.git_worktree) } : {}),
         ...(input?.rationale ? { rationale: String(input.rationale) } : {}),
         ...(input?.verification_hint ? { verification_hint: normalizeHint(input.verification_hint) } : {}),
         ...(input?.rollback_hint ? { rollback_hint: normalizeHint(input.rollback_hint) } : {}),
@@ -49,12 +50,14 @@ export function validateAgentPatchEnvelope(envelope) {
         violations.push('lease_id_missing');
     if (!envelope.operations.length)
         violations.push('operations_missing');
-    if (envelope.source && !['fixture', 'model_authored', 'process_generated', 'zellij_generated'].includes(envelope.source))
+    if (envelope.source && !['fixture', 'model_authored', 'process_generated', 'zellij_generated', 'git-worktree-diff'].includes(envelope.source))
         violations.push('source_invalid');
     if (envelope.source === 'model_authored' && !hasFiniteNumber(envelope.backend_child_process_id) && !envelope.backend_sdk_thread_id && !envelope.backend_ollama_request_id)
         violations.push('model_authored_backend_proof_missing');
     if (envelope.source === 'fixture' && envelope.backend_child_process_id !== undefined)
         violations.push('fixture_backend_child_process_id_present');
+    if (envelope.source === 'git-worktree-diff' && !envelope.git_worktree?.worktree_path)
+        violations.push('git_worktree_metadata_missing');
     for (const operation of envelope.operations) {
         if (!operation.path || operation.path.includes('\0') || operation.path.startsWith('/') || operation.path.split(/[\\/]/).includes('..')) {
             violations.push(`invalid_path:${operation.path || 'missing'}`);
@@ -74,7 +77,7 @@ export function validateAgentPatchEnvelope(envelope) {
 }
 function normalizeEnvelopeSource(value) {
     const text = String(value || '');
-    return text === 'fixture' || text === 'model_authored' || text === 'process_generated' || text === 'zellij_generated' ? text : null;
+    return text === 'fixture' || text === 'model_authored' || text === 'process_generated' || text === 'zellij_generated' || text === 'git-worktree-diff' ? text : null;
 }
 function hasFiniteNumber(value) {
     return value !== null && value !== undefined && value !== '' && Number.isFinite(Number(value));
@@ -104,6 +107,17 @@ function normalizeLeaseProof(input) {
         ...(input?.rollback_node_id === undefined ? {} : { rollback_node_id: String(input.rollback_node_id) })
     };
 }
+function normalizeGitWorktreeMetadata(input) {
+    return {
+        main_repo_root: String(input?.main_repo_root || ''),
+        worktree_path: String(input?.worktree_path || ''),
+        branch: input?.branch == null ? null : String(input.branch),
+        base_head: input?.base_head == null ? null : String(input.base_head),
+        worktree_head: input?.worktree_head == null ? null : String(input.worktree_head),
+        changed_files: Array.isArray(input?.changed_files) ? input.changed_files.map(String) : [],
+        diff_bytes: Number(input?.diff_bytes || 0)
+    };
+}
 function normalizeHint(input) {
     return {
         ...(input?.command === undefined ? {} : { command: String(input.command) }),

package/dist/core/agents/agent-proof-evidence.js

@@ -21,6 +21,7 @@ export async function writeAgentProofEvidence(root, input) {
     const scheduler = input.scheduler || await readJson(path.join(root, 'agent-scheduler-state.json'), null);
     const taskGraph = input.partition?.task_graph || await readJson(path.join(root, 'agent-task-graph.json'), null);
     const parallelWritePolicy = input.parallelWritePolicy || await readJson(path.join(root, 'agent-parallel-write-policy.json'), null);
+    const gitWorktreeRuntime = input.gitWorktreeRuntime || await readJson(path.join(root, 'agent-git-worktree-runtime.json'), null);
     const patchQueue = await readJson(path.join(root, 'agent-patch-queue.json'), null);
     const patchQueueEvents = await readTextSafe(path.join(root, 'agent-patch-queue-events.jsonl'));
     const patchMerge = await readJson(path.join(root, 'agent-merge-coordinator-report.json'), null);
@@ -180,6 +181,7 @@ export async function writeAgentProofEvidence(root, input) {
         ...(noSubagentScalingPolicy?.ok === false ? noSubagentScalingPolicy.blockers || ['no_subagent_scaling_policy_not_ok'] : []),
         ...(fastModePropagation?.ok === false ? fastModePropagation.blockers || ['fast_mode_propagation_not_ok'] : []),
         ...(patchSwarm?.ok === false ? patchSwarm.blockers || ['patch_swarm_not_ok'] : []),
+        ...(gitWorktreeRuntime?.required === true && gitWorktreeRuntime?.ok === false ? gitWorktreeRuntime.blockers || ['git_worktree_runtime_not_ok'] : []),
         ...(patchSwarm && !patchQueue ? ['patch_queue_missing'] : []),
         ...(patchSwarm && !patchMerge ? ['patch_merge_report_missing'] : []),
         ...(patchSwarm && !patchApplyResults ? ['patch_apply_results_missing'] : []),
@@ -217,6 +219,7 @@ export async function writeAgentProofEvidence(root, input) {
         // Deployed Core Skill snapshot consulted at route start (read-only; never
         // confers mutation rights). Null when no snapshot is deployed for this route.
         selected_core_skill: input.selectedCoreSkill || null,
+        git_worktree_runtime: gitWorktreeRuntime,
         route_blackbox_kind: input.routeBlackboxKind || (realRouteCommandUsed ? 'actual_route_command' : 'generic_agent_route_standin'),
         real_route_command_used: realRouteCommandUsed,
         native_cli_session_proof: nativeCliSessionProof ? 'native-cli-session-proof.json' : null,

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,6 +94,7 @@ 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: []
@@ -110,7 +116,7 @@ class NativeCliSessionSwarmRecorder {
             });
         }
         const child = spawn(process.execPath, args, {
-            cwd: ctx.opts.cwd || packageRoot(),
+            cwd: workerCwd,
             env: {
                 ...process.env,
                 ...(ctx.opts.env || {}),
@@ -179,6 +185,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 +230,10 @@ 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
         });
         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 +248,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 +333,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 +472,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