jorgex-stack 1.9.46 → 1.9.48

package/dist/cli.js

@@ -1401,11 +1401,6 @@ ${gitReadCommands.map((command) => `- \`${command}\``).join("\n")}
 import path10 from "path";
 import fs7 from "fs";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
-
-// src/lib/git-guard.ts
-var GIT_GUARD_SCRIPT = "block-destructive-git.cjs";
-
-// src/adapters/claude-code.ts
 function yamlString2(value) {
   return JSON.stringify(value);
 }
@@ -1551,16 +1546,6 @@ ${agent.body}`;
     const tools = toolsFor(agent);
     if (tools !== null) lines.push(`tools: ${tools}`);
     lines.push(`model: ${resolveAgentModel(models, agent.name, agent.tier).model}`);
-    if (agent.bash === "full") {
-      lines.push(
-        "hooks:",
-        "  PreToolUse:",
-        '    - matcher: "Bash|PowerShell"',
-        "      hooks:",
-        "        - type: command",
-        `          command: "node \\"{{SCRIPTS_DIR}}/${GIT_GUARD_SCRIPT}\\""`
-      );
-    }
     return [
       {
         file: `${agent.name}.md`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jorgex-stack",
-  "version": "1.9.46",
+  "version": "1.9.48",
   "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/agents/implementer.md

@@ -13,7 +13,7 @@ You implement real changes. You don't stop at analysis, you don't answer with ju
 
 **Mandatory first action**: load the `agent-delegation` skill.
 
-**Never run destructive git** (`reset`, `clean`, `checkout --`, `restore`, `push --force`) — it can discard work or rewrite history. Commit forward; if you think you need to discard or reset repo state, stop and ask the main agent/orchestrator.
+**Ask before destructive git** (`reset`, `clean`, `checkout --`, `restore`, `push --force`) — it can discard work or rewrite history. Prefer commit forward; if you need to discard or reset repo state, ask the main agent/orchestrator first and only proceed with explicit approval.
 
 **Conditional skill**:
 

package/stack/agents/tester.md

@@ -13,7 +13,7 @@ Your job is to produce the strongest testing evidence for the risk—not to maxi
 
 **Mandatory first action**: load the `tdd` and `agent-delegation` skills.
 
-**Never run destructive git** (`reset`, `clean`, `checkout --`, `restore`, `push --force`) — it can discard work or rewrite history. Commit forward; if you think you need to discard or reset repo state, stop and ask the main agent/orchestrator.
+**Ask before destructive git** (`reset`, `clean`, `checkout --`, `restore`, `push --force`) — it can discard work or rewrite history. Prefer commit forward; if you need to discard or reset repo state, ask the main agent/orchestrator first and only proceed with explicit approval.
 
 ## Before acting
 

package/stack/agents/translator.md

@@ -13,7 +13,7 @@ You handle translations, multi-language text and integration with the project's
 
 **Mandatory first action**: load the `agent-delegation` skill.
 
-**Never run destructive git** (`reset`, `clean`, `checkout --`, `restore`, `push --force`) — it can discard work or rewrite history. Commit forward; if you think you need to discard or reset repo state, stop and ask the main agent/orchestrator.
+**Ask before destructive git** (`reset`, `clean`, `checkout --`, `restore`, `push --force`) — it can discard work or rewrite history. Prefer commit forward; if you need to discard or reset repo state, ask the main agent/orchestrator first and only proceed with explicit approval.
 
 **Final output, last of all**: your final report (ending with the Result contract) must be the very last thing you emit. If you need to save anything to memory, do it BEFORE that output — never after.
 

package/stack/config/defaults.json

@@ -162,6 +162,41 @@
         "git.exe *push*": "ask",
         "*/git.exe *push*": "ask",
         "*\\git.exe *push*": "ask",
+        "git *checkout*--*": "ask",
+        "*/git *checkout*--*": "ask",
+        "git.exe *checkout*--*": "ask",
+        "*/git.exe *checkout*--*": "ask",
+        "*\\git.exe *checkout*--*": "ask",
+        "git *checkout* -f*": "ask",
+        "*/git *checkout* -f*": "ask",
+        "git.exe *checkout* -f*": "ask",
+        "*/git.exe *checkout* -f*": "ask",
+        "*\\git.exe *checkout* -f*": "ask",
+        "git *restore*": "ask",
+        "*/git *restore*": "ask",
+        "git.exe *restore*": "ask",
+        "*/git.exe *restore*": "ask",
+        "*\\git.exe *restore*": "ask",
+        "git *switch*--discard-changes*": "ask",
+        "*/git *switch*--discard-changes*": "ask",
+        "git.exe *switch*--discard-changes*": "ask",
+        "*/git.exe *switch*--discard-changes*": "ask",
+        "*\\git.exe *switch*--discard-changes*": "ask",
+        "git *rebase*": "ask",
+        "*/git *rebase*": "ask",
+        "git.exe *rebase*": "ask",
+        "*/git.exe *rebase*": "ask",
+        "*\\git.exe *rebase*": "ask",
+        "* git *checkout*--*": "ask",
+        "* git.exe *checkout*--*": "ask",
+        "* git *checkout* -f*": "ask",
+        "* git.exe *checkout* -f*": "ask",
+        "* git *restore*": "ask",
+        "* git.exe *restore*": "ask",
+        "* git *switch*--discard-changes*": "ask",
+        "* git.exe *switch*--discard-changes*": "ask",
+        "* git *rebase*": "ask",
+        "* git.exe *rebase*": "ask",
         "git -c *": "ask",
         "*/git -c *": "ask",
         "git.exe -c *": "ask",

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(

package/stack/scripts/repair-worktree-config.cjs

@@ -17,8 +17,8 @@
 //
 // Cross-agent (Claude Code / Codex / OpenCode) y cross-platform: node puro, sin deps.
 // Idempotente, INDEPENDIENTE del cwd de escritura (opera con --file sobre rutas absolutas),
-// fail-open y exit 0 SIEMPRE (un guardian nunca debe bloquear una tool). Como el guardian
-// hermano (block-destructive-git.cjs), un fail-open deja rastro en stderr para ser diagnosticable.
+// fail-open y exit 0 SIEMPRE (un guardian nunca debe bloquear una tool): un
+// fail-open deja rastro en stderr para ser diagnosticable.
 
 const { execFileSync } = require("node:child_process");
 const fs = require("node:fs");

package/stack/scripts/block-destructive-git.cjs

@@ -1,110 +0,0 @@
-#!/usr/bin/env node
-// PreToolUse guard (Claude Code): blocks destructive git commands in the
-// subagents that declare it, leaving the main agent unrestricted. Claude Code
-// has no per-subagent command denylist, so this is the documented mechanism
-// (sub-agents docs -> "Conditional rules with hooks"). Reads the PreToolUse
-// payload from stdin and exits 2 to block if any segment of the command would
-// discard work or rewrite history. Best-effort guardrail, not an adversarial
-// sandbox. Fail-open: any read/parse problem allows the command (exit 0) so the
-// guard can never wedge legitimate work — but it logs why, so a silent no-op is
-// diagnosable.
-
-// git global options that sit BETWEEN `git` and the subcommand. Without skipping
-// them, `git -C /repo reset --hard` would slip past a naive `git reset` match.
-const GLOBAL_OPT_WITH_ARG = new Set([
-  "-C", "-c", "--git-dir", "--work-tree", "--namespace", "--exec-path", "--super-prefix", "--config-env",
-]);
-
-const isForceFlag = (token) =>
-  token === "--force" || token === "--force-with-lease" || /^-[a-z]*f[a-z]*$/i.test(token);
-
-/** True if a single command segment is a destructive git invocation. */
-function isDestructiveSegment(segment) {
-  const tokens = segment.trim().split(/\s+/).filter(Boolean);
-  const gitIdx = tokens.indexOf("git");
-  if (gitIdx === -1) return false;
-
-  // Skip leading git global options to reach the real subcommand.
-  let i = gitIdx + 1;
-  while (i < tokens.length) {
-    const token = tokens[i];
-    if (token === "--") break;
-    if (/^(--git-dir|--work-tree|--namespace|--exec-path|--super-prefix|--config-env)=/.test(token)) { i++; continue; }
-    if (GLOBAL_OPT_WITH_ARG.has(token)) { i += 2; continue; } // option + its value
-    if (token.startsWith("-")) { i++; continue; } // any other global flag
-    break;
-  }
-
-  const sub = tokens[i];
-  const rest = tokens.slice(i + 1);
-  if (!sub) return false;
-
-  // Always destructive: discard worktree/index, delete untracked files.
-  if (sub === "reset" || sub === "clean" || sub === "restore") return true;
-  // git switch --discard-changes drops local modifications.
-  if (sub === "switch") return rest.includes("--discard-changes");
-  // git checkout: a branch switch is safe; the discard forms carry "--", a
-  // force flag, or a "." pathspec (git checkout . / git checkout HEAD -- .).
-  if (sub === "checkout") {
-    return rest.includes("--") || rest.includes(".") || rest.some(isForceFlag);
-  }
-  // git push --force / --force-with-lease / -f (incl. bundled like -fq) or a
-  // leading "+" refspec all force-overwrite remote history.
-  if (sub === "push") {
-    return rest.some((t) => isForceFlag(t) || /^\+/.test(t));
-  }
-  return false;
-}
-
-function isDestructive(command) {
-  // Evaluate each command segment independently so a destructive op anywhere in
-  // a compound command is caught (cd x && git reset), without a quoted token in
-  // one command (git commit -m "git reset") leaking into another's match.
-  return command
-    .split(/&&|\|\||[;|\n]/)
-    .some((segment) => isDestructiveSegment(segment));
-}
-
-function extractCommand(payload) {
-  const toolInput = payload && payload.tool_input;
-  const raw = toolInput && (toolInput.command != null ? toolInput.command : toolInput.script);
-  // Codex-style hooks pass argv as an array; normalize like post-pr-review.cjs.
-  if (Array.isArray(raw)) return raw.join(" ");
-  return typeof raw === "string" ? raw : "";
-}
-
-function allow(reason) {
-  if (reason) process.stderr.write(`block-destructive-git: ${reason} (fail-open, allowing)\n`);
-  process.exit(0);
-}
-
-let input = "";
-process.stdin.on("data", (chunk) => {
-  input += chunk;
-});
-process.stdin.on("error", () => allow("stdin error"));
-process.stdin.on("end", () => {
-  let command = "";
-  try {
-    command = extractCommand(JSON.parse(input || "{}"));
-  } catch {
-    allow("unreadable payload");
-    return;
-  }
-  if (command.trim() === "") process.exit(0);
-
-  if (isDestructive(command)) {
-    process.stderr.write(
-      "Blocked: destructive git is not allowed in this subagent " +
-        "(reset / clean / checkout discard / restore / switch --discard-changes / push --force). " +
-        "Don't discard or rewrite repo state — commit forward, or stop and ask the user.\n",
-    );
-    process.exit(2);
-  }
-  process.exit(0);
-});
-
-// Safety nets so the guard can never hang the tool call: resume the stream (some
-// shells need it to emit EOF) and bail out fail-open if stdin never ends.
-process.stdin.resume();
-setTimeout(() => allow("stdin timeout"), 2000).unref();