jorgex-stack 1.9.45 → 1.9.47

package/README.md

@@ -116,7 +116,7 @@ Programmatic mode does **not** provide:
 
 El canon de Stack y el paquete Pi adoptado mantienen una snapshot de 17 árboles de skills con 89 archivos de skill. La identidad, procedencia e integridad del paquete adoptado son autoritativas en `src/lib/pi-runtime-pin.json`.
 
-Pi combines the frozen **snapshot v2** package with a Stack-owned shared projection. The version references that follow describe historical Stack/Pi transitions, not the current pin. The current pin, package integrity and lifecycle are maintained in [docs/references/pi-runtime.md](docs/references/pi-runtime.md) and `src/lib/pi-runtime-pin.json`; this README does not imply a future release.
+Pi combines the frozen **snapshot v2** package with a Stack-owned shared projection. The version references that follow describe historical Stack/Pi transitions, not the current pin. The current pin is the published `jorgex-pi@0.8.23` artifact. Package integrity and lifecycle are maintained in [docs/references/pi-runtime.md](docs/references/pi-runtime.md) and `src/lib/pi-runtime-pin.json`; this README does not imply a future Stack release.
 
 The following command block is retained as historical reference for that transition:
 
@@ -128,11 +128,13 @@ pnpm dlx jorgex-stack@1.9.7 sync --agents pi
 pnpm dlx jorgex-stack@1.9.7 uninstall --agents pi
 ```
 
-Stack downloads the frozen registry tarball, verifies its exact size plus SHA-256/SHA-512, backs up Pi's `settings.json`, and only then asks Pi to install that local file. The exact artifact and integrity values are authoritative in `src/lib/pi-runtime-pin.json`, while the lifecycle remains authoritative in `src/lib/pi-runtime.ts`. Pi's own package-manager invocation is the narrow runtime exception to the repository's pnpm-only rule; the Stack lifecycle never launches npm directly. A managed install then runs `package install → projection install → package sync`: after the package is healthy, Stack projects the shared resources into Pi and invokes Pi's native sync to complete initialization. The projection includes marked `jorgex:system-prompt` and `jorgex:engram-protocol` sections in `~/.pi/agent/AGENTS.md`, canonical skills under `~/.agents/skills`, and `~/.pi/agent/prompts/lean-audit.md`. Pi 0.8.22 registers Context7 through an isolated in-memory HTTP bridge during bootstrap; `available` means configuration permits registration and does not imply an HTTP handshake. A conflict preserves the existing MCP file and blocks managed activation. No MCP configuration or credentials are written. For the file runtimes, Context7, Playwright and DevTools use independent managed sections. The global Playwright package and Chromium cache are shared by the machine; `--playwright-runtimes` controls which runtime receives the guide. The adopted Pi package implements and tests `playwright-handoff-v1` through `PI_CODING_AGENT_DIR/jorgex-pi/playwright.v1.json`. Historical package entries do not describe the current pin. Filters are applied only after this projection exists, so the package does not duplicate shared resources. Package ownership is recorded separately in `~/.jorgex-stack/pi-receipt.json`; projection ownership is recorded in `~/.jorgex-stack/pi-projection-receipt.json`. Package receipts reject manual, duplicate, divergent, partial, corrupt, copied-to-another-scope, or unknown-history state. Projection cleanup requires an exact scope-bound ownership receipt; DevTools conflicts preserve the handoff for review.
+For the current Pi `0.8.23` pin, package identity and runner validation precede projection; the exact pending initialization diagnostic remains provisional until projection and final `sync` complete.
 
-The static `AGENTS.md` projected by Stack does not include Context7; Pi's native bootstrap adds that section after registering the isolated bridge. Pi never writes, owns or removes MCP files. In Claude Code, Codex and OpenCode, a compatible existing Context7 entry is preserved and removed only with explicit canonical Stack ownership.
+Stack downloads the frozen registry tarball, verifies its exact size plus SHA-256/SHA-512, backs up Pi's `settings.json`, and only then asks Pi to install that local file. The exact artifact and integrity values are authoritative in `src/lib/pi-runtime-pin.json`, while the lifecycle remains authoritative in `src/lib/pi-runtime.ts`. Pi's own package-manager invocation is the narrow runtime exception to the repository's pnpm-only rule; the Stack lifecycle never launches npm directly. A managed install then runs `package install → projection install → package sync`: after the package identity and runner are validated, Stack projects the shared resources into Pi and invokes Pi's native sync to complete initialization. The projection includes marked `jorgex:system-prompt` and `jorgex:engram-protocol` sections in `~/.pi/agent/AGENTS.md`, canonical skills under `~/.agents/skills`, and `~/.pi/agent/prompts/lean-audit.md`. Pi 0.8.23 registers Context7 through an isolated in-memory HTTP bridge during bootstrap; `available` means configuration permits registration and does not imply an HTTP handshake. A conflict preserves the existing MCP file and blocks managed activation. No MCP configuration or credentials are written. For the file runtimes, Context7, Playwright and DevTools use independent managed sections. The global Playwright package and Chromium cache are shared by the machine; `--playwright-runtimes` controls which runtime receives the guide. The adopted Pi package implements and tests `playwright-handoff-v1` through `PI_CODING_AGENT_DIR/jorgex-pi/playwright.v1.json`. Historical package entries do not describe the current pin. Filters are applied only after this projection exists, so the package does not duplicate shared resources. Package ownership is recorded separately in `~/.jorgex-stack/pi-receipt.json`; projection ownership is recorded in `~/.jorgex-stack/pi-projection-receipt.json`. Package receipts reject manual, duplicate, divergent, partial, corrupt, copied-to-another-scope, or unknown-history state. Projection cleanup requires an exact scope-bound ownership receipt; DevTools conflicts preserve the handoff for review.
 
-Pi 0.8.22 also seeds `theme=JorgeX`, `quietStartup=true`, and `hideThinkingBlock=true` only for missing fields during first initialization. User changes and deletions are preserved without reseeding. `hideThinkingBlock` changes presentation only; `defaultThinkingLevel` and reasoning remain unchanged. Pi owns only the fields it creates and records in its lifecycle receipt; pre-existing user settings remain unowned. The JorgeX header preserves builtin and custom commands. `Ctrl+O` remains Pi's native tool presentation, with `NO_COLOR` and `JORGEX_PI_MOTION` behavior unchanged; Stack adds no renderer.
+The static `AGENTS.md` projected by Stack does not include Context7; Pi's native bootstrap adds that section after registering the isolated bridge. Pi never writes, owns or removes MCP files. In Claude Code, Codex and OpenCode, a compatible existing Context7 entry is preserved and removed only with explicit canonical Stack ownership. During package installation only, `initialization-diagnostics-v1` permits the exact pending `doctor` envelope described in [the Pi runtime reference](docs/references/pi-runtime.md); it is provisional and does not make Pi healthy. Projection and final `sync` must still complete, and every other unhealthy or malformed result remains blocked.
+
+Pi 0.8.23 also seeds `theme=JorgeX`, `quietStartup=true`, and `hideThinkingBlock=true` only for missing fields during first initialization. User changes and deletions are preserved without reseeding. `hideThinkingBlock` changes presentation only; `defaultThinkingLevel` and reasoning remain unchanged. Pi owns only the fields it creates and records in its lifecycle receipt; pre-existing user settings remain unowned. The JorgeX header preserves builtin and custom commands. `Ctrl+O` remains Pi's native tool presentation, with `NO_COLOR` and `JORGEX_PI_MOTION` behavior unchanged; Stack adds no renderer.
 
 Historically, the published Pi 0.8.0 direct-package snapshot added `work-audit`: the snapshot grew from **17 to 18 skill trees** (96 to 97 files), and the active runtime allowlist grew from **16 to 17 skills**. The historical Pi 0.8.5 snapshot reference records 18 skill trees and 98 files; it does not describe the adopted pin. Reference F2-A is included while the private F1 skills remain preserved. `playwright-cli` remains in the snapshot but inactive because browser automation is a separate opt-in integration.
 

package/dist/cli.js

@@ -6146,16 +6146,16 @@ import { createHash as createHash2 } from "crypto";
 var pi_runtime_pin_default = {
   package: {
     name: "jorgex-pi",
-    version: "0.8.22",
-    source: "npm:jorgex-pi@0.8.22"
+    version: "0.8.23",
+    source: "npm:jorgex-pi@0.8.23"
   },
   provenance: {
-    commit: "462de6f6f52dbc86b6808ed051dd441932974500"
+    commit: "ebb5e6e18e8e9297ffbf7bd53cf6785b952474b9"
   },
   tarball: {
-    bytes: 89140502,
-    sha256: "98fbcffe5ee81e9fd8754dfbb40d786ee7c10251ef7050d68e70808f8de4d1df",
-    sha512: "ef415061fab27328cc1e43238653705bca089d32719034a3e6543da19069d42996d5b799b1f94eac8b2fccd64d97b2440dbf1ddcd1f3d22d9fc45ac0a805a7cd"
+    bytes: 89140657,
+    sha256: "cbe75c7975353c6ed3123a9bd9c3395e18263a49f33f80a607123392ba27a8fd",
+    sha512: "bb6dd4075a25818f301ed73d6b7b1432beca635fb6c130c0b0543844d086475640c41fa1e1e68035f3df97ad3cee52e5de8917b05fe01d7483875ae934e3374d"
   }
 };
 
@@ -6187,7 +6187,8 @@ var PI_RUNTIME_CANDIDATE = {
       "tui-branding-v1",
       "managed-primary-model-v1",
       "quality-receipt-contract-v1",
-      "quality-capabilities-contract-v1"
+      "quality-capabilities-contract-v1",
+      "initialization-diagnostics-v1"
     ],
     runner: {
       bin: "jorgex-pi",
@@ -6338,6 +6339,49 @@ function healthyDoctor(stdout, stderr, packageRunner, candidate) {
     return false;
   }
 }
+function provisionalPendingDoctor(exitCode, stdout, stderr, packageRunner, candidate) {
+  const capabilities = candidate.capabilities ?? PI_RUNTIME_CANDIDATE.contract.capabilities;
+  if (!capabilities.includes("initialization-diagnostics-v1")) return false;
+  if (exitCode !== 1 || stderr !== "" || !stdout.endsWith("\n") || stdout.slice(0, -1).includes("\n")) return false;
+  try {
+    const record = JSON.parse(stdout.slice(0, -1));
+    if (record === null || typeof record !== "object" || Array.isArray(record)) return false;
+    if (JSON.stringify(Object.keys(record).sort()) !== JSON.stringify(["command", "error", "ok", "package", "result", "schemaVersion"])) return false;
+    if (Reflect.get(record, "schemaVersion") !== 1) return false;
+    if (Reflect.get(record, "command") !== "doctor") return false;
+    if (Reflect.get(record, "ok") !== false) return false;
+    const packageValue = Reflect.get(record, "package");
+    if (packageValue === null || typeof packageValue !== "object" || Array.isArray(packageValue)) return false;
+    if (JSON.stringify(Object.keys(packageValue).sort()) !== JSON.stringify(["name", "root", "version"])) return false;
+    if (Reflect.get(packageValue, "name") !== "jorgex-pi") return false;
+    if (Reflect.get(packageValue, "version") !== (candidate.package?.version ?? /^npm:jorgex-pi@([^\s]+)$/.exec(candidate.source)?.[1])) return false;
+    if (path33.resolve(packageRunner) !== path33.resolve(String(Reflect.get(packageValue, "root")), "bin", "jorgex-pi.mjs")) return false;
+    const result = Reflect.get(record, "result");
+    if (result === null || typeof result !== "object" || Array.isArray(result)) return false;
+    if (JSON.stringify(Object.keys(result).sort()) !== JSON.stringify(["checks", "healthy"])) return false;
+    if (Reflect.get(result, "healthy") !== false) return false;
+    const checks = Reflect.get(result, "checks");
+    if (!Array.isArray(checks) || checks.length !== 5) return false;
+    const expectedIds = ["package", "engram", "context7", "permissions", "experience"];
+    for (let index = 0; index < 5; index++) {
+      const check = checks[index];
+      if (check === null || typeof check !== "object" || Array.isArray(check)) return false;
+      if (JSON.stringify(Object.keys(check).sort()) !== JSON.stringify(["id", "status"])) return false;
+      if (Reflect.get(check, "id") !== expectedIds[index]) return false;
+      const status = Reflect.get(check, "status");
+      if (index < 3) {
+        if (status !== "ok") return false;
+      } else if (status !== "ok" && status !== "error") return false;
+    }
+    if (Reflect.get(checks[3], "status") === "ok" && Reflect.get(checks[4], "status") === "ok") return false;
+    const errorValue = Reflect.get(record, "error");
+    if (errorValue === null || typeof errorValue !== "object" || Array.isArray(errorValue)) return false;
+    if (JSON.stringify(Object.keys(errorValue).sort()) !== JSON.stringify(["code", "message", "phase", "remedy"])) return false;
+    return Reflect.get(errorValue, "phase") === "initialization" && Reflect.get(errorValue, "code") === "INITIALIZATION_REQUIRED" && Reflect.get(errorValue, "message") === "Pi initialization is pending: run sync to complete first initialization." && Reflect.get(errorValue, "remedy") === "Run jorgex-pi sync --json and retry.";
+  } catch {
+    return false;
+  }
+}
 function installPiFromVerifiedTarball(input, deps) {
   const paths = input.targetDir === void 0 ? userPaths(input.engramBin, input.piExecutable) : targetPaths(input.targetDir, input.engramBin, input.piExecutable);
   const destination = input.targetDir === void 0 ? path33.join(dataDir(), "packages", `jorgex-pi-${PI_RUNTIME_CANDIDATE.package.version}.tgz`) : path33.join(path33.resolve(input.targetDir), "downloads", `jorgex-pi-${PI_RUNTIME_CANDIDATE.package.version}.tgz`);
@@ -6368,7 +6412,9 @@ function installPiFromVerifiedTarball(input, deps) {
     args: [paths.packageRunner, "doctor", "--json"],
     environment: paths.environment
   });
-  if (doctor.exitCode !== 0 || !healthyDoctor(doctor.stdout, doctor.stderr, paths.packageRunner, input.candidate)) {
+  const healthy = doctor.exitCode === 0 && healthyDoctor(doctor.stdout, doctor.stderr, paths.packageRunner, input.candidate);
+  const pending = provisionalPendingDoctor(doctor.exitCode, doctor.stdout, doctor.stderr, paths.packageRunner, input.candidate);
+  if (!healthy && !pending) {
     return { kind: "blocked", reason: "runner-unhealthy" };
   }
   const receipt = flatCandidateReceipt(input.candidate, scope, "installed", input.engramBin);
@@ -6680,7 +6726,8 @@ async function runPiRuntimeSystem(input) {
         source: PI_RUNTIME_CANDIDATE.package.source,
         ...PI_RUNTIME_CANDIDATE.tarball,
         package: PI_RUNTIME_CANDIDATE.package,
-        provenance: PI_RUNTIME_CANDIDATE.provenance
+        provenance: PI_RUNTIME_CANDIDATE.provenance,
+        capabilities: PI_RUNTIME_CANDIDATE.contract.capabilities
       }
     }, {
       download: () => artifact,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jorgex-stack",
-  "version": "1.9.45",
+  "version": "1.9.47",
   "description": "Harness multi-agente portable: instala la config JorgeX (agentes, skills, hooks, Engram, MCPs) en Claude Code, Codex CLI, OpenCode y Pi",
   "type": "module",
   "license": "MIT",

package/stack/plugins/opencode/worktree.ts

@@ -284,18 +284,6 @@ const truncateMessage = (value: string, maxLength = 1200) => {
   return `${value.slice(0, maxLength)}\n...`;
 };
 
-const parseWorktreePath = (command: string) => {
-  const match = command.match(
-    /git\s+worktree\s+add\s+(?:-[^\s]+\s+)*(?:-b\s+[^\s]+\s+)?(?:"([^"]+)"|'([^']+)'|(\S+))/i,
-  );
-  return match?.[1] || match?.[2] || match?.[3] || null;
-};
-
-const getWorktreeName = (worktreePath: string) => {
-  const segments = toSlashes(worktreePath).split("/").filter(Boolean);
-  return segments[segments.length - 1] || null;
-};
-
 const normalizePath = (value: string) =>
   toSlashes(value).replace(/\/+$/, "");
 
@@ -328,6 +316,132 @@ const isMissingFileError = (error: unknown) => {
   );
 };
 
+// Pre/post validation against real Git state. The Bash command is only a
+// cheap candidate filter; path, branch and detached state come from `git
+// worktree list --porcelain -z` (NUL-separated fields, NUL-terminated
+// records). Repository identity comes from `git rev-parse
+// --path-format=absolute --git-common-dir`, which is shared by every worktree
+// of one repository: it is the sufficient authority, so sibling linked
+// worktrees are admitted and foreign repositories are rejected.
+const isWorktreeAddCommand = (command: string) =>
+  /\bgit\b.*\bworktree\s+add\b/i.test(command);
+
+interface PorcelainWorktree {
+  path: string;
+  branch?: string;
+  detached: boolean;
+}
+
+const NUL = String.fromCharCode(0);
+
+const parsePorcelain = (raw: string): PorcelainWorktree[] => {
+  const text = String(raw);
+  if (!text) throw new Error("Empty porcelain inventory.");
+  if (!text.endsWith(NUL + NUL)) {
+    throw new Error("Truncated porcelain inventory: missing record terminator.");
+  }
+  const chunks = text.split(NUL + NUL);
+  chunks.pop();
+  const entries: PorcelainWorktree[] = [];
+  const seenBranches = new Set<string>();
+  for (const chunk of chunks) {
+    if (!chunk) throw new Error("Malformed porcelain inventory: empty record.");
+    const fields = chunk.split(NUL);
+    const first = fields[0];
+    if (typeof first !== "string" || !first.startsWith("worktree ")) {
+      throw new Error("Malformed porcelain inventory: record without worktree path.");
+    }
+    const worktreePath = first.slice("worktree ".length);
+    if (!worktreePath) {
+      throw new Error("Malformed porcelain inventory: empty worktree path.");
+    }
+    let head: string | undefined;
+    let branch: string | undefined;
+    let sawBranch = false;
+    let detached = false;
+    for (const field of fields.slice(1)) {
+      if (field.startsWith("worktree ")) {
+        throw new Error("Malformed porcelain inventory: nested worktree record.");
+      } else if (field.startsWith("HEAD ")) {
+        if (head !== undefined) {
+          throw new Error("Malformed porcelain inventory: duplicate HEAD.");
+        }
+        head = field;
+      } else if (field.startsWith("branch ")) {
+        if (sawBranch) {
+          throw new Error("Malformed porcelain inventory: duplicate branch.");
+        }
+        sawBranch = true;
+        const ref = field.slice("branch ".length).trim();
+        const prefix = "refs/heads/";
+        if (!ref.startsWith(prefix) || ref.length === prefix.length) {
+          throw new Error("Malformed porcelain inventory: malformed branch ref.");
+        }
+        branch = ref.slice(prefix.length);
+      } else if (field === "detached") {
+        if (detached) {
+          throw new Error("Malformed porcelain inventory: duplicate detached.");
+        }
+        detached = true;
+      }
+      // Any other legitimate optional Git field (bare, locked, prunable, ...)
+      // is accepted as-is.
+    }
+    if (head === undefined) {
+      throw new Error("Malformed porcelain inventory: record without HEAD.");
+    }
+    if (branch !== undefined && detached) {
+      throw new Error("Malformed porcelain inventory: branch with detached HEAD.");
+    }
+    if (branch !== undefined) {
+      if (seenBranches.has(branch)) {
+        throw new Error(`Malformed porcelain inventory: duplicate branch ${branch}.`);
+      }
+      seenBranches.add(branch);
+    }
+    entries.push({ path: toSlashes(worktreePath), branch, detached });
+  }
+  return entries;
+};
+
+const diffNewWorktrees = (
+  pre: PorcelainWorktree[],
+  post: PorcelainWorktree[],
+) => post.filter((postEntry) => !pre.some((preEntry) => samePath(preEntry.path, postEntry.path)));
+
+const getCallID = (input: any, output: any) => {
+  const value =
+    input?.callID ?? input?.callId ?? output?.callID ?? output?.callId;
+  return typeof value === "string" && value ? value : undefined;
+};
+
+const getToolArgs = (input: any, output: any): Record<string, unknown> => {
+  const args = input?.args ?? output?.args;
+  return isPlainObject(args) ? args : {};
+};
+
+interface PendingCapturing {
+  status: "capturing";
+  cwd: string;
+  ambiguous: boolean;
+}
+
+interface PendingReadyCapture {
+  status: "ready";
+  pre: string;
+  repo: string;
+  cwd: string;
+  ambiguous: boolean;
+}
+
+interface PendingFailedCapture {
+  status: "failed";
+  cwd: string;
+  error: string;
+}
+
+type PendingCapture = PendingCapturing | PendingReadyCapture | PendingFailedCapture;
+
 export const WorktreePlugin: Plugin = async ({ $, client, directory }) => {
   let config: WorktreePluginConfig = {
     pathContains: "worktrees/",
@@ -371,12 +485,74 @@ export const WorktreePlugin: Plugin = async ({ $, client, directory }) => {
     }
   }
 
+  const pending = new Map<string, PendingCapture>();
+
+  const readCommonDir = async (cwd: string) =>
+    toSlashes(
+      String(
+        await $`git -C ${cwd} rev-parse --path-format=absolute --git-common-dir`.quiet().text(),
+      ).trim(),
+    );
+
+  const failCapture = async (callID: string, cwd: string, cause: unknown) => {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    pending.set(callID, { status: "failed", cwd, error: truncateMessage(message) });
+    await logToOpenCode(client, "error", "Worktree pre-inventory failed", {
+      error: message,
+    });
+  };
+
   return {
+    "tool.execute.before": async (input: any, output: any) => {
+      try {
+        const tool = String(input?.tool || "").toLowerCase();
+        if (tool !== "bash") return;
+        const args = getToolArgs(input, output);
+        const command = args.command;
+        if (typeof command !== "string" || !isWorktreeAddCommand(command)) return;
+        const callID = getCallID(input, output);
+        if (!callID) return;
+        const commandCwd = getCommandCwd(args, directory);
+        const provisional: PendingCapturing = { status: "capturing", cwd: commandCwd, ambiguous: false };
+        for (const [id, cap] of pending) {
+          if (id !== callID) {
+            if (cap.status === "capturing" || cap.status === "ready") cap.ambiguous = true;
+            provisional.ambiguous = true;
+          }
+        }
+        pending.set(callID, provisional);
+        let preRaw: string;
+        try {
+          preRaw = String(
+            await $`git -C ${commandCwd} worktree list --porcelain -z`.quiet().text(),
+          );
+        } catch (error) {
+          await failCapture(callID, commandCwd, error);
+          return;
+        }
+        let repo: string;
+        try {
+          repo = await readCommonDir(commandCwd);
+          if (!isAbsolutePath(repo)) {
+            throw new Error(`empty repository identity (common-dir) for ${commandCwd}`);
+          }
+        } catch (error) {
+          await failCapture(callID, commandCwd, error);
+          return;
+        }
+        pending.set(callID, { status: "ready", pre: preRaw, repo, cwd: commandCwd, ambiguous: provisional.ambiguous });
+      } catch (error) {
+        await logToOpenCode(client, "error", "Worktree plugin execution failed", {
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    },
     "tool.execute.after": async (input: any, output: any) => {
       try {
-        const tool = (input.tool || "").toLowerCase();
-        const args = input.args || {};
-        const command = args.command || "";
+        const tool = ((input.tool || "") as string).toLowerCase();
+        const args = getToolArgs(input, output);
+        const command =
+          typeof args.command === "string" ? (args.command as string) : "";
 
         const payload = {
           event: "tool.execute.after",
@@ -413,107 +589,254 @@ export const WorktreePlugin: Plugin = async ({ $, client, directory }) => {
 
         if (tool !== "bash") return;
 
-        const commandLower = command.toLowerCase();
-        const pathContains = toSlashes(
-          config.pathContains || "worktrees/",
-        ).toLowerCase();
+        if (!isWorktreeAddCommand(command)) {
+          const stale = getCallID(input, output);
+          if (stale) pending.delete(stale);
+          return;
+        }
 
-        if (!commandLower.includes("git worktree add")) {
+        const callID = getCallID(input, output);
+        const capture = callID ? pending.get(callID) : undefined;
+        if (!callID || !capture) {
+          appendToolOutput(output, [
+            "Worktree creation is ambiguous: missing pre-execution inventory. Skipping setup.",
+            "Run `git worktree list --porcelain` to inspect the current inventory.",
+          ]);
           return;
         }
+        try {
+          if (capture.status === "failed") {
+            appendToolOutput(output, [
+              `Worktree pre-inventory capture failed for ${capture.cwd}; skipping worktree setup.`,
+              "Run `git worktree list --porcelain -z` from the project root and retry.",
+              "Run `git rev-parse --show-toplevel` from the project root and retry.",
+              ...(capture.error ? [`Details: ${capture.error}`] : []),
+            ]);
+            return;
+          }
+
+          if (capture.status === "capturing") {
+            appendToolOutput(output, [
+              "Worktree creation is ambiguous: overlapping candidate commands in the same repository cannot be attributed to a single call. Skipping setup.",
+              "Run `git worktree list --porcelain` to inspect the current inventory.",
+            ]);
+            return;
+          }
+
+          let preList: PorcelainWorktree[];
+          try {
+            preList = parsePorcelain(capture.pre);
+          } catch (error) {
+            appendToolOutput(output, [
+              "Worktree inventory is unreadable; skipping worktree setup.",
+              "Run `git worktree list --porcelain` from the project root and retry.",
+            ]);
+            await logToOpenCode(client, "error", "Worktree inventory parse failed", {
+              error: error instanceof Error ? error.message : String(error),
+            });
+            return;
+          }
 
-        const parsedWorktreePath = parseWorktreePath(command);
-        if (!parsedWorktreePath) return;
+          const exit = output?.metadata?.exit;
+          if (typeof exit !== "number" || exit !== 0) {
+            const ambiguous =
+              exit === undefined || exit === null
+                ? "Worktree command result is ambiguous (missing exit code); skipping worktree setup."
+                : `Worktree command did not succeed (exit ${String(exit)}); skipping worktree setup.`;
+            appendToolOutput(output, [ambiguous]);
+            return;
+          }
 
-        const worktreeName = getWorktreeName(parsedWorktreePath);
-        if (!worktreeName) return;
+          if (capture.ambiguous) {
+            appendToolOutput(output, [
+              "Worktree creation is ambiguous: overlapping candidate commands in the same repository cannot be attributed to a single call. Skipping setup.",
+              "Run `git worktree list --porcelain` to inspect the current inventory.",
+            ]);
+            return;
+          }
 
-        const branchName = worktreeName;
+          const commandCwd = getCommandCwd(args, directory);
+          let postRaw: string;
+          let gitRoot: string;
+          let commonCwd: string;
+          let commonDir: string;
+          try {
+            postRaw = String(
+              await $`git -C ${commandCwd} worktree list --porcelain -z`.quiet().text(),
+            );
+            gitRoot = String(
+              await $`git -C ${commandCwd} rev-parse --show-toplevel`.quiet().text(),
+            )
+              .trim()
+              .replace(/\\/g, "/");
+            commonCwd = await readCommonDir(commandCwd);
+            commonDir = await readCommonDir(directory);
+          } catch (error) {
+            const details = truncateMessage(
+              error instanceof Error ? error.message : String(error),
+            );
+            appendToolOutput(output, [
+              "Worktree plugin could not process this worktree command.",
+              "Run `git rev-parse --show-toplevel` from the project root and retry.",
+              ...(details ? [`Details: ${details}`] : []),
+            ]);
+            await logToOpenCode(client, "error", "Worktree plugin execution failed", {
+              error: error instanceof Error ? error.message : String(error),
+            });
+            return;
+          }
 
-        // .quiet() suppresses stderr to prevent noisy TUI logs from git calls
-        const gitRoot = await $`git rev-parse --show-toplevel`.quiet().text();
-        const projectRoot = String(gitRoot).trim().replace(/\\/g, "/");
-        const commandCwd = getCommandCwd(args, directory);
-        const absoluteWorktreePath = resolvePath(commandCwd, parsedWorktreePath);
-        const expectedWorktreePath = joinProjectPath(
-          projectRoot,
-          `worktrees/${worktreeName}`,
-        );
+          // A concurrent candidate may have started while the post reads above
+          // were in flight and flagged this capture: re-check after every await
+          // and right before attributing effects.
+          if (capture.ambiguous) {
+            appendToolOutput(output, [
+              "Worktree creation is ambiguous: overlapping candidate commands in the same repository cannot be attributed to a single call. Skipping setup.",
+              "Run `git worktree list --porcelain` to inspect the current inventory.",
+            ]);
+            return;
+          }
 
-        const isCanonicalPath = samePath(
-          absoluteWorktreePath,
-          expectedWorktreePath,
-        );
-        if (!isCanonicalPath) {
-          appendToolOutput(output, [
-            `Worktree path is not canonical: ${absoluteWorktreePath}`,
-            `Use the project-local path instead: ${expectedWorktreePath}`,
-            "Canonical rule: <project-root>/worktrees/<canonical-name> or <project-root>/worktrees/<canonical-name>-prNN.",
-          ]);
-        }
+          if (!samePath(commonCwd, capture.repo)) {
+            appendToolOutput(output, [
+              "Worktree creation is ambiguous: repository identity changed between pre- and post-execution inventory. Skipping setup.",
+              "Run `git worktree list --porcelain` to inspect the current inventory.",
+            ]);
+            return;
+          }
 
-        if (configError) {
-          appendToolOutput(output, [configError]);
-          return;
-        }
+          const toplevel = toSlashes(gitRoot).replace(/\/+$/, "");
+          if (!samePath(commonCwd, commonDir)) {
+            appendToolOutput(output, [
+              `Worktree command targets a foreign repository: ${toplevel}. Skipping setup.`,
+              `The plugin directory belongs to a different repository (${normalizePath(directory)}). Run the command inside the project repository.`,
+            ]);
+            return;
+          }
 
-        if (!isCanonicalPath) {
-          return;
-        }
+          let postList: PorcelainWorktree[];
+          try {
+            postList = parsePorcelain(postRaw);
+          } catch (error) {
+            appendToolOutput(output, [
+              "Worktree inventory is unreadable; skipping worktree setup.",
+              "Run `git worktree list --porcelain` from the project root and retry.",
+            ]);
+            await logToOpenCode(client, "error", "Worktree inventory parse failed", {
+              error: error instanceof Error ? error.message : String(error),
+            });
+            return;
+          }
 
-        if (!normalizePath(absoluteWorktreePath).toLowerCase().includes(pathContains)) {
-          return;
-        }
+          const added = diffNewWorktrees(preList, postList);
+          if (added.length !== 1) {
+            appendToolOutput(output, [
+              `Worktree creation is ambiguous: expected 1 new worktree, found ${added.length}. Skipping setup.`,
+              "Run `git worktree list --porcelain` to inspect the current inventory.",
+            ]);
+            return;
+          }
 
-        const setupScript = resolveProjectPath(directory, config.setupScript);
-        if (setupScript) {
-          const setupResult = await runScript(client, directory, setupScript, {
-            payload: {
-              ...payload,
-              worktreePath: absoluteWorktreePath,
-              worktreeName,
-              branchName,
-            },
-            commandArgs: ["-WorktreePath", absoluteWorktreePath],
-            activeWorktreePath: absoluteWorktreePath,
-          });
-
-          if (setupResult.exitCode !== 0) {
-            const setupErrorMessage = truncateMessage(
-              [setupResult.stderr.trim(), setupResult.stdout.trim()]
-                .filter(Boolean)
-                .join("\n\n"),
-            );
+          const created = added[0] as PorcelainWorktree;
+          const branchName = created.detached ? undefined : created.branch;
+          if (!branchName) {
             appendToolOutput(output, [
-              `Worktree setup failed for ${worktreeName}.`,
-              setupErrorMessage || "No additional details from setup script.",
+              created.detached
+                ? "Worktree is detached; skipping setup. Use a branch worktree under <project-root>/worktrees/<branch>."
+                : "Worktree branch could not be determined from Git; skipping setup.",
+              "Run `git worktree list --porcelain` to inspect the current inventory.",
             ]);
-          } else {
+            return;
+          }
+
+          const absoluteWorktreePath = toSlashes(created.path);
+          const projectRoot = toplevel;
+          const expectedWorktreePath = resolvePath(
+            projectRoot,
+            `worktrees/${branchName}`,
+          );
+          const pathContains = toSlashes(
+            config.pathContains || "worktrees/",
+          ).toLowerCase();
+
+          const isCanonicalPath = samePath(
+            absoluteWorktreePath,
+            expectedWorktreePath,
+          );
+          if (!isCanonicalPath) {
             appendToolOutput(output, [
-              `Worktree setup complete: ${worktreeName}`,
+              `Worktree path is not canonical: ${absoluteWorktreePath}`,
+              `Use the project-local path instead: ${expectedWorktreePath}`,
+              "Canonical rule: <project-root>/worktrees/<canonical-name> or <project-root>/worktrees/<canonical-name>-prNN.",
             ]);
           }
-        }
 
-        const reminderLines = (config.reminderLines || []).map((line) =>
-          replaceToken(
+          if (configError) {
+            appendToolOutput(output, [configError]);
+            return;
+          }
+
+          if (!isCanonicalPath) {
+            return;
+          }
+
+          if (!normalizePath(absoluteWorktreePath).toLowerCase().includes(pathContains)) {
+            return;
+          }
+
+          const setupScript = resolveProjectPath(directory, config.setupScript);
+          if (setupScript) {
+            const setupResult = await runScript(client, directory, setupScript, {
+              payload: {
+                ...payload,
+                worktreePath: absoluteWorktreePath,
+                worktreeName: branchName,
+                branchName,
+              },
+              commandArgs: ["-WorktreePath", absoluteWorktreePath],
+              activeWorktreePath: absoluteWorktreePath,
+            });
+
+            if (setupResult.exitCode !== 0) {
+              const setupErrorMessage = truncateMessage(
+                [setupResult.stderr.trim(), setupResult.stdout.trim()]
+                  .filter(Boolean)
+                  .join("\n\n"),
+              );
+              appendToolOutput(output, [
+                `Worktree setup failed for ${branchName}.`,
+                setupErrorMessage || "No additional details from setup script.",
+              ]);
+            } else {
+              appendToolOutput(output, [
+                `Worktree setup complete: ${branchName}`,
+              ]);
+            }
+          }
+
+          const reminderLines = (config.reminderLines || []).map((line) =>
             replaceToken(
-              replaceToken(line, "{worktreeName}", worktreeName),
-              "{worktreePath}",
-              absoluteWorktreePath,
+              replaceToken(
+                replaceToken(line, "{worktreeName}", branchName),
+                "{worktreePath}",
+                absoluteWorktreePath,
+              ),
+              "{branchName}",
+              branchName,
             ),
-            "{branchName}",
-            branchName,
-          ),
-        );
+          );
 
-        if (reminderLines.length > 0) {
-          const banner = [
-            "--------------------------------------------------",
-            ...reminderLines,
-            "--------------------------------------------------",
-          ].join("\n");
-          appendToolOutput(output, [banner]);
+          if (reminderLines.length > 0) {
+            const banner = [
+              "--------------------------------------------------",
+              ...reminderLines,
+              "--------------------------------------------------",
+            ].join("\n");
+            appendToolOutput(output, [banner]);
+          }
+          return;
+        } finally {
+          if (pending.get(callID) === capture) pending.delete(callID);
         }
       } catch (error) {
         const details = truncateMessage(