@kylecheng3146/agent-ops 0.3.0 → 0.3.2

package/dist/packages/cli/src/args.js

@@ -86,6 +86,7 @@ export function parseArgs(argv) {
     let versionSeen = false;
     let worktreeName;
     let force = false;
+    let worktree;
     for (let index = 0; index < argv.length; index += 1) {
         const token = argv[index];
         if (token === undefined) {
@@ -229,6 +230,18 @@ export function parseArgs(argv) {
                 }
                 completionGate = true;
                 break;
+            case "--worktree": {
+                if (worktree !== undefined) {
+                    duplicate(token);
+                }
+                const value = readOptionValue(argv, index, token);
+                if (value !== "auto" && value !== "off") {
+                    throw new CliArgumentError("CLI_INVALID_VALUE", `Worktree mode must be auto or off: ${value}`, token);
+                }
+                worktree = value;
+                index += 1;
+                break;
+            }
             case "--dry-run":
                 if (dryRun) {
                     duplicate(token);
@@ -367,6 +380,7 @@ export function parseArgs(argv) {
             dryRun ||
             yes ||
             rerun ||
+            worktree !== undefined ||
             force) {
             throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Only --json may be combined with global help or version.");
         }
@@ -432,6 +446,9 @@ export function parseArgs(argv) {
     if (completionGate !== undefined && command !== "init") {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--completion-gate may be used only with init.");
     }
+    if (worktree !== undefined && command !== "init" && command !== "update") {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--worktree may be used only with init or update.");
+    }
     if (command === "task") {
         if (harness !== undefined ||
             profiles.length > 0 ||
@@ -551,6 +568,7 @@ export function parseArgs(argv) {
         rerun,
         dryRun,
         json,
-        yes
+        yes,
+        ...(worktree === undefined ? {} : { worktree })
     };
 }

package/dist/packages/cli/src/bin.js

@@ -3,7 +3,7 @@ import { readFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { execFile, execFileSync, spawn } from "node:child_process";
+import { execFileSync, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { commonHarnessAdapters, harnessHookPath, HARNESS_IDS } from "../../../runtime/src/install/harness.js";
 import { agyRuntimeStatus, agyVersionSupported, hookRegistrationDrift, repositoryTrustStatus, smokeAvailabilityStatus } from "../../../runtime/src/install/probes.js";
@@ -12,8 +12,6 @@ import { readRecordedSessionId } from "../../../runtime/src/hooks/codex-loop.js"
 import { NpmRegistryClient } from "../../../runtime/src/registry/npm.js";
 import { TaskService } from "../../../runtime/src/task/service.js";
 import { FileTaskStore } from "../../../runtime/src/task/store.js";
-import { FileTrustStore } from "../../../runtime/src/security/trust.js";
-import { localStatePaths } from "../../../runtime/src/security/permissions.js";
 import { calculateConfigHash } from "../../../runtime/src/config/hash.js";
 import { FileEvidenceStore } from "../../../runtime/src/verify/evidence.js";
 import { calculateSourceFingerprint } from "../../../runtime/src/verify/source-fingerprint.js";
@@ -22,6 +20,7 @@ import { NodeVerificationProcessRunner } from "../../../runtime/src/verify/spawn
 import { runCli } from "./cli.js";
 import { loadEffectiveConfig, repositoryTrust, repositoryTrustBinding } from "./context.js";
 import { runHookProcess } from "./hook-process.js";
+import { gitRunner, trustStore, worktreeDependencies } from "./parallel-deps.js";
 import { selectYesNo, writeBanner } from "./ui.js";
 import { CLI_VERSION } from "./version.js";
 import { createCommandRegistry } from "./commands/index.js";
@@ -43,6 +42,7 @@ import { formatUpdatePlan, runUpdateCommand } from "./commands/update.js";
 import { errorEnvelope } from "./output.js";
 import { runAgyHeadless } from "./agy-headless.js";
 import { runWorktreeCommand } from "./commands/parallel.js";
+import { ensureSessionWorktree, resolveCheckouts } from "../../../runtime/src/parallel/service.js";
 import { listWorktrees, worktreeDoctorResult } from "../../../runtime/src/parallel/manage.js";
 const HOOK_RUNTIME_PATH = fileURLToPath(new URL("./hook-entry.js", import.meta.url));
 async function readOptionalText(path) {
@@ -78,29 +78,6 @@ async function installedManifest(root) {
 async function installedHarness(root) {
     return (await installedManifest(root))?.harness ?? [...HARNESS_IDS];
 }
-function gitRunner(root) {
-    return {
-        run: async (gitArgs) => {
-            try {
-                return {
-                    exitCode: 0,
-                    stdout: execFileSync("git", [...gitArgs], {
-                        cwd: root,
-                        encoding: "buffer",
-                        stdio: ["ignore", "pipe", "ignore"]
-                    })
-                };
-            }
-            catch (error) {
-                const failure = error;
-                return {
-                    exitCode: failure.status ?? 1,
-                    stdout: failure.stdout ?? new Uint8Array()
-                };
-            }
-        }
-    };
-}
 async function confirmInit(plan, trust, warnings = []) {
     writeBanner({
         isTTY: process.stdout.isTTY === true,
@@ -113,59 +90,12 @@ async function confirmPlan(text) {
     process.stdout.write(text);
     return await selectYesNo("Apply this installation plan?", { input: process.stdin, output: process.stdout }, false);
 }
-function trustStore() {
-    const state = localStatePaths(process.env.AGENT_OPS_HOME ?? homedir());
-    return new FileTrustStore(state.trustStore, state.anchorDirectory);
-}
 async function plannedTrustBinding(root, projectConfig) {
     const config = (await loadEffectiveConfig(root, "project", projectConfig)).config;
     return config.verification.commands.length === 0
         ? null
         : await repositoryTrustBinding(root, config, CLI_VERSION);
 }
-function worktreeDependencies() {
-    const gateFor = async (root, config) => new CompletionGateService({
-        root,
-        config,
-        gitRunner: gitRunner(root),
-        taskService: new TaskService(new FileTaskStore(join(root, ".agent-ops", "tasks", "state.json"), root)),
-        evidenceStore: new FileEvidenceStore(root, root)
-    });
-    return {
-        git: async (cwd, gitArgs) => await new Promise((resolve) => {
-            execFile("git", [...gitArgs], { cwd, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 }, (error, stdout, stderr) => resolve({
-                exitCode: error === null ? 0 : typeof error.code === "number" ? error.code : 1,
-                stdout,
-                stderr
-            }));
-        }),
-        loadConfig: async (root) => (await loadEffectiveConfig(root, "project")).config,
-        trust: {
-            status: async (root, config) => await repositoryTrust(root, config, CLI_VERSION),
-            grant: async (root, config) => await trustStore().grant(await repositoryTrustBinding(root, config, CLI_VERSION)),
-            revoke: async (root, config) => {
-                await trustStore().revoke(await repositoryTrustBinding(root, config, CLI_VERSION));
-            }
-        },
-        gate: gateFor,
-        tasks: (root) => new TaskService(new FileTaskStore(join(root, ".agent-ops", "tasks", "state.json"), root)),
-        processRunner: new NodeVerificationProcessRunner(),
-        runSetup: async (cwd, step) => await new Promise((resolve) => {
-            execFile(step.command, [...step.args], {
-                cwd,
-                encoding: "utf8",
-                timeout: step.timeoutMs,
-                maxBuffer: 16 * 1024 * 1024,
-                ...(process.platform === "win32" ? { shell: true } : {})
-            }, (error, stdout, stderr) => resolve({
-                exitCode: error === null
-                    ? 0
-                    : typeof error.code === "number" && error.killed !== true ? error.code : null,
-                output: `${stdout}${stderr}`
-            }));
-        })
-    };
-}
 async function worktreeDoctorProbe(root) {
     let statuses;
     try {
@@ -222,7 +152,7 @@ else if (argv[0] === "hook") {
         stdin: process.stdin,
         writeStdout: (value) => process.stdout.write(value),
         writeStderr: (value) => process.stderr.write(value)
-    }, CLI_VERSION);
+    }, CLI_VERSION, { worktree: worktreeDependencies() });
 }
 else {
     process.exitCode = await runCli(argv, {
@@ -418,6 +348,7 @@ else {
                         trustStore: store,
                         calculateTrustBinding: async (config) => await plannedTrustBinding(root, config),
                         confirm: async (plan, trust) => await confirmPlan(formatUpdatePlan(plan, trust)),
+                        promptWorktree: async (message) => await selectYesNo(message, { input: process.stdin, output: process.stdout }, true),
                         ...(updateArgs.targetVersion === undefined
                             ? {}
                             : { targetVersion: updateArgs.targetVersion })
@@ -448,14 +379,40 @@ else {
                     // run inside a session is never told which session it is in.
                     const sessionId = process.env.AGENT_OPS_SESSION_ID ??
                         await readRecordedSessionId(root);
-                    const policyConfigHash = args.action === "create"
-                        ? calculateConfigHash((await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project")).config)
+                    const createConfig = args.action === "create"
+                        ? (await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project")).config
                         : undefined;
+                    const policyConfigHash = createConfig === undefined
+                        ? undefined
+                        : calculateConfigHash(createConfig);
+                    // Auto mode starts the work where it belongs: a task created from
+                    // the main checkout lands in the session's own worktree.
+                    const worktreeDeps = worktreeDependencies();
+                    const fromMain = createConfig?.worktree?.mode === "auto" &&
+                        args.scope !== "user" &&
+                        await resolveCheckouts(worktreeDeps, root)
+                            .then(({ mainRoot, currentRoot }) => mainRoot === currentRoot)
+                            .catch(() => false);
                     return await runTaskCommand({
                         args,
                         service: taskService,
                         ...(policyConfigHash === undefined ? {} : { policyConfigHash }),
-                        ...(sessionId === undefined ? {} : { sessionId })
+                        ...(sessionId === undefined ? {} : { sessionId }),
+                        ...(fromMain
+                            ? {
+                                sessionWorktree: async (session) => {
+                                    const record = await ensureSessionWorktree(worktreeDeps, {
+                                        cwd: root,
+                                        sessionId: session
+                                    });
+                                    return {
+                                        path: record.path,
+                                        base: record.base,
+                                        service: new TaskService(new FileTaskStore(join(record.path, ".agent-ops", "tasks", "state.json"), record.path))
+                                    };
+                                }
+                            }
+                            : {})
                     });
                 }
                 if (args.command === "review") {

package/dist/packages/cli/src/cli.js

@@ -39,6 +39,7 @@ Options:
   --profile <core|advisory|guardrails|loop>  Repeatable
   --review-target <codex|agy|claude>  Repeatable init option; review pair order
   --completion-gate                  Init only: enable the project-loop completion gate
+  --worktree <auto|off>              Init/update: configure session worktree isolation
   --check-auth                        Doctor only: probe selected review targets'
                                       authentication with one real call
   --check-auth-target <target>        Repeatable doctor filter with --check-auth
@@ -75,6 +76,7 @@ Options:
   --profile <core|advisory|guardrails|loop>  Repeatable
   --review-target <codex|agy|claude>   Repeatable, in fallback-chain order
   --completion-gate                    Enable the project-loop completion gate
+  --worktree <auto|off>                Configure session worktree isolation
   --dry-run                            Print the plan without writing
   --json
   --yes
@@ -114,6 +116,7 @@ Options:
   --scope <project|user>
   --harness <all|both|agy|claude|codex|opencode|comma-separated>
   --target-version <version>   Offline-capable update target
+  --worktree <auto|off>        Configure session worktree isolation
   --dry-run
   --json
   --yes

package/dist/packages/cli/src/commands/init.js

@@ -5,6 +5,7 @@ import { okEnvelope } from "../output.js";
 import { formatOperationPlan } from "../plan-output.js";
 import { toPublicInstallPlan } from "../public-plan.js";
 import { formatTrustChange, planTrustGrant } from "./trust.js";
+import { checkWorktreeEnvWarning, detectWorktreeSetup } from "../../../../runtime/src/install/parallel-setup.js";
 export function formatInstallPlan(plan, trust, warnings = []) {
     const hooks = plan.manifest.hooks ?? [];
     const detectedVerification = plan.detectedVerification;
@@ -14,6 +15,13 @@ export function formatInstallPlan(plan, trust, warnings = []) {
             `Scope: ${plan.scope}`,
             `Harness: ${plan.harness}`,
             `Profiles: ${plan.profiles.join(", ")}`,
+            ...(plan.config.worktree === undefined
+                ? []
+                : [
+                    `Worktree: mode=${plan.config.worktree.mode}${plan.config.worktree.setup && plan.config.worktree.setup.length > 0
+                        ? `, setup=${plan.config.worktree.setup.map((s) => `${s.command} ${s.args.join(" ")}`.trim()).join("; ")}`
+                        : ""}`
+                ]),
             ...(plan.scope === "user" && plan.harness.includes("agy")
                 ? ["Notice: .gemini/GEMINI.md is a shared Gemini rule surface."]
                 : []),
@@ -85,6 +93,11 @@ export async function runInitCommand(options) {
         args.profiles.length === 0) {
         throw new AgentOpsError("INIT_CHOICES_REQUIRED", "Init requires complete scope, harness, and profile choices.");
     }
+    const worktreeConfig = args.worktree === "auto"
+        ? { mode: "auto", setup: await detectWorktreeSetup(options.root) }
+        : args.worktree === "off"
+            ? { mode: "off" }
+            : undefined;
     const plan = await createInstallPlan({
         root: options.root,
         scope: args.scope,
@@ -105,7 +118,10 @@ export async function runInitCommand(options) {
             : { reviewTargets: args.reviewTargets }),
         ...(args.completionGate === undefined
             ? {}
-            : { completionGateEnabled: args.completionGate })
+            : { completionGateEnabled: args.completionGate }),
+        ...(worktreeConfig === undefined
+            ? {}
+            : { worktree: worktreeConfig })
     });
     const trust = await trustChange(options, plan);
     // An installation with no verifier looks finished and is not: every task
@@ -121,7 +137,14 @@ export async function runInitCommand(options) {
                     : ` Detection stopped because — ${plan.verificationBlockers.join("; ")}`)
         ]
         : [];
-    const warnings = [...verificationWarnings, ...(plan.harness.includes("agy") && options.agyWarning !== undefined
+    const worktreeEnvWarning = plan.config.worktree?.mode === "auto"
+        ? await checkWorktreeEnvWarning(options.root)
+        : undefined;
+    const worktreeWarnings = worktreeEnvWarning === undefined ? [] : [worktreeEnvWarning];
+    const warnings = [
+        ...verificationWarnings,
+        ...worktreeWarnings,
+        ...(plan.harness.includes("agy") && options.agyWarning !== undefined
             ? (() => {
                 try {
                     const warning = options.agyWarning();
@@ -131,7 +154,8 @@ export async function runInitCommand(options) {
                     return ["agy could not be probed; run `agent-ops doctor` to verify it."];
                 }
             })()
-            : [])];
+            : [])
+    ];
     if (args.dryRun) {
         return okEnvelope("INIT_PLAN_READY", {
             applied: false,

package/dist/packages/cli/src/commands/parallel.js

@@ -28,16 +28,17 @@ function addText(result) {
         "Work only inside that path from now on:",
         `- Claude Code: EnterWorktree with path ${record.path}`,
         `- Codex and agy: run every command with ${record.path} as its working directory`,
-        `Finish with: commit, agent-ops verify/review/task complete with --base ${record.base},`,
-        `then agent-ops worktree finish ${record.name} from ${record.mainRoot}`,
-        "(Claude Code: ExitWorktree with action keep before finishing)."
+        `Finish with: commit, agent-ops verify and review with --base ${record.base},`,
+        `then agent-ops worktree finish ${record.name} from ${record.mainRoot}, which`,
+        "completes every task in the worktree and merges",
+        "(Claude Code: ExitWorktree with action keep before finishing; do not run task complete in the worktree)."
     ].join("\n");
 }
 function finishText(result) {
     const { record } = result;
     return [
         `Merged ${record.branch} into ${record.targetBranch} at ${result.mergedHead}${result.rebased ? " after a clean rebase and re-verification" : ""}.`,
-        `Task ${result.taskId} is recorded in git notes (refs/notes/agent-ops).`,
+        `Completed and recorded in git notes (refs/notes/agent-ops): ${result.taskIds.join(", ")}.`,
         `Removed ${record.path}.`,
         ...result.warnings.map((warning) => `Warning: ${warning}`)
     ].join("\n");

package/dist/packages/cli/src/commands/review.js

@@ -273,7 +273,7 @@ async function reusableReview(options, sourceFingerprint, context) {
     if (options.root === undefined) {
         return null;
     }
-    const attestation = await findReviewAttestation(options.root, sourceFingerprint);
+    const attestation = await findReviewAttestation(options.root, sourceFingerprint, context?.taskId);
     if (attestation === null || attestation.taskId !== context?.taskId) {
         return null;
     }
@@ -284,7 +284,7 @@ async function reusableReview(options, sourceFingerprint, context) {
         context?.policyConfigHash !== options.policyConfigHash) {
         return null;
     }
-    const artifact = await readReviewReportArtifact(options.root, sourceFingerprint);
+    const artifact = await readReviewReportArtifact(options.root, sourceFingerprint, attestation.taskId);
     if (artifact === null ||
         artifact.taskId !== attestation.taskId ||
         artifact.report === undefined ||
@@ -488,7 +488,7 @@ export async function runReviewCommand(options) {
                     })
                 });
             }
-            await invalidateReviewAttestation(options.root, sourceFingerprint);
+            await invalidateReviewAttestation(options.root, sourceFingerprint, context?.taskId);
             pendingInvalidation = false;
         }
     }
@@ -605,7 +605,9 @@ export async function runReviewCommand(options) {
         await options.tasks.recordEvidence(context.taskId, Object.fromEntries(finalResult.results.map((item) => [
             item.criterionId,
             item.evidence.map((reference) => `review:${finalResult.harness}:${reference}`)
-        ])));
+        ])), 
+        // What `worktree finish` completes this task against.
+        scope?.mode === "base" ? scope.resolvedBase : null);
     }
     const message = finalResult.status === "PASS"
         ? "Independent review passed."

package/dist/packages/cli/src/commands/task.js

@@ -87,7 +87,10 @@ export async function runTaskCommand(options) {
             if (options.args.title === undefined) {
                 throw new AgentOpsError("TASK_TITLE_REQUIRED", "Task creation requires --title.");
             }
-            const record = await options.service.create({
+            const worktree = sessionId === undefined || options.sessionWorktree === undefined
+                ? undefined
+                : await options.sessionWorktree(sessionId);
+            const record = await (worktree?.service ?? options.service).create({
                 title: options.args.title,
                 criteria: (options.args.criteria ?? []).map(parseCriterion),
                 ...(options.policyConfigHash === undefined
@@ -98,9 +101,30 @@ export async function runTaskCommand(options) {
                     : { parentTaskId: options.args.parentTaskId }),
                 ...(sessionId === undefined ? {} : { sessionId })
             });
-            return taskEnvelope(action, "TASK_CREATED", sessionId === undefined
+            const created = taskEnvelope(action, "TASK_CREATED", sessionId === undefined
                 ? `Created task ${record.task.id}.`
-                : `Created and attached task ${record.task.id}.`, record);
+                : record.task.parentTaskId === undefined
+                    ? `Created and attached task ${record.task.id}.`
+                    : `Created subtask ${record.task.id}; the session stays on the top of its task tree.`, record);
+            if (worktree === undefined || created.data === null)
+                return created;
+            return {
+                ...created,
+                data: {
+                    ...created.data,
+                    text: [
+                        `Created in this session's worktree ${worktree.path}.`,
+                        "Work only inside that path from now on:",
+                        `- Claude Code: EnterWorktree with path ${worktree.path}`,
+                        `- Codex and agy: run every command with ${worktree.path} as its working directory`,
+                        `Commit, then run verify and review there with --base ${worktree.base};`,
+                        "then leave the worktree (Claude Code: ExitWorktree with action keep) and run",
+                        "agent-ops worktree finish from the main checkout, which completes the task and merges.",
+                        "",
+                        created.data.text
+                    ].join("\n")
+                }
+            };
         }
         if (action === "status") {
             if (options.args.taskId === undefined && sessionId === undefined) {

package/dist/packages/cli/src/commands/update.js

@@ -1,3 +1,6 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { detectWorktreeSetup } from "../../../../runtime/src/install/parallel-setup.js";
 import { applyUpdatePlan, createUpdatePlan } from "../../../../runtime/src/install/update.js";
 import { okEnvelope } from "../output.js";
 import { formatOperationPlan } from "../plan-output.js";
@@ -10,6 +13,13 @@ export function formatUpdatePlan(plan, trust) {
         metadata: [
             `Target version: ${plan.targetVersion}`,
             `Harness: ${plan.installation.harness.join(", ")}`,
+            ...(plan.installation.config.worktree === undefined
+                ? []
+                : [
+                    `Worktree: mode=${plan.installation.config.worktree.mode}${plan.installation.config.worktree.setup && plan.installation.config.worktree.setup.length > 0
+                        ? `, setup=${plan.installation.config.worktree.setup.map((s) => `${s.command} ${s.args.join(" ")}`.trim()).join("; ")}`
+                        : ""}`
+                ]),
             ...(trust === undefined ? [] : formatTrustChange(trust)),
             `Schema migrations: ${plan.migrationSteps.length === 0
                 ? "none"
@@ -47,7 +57,40 @@ async function trustChange(options, plan) {
         ? { action: "skipped", reason: "no-verification-commands" }
         : await planTrustGrant(binding, options.trustStore);
 }
+async function existingConfigHasWorktree(root) {
+    try {
+        const content = await readFile(join(root, ".agent-ops", "config.json"), "utf8");
+        const parsed = JSON.parse(content);
+        return parsed.worktree !== undefined;
+    }
+    catch {
+        return false;
+    }
+}
 export async function runUpdateCommand(options) {
+    let worktree;
+    if (options.args.worktree === "auto") {
+        worktree = {
+            mode: "auto",
+            setup: await detectWorktreeSetup(options.root)
+        };
+    }
+    else if (options.args.worktree === "off") {
+        worktree = { mode: "off" };
+    }
+    else if (options.args.worktree === undefined &&
+        options.promptWorktree !== undefined &&
+        options.isTTY &&
+        !options.args.yes &&
+        !(await existingConfigHasWorktree(options.root))) {
+        const shouldEnable = await options.promptWorktree("Enable Git worktree isolation for parallel agent sessions?");
+        if (shouldEnable) {
+            worktree = {
+                mode: "auto",
+                setup: await detectWorktreeSetup(options.root)
+            };
+        }
+    }
     const plan = await createUpdatePlan({
         root: options.root,
         adapters: options.adapters,
@@ -57,9 +100,9 @@ export async function runUpdateCommand(options) {
         ...(options.registry === undefined
             ? {}
             : { registry: options.registry }),
-        ...(options.targetVersion === undefined
+        ...((options.targetVersion ?? options.args.targetVersion) === undefined
             ? {}
-            : { targetVersion: options.targetVersion }),
+            : { targetVersion: options.targetVersion ?? options.args.targetVersion }),
         ...(options.toolkitVersion === undefined
             ? {}
             : { toolkitVersion: options.toolkitVersion }),
@@ -68,7 +111,8 @@ export async function runUpdateCommand(options) {
             : { hookRuntimePath: options.hookRuntimePath }),
         ...((options.hookTargets ?? options.args.hookTargets) === undefined
             ? {}
-            : { hookTargets: options.hookTargets ?? options.args.hookTargets })
+            : { hookTargets: options.hookTargets ?? options.args.hookTargets }),
+        ...(worktree === undefined ? {} : { worktree })
     });
     const trust = await trustChange(options, plan);
     if (options.args.dryRun) {

package/dist/packages/cli/src/hook-entry.js

@@ -3,8 +3,9 @@
 //   node <this file> <harness> <event> --managed-by=agent-ops
 import { CLI_VERSION } from "./version.js";
 import { runHookProcess } from "./hook-process.js";
+import { worktreeDependencies } from "./parallel-deps.js";
 process.exitCode = await runHookProcess(process.argv.slice(2), {
     stdin: process.stdin,
     writeStdout: (value) => process.stdout.write(value),
     writeStderr: (value) => process.stderr.write(value)
-}, CLI_VERSION);
+}, CLI_VERSION, { worktree: worktreeDependencies() });

package/dist/packages/cli/src/hook-process.js

@@ -10,6 +10,7 @@ import { redactSecrets } from "../../../runtime/src/security/redact.js";
 import { claudeStopRecursionMarker } from "../../../runtime/src/adapters/claude/input.js";
 import { HARNESS_IDS, harnessDescriptor } from "../../../runtime/src/install/harness.js";
 import { evaluateWorktreeWrite, resolveMainRoot } from "../../../runtime/src/parallel/guard.js";
+import { ensureSessionWorktree } from "../../../runtime/src/parallel/service.js";
 import { CompletionGateService } from "../../../runtime/src/hooks/completion-gate.js";
 import { TaskService } from "../../../runtime/src/task/service.js";
 import { FileTaskStore } from "../../../runtime/src/task/store.js";
@@ -348,7 +349,9 @@ export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
                 const mainRoot = await resolveMainRoot(gitRunner);
                 return mainRoot === null
                     ? { action: "continue", status: "UNKNOWN", code: "WORKTREE_GUARD_UNAVAILABLE" }
-                    : await evaluateWorktreeWrite(mainRoot, write.paths, write.sessionId);
+                    : await evaluateWorktreeWrite(mainRoot, write.paths, write.sessionId, dependencies.worktree === undefined
+                        ? undefined
+                        : async (sessionId) => (await ensureSessionWorktree(dependencies.worktree, { cwd: mainRoot, sessionId })).path);
             }
             : undefined;
         const output = await runHookCommand({

package/dist/packages/cli/src/parallel-deps.js

@@ -0,0 +1,89 @@
+import { execFile, execFileSync } from "node:child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { CompletionGateService } from "../../../runtime/src/hooks/completion-gate.js";
+import { localStatePaths } from "../../../runtime/src/security/permissions.js";
+import { FileTrustStore } from "../../../runtime/src/security/trust.js";
+import { TaskService } from "../../../runtime/src/task/service.js";
+import { FileTaskStore } from "../../../runtime/src/task/store.js";
+import { FileEvidenceStore } from "../../../runtime/src/verify/evidence.js";
+import { NodeVerificationProcessRunner } from "../../../runtime/src/verify/spawn.js";
+import { loadEffectiveConfig, repositoryTrust, repositoryTrustBinding } from "./context.js";
+import { CLI_VERSION } from "./version.js";
+// Shared by the CLI and the hook entry point: Claude Code runs hooks through
+// hook-entry.js, never bin.js, and its worktree guard needs these too.
+export function gitRunner(root) {
+    return {
+        run: async (gitArgs) => {
+            try {
+                return {
+                    exitCode: 0,
+                    stdout: execFileSync("git", [...gitArgs], {
+                        cwd: root,
+                        encoding: "buffer",
+                        stdio: ["ignore", "pipe", "ignore"]
+                    })
+                };
+            }
+            catch (error) {
+                const failure = error;
+                return {
+                    exitCode: failure.status ?? 1,
+                    stdout: failure.stdout ?? new Uint8Array()
+                };
+            }
+        }
+    };
+}
+export function trustStore() {
+    const state = localStatePaths(process.env.AGENT_OPS_HOME ?? homedir());
+    return new FileTrustStore(state.trustStore, state.anchorDirectory);
+}
+export function worktreeDependencies() {
+    const gateFor = async (root, config) => new CompletionGateService({
+        root,
+        config,
+        gitRunner: gitRunner(root),
+        taskService: new TaskService(new FileTaskStore(join(root, ".agent-ops", "tasks", "state.json"), root)),
+        evidenceStore: new FileEvidenceStore(root, root)
+    });
+    return {
+        git: async (cwd, gitArgs) => await new Promise((resolve) => {
+            execFile("git", [...gitArgs], { cwd, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 }, (error, stdout, stderr) => resolve({
+                exitCode: error === null ? 0 : typeof error.code === "number" ? error.code : 1,
+                stdout,
+                stderr
+            }));
+        }),
+        loadConfig: async (root) => (await loadEffectiveConfig(root, "project")).config,
+        trust: {
+            status: async (root, config) => await repositoryTrust(root, config, CLI_VERSION),
+            grant: async (root, config) => await trustStore().grant(await repositoryTrustBinding(root, config, CLI_VERSION)),
+            revoke: async (root, config) => {
+                await trustStore().revoke(await repositoryTrustBinding(root, config, CLI_VERSION));
+            }
+        },
+        gate: gateFor,
+        tasks: (root, base) => new TaskService(new FileTaskStore(join(root, ".agent-ops", "tasks", "state.json"), root), base === undefined ? {} : { completion: {
+                root,
+                gitRunner: gitRunner(root),
+                base,
+                loadConfig: async () => (await loadEffectiveConfig(root, "project")).config
+            } }),
+        processRunner: new NodeVerificationProcessRunner(),
+        runSetup: async (cwd, step) => await new Promise((resolve) => {
+            execFile(step.command, [...step.args], {
+                cwd,
+                encoding: "utf8",
+                timeout: step.timeoutMs,
+                maxBuffer: 16 * 1024 * 1024,
+                ...(process.platform === "win32" ? { shell: true } : {})
+            }, (error, stdout, stderr) => resolve({
+                exitCode: error === null
+                    ? 0
+                    : typeof error.code === "number" && error.killed !== true ? error.code : null,
+                output: `${stdout}${stderr}`
+            }));
+        })
+    };
+}