jorgex-stack 1.9.73 → 1.9.74

package/stack/plugins/opencode/worktree.ts

@@ -1,4 +1,5 @@
-import type { Plugin } from "@opencode-ai/plugin";
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
 import path from "node:path";
 
 interface WorktreePluginConfig {
@@ -16,31 +17,21 @@ interface ScriptResult {
   scriptPath: string;
 }
 
-const logToOpenCode = async (
-  client: unknown,
-  level: "warn" | "error",
-  message: string,
-  extra?: unknown,
-) => {
-  if (typeof client !== "object" || client === null) return;
-  const app = (client as { app?: unknown }).app;
-  if (typeof app !== "object" || app === null) return;
-  const log = (app as { log?: unknown }).log;
-  if (typeof log !== "function") return;
-
-  const safeExtra =
-    extra instanceof Error
-      ? { message: extra.message, stack: extra.stack }
-      : extra;
+interface RunScriptOptions {
+  payload?: unknown;
+  commandArgs?: string[];
+  activeWorktreePath?: string;
+}
 
-  try {
-    await log.call(app, {
-      body: { service: "hooks", level, message, extra: safeExtra },
-    });
-  } catch {
-    // Logging must not break the OpenCode TUI hook.
-  }
-};
+interface GitResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+// El host v2 llama `shell` a la herramienta de shell; `bash` se conserva como
+// alias porque el nombre observado varía entre builds.
+const SHELL_TOOLS = new Set(["shell", "bash"]);
 
 const isAbsolutePath = (value: string) =>
   /^[a-zA-Z]:[\\/]/.test(value) || value.startsWith("/");
@@ -57,8 +48,7 @@ const joinProjectPath = (directory: string, target: string) => {
 
 const resolvePath = (base: string, target: string) => {
   const api = isWindowsPath(base) || isWindowsPath(target) ? path.win32 : path.posix;
-  const resolved = api.resolve(base, target);
-  return toSlashes(resolved);
+  return toSlashes(api.resolve(base, target));
 };
 
 const resolveProjectPath = (directory: string, target?: string) => {
@@ -69,6 +59,11 @@ const resolveProjectPath = (directory: string, target?: string) => {
 const isPlainObject = (value: unknown): value is Record<string, unknown> =>
   typeof value === "object" && value !== null && !Array.isArray(value);
 
+const commandText = (command: unknown): string => {
+  if (Array.isArray(command)) return command.map(String).join(" ");
+  return typeof command === "string" ? command : "";
+};
+
 const validateConfig = (config: Record<string, unknown>) => {
   for (const field of ["setupScript", "docsReminderScript", "pathContains"]) {
     if (field in config && typeof config[field] !== "string") {
@@ -85,19 +80,6 @@ const validateConfig = (config: Record<string, unknown>) => {
   }
 };
 
-const getPayloadWorktreePath = (payload: unknown) => {
-  if (!isPlainObject(payload)) return undefined;
-
-  const topLevel = payload.activeWorktreePath || payload.worktreePath;
-  if (typeof topLevel === "string" && topLevel) return topLevel;
-
-  const args = payload.args;
-  if (!isPlainObject(args)) return undefined;
-
-  const argPath = args.activeWorktreePath || args.worktreePath;
-  return typeof argPath === "string" && argPath ? argPath : undefined;
-};
-
 const buildScriptEnv = (scriptPath: string, activeWorktreePath?: string) => {
   const env = Object.fromEntries(
     Object.entries(process.env).filter((entry): entry is [string, string] =>
@@ -122,22 +104,13 @@ const buildScriptEnv = (scriptPath: string, activeWorktreePath?: string) => {
   return env;
 };
 
-interface RunScriptOptions {
-  payload?: unknown;
-  commandArgs?: string[];
-  activeWorktreePath?: string;
-}
-
 const runScript = async (
-  client: any,
   directory: string,
   script: string,
   options?: RunScriptOptions,
 ): Promise<ScriptResult> => {
   const payload = options?.payload;
-  const scriptPath = isAbsolutePath(script)
-    ? script
-    : joinProjectPath(directory, script);
+  const scriptPath = isAbsolutePath(script) ? script : joinProjectPath(directory, script);
   const stdin = payload ? JSON.stringify(payload) : "";
   const stdinSource = new Response(stdin);
 
@@ -145,7 +118,6 @@ const runScript = async (
 
   // Resolve bash path: Bun's spawned process may not inherit Git Bash in PATH on Windows
   const resolveBash = (): string => {
-    const fs = require("fs");
     const candidates = [
       "C:/Program Files/Git/usr/bin/bash.exe",
       "C:/Program Files/Git/bin/bash.exe",
@@ -155,7 +127,7 @@ const runScript = async (
     ].filter(Boolean) as string[];
     for (const candidate of candidates) {
       try {
-        if (fs.existsSync(candidate)) return candidate;
+        if (existsSync(candidate)) return candidate;
       } catch {
         /* skip */
       }
@@ -184,21 +156,20 @@ const runScript = async (
   }
 
   if (!command) {
-    const stderr = `Unsupported worktree hook script extension for ${scriptPath}.`;
-    await logToOpenCode(
-      client,
-      "warn",
-      "Unsupported worktree hook script extension",
-      { script, scriptPath },
-    );
-    return { exitCode: 1, stdout: "", stderr, script, scriptPath };
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: `Unsupported worktree hook script extension for ${scriptPath}.`,
+      script,
+      scriptPath,
+    };
   }
 
   try {
-    const activeWorktreePath =
-      options?.activeWorktreePath || getPayloadWorktreePath(payload);
-    const spawnEnv = buildScriptEnv(scriptPath, activeWorktreePath);
-
+    const spawnEnv = buildScriptEnv(
+      scriptPath,
+      options?.activeWorktreePath,
+    );
     const proc = (globalThis as any).Bun.spawn(command, {
       stdin: stdinSource,
       stdout: "pipe",
@@ -213,28 +184,8 @@ const runScript = async (
       proc.exited,
     ]);
 
-    if (exitCode !== 0) {
-      await logToOpenCode(
-        client,
-        "error",
-        "Worktree hook script execution failed",
-        {
-          script,
-          scriptPath,
-          exitCode,
-          stderr: stderr.trim(),
-          stdout: stdout.trim(),
-        },
-      );
-    }
-
     return { exitCode, stdout, stderr, script, scriptPath };
   } catch (error) {
-    await logToOpenCode(client, "error", "Worktree hook script execution failed", {
-      script,
-      scriptPath,
-      error: error instanceof Error ? error.message : String(error),
-    });
     return {
       exitCode: 1,
       stdout: "",
@@ -260,23 +211,23 @@ const extractScriptMessage = (text: string) => {
   }
 };
 
-const appendToolOutput = (output: any, messages: string[]) => {
-  if (!output || messages.length === 0) return;
+// v2 entrega `result.content` como array readonly. Se reemplaza el objeto
+// entero (nunca se muta el original) conservando output/metadata y anexando el
+// aviso como bloque de texto.
+const appendToResult = (event: any, messages: string[]) => {
+  const result = event?.result;
+  if (!result || typeof result !== "object" || messages.length === 0) return;
   const section = messages.join("\n\n");
-  // Built-in tools (bash, edit, read, write) use output.output (string)
-  // MCP tools (github_*, supabase_*) use output.content (array of content blocks)
-  if ("output" in output && typeof output.output === "string") {
-    output.output = output.output ? `${output.output}\n\n${section}` : section;
-  } else if ("content" in output && Array.isArray(output.content)) {
-    output.content.push({ type: "text", text: `\n\n${section}` });
-  } else if ("content" in output && typeof output.content === "string") {
-    output.content = output.content
-      ? `${output.content}\n\n${section}`
-      : section;
-  } else {
-    output.output = section;
-    output.content = section;
-  }
+  const current = result.content;
+  const base = Array.isArray(current)
+    ? current
+    : typeof current === "string" && current
+      ? [{ type: "text", text: current }]
+      : [];
+  event.result = {
+    ...result,
+    content: [...base, { type: "text", text: `\n\n${section}` }],
+  };
 };
 
 const truncateMessage = (value: string, maxLength = 1200) => {
@@ -284,8 +235,7 @@ const truncateMessage = (value: string, maxLength = 1200) => {
   return `${value.slice(0, maxLength)}\n...`;
 };
 
-const normalizePath = (value: string) =>
-  toSlashes(value).replace(/\/+$/, "");
+const normalizePath = (value: string) => toSlashes(value).replace(/\/+$/, "");
 
 const samePath = (left: string, right: string) => {
   const normalizedLeft = normalizePath(left);
@@ -296,12 +246,6 @@ const samePath = (left: string, right: string) => {
   return normalizedLeft === normalizedRight;
 };
 
-const getCommandCwd = (args: Record<string, unknown>, directory: string) => {
-  const cwd = args.workdir || args.cwd;
-  if (typeof cwd !== "string" || cwd.length === 0) return directory;
-  return isAbsolutePath(cwd) ? cwd : resolvePath(directory, cwd);
-};
-
 const replaceToken = (value: string, token: string, replacement: string) =>
   value.split(token).join(replacement);
 
@@ -316,6 +260,33 @@ const isMissingFileError = (error: unknown) => {
   );
 };
 
+// El cwd del servidor es compartido. La sesión aporta el directorio del
+// proyecto; `input.workdir` (relativo o absoluto) afina el comando concreto.
+const resolveSessionDirectory = async (
+  ctx: any,
+  sessionID: unknown,
+): Promise<string | undefined> => {
+  if (!ctx?.session || typeof ctx.session.get !== "function") return undefined;
+  if (typeof sessionID !== "string" || !sessionID) return undefined;
+  try {
+    const session = await ctx.session.get({ sessionID });
+    const directory = session?.location?.directory;
+    return typeof directory === "string" && directory ? directory : undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+const resolveDirectories = async (ctx: any, event: any) => {
+  const base = await resolveSessionDirectory(ctx, event?.sessionID);
+  const workdir = event?.input?.workdir;
+  if (typeof workdir === "string" && workdir) {
+    if (isAbsolutePath(workdir)) return { base, command: workdir };
+    return { base, command: base ? resolvePath(base, workdir) : undefined };
+  }
+  return { base, command: base };
+};
+
 // 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
@@ -409,15 +380,74 @@ const diffNewWorktrees = (
   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 MAX_BUFFER = 32 * 1024 * 1024;
+
+const runGit = (args: string[], cwd: string): Promise<GitResult> =>
+  new Promise((resolve) => {
+    execFile(
+      "git",
+      args,
+      { cwd, encoding: "utf8", maxBuffer: MAX_BUFFER },
+      (error, stdout, stderr) => {
+        const exitCode =
+          error && typeof (error as { code?: unknown }).code === "number"
+            ? (error as { code: number }).code
+            : error
+              ? 1
+              : 0;
+        resolve({ stdout: stdout ?? "", stderr: stderr ?? "", exitCode });
+      },
+    );
+  });
+
+const gitText = async (args: string[], cwd: string): Promise<string> => {
+  const { stdout, stderr, exitCode } = await runGit(args, cwd);
+  if (exitCode !== 0) {
+    throw new Error(
+      stderr.trim() || `git ${args.join(" ")} failed with exit code ${exitCode}`,
+    );
+  }
+  return stdout;
 };
 
-const getToolArgs = (input: any, output: any): Record<string, unknown> => {
-  const args = input?.args ?? output?.args;
-  return isPlainObject(args) ? args : {};
+const readPorcelain = (cwd: string) =>
+  gitText(["worktree", "list", "--porcelain", "-z"], cwd);
+
+const readCommonDir = async (cwd: string) =>
+  toSlashes(
+    (await gitText(["rev-parse", "--path-format=absolute", "--git-common-dir"], cwd)).trim(),
+  );
+
+const defaultConfig = (): WorktreePluginConfig => ({
+  pathContains: "worktrees/",
+  reminderLines: [],
+});
+
+const readWorktreeConfig = async (
+  directory: string,
+): Promise<{ config: WorktreePluginConfig; error?: string }> => {
+  try {
+    const configFile = (globalThis as any).Bun.file(`${directory}/.opencode/worktree.json`);
+    if (typeof configFile.exists === "function" && !(await configFile.exists())) {
+      return { config: defaultConfig() };
+    }
+    const parsed = JSON.parse(await configFile.text()) as unknown;
+    if (!isPlainObject(parsed)) {
+      return { config: defaultConfig(), error: "Worktree config must be a JSON object." };
+    }
+    const error = validateConfig(parsed);
+    if (error) return { config: defaultConfig(), error };
+    return { config: { ...defaultConfig(), ...(parsed as WorktreePluginConfig) } };
+  } catch (error) {
+    if (isMissingFileError(error)) return { config: defaultConfig() };
+    const couldNotParse = error instanceof SyntaxError;
+    return {
+      config: defaultConfig(),
+      error: couldNotParse
+        ? "Worktree config could not be parsed as JSON."
+        : "Worktree config could not be read.",
+    };
+  }
 };
 
 interface PendingCapturing {
@@ -442,94 +472,52 @@ interface PendingFailedCapture {
 
 type PendingCapture = PendingCapturing | PendingReadyCapture | PendingFailedCapture;
 
-export const WorktreePlugin: Plugin = async ({ $, client, directory }) => {
-  let config: WorktreePluginConfig = {
-    pathContains: "worktrees/",
-    reminderLines: [],
-  };
-  let configError: string | undefined;
-
-  try {
-    const configPath = `${directory}/.opencode/worktree.json`;
-    const configFile = (globalThis as any).Bun.file(configPath);
-    if (
-      typeof configFile.exists === "function" &&
-      !(await configFile.exists())
-    ) {
-      // Optional project config.
-    } else {
-      const parsed = JSON.parse(await configFile.text()) as unknown;
-      if (!isPlainObject(parsed)) {
-        configError = "Worktree config must be a JSON object.";
-      } else {
-        configError = validateConfig(parsed);
-        if (!configError) {
-          config = { ...config, ...(parsed as WorktreePluginConfig) };
-        }
-      }
-    }
-  } catch (error) {
-    if (!isMissingFileError(error)) {
-      const couldNotParse = error instanceof SyntaxError;
-      configError = couldNotParse
-        ? "Worktree config could not be parsed as JSON."
-        : "Worktree config could not be read.";
-      await logToOpenCode(
-        client,
-        "warn",
-        couldNotParse
-          ? "Worktree config could not be parsed"
-          : "Worktree config could not be read",
-        error,
-      );
-    }
-  }
+const AMBIGUOUS_MESSAGES = (reason: string) => [
+  reason,
+  "Run `git worktree list --porcelain` to inspect the current inventory.",
+];
 
-  const pending = new Map<string, PendingCapture>();
+export default {
+  id: "stack-worktree",
 
-  const readCommonDir = async (cwd: string) =>
-    toSlashes(
-      String(
-        await $`git -C ${cwd} rev-parse --path-format=absolute --git-common-dir`.quiet().text(),
-      ).trim(),
-    );
+  async setup(ctx: any) {
+    const pending = new Map<string, PendingCapture>();
 
-  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,
-    });
-  };
+    const failCapture = (id: string, cwd: string, cause: unknown) => {
+      const message = cause instanceof Error ? cause.message : String(cause);
+      pending.set(id, { status: "failed", cwd, error: truncateMessage(message) });
+    };
 
-  return {
-    "tool.execute.before": async (input: any, output: any) => {
+    const handleBefore = async (event: 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 (!SHELL_TOOLS.has(String(event?.tool ?? "").toLowerCase())) return;
+        if (!isWorktreeAddCommand(commandText(event?.input?.command))) return;
+        const id = typeof event?.id === "string" ? event.id : "";
+        if (!id) return;
+        const { command: commandCwd } = await resolveDirectories(ctx, event);
+        if (!commandCwd) return;
+
+        const provisional: PendingCapturing = {
+          status: "capturing",
+          cwd: commandCwd,
+          ambiguous: false,
+        };
+        for (const [otherId, cap] of pending) {
+          if (otherId !== id) {
             if (cap.status === "capturing" || cap.status === "ready") cap.ambiguous = true;
             provisional.ambiguous = true;
           }
         }
-        pending.set(callID, provisional);
+        pending.set(id, provisional);
+
         let preRaw: string;
         try {
-          preRaw = String(
-            await $`git -C ${commandCwd} worktree list --porcelain -z`.quiet().text(),
-          );
+          preRaw = await readPorcelain(commandCwd);
         } catch (error) {
-          await failCapture(callID, commandCwd, error);
+          failCapture(id, commandCwd, error);
           return;
         }
+
         let repo: string;
         try {
           repo = await readCommonDir(commandCwd);
@@ -537,76 +525,66 @@ export const WorktreePlugin: Plugin = async ({ $, client, directory }) => {
             throw new Error(`empty repository identity (common-dir) for ${commandCwd}`);
           }
         } catch (error) {
-          await failCapture(callID, commandCwd, error);
+          failCapture(id, 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),
+
+        pending.set(id, {
+          status: "ready",
+          pre: preRaw,
+          repo,
+          cwd: commandCwd,
+          ambiguous: provisional.ambiguous,
         });
+      } catch {
+        // fail-open: un fallo del guardia no bloquea la herramienta.
       }
-    },
-    "tool.execute.after": async (input: any, output: any) => {
-      try {
-        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",
-          directory,
-          tool: input.tool,
-          args: input.args || {},
-        };
+    };
 
-        if (tool === "enterworktree") {
-          if (configError) {
-            appendToolOutput(output, [configError]);
-            return;
-          }
+    const handleAfter = async (event: any) => {
+      try {
+        if (!SHELL_TOOLS.has(String(event?.tool ?? "").toLowerCase())) return;
+        const command = commandText(event?.input?.command);
+        const id = typeof event?.id === "string" ? event.id : "";
 
-          const docsReminderScript = resolveProjectPath(
-            directory,
-            config.docsReminderScript,
-          );
-          if (docsReminderScript) {
-            const result = await runScript(
-              client,
-              directory,
-              docsReminderScript,
-              { payload },
-            );
-            const messages = [
-              extractScriptMessage(result.stdout),
-              extractScriptMessage(result.stderr),
-            ].filter(Boolean);
-            appendToolOutput(output, messages);
-          }
+        if (!isWorktreeAddCommand(command)) {
+          if (id) pending.delete(id);
           return;
         }
 
-        if (tool !== "bash") return;
-
-        if (!isWorktreeAddCommand(command)) {
-          const stale = getCallID(input, output);
-          if (stale) pending.delete(stale);
+        // Un `error` es terminal: la captura de ese ID se retira para no dejar
+        // un solapamiento fantasma. El error original no se toca ni se fabrica
+        // result. `running`/`background` no son terminales y conservan la
+        // captura para el `completed` del mismo ID.
+        if (event?.status === "error") {
+          if (id) pending.delete(id);
           return;
         }
 
-        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.",
-          ]);
+        // Sin un result terminal no hay éxito que validar: `running`/`background`
+        // (o un error sin result) nunca fabrican setup.
+        if (event?.status !== "completed" || !isPlainObject(event.result)) return;
+
+        const { base, command: commandCwd } = await resolveDirectories(ctx, event);
+        const projectDir = base ?? commandCwd;
+        const { config, error: configError } = projectDir
+          ? await readWorktreeConfig(projectDir)
+          : { config: defaultConfig(), error: undefined };
+
+        const capture = id ? pending.get(id) : undefined;
+        if (!capture) {
+          appendToResult(
+            event,
+            AMBIGUOUS_MESSAGES(
+              "Worktree creation is ambiguous: missing pre-execution inventory. Skipping setup.",
+            ),
+          );
           return;
         }
+
         try {
           if (capture.status === "failed") {
-            appendToolOutput(output, [
+            appendToResult(event, [
               `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.",
@@ -616,73 +594,74 @@ export const WorktreePlugin: Plugin = async ({ $, client, directory }) => {
           }
 
           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.",
-            ]);
+            appendToResult(
+              event,
+              AMBIGUOUS_MESSAGES(
+                "Worktree creation is ambiguous: overlapping candidate commands in the same repository cannot be attributed to a single call. Skipping setup.",
+              ),
+            );
             return;
           }
 
           let preList: PorcelainWorktree[];
           try {
             preList = parsePorcelain(capture.pre);
-          } catch (error) {
-            appendToolOutput(output, [
+          } catch {
+            appendToResult(event, [
               "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 exit = output?.metadata?.exit;
+          const exit = event.result?.metadata?.exit;
           if (typeof exit !== "number" || exit !== 0) {
-            const ambiguous =
+            appendToResult(event, [
               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]);
+                : `Worktree command did not succeed (exit ${String(exit)}); skipping worktree setup.`,
+            ]);
             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.",
+            appendToResult(
+              event,
+              AMBIGUOUS_MESSAGES(
+                "Worktree creation is ambiguous: overlapping candidate commands in the same repository cannot be attributed to a single call. Skipping setup.",
+              ),
+            );
+            return;
+          }
+
+          if (!commandCwd) {
+            appendToResult(event, [
+              "Worktree setup omitted: could not resolve the session directory or the command workdir.",
+              "The plugin never falls back to its own server cwd. Verify `ctx.session.get` and the command workdir, then retry.",
             ]);
             return;
           }
 
-          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(),
+            postRaw = await readPorcelain(commandCwd);
+            gitRoot = toSlashes(
+              (await gitText(["rev-parse", "--show-toplevel"], commandCwd)).trim(),
             );
-            gitRoot = String(
-              await $`git -C ${commandCwd} rev-parse --show-toplevel`.quiet().text(),
-            )
-              .trim()
-              .replace(/\\/g, "/");
             commonCwd = await readCommonDir(commandCwd);
-            commonDir = await readCommonDir(directory);
+            commonDir = await readCommonDir(projectDir ?? commandCwd);
           } catch (error) {
             const details = truncateMessage(
               error instanceof Error ? error.message : String(error),
             );
-            appendToolOutput(output, [
+            appendToResult(event, [
               "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;
           }
 
@@ -690,26 +669,30 @@ export const WorktreePlugin: Plugin = async ({ $, client, directory }) => {
           // 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.",
-            ]);
+            appendToResult(
+              event,
+              AMBIGUOUS_MESSAGES(
+                "Worktree creation is ambiguous: overlapping candidate commands in the same repository cannot be attributed to a single call. Skipping setup.",
+              ),
+            );
             return;
           }
 
           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.",
-            ]);
+            appendToResult(
+              event,
+              AMBIGUOUS_MESSAGES(
+                "Worktree creation is ambiguous: repository identity changed between pre- and post-execution inventory. Skipping setup.",
+              ),
+            );
             return;
           }
 
           const toplevel = toSlashes(gitRoot).replace(/\/+$/, "");
           if (!samePath(commonCwd, commonDir)) {
-            appendToolOutput(output, [
+            appendToResult(event, [
               `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.`,
+              `The plugin directory belongs to a different repository (${normalizePath(projectDir ?? commandCwd)}). Run the command inside the project repository.`,
             ]);
             return;
           }
@@ -717,20 +700,17 @@ export const WorktreePlugin: Plugin = async ({ $, client, directory }) => {
           let postList: PorcelainWorktree[];
           try {
             postList = parsePorcelain(postRaw);
-          } catch (error) {
-            appendToolOutput(output, [
+          } catch {
+            appendToResult(event, [
               "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 added = diffNewWorktrees(preList, postList);
           if (added.length !== 1) {
-            appendToolOutput(output, [
+            appendToResult(event, [
               `Worktree creation is ambiguous: expected 1 new worktree, found ${added.length}. Skipping setup.`,
               "Run `git worktree list --porcelain` to inspect the current inventory.",
             ]);
@@ -740,7 +720,7 @@ export const WorktreePlugin: Plugin = async ({ $, client, directory }) => {
           const created = added[0] as PorcelainWorktree;
           const branchName = created.detached ? undefined : created.branch;
           if (!branchName) {
-            appendToolOutput(output, [
+            appendToResult(event, [
               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.",
@@ -751,20 +731,12 @@ export const WorktreePlugin: Plugin = async ({ $, client, directory }) => {
 
           const absoluteWorktreePath = toSlashes(created.path);
           const projectRoot = toplevel;
-          const expectedWorktreePath = resolvePath(
-            projectRoot,
-            `worktrees/${branchName}`,
-          );
-          const pathContains = toSlashes(
-            config.pathContains || "worktrees/",
-          ).toLowerCase();
+          const expectedWorktreePath = resolvePath(projectRoot, `worktrees/${branchName}`);
+          const pathContains = toSlashes(config.pathContains || "worktrees/").toLowerCase();
 
-          const isCanonicalPath = samePath(
-            absoluteWorktreePath,
-            expectedWorktreePath,
-          );
+          const isCanonicalPath = samePath(absoluteWorktreePath, expectedWorktreePath);
           if (!isCanonicalPath) {
-            appendToolOutput(output, [
+            appendToResult(event, [
               `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.",
@@ -772,23 +744,24 @@ export const WorktreePlugin: Plugin = async ({ $, client, directory }) => {
           }
 
           if (configError) {
-            appendToolOutput(output, [configError]);
+            appendToResult(event, [configError]);
             return;
           }
 
-          if (!isCanonicalPath) {
-            return;
-          }
+          if (!isCanonicalPath) return;
 
           if (!normalizePath(absoluteWorktreePath).toLowerCase().includes(pathContains)) {
             return;
           }
 
-          const setupScript = resolveProjectPath(directory, config.setupScript);
+          const setupScript = resolveProjectPath(projectDir ?? commandCwd, config.setupScript);
           if (setupScript) {
-            const setupResult = await runScript(client, directory, setupScript, {
+            const setupResult = await runScript(projectDir ?? commandCwd, setupScript, {
               payload: {
-                ...payload,
+                event: "tool.execute.after",
+                directory: projectDir ?? commandCwd,
+                tool: "bash",
+                args: { command },
                 worktreePath: absoluteWorktreePath,
                 worktreeName: branchName,
                 branchName,
@@ -803,14 +776,12 @@ export const WorktreePlugin: Plugin = async ({ $, client, directory }) => {
                   .filter(Boolean)
                   .join("\n\n"),
               );
-              appendToolOutput(output, [
+              appendToResult(event, [
                 `Worktree setup failed for ${branchName}.`,
                 setupErrorMessage || "No additional details from setup script.",
               ]);
             } else {
-              appendToolOutput(output, [
-                `Worktree setup complete: ${branchName}`,
-              ]);
+              appendToResult(event, [`Worktree setup complete: ${branchName}`]);
             }
           }
 
@@ -832,25 +803,25 @@ export const WorktreePlugin: Plugin = async ({ $, client, directory }) => {
               ...reminderLines,
               "--------------------------------------------------",
             ].join("\n");
-            appendToolOutput(output, [banner]);
+            appendToResult(event, [banner]);
           }
           return;
         } finally {
-          if (pending.get(callID) === capture) pending.delete(callID);
+          if (pending.get(id) === capture) pending.delete(id);
         }
       } catch (error) {
         const details = truncateMessage(
           error instanceof Error ? error.message : String(error),
         );
-        appendToolOutput(output, [
+        appendToResult(event, [
           "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),
-        });
       }
-    },
-  };
+    };
+
+    await ctx.tool.hook("execute.before", handleBefore);
+    await ctx.tool.hook("execute.after", handleAfter);
+  },
 };