@kylecheng3146/agent-ops 0.2.8 → 0.3.1

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

@@ -9,13 +9,15 @@ export const COMMAND_NAMES = [
     "task",
     "verify",
     "review",
-    "allow-stop"
+    "allow-stop",
+    "worktree"
 ];
 const COMMAND_SET = new Set(COMMAND_NAMES);
 const SCOPES = new Set(["project", "user"]);
 const PROFILES = new Set(["advisory", "core", "guardrails", "loop"]);
 // opencode is absent: it has no read-only flag, so it cannot review.
 const REVIEW_TARGETS = new Set(["agy", "claude", "codex"]);
+export const WORKTREE_ACTIONS = ["add", "finish", "list", "resume", "remove"];
 export class CliArgumentError extends Error {
     code;
     option;
@@ -82,6 +84,8 @@ export function parseArgs(argv) {
     let rerun = false;
     let helpSeen = false;
     let versionSeen = false;
+    let worktreeName;
+    let force = false;
     for (let index = 0; index < argv.length; index += 1) {
         const token = argv[index];
         if (token === undefined) {
@@ -243,6 +247,12 @@ export function parseArgs(argv) {
                 }
                 yes = true;
                 break;
+            case "--force":
+                if (force) {
+                    duplicate(token);
+                }
+                force = true;
+                break;
             case "--rerun":
                 if (rerun) {
                     duplicate(token);
@@ -292,6 +302,16 @@ export function parseArgs(argv) {
                     action = token;
                     break;
                 }
+                if (command === "worktree" &&
+                    action === undefined &&
+                    WORKTREE_ACTIONS.includes(token)) {
+                    action = token;
+                    break;
+                }
+                if (command === "worktree" && action !== undefined && action !== "list" && worktreeName === undefined) {
+                    worktreeName = token;
+                    break;
+                }
                 if (command !== undefined) {
                     throw new CliArgumentError("CLI_UNEXPECTED_ARGUMENT", `Unexpected argument: ${token}`);
                 }
@@ -346,7 +366,8 @@ export function parseArgs(argv) {
             checkAuthTargets.length > 0 ||
             dryRun ||
             yes ||
-            rerun) {
+            rerun ||
+            force) {
             throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Only --json may be combined with global help or version.");
         }
         command = helpSeen ? "help" : "version";
@@ -357,6 +378,12 @@ export function parseArgs(argv) {
     if (command === "trust" && action === undefined) {
         throw new CliArgumentError("CLI_ACTION_REQUIRED", "The trust command requires one of: status, grant, revoke.");
     }
+    if (command === "worktree" && action === undefined) {
+        throw new CliArgumentError("CLI_ACTION_REQUIRED", `The worktree command requires one of: ${WORKTREE_ACTIONS.join(", ")}.`);
+    }
+    if (command === "worktree" && action !== "list" && worktreeName === undefined) {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", `worktree ${action} requires a worktree name.`);
+    }
     if (command === "task" && action === undefined) {
         throw new CliArgumentError("CLI_ACTION_REQUIRED", "The task command requires one of: create, status, attach, complete, archive, export.");
     }
@@ -369,6 +396,7 @@ export function parseArgs(argv) {
         command !== "verify" &&
         command !== "review" &&
         command !== "allow-stop" &&
+        !(command === "worktree" && sessionId !== undefined && taskId === undefined) &&
         (hasTaskTargetOptions || hasTaskMutationOptions)) {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Task target options may be used only with task or verify.");
     }
@@ -483,9 +511,27 @@ export function parseArgs(argv) {
             yes)) {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "allow-stop requires only --session (and optional --json).");
     }
+    if (command === "worktree" &&
+        (scope !== undefined ||
+            harness !== undefined ||
+            profiles.length > 0 ||
+            hasTaskMutationOptions ||
+            dryRun ||
+            yes ||
+            rerun)) {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "worktree accepts only a name, --session and --json.");
+    }
+    if (force && !(command === "worktree" && action === "remove")) {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--force may be used only with worktree remove.");
+    }
+    if (command === "worktree" && action !== "add" && action !== "resume" && sessionId !== undefined) {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", `worktree ${action} takes the session from the worktree; omit --session.`);
+    }
     return {
         command,
         ...(action === undefined ? {} : { action }),
+        ...(worktreeName === undefined ? {} : { worktreeName }),
+        ...(force ? { force } : {}),
         ...(scope === undefined ? {} : { scope }),
         ...(harness === undefined ? {} : { harness }),
         ...(hookTargets.length === 0 ? {} : { hookTargets }),

package/dist/packages/cli/src/bin.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";
@@ -42,6 +41,9 @@ import { CompletionGateService } from "../../../runtime/src/hooks/completion-gat
 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) {
     try {
@@ -76,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,
@@ -111,16 +90,22 @@ 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);
 }
+async function worktreeDoctorProbe(root) {
+    let statuses;
+    try {
+        statuses = await listWorktrees(worktreeDependencies(), root);
+    }
+    catch {
+        return { status: "PASS", message: "No agent-ops worktrees to inspect." };
+    }
+    return worktreeDoctorResult(statuses, Date.now());
+}
 const argv = process.argv.slice(2);
 function runAgy(args, options = {}) {
     return execFileSync("agy", [...args], {
@@ -167,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, {
@@ -188,7 +173,8 @@ else {
             "task",
             "verify",
             "review",
-            "allow-stop"
+            "allow-stop",
+            "worktree"
         ].map((command) => [command, async (args) => {
                 const root = args.scope === "user"
                     ? process.env.AGENT_OPS_HOME ?? homedir()
@@ -224,6 +210,13 @@ else {
                         confirm: async (plan, trust, warnings) => await confirmInit(plan, trust, warnings)
                     });
                 }
+                if (args.command === "worktree") {
+                    return await runWorktreeCommand({
+                        args,
+                        cwd: root,
+                        deps: worktreeDependencies()
+                    });
+                }
                 if (args.command === "doctor") {
                     const doctorManifest = await installedManifest(root);
                     const config = (await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project")).config;
@@ -307,7 +300,8 @@ else {
                                     }
                                     : { status };
                             },
-                            reviewTarget: async (target, deep) => await probeReviewTarget(target, { cwd: root, deep })
+                            reviewTarget: async (target, deep) => await probeReviewTarget(target, { cwd: root, deep }),
+                            worktrees: async () => await worktreeDoctorProbe(root)
                         },
                         ...(args.checkAuth === true
                             ? { checkReviewTargetAuth: true }
@@ -384,14 +378,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

@@ -29,6 +29,8 @@ Commands:
   review     Run an independent review
   allow-stop Grant one fingerprint-bound completion-gate Stop permit (requires --session)
   agy-run    Run headless agy with a process-exit completion recheck
+  worktree <add|finish|list|resume|remove>
+             Give one session its own Git worktree for parallel work
 
 Options:
   --scope <project|user>
@@ -179,6 +181,35 @@ agent cannot self-authorize it.
 Options:
   --session <id>   Required
   --json
+`,
+    worktree: `Usage: agent-ops worktree <add|finish|resume|remove> <name> [options]
+       agent-ops worktree list [--json]
+
+Give one writing session its own Git worktree, so parallel sessions stop
+voiding each other's verification and review. Run it from the main checkout.
+
+  add <name>   Create .worktrees/<name> on branch agent-ops/<name> from HEAD,
+               copy the ignored agent-ops files and .worktreeinclude matches,
+               inherit trust for an identical config, run worktree.setup, and
+               point the session's completion gate at the new worktree.
+  finish <name>
+               Once its task is complete, fast-forward the main checkout's
+               branch to the worktree's (after a clean rebase and
+               re-verification if the branch moved), record the task in
+               git notes, and remove the worktree. One finish runs at a time.
+  list         Every agent-ops worktree: session, commits ahead, uncommitted
+               changes, task status and last activity.
+  resume <name>
+               Hand a worktree whose session ended to --session <id>.
+  remove <name>
+               Delete the worktree and its branch. Uncommitted or unmerged
+               work needs --force, which the completion gate asks the user
+               about.
+
+Options:
+  --session <id>   add, resume: the conversation that will work there (required)
+  --force          remove: discard uncommitted or unmerged work
+  --json
 `
 };
 function wantsJson(argv) {

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

@@ -47,7 +47,10 @@ export async function runHookCommand(options) {
             ...(stopVerification === undefined ? {} : { stopVerification }),
             ...(options.completionGate === undefined
                 ? {}
-                : { completionGate: options.completionGate })
+                : { completionGate: options.completionGate }),
+            ...(options.worktreeGuard === undefined
+                ? {}
+                : { worktreeGuard: options.worktreeGuard })
         });
         return descriptor.runtime.formatOutput(options.event, result);
     }

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

@@ -0,0 +1,88 @@
+import { okEnvelope } from "../output.js";
+import { addWorktree } from "../../../../runtime/src/parallel/service.js";
+import { finishWorktree } from "../../../../runtime/src/parallel/finish.js";
+import { idleWorktrees, listWorktrees, removeWorktree, resumeWorktree } from "../../../../runtime/src/parallel/manage.js";
+function listText(statuses, now) {
+    if (statuses.length === 0)
+        return "No agent-ops worktrees.";
+    const idle = new Set(idleWorktrees(statuses, now).map(({ record }) => record.name));
+    return statuses.map(({ record, dirty, ahead, taskStatus, lastActivity }) => [
+        `${record.name}${idle.has(record.name) ? " (idle)" : ""}`,
+        `  path: ${record.path}`,
+        `  session: ${record.sessionId}`,
+        `  branch: ${record.branch}, ${ahead} commit(s) ahead of ${record.targetBranch}${dirty ? ", uncommitted changes" : ""}`,
+        `  task: ${taskStatus}`,
+        `  last activity: ${lastActivity}`
+    ].join("\n")).join("\n");
+}
+function addText(result) {
+    const { record } = result;
+    return [
+        `Created worktree ${record.name} for session ${record.sessionId}.`,
+        `Path: ${record.path}`,
+        `Branch: ${record.branch} (from ${record.targetBranch} at ${record.base})`,
+        `Copied: ${result.copied.length === 0 ? "nothing" : result.copied.join(", ")}`,
+        `Trust: ${result.trusted ? "inherited" : "not inherited; run agent-ops trust grant inside the worktree"}`,
+        ...(result.setup.length === 0 ? [] : [`Setup: ${result.setup.join("; ")}`]),
+        "",
+        "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 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" : ""}.`,
+        `Completed and recorded in git notes (refs/notes/agent-ops): ${result.taskIds.join(", ")}.`,
+        `Removed ${record.path}.`,
+        ...result.warnings.map((warning) => `Warning: ${warning}`)
+    ].join("\n");
+}
+export async function runWorktreeCommand(options) {
+    const { args } = options;
+    if (args.action === "list") {
+        const worktrees = await listWorktrees(options.deps, options.cwd);
+        return okEnvelope("WORKTREE_LIST", { worktrees, text: listText(worktrees, Date.now()) });
+    }
+    if (args.action === "resume") {
+        const record = await resumeWorktree(options.deps, {
+            cwd: options.cwd,
+            name: args.worktreeName,
+            sessionId: args.sessionId ?? process.env.AGENT_OPS_SESSION_ID
+        });
+        return okEnvelope("WORKTREE_RESUMED", {
+            record,
+            text: [
+                `Session ${record.sessionId} now owns worktree ${record.name}.`,
+                `Path: ${record.path}`,
+                `- Claude Code: EnterWorktree with path ${record.path}`,
+                `- Codex and agy: run every command with ${record.path} as its working directory`,
+                "Its next Stop is judged against everything already in the worktree."
+            ].join("\n")
+        });
+    }
+    if (args.action === "remove") {
+        const removed = await removeWorktree(options.deps, {
+            cwd: options.cwd,
+            name: args.worktreeName,
+            force: args.force === true
+        });
+        return okEnvelope("WORKTREE_REMOVED", { ...removed, text: `Removed ${removed.record.path} and ${removed.record.branch}.` });
+    }
+    if (args.action === "finish") {
+        const finished = await finishWorktree(options.deps, { cwd: options.cwd, name: args.worktreeName });
+        return okEnvelope("WORKTREE_FINISHED", { ...finished, text: finishText(finished) });
+    }
+    const sessionId = args.sessionId ?? process.env.AGENT_OPS_SESSION_ID;
+    const result = await addWorktree(options.deps, {
+        cwd: options.cwd,
+        name: args.worktreeName,
+        sessionId
+    });
+    return okEnvelope("WORKTREE_CREATED", { ...result, text: addText(result) });
+}

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/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

@@ -9,6 +9,8 @@ import { resolveContainedPath } from "../../../runtime/src/fs/paths.js";
 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";
@@ -208,6 +210,26 @@ function shouldBuildStopVerification(harness, event, config, rawInput) {
     }
     return harnessDescriptor(harness).control.registrations.some(({ capability, support }) => capability === "optional-stop-verify" && support !== "unsupported");
 }
+/**
+ * The gate of one checkout. A session redirected into a worktree is judged by
+ * that worktree's gate, built the same way from the worktree's own config.
+ */
+function completionGateFor(root, config, gitRunner) {
+    return new CompletionGateService({
+        root,
+        config,
+        gitRunner,
+        taskService: new TaskService(new FileTaskStore(join(root, ".agent-ops", "tasks", "state.json"), root)),
+        evidenceStore: new FileEvidenceStore(root, root),
+        forRoot: async (worktree) => {
+            const outcome = await loadProjectHookConfig(worktree);
+            if (outcome.kind !== "loaded" || !outcome.config.features.completionGate.enabled) {
+                throw new Error("The redirected worktree has no enabled completion gate.");
+            }
+            return completionGateFor(worktree, outcome.config, defaultGitRunner(worktree));
+        }
+    });
+}
 /**
  * Runs one hook invocation. Exit code stays zero because native JSON carries
  * decisions; only an explicitly installed agy completion gate fails closed.
@@ -319,13 +341,17 @@ export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
         const completionGate = (harnessId === "agy" || harnessId === "claude") &&
             config.features.completionGate.enabled
             ? dependencies.completionGate ?? {
-                handle: async (normalized) => await new CompletionGateService({
-                    root,
-                    config,
-                    gitRunner,
-                    taskService: new TaskService(new FileTaskStore(join(root, ".agent-ops", "tasks", "state.json"), root)),
-                    evidenceStore: new FileEvidenceStore(root, root)
-                }).handle(normalized)
+                handle: async (normalized) => await completionGateFor(root, config, gitRunner).handle(normalized)
+            }
+            : undefined;
+        const worktreeGuard = config.worktree?.mode === "auto"
+            ? async (write) => {
+                const mainRoot = await resolveMainRoot(gitRunner);
+                return mainRoot === null
+                    ? { action: "continue", status: "UNKNOWN", code: "WORKTREE_GUARD_UNAVAILABLE" }
+                    : 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({
@@ -334,6 +360,7 @@ export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
             stdin: rawInput,
             config,
             trusted,
+            ...(worktreeGuard === undefined ? {} : { worktreeGuard }),
             ...(dependencies.advisory === undefined
                 ? {}
                 : { advisory: dependencies.advisory }),