sneakoscope 2.0.5 → 2.0.7

package/README.md

@@ -16,10 +16,18 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## Current Release
 
-SKS **2.0.5** is a P0 Codex App Fast UI and MAD Zellij worker-pane closure patch on top of the 2.0 execution layer. `sks --mad` now relies on launch-time Fast/high overrides instead of user-level Codex config rewrites, safe Fast UI repair runs through `sks doctor --fix`, provider badges read env/auth/config.toml consistently, and interactive MAD worker panes attach to the real Zellij session as scheduler slots spawn.
+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.
 - `codex-sdk` is the default native agent backend for Team, QA, Research, Naruto, MAD-SKS, and direct agent runs, with every runtime task entering through `runCodexTask`.
 - Codex App UI snapshot, preservation, clobber guard, and doctor repair checks protect host-owned Fast UI/profile settings around `sks --mad`.
 - Provider context resolves `openai`, `codex-lb`, and `codex-app` with badge/fallback surfaces while avoiding private Codex App UI mutation.
@@ -78,7 +86,7 @@ Broader release checks still live behind `npm run release:check`. Detailed relea
   sks xai docs
   ```
 
-- **Quieter update prompts.** The "update available" choice is shown once per conversation and then stays quiet for a short window (default 8 min, `SKS_UPDATE_OFFER_THROTTLE_MS`) instead of repeating on every prompt. The check compares npm latest against source metadata, PATH `sks --version`, and the global npm package, so a completed `npm i -g sneakoscope` clears stale pending/accepted offers.
+- **CLI-only SKS update notices.** Codex App hooks no longer stop normal work to ask for an SKS update. CLI launch surfaces such as `sks --mad` print a non-blocking latest-version notice, `sks update-check` / `sks update check` show the explicit status, and `sks doctor --fix` runs the guarded global SKS update path before repair.
 
 ## Retention And Cleanup
 
@@ -359,7 +367,7 @@ sks --mad --allow-package-install --allow-service-control --allow-network --yes
 
 This syncs existing codex-lb provider auth, creates/uses the `sks-mad-high` xhigh maintenance profile, opens the MAD-SKS permission gate for that Zellij run, starts a same-mission read-only native agent swarm, and launches a Codex CLI layout whose right-side lanes read that MAD ledger. Bare `sks --mad` grants target-project file and shell scope only; add explicit `--allow-*` flags for packages, services, network, Computer Use, browser use, generated assets, file permissions, DB writes, or other high-risk scopes. MAD-SKS is not a DB-only unlock: it is explicit user authorization to widen approved target-project scopes. Catastrophic database wipe/all-row/project-management safeguards remain active, and the pipeline contract still forbids unrequested fallback implementation code.
 
-Before launching, SKS checks npm for a newer `sneakoscope`; answer `y` to update or `n` to continue. Use `--yes` to approve missing dependency installs automatically. Tune MAD swarm startup with `--mad-agents <n>`, `--mad-swarm-work-items <n>`, and `--mad-swarm-backend <backend>`; `--no-mad-swarm` keeps only the cockpit UI if you need a temporary fallback.
+Before launching, SKS checks npm for a newer `sneakoscope` and prints a non-blocking update notice when one is available; use `sks update now` or `sks doctor --fix` when you want SKS to update itself. Use `--yes` to approve missing dependency installs automatically. Tune MAD swarm startup with `--mad-agents <n>`, `--mad-swarm-work-items <n>`, and `--mad-swarm-backend <backend>`; `--no-mad-swarm` keeps only the cockpit UI if you need a temporary fallback.
 
 ### Team Missions
 
@@ -659,7 +667,7 @@ npm ls -g sneakoscope --depth=0
 sks doctor --fix
 ```
 
-Update prompts compare npm latest against the effective installed version from source metadata, PATH `sks --version`, and global npm package metadata. `sks update now` installs through npm global mode instead of mutating the current project's dependencies. If a global update succeeded but an old shim remains earlier on PATH, `sks doctor --fix` can remove duplicate global installs and refresh the managed setup.
+CLI update checks compare npm latest against the effective installed version from source metadata, PATH `sks --version`, and global npm package metadata. Codex App hooks do not force update choices during ordinary work. `sks update now` installs through npm global mode instead of mutating the current project's dependencies, and `sks doctor --fix` runs that guarded global update path before setup/config repair. If a global update succeeded but an old shim remains earlier on PATH, `sks doctor --fix` can remove duplicate global installs and refresh the managed setup.
 
 ### Zellij is missing
 

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "2.0.5"
+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.5"),
+        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.5",
-  "source_digest": "696706cb9d175c4200c967130fbc5e680f4b6c905ec6e7fad5b1671827bcb4cb",
-  "source_file_count": 1948,
-  "built_at_source_time": 1780613485190
+  "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.5';
+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.5",
-  "package_version": "2.0.5",
+  "version": "2.0.7",
+  "package_version": "2.0.7",
   "typescript": true,
   "mjs_runtime_files": 0,
-  "compiled_file_count": 1014,
-  "compiled_js_count": 1014,
+  "compiled_file_count": 1043,
+  "compiled_js_count": 1043,
   "compiled_dts_count": 0,
-  "source_digest": "696706cb9d175c4200c967130fbc5e680f4b6c905ec6e7fad5b1671827bcb4cb",
-  "source_file_count": 1948,
-  "source_files_hash": "50906865545a9076d7b2736ee379a428160a8869749b85ee79c4ddab8eab4b12",
-  "source_list_hash": "50906865545a9076d7b2736ee379a428160a8869749b85ee79c4ddab8eab4b12",
+  "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",
@@ -473,6 +486,8 @@
     "core/ppt-review/slide-issue-extraction.js",
     "core/ppt.js",
     "core/preflight/parallel-preflight-engine.js",
+    "core/product-design-app-server.js",
+    "core/product-design-plugin.js",
     "core/prompt-context-builder.js",
     "core/prompt/prompt-placeholder-guard.js",
     "core/proof-field.js",
@@ -812,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",
@@ -839,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",
@@ -886,11 +909,15 @@
     "scripts/naruto-concurrency-governor-check.js",
     "scripts/naruto-gpt-final-pack-check.js",
     "scripts/naruto-parallel-patch-apply-check.js",
+    "scripts/naruto-readonly-routing-check.js",
     "scripts/naruto-real-local-gpt-final-smoke.js",
     "scripts/naruto-role-distribution-check.js",
     "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",
@@ -916,6 +943,8 @@
     "scripts/prepublish-fast-check.js",
     "scripts/prepublish-release-check-or-fast.js",
     "scripts/priority-full-closure-check.js",
+    "scripts/product-design-auto-install-check.js",
+    "scripts/product-design-plugin-routing-check.js",
     "scripts/prompt-placeholder-guard-check.js",
     "scripts/provider-badge-context-check.js",
     "scripts/provider-context-config-toml-check.js",

package/dist/cli/install-helpers.js

@@ -13,6 +13,7 @@ import { context7ConfigToml, DOLLAR_SKILL_NAMES, GETDESIGN_REFERENCE, hasContext
 import { checkZellijCapability } from '../core/zellij/zellij-capability.js';
 import { reconcileCodexAppUpgradeProcesses } from '../core/codex-app.js';
 import { recordCodexLbHealthEvent } from '../core/codex-lb-circuit.js';
+import { runSksUpdateCheck, runSksUpdateNow } from '../core/update-check.js';
 import { loadCodexLbEnv, writeCodexLbKeychain, codexLbMetadataPath } from '../core/codex-lb/codex-lb-env.js';
 import { buildCodexLbSetupPlan, codexLbPersistenceSummary, installCodexLbShellProfileSnippet, selectedCodexLbPersistenceModes } from '../core/codex-lb/codex-lb-setup.js';
 const DEFAULT_CODEX_APP_PLUGINS = [
@@ -2231,6 +2232,28 @@ export async function maybePromptCodexUpdateForLaunch(args = [], opts = {}) {
         return { status: 'skipped_by_user', latest: latest.version || null, current, command, bin: codex.bin || null };
     return installCodexLatest(command, latest.version, current);
 }
+export async function maybePromptSksUpdateForLaunch(args = [], opts = {}) {
+    if (hasFlag(args, '--json') || hasFlag(args, '--skip-sks-update') || process.env.SKS_SKIP_SKS_UPDATE === '1')
+        return { status: 'skipped' };
+    const label = opts.label || 'SKS launch';
+    const check = await runSksUpdateCheck({ timeoutMs: 5000 }).catch((err) => ({
+        ok: false,
+        update_available: false,
+        latest: null,
+        current: PACKAGE_VERSION,
+        command: null,
+        error: err?.message || String(err)
+    }));
+    if (!check.update_available) {
+        return { status: check.error ? 'unavailable' : 'current', latest: check.latest || null, current: check.current || PACKAGE_VERSION, error: check.error || null };
+    }
+    const command = check.command || `sks update now --version ${check.latest}`;
+    if (shouldAutoApproveInstall(args)) {
+        return runSksUpdateNow({ version: check.latest, timeoutMs: 10 * 60 * 1000, maxOutputBytes: 128 * 1024 });
+    }
+    console.log(`SKS update available before ${label}: ${check.current} -> ${check.latest}. Run when ready: ${command}`);
+    return { status: 'available', latest: check.latest || null, current: check.current || PACKAGE_VERSION, command };
+}
 export function shouldAutoApproveInstall(args = [], env = process.env) {
     if (hasFlag(args, '--from-postinstall') && env.SKS_POSTINSTALL_AUTO_INSTALL_CLI_TOOLS !== '1')
         return false;

package/dist/commands/codex-app.js

@@ -1,11 +1,31 @@
 import { flag } from '../cli/args.js';
 import { printJson } from '../cli/output.js';
-import { codexAccessTokenStatus, codexAppIntegrationStatus, codexChromeExtensionStatus, formatCodexAppStatus } from '../core/codex-app.js';
+import { codexAccessTokenStatus, codexAppIntegrationStatus, codexChromeExtensionStatus, codexProductDesignPluginStatus, formatCodexAppStatus, formatCodexProductDesignPluginStatus } from '../core/codex-app.js';
 import { codexAppRemoteControlCommand } from '../cli/codex-app-command.js';
 export async function run(_command, args = []) {
     const action = args[0] || 'check';
     if (action === 'remote-control' || action === 'remote')
         return codexAppRemoteControlCommand(args.slice(1));
+    if (action === 'product-design' || action === 'design-product' || action === 'ensure-product-design') {
+        const checkOnly = flag(args, '--check-only') || flag(args, '--no-install');
+        const status = await codexProductDesignPluginStatus({
+            autoInstallProductDesign: !checkOnly && (action === 'product-design'
+                || action === 'design-product'
+                || action === 'ensure-product-design'
+                || flag(args, '--install')
+                || flag(args, '--auto-install'))
+        });
+        if (flag(args, '--json')) {
+            printJson(status);
+            if (!status.ok)
+                process.exitCode = 1;
+            return;
+        }
+        console.log(formatCodexProductDesignPluginStatus(status));
+        if (!status.ok)
+            process.exitCode = 1;
+        return;
+    }
     if (action === 'chrome-extension' || action === 'chrome') {
         const status = await codexChromeExtensionStatus();
         if (flag(args, '--json')) {
@@ -32,7 +52,9 @@ export async function run(_command, args = []) {
         return;
     }
     if (action === 'check' || action === 'status') {
-        const status = await codexAppIntegrationStatus();
+        const status = await codexAppIntegrationStatus({
+            autoInstallProductDesign: flag(args, '--install-product-design') || flag(args, '--auto-install-product-design')
+        });
         if (flag(args, '--json')) {
             printJson(status);
             if (!status.ok)
@@ -44,7 +66,7 @@ export async function run(_command, args = []) {
             process.exitCode = 1;
         return;
     }
-    console.error('Usage: sks codex-app check|status|chrome-extension|pat status|remote-control [--json]');
+    console.error('Usage: sks codex-app check|status|product-design [--check-only]|ensure-product-design|chrome-extension|pat status|remote-control [--json]');
     process.exitCode = 1;
 }
 //# sourceMappingURL=codex-app.js.map

package/dist/commands/doctor.js

@@ -18,10 +18,23 @@ import { appendMigrationEvents, hashConfigText } from '../core/migration/migrati
 import { repairCodexAppFastUi } from '../core/codex-app/codex-app-fast-ui-repair.js';
 import { resolveProviderContext } from '../core/provider/provider-context.js';
 import { readLocalModelConfig } from '../core/agents/ollama-worker-config.js';
+import { runSksUpdateNow } from '../core/update-check.js';
 export async function run(_command, args = []) {
+    const doctorFix = flag(args, '--fix');
     let setupRepair = null;
+    const sksUpdate = doctorFix
+        ? await runSksUpdateNow({
+            timeoutMs: 10 * 60 * 1000,
+            maxOutputBytes: 128 * 1024
+        }).catch((err) => ({
+            schema: 'sks.update-now.v1',
+            ok: false,
+            status: 'failed',
+            error: err?.message || String(err)
+        }))
+        : null;
     let migrationPreFix = null;
-    if (flag(args, '--fix')) {
+    if (doctorFix) {
         // Snapshot config content before ANY mutation so the migration journal can
         // record real before/after hashes for the whole --fix transaction.
         migrationPreFix = await captureCodexConfigSnapshot();
@@ -97,7 +110,6 @@ export async function run(_command, args = []) {
             model_provider: null
         }
     }));
-    const doctorFix = flag(args, '--fix');
     const explicitCodexAppUiRepair = flag(args, '--repair-codex-app-ui') || flag(args, '--yes');
     const codexAppUiPlan = await repairCodexAppFastUi(root, {
         apply: false,
@@ -165,7 +177,7 @@ export async function run(_command, args = []) {
     const zellijReadiness = buildZellijReadiness(root, zellij, ready);
     const result = {
         schema: 'sks.doctor-status.v1',
-        ok: ready.ready,
+        ok: ready.ready && (!sksUpdate || sksUpdate.ok !== false),
         root,
         node: { ok: Number(process.versions.node.split('.')[0]) >= 20, version: process.version },
         codex,
@@ -189,7 +201,7 @@ export async function run(_command, args = []) {
         ready,
         sneakoscope: { ok: await exists(`${root}/.sneakoscope`) },
         package: { bytes: pkgBytes, human: formatBytes(pkgBytes) },
-        repair: { setup: setupRepair, codex_config: configRepair, migration_journal: migrationJournal, global_sks_installs: globalSksInstallCleanup }
+        repair: { sks_update: sksUpdate, setup: setupRepair, codex_config: configRepair, migration_journal: migrationJournal, global_sks_installs: globalSksInstallCleanup }
     };
     if (flag(args, '--json')) {
         printJson(result);
@@ -265,6 +277,9 @@ export async function run(_command, args = []) {
     if (migrationJournal?.journal_path) {
         console.log(`Migration journal: ${migrationJournal.journal_path} (${migrationJournal.event_count} events, ${migrationJournal.mutations_without_rollback} without rollback)`);
     }
+    if (sksUpdate) {
+        console.log(`SKS update: ${sksUpdate.status}${sksUpdate.latest ? ` latest ${sksUpdate.latest}` : ''}${sksUpdate.error ? ` (${sksUpdate.error})` : ''}`);
+    }
     if (globalSksInstallCleanup) {
         console.log(`Global SKS installs: kept ${globalSksInstallCleanup.kept?.length ?? 0}, removed ${globalSksInstallCleanup.removed?.filter((entry) => entry.ok).length ?? 0}, source repo exempt ${globalSksInstallCleanup.candidates?.filter((entry) => entry.source_repo_exempt).length ?? 0}`);
     }

package/dist/commands/mad-sks.js

@@ -1,9 +1,9 @@
 import { madHighCommand } from '../core/commands/mad-sks-command.js';
-import { ensureMadLaunchDependencies, formatMadLaunchDependencyAction, maybePromptCodexUpdateForLaunch, maybePromptCodexLbSetupForLaunch } from '../cli/install-helpers.js';
+import { ensureMadLaunchDependencies, formatMadLaunchDependencyAction, maybePromptCodexUpdateForLaunch, maybePromptCodexLbSetupForLaunch, maybePromptSksUpdateForLaunch } from '../cli/install-helpers.js';
 import { PACKAGE_VERSION } from '../core/fsx.js';
 export async function run(_command, args = []) {
     return madHighCommand(['--mad-sks', ...args], {
-        maybePromptSksUpdateForLaunch: async () => ({ status: 'skipped' }),
+        maybePromptSksUpdateForLaunch,
         maybePromptCodexUpdateForLaunch,
         ensureMadLaunchDependencies,
         printDepsInstallAction: (action) => console.error(formatMadLaunchDependencyAction(action)),

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');
@@ -117,6 +121,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
     const strategyCompiled = compileStrategy({
         prompt,
         route,
+        ...(writeCapable ? {} : { writeTargets: [] }),
         agentCount: roster.agent_count,
         visualRequired
     });
@@ -235,12 +240,13 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         rate_limit_delay_ms: backend === 'codex-sdk' ? 250 : 0,
         resource_pressure_warnings: roster.agent_count > roster.concurrency ? ['agents_exceed_concurrency_batches'] : []
     });
+    const effectiveWriteMode = writeCapable ? opts.writeMode || 'off' : 'off';
     const parallelWritePolicy = {
         schema: 'sks.agent-parallel-write-policy.v1',
         generated_at: nowIso(),
         route,
         route_command: routeCommand,
-        write_mode: opts.writeMode || 'off',
+        write_mode: effectiveWriteMode,
         apply_patches: opts.applyPatches === true,
         dry_run_patches: opts.dryRunPatches === true,
         max_write_agents: Number(opts.maxWriteAgents || 0),
@@ -251,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),
@@ -278,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, {
@@ -301,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,
@@ -442,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),
@@ -478,6 +522,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         noSubagentScalingPolicy,
         fastModePolicy,
         fastModePropagation,
+        gitWorktreeRuntime,
         triwikiContext,
         selectedCoreSkill,
         localCollaborationPolicy,
@@ -522,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,
@@ -546,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');
@@ -779,7 +916,7 @@ async function runAgentPatchSwarmRuntime(root, ledgerRoot, input) {
     await queueStore.persistSnapshot();
     const journalSummary = await queueStore.journal.writeSummary();
     const proof = buildAgentPatchProof({ ...proofInput, transactionJournal: journalSummary });
-    const zeroPatchBlockers = input.writeCapable && input.parallelWritePolicy?.write_mode === 'parallel' && pendingEntries.length === 0 && input.parallelWritePolicy?.dry_run_patches !== true
+    const zeroPatchBlockers = input.writeCapable && input.parallelWritePolicy?.write_mode === 'parallel' && pendingEntries.length === 0 && input.dryRun !== true && input.parallelWritePolicy?.dry_run_patches !== true
         ? ['write_mode_parallel_zero_patch_envelopes']
         : [];
     const blockers = [
@@ -870,6 +1007,8 @@ function normalizeVisualLaneCount(value, fallback, maxAgentCount) {
     return Math.max(1, Math.min(maxAgentCount, Math.floor(raw)));
 }
 function isWriteCapableRun(opts) {
+    if (opts.readonly === true)
+        return false;
     return opts.applyPatches === true || opts.dryRunPatches === true || (opts.writeMode !== undefined && opts.writeMode !== 'off');
 }
 function defaultRouteCommand(route) {
@@ -991,6 +1130,7 @@ async function runAgentByBackend(backend, agent, slice, opts) {
             ...sdkWorkerResult,
             backend: 'codex-sdk',
             patch_envelopes: patchEnvelopes,
+            ...(patchEnvelopes.length ? {} : { no_patch_reason: buildDirectNoPatchReason(slice, opts) }),
             codex_child_report: sdkReport,
             codex_sdk_thread: sdkReport,
             model_authored_patch_envelopes: patchEnvelopes.length > 0,
@@ -1027,10 +1167,24 @@ function buildDirectSdkWorkerPrompt(slice) {
         '',
         write.length
             ? `Write-capable slice. Return JSON matching ${CODEX_AGENT_WORKER_RESULT_SCHEMA_ID}; include patch_envelopes for write_paths=${JSON.stringify(write)}. Each patch envelope must include schema, source "model_authored", agent_id, session_id, slot_id, generation_index, task_slice_id, lease_id, allowed_paths, operations, and rationale. Each operation must include op, path, search, replace, content, and diff; use empty strings for operation fields that do not apply.`
-            : `Read-only slice. Return JSON matching ${CODEX_AGENT_WORKER_RESULT_SCHEMA_ID}.`,
+            : `Read-only slice. Return JSON matching ${CODEX_AGENT_WORKER_RESULT_SCHEMA_ID}; do not report pre-existing repository dirtiness as changed_files.`,
         'Required JSON fields: status, summary, findings, changed_files, patch_envelopes, verification, rollback_notes, blockers.'
     ].join('\n');
 }
+function buildDirectNoPatchReason(slice, opts) {
+    const writePathCount = sdkWritePaths(slice, opts).length;
+    return {
+        schema: 'sks.native-cli-worker-no-patch-reason.v1',
+        generated_at: nowIso(),
+        ok: writePathCount === 0,
+        reason: writePathCount ? 'write_capable_task_without_backend_patch_envelope' : 'read_only_or_no_write_paths',
+        route_justification: writePathCount ? 'backend returned no patch envelopes for a write-capable task' : 'task has no write paths',
+        read_only_or_noop_evidence: writePathCount === 0,
+        task_slice_id: slice?.id || null,
+        backend: 'codex-sdk',
+        blockers: writePathCount ? ['write_capable_no_patch_envelope'] : []
+    };
+}
 function sdkWritePaths(slice, opts) {
     return [
         ...(Array.isArray(slice?.write_paths) ? slice.write_paths : []),