sneakoscope 2.0.6 → 2.0.8

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.8** makes the release path DAG-parallel by default and hardens the Naruto/MAD-SKS worktree proof chain. `release:check` now runs a manifest-backed DAG runner with resource-aware scheduling, hermetic per-gate environments, bounded logs, per-gate reports, cache proof, and parallel speed-budget evidence. Git worktree coding now preserves allocation manifests, detects dirty main worktrees, includes untracked content in exported diffs, emits one `git_apply_patch` envelope operation, applies worktree diffs through an integration queue, and locks retained dirty worktrees.
 
 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.8"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "2.0.6"
+version = "2.0.8"
 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.8"),
         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.8",
+  "source_digest": "5009938d20628f783aa7ac19da170d2737fef89481b49d9c8dc3f2f97c0dcf9d",
+  "source_file_count": 2004,
+  "built_at_source_time": 1780739165211
 }

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.8';
 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.8",
+  "package_version": "2.0.8",
   "typescript": true,
   "mjs_runtime_files": 0,
-  "compiled_file_count": 1019,
-  "compiled_js_count": 1019,
+  "compiled_file_count": 1067,
+  "compiled_js_count": 1067,
   "compiled_dts_count": 0,
-  "source_digest": "3947e39c47a565506e9ffd37568ae889bc7943f6dc342b5c357976b840770f94",
-  "source_file_count": 1953,
-  "source_files_hash": "5d6f0e4186fc37279e1cf6de0c6b3c7230123c4a588966f8fda2a9324eb75192",
-  "source_list_hash": "5d6f0e4186fc37279e1cf6de0c6b3c7230123c4a588966f8fda2a9324eb75192",
+  "source_digest": "5009938d20628f783aa7ac19da170d2737fef89481b49d9c8dc3f2f97c0dcf9d",
+  "source_file_count": 2004,
+  "source_files_hash": "045de0cf4e0b27b18838e5826c77f19ee281908588bbfde4a00a448b5a3c03eb",
+  "source_list_hash": "045de0cf4e0b27b18838e5826c77f19ee281908588bbfde4a00a448b5a3c03eb",
   "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",
@@ -506,6 +519,13 @@
     "core/release-parallel-full-coverage.js",
     "core/release/gate-cache.js",
     "core/release/gate-manifest.js",
+    "core/release/release-gate-cache-v2.js",
+    "core/release/release-gate-dag.js",
+    "core/release/release-gate-hermetic-env.js",
+    "core/release/release-gate-node.js",
+    "core/release/release-gate-report.js",
+    "core/release/release-gate-resource-governor.js",
+    "core/release/release-gate-scheduler.js",
     "core/reporting/markdown-table.js",
     "core/research.js",
     "core/responses-retry-policy.js",
@@ -603,6 +623,8 @@
     "core/zellij/zellij-capability.js",
     "core/zellij/zellij-clipboard-config.js",
     "core/zellij/zellij-command.js",
+    "core/zellij/zellij-dashboard-pane.js",
+    "core/zellij/zellij-dashboard-renderer.js",
     "core/zellij/zellij-lane-renderer.js",
     "core/zellij/zellij-lane-runtime.js",
     "core/zellij/zellij-launcher.js",
@@ -814,6 +836,19 @@
     "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-envelope-check.js",
+    "scripts/git-worktree-diff-export-check.js",
+    "scripts/git-worktree-dirty-lock-check.js",
+    "scripts/git-worktree-dirty-main-detection-check.js",
+    "scripts/git-worktree-integration-primary-check.js",
+    "scripts/git-worktree-manager-check.js",
+    "scripts/git-worktree-manifest-append-check.js",
+    "scripts/git-worktree-merge-queue-check.js",
+    "scripts/git-worktree-pool-performance-check.js",
+    "scripts/git-worktree-untracked-diff-check.js",
     "scripts/goal-mode-official-default-check.js",
     "scripts/gpt-final-arbiter-check.js",
     "scripts/gpt-final-arbiter-performance-check.js",
@@ -841,6 +876,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 +930,10 @@
     "scripts/naruto-shadow-clone-swarm-check.js",
     "scripts/naruto-verification-pool-check.js",
     "scripts/naruto-work-graph-check.js",
+    "scripts/naruto-worktree-coding-blackbox.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",
@@ -939,8 +979,11 @@
     "scripts/release-dist-freshness-check.js",
     "scripts/release-dynamic-performance-check.js",
     "scripts/release-gate-budget-check.js",
+    "scripts/release-gate-dag-runner-check.js",
+    "scripts/release-gate-dag-runner.js",
     "scripts/release-gate-existence-audit.js",
     "scripts/release-gate-planner.js",
+    "scripts/release-gate-worker.js",
     "scripts/release-metadata-1-11-check.js",
     "scripts/release-metadata-1-12-check.js",
     "scripts/release-metadata-1-13-check.js",
@@ -952,11 +995,13 @@
     "scripts/release-native-agent-fixture-check.js",
     "scripts/release-parallel-check.js",
     "scripts/release-parallel-full-coverage-check.js",
+    "scripts/release-parallel-speed-budget-check.js",
     "scripts/release-provenance-check.js",
     "scripts/release-readiness-report.js",
     "scripts/release-real-check.js",
     "scripts/release-registry-check.js",
     "scripts/release-runtime-truth-matrix-check.js",
+    "scripts/release-stability-report-check.js",
     "scripts/release-version-truth-check.js",
     "scripts/repo-audit.js",
     "scripts/research-actual-route-backfill-check.js",
@@ -1020,6 +1065,8 @@
     "scripts/wrongness-fixture-check.js",
     "scripts/xai-mcp-capability-check.js",
     "scripts/zellij-capability-check.js",
+    "scripts/zellij-dashboard-pane-check.js",
+    "scripts/zellij-dashboard-watch.js",
     "scripts/zellij-doctor-readiness-check.js",
     "scripts/zellij-lane-renderer-check.js",
     "scripts/zellij-launch-command-truth-check.js",
@@ -1033,6 +1080,7 @@
     "scripts/zellij-ui-design-check.js",
     "scripts/zellij-worker-pane-manager-check.js",
     "scripts/zellij-worker-pane-manager-single-owner-check.js",
+    "scripts/zellij-worker-pane-real-ui-blackbox.js",
     "scripts/zellij-worker-pane-spawn-order-check.js",
     "vendor/openai-codex/latest/hooks/permission-request.command.input.schema.json",
     "vendor/openai-codex/latest/hooks/permission-request.command.output.schema.json",

package/dist/core/agents/agent-command-surface.js

@@ -33,6 +33,8 @@ export function parseAgentCommandArgs(command, args = []) {
     const ollamaBaseUrl = String(readOption(args, '--ollama-base-url', readOption(args, '--local-model-base-url', '')) || '') || null;
     const zellijSessionName = String(readOption(args, '--zellij-session-name', '') || '') || null;
     const zellijPaneWorker = hasFlag(args, '--no-zellij-pane-worker') ? false : hasFlag(args, '--zellij-pane-worker') ? true : undefined;
+    const workerPlacement = String(readOption(args, '--worker-placement', zellijPaneWorker === true ? 'zellij-pane' : '') || '') || undefined;
+    const zellijVisiblePaneCap = Number(readOption(args, '--zellij-visible-pane-cap', process.env.SKS_ZELLIJ_VISIBLE_PANE_CAP || 12));
     const apply = hasFlag(args, '--apply');
     const dryRun = hasFlag(args, '--dry-run') || hasFlag(args, '--dryrun');
     const drain = hasFlag(args, '--drain');
@@ -40,7 +42,7 @@ export function parseAgentCommandArgs(command, args = []) {
     const graceMs = Number(readOption(args, '--grace-ms', 750));
     const killEscalation = hasFlag(args, '--kill-escalation') || !hasFlag(args, '--no-kill-escalation');
     const codexApp = hasFlag(args, '--codex-app');
-    const positionals = positionalArgs(rest, new Set(['--agents', '--target-active-slots', '--work-items', '--minimum-work-items', '--max-queue-expansion', '--concurrency', '--backend', '--route', '--mission', '--mission-id', '--agent', '--lane', '--stale-ms', '--grace-ms', '--profile', '--write-mode', '--max-write-agents', '--patch-entry-id', '--patch-entry', '--service-tier', '--zellij-session-name', '--intake', '--agent-root', '--artifact-dir', '--result-path', '--heartbeat-path', '--patch-envelope-path', '--ollama-model', '--local-model-model', '--ollama-base-url', '--local-model-base-url']));
+    const positionals = positionalArgs(rest, new Set(['--agents', '--target-active-slots', '--work-items', '--minimum-work-items', '--max-queue-expansion', '--concurrency', '--backend', '--route', '--mission', '--mission-id', '--agent', '--lane', '--stale-ms', '--grace-ms', '--profile', '--write-mode', '--max-write-agents', '--patch-entry-id', '--patch-entry', '--service-tier', '--zellij-session-name', '--worker-placement', '--zellij-visible-pane-cap', '--intake', '--agent-root', '--artifact-dir', '--result-path', '--heartbeat-path', '--patch-envelope-path', '--ollama-model', '--local-model-model', '--ollama-base-url', '--local-model-base-url']));
     const missionDefault = action === 'run' || action === 'spawn' || action === 'plan' ? '' : 'latest';
     const positionalMission = action === 'run' || action === 'spawn' || action === 'plan' ? '' : (positionals[0] || '');
     const missionId = String(readOption(args, '--mission', readOption(args, '--mission-id', positionalMission || missionDefault)));
@@ -48,7 +50,7 @@ export function parseAgentCommandArgs(command, args = []) {
     const patchEntryId = String(readOption(args, '--patch-entry-id', readOption(args, '--patch-entry', '')));
     const promptPositionals = positionalMission ? positionals.slice(1) : positionals;
     const prompt = promptPositionals.join(' ').trim() || 'Native agent run';
-    return { command, action, prompt, route, agents, targetActiveSlots, desiredWorkItemCount, minimumWorkItems, maxQueueExpansion, concurrency, backend, backendExplicit, mock, real, readonly, profile, writeMode, applyPatches, dryRunPatches, maxWriteAgents, fastMode, serviceTier, noFast, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, zellijSessionName, zellijPaneWorker, apply, dryRun, drain, staleMs, graceMs, killEscalation, json, missionId, lane, codexApp, patchEntryId };
+    return { command, action, prompt, route, agents, targetActiveSlots, desiredWorkItemCount, minimumWorkItems, maxQueueExpansion, concurrency, backend, backendExplicit, mock, real, readonly, profile, writeMode, applyPatches, dryRunPatches, maxWriteAgents, fastMode, serviceTier, noFast, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, zellijSessionName, zellijPaneWorker, workerPlacement, zellijVisiblePaneCap, apply, dryRun, drain, staleMs, graceMs, killEscalation, json, missionId, lane, codexApp, patchEntryId };
 }
 function hasFlag(args, flag) {
     return args.includes(flag);

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),
@@ -261,7 +280,8 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         backendExplicit: opts.backendExplicit === true,
         noOllama: opts.noOllama === true,
         route,
-        fastModePolicy
+        fastModePolicy,
+        ...(opts.workerPlacement === undefined ? {} : { workerPlacement: String(opts.workerPlacement) })
     });
     await nativeCliSwarm.initialize();
     await setCurrent(root, { mission_id: missionId, mode: 'AGENT', phase: 'AGENT_NATIVE_KERNEL_RUNNING', route_command: routeCommand, native_agent_backend: backend });
@@ -280,6 +300,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 +334,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 +486,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 +523,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         noSubagentScalingPolicy,
         fastModePolicy,
         fastModePropagation,
+        gitWorktreeRuntime,
         triwikiContext,
         selectedCoreSkill,
         localCollaborationPolicy,
@@ -524,6 +568,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 +593,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'}`);
@@ -65,8 +68,10 @@ export function validateAgentPatchEnvelope(envelope) {
             violations.push(`write_content_missing:${operation.path}`);
         if (operation.op === 'unified_diff' && typeof operation.diff !== 'string')
             violations.push(`unified_diff_missing:${operation.path}`);
+        if (operation.op === 'git_apply_patch' && typeof operation.diff !== 'string')
+            violations.push(`git_apply_patch_missing:${operation.path}`);
         const allowedPaths = envelope.allowed_paths?.length ? envelope.allowed_paths : envelope.lease_proof?.allowed_paths;
-        if (allowedPaths?.length && !pathAllowedByLease(operation.path, allowedPaths)) {
+        if (operation.op !== 'git_apply_patch' && allowedPaths?.length && !pathAllowedByLease(operation.path, allowedPaths)) {
             violations.push(`lease_path_not_allowed:${operation.path}`);
         }
     }
@@ -74,13 +79,13 @@ 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));
 }
 function normalizeOperation(input) {
-    const op = input?.op === 'write' ? 'write' : input?.op === 'unified_diff' || input?.op === 'patch' ? 'unified_diff' : 'replace';
+    const op = input?.op === 'write' ? 'write' : input?.op === 'git_apply_patch' ? 'git_apply_patch' : input?.op === 'unified_diff' || input?.op === 'patch' ? 'unified_diff' : 'replace';
     return {
         op,
         path: String(input?.path || ''),
@@ -104,6 +109,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,