pi-graphite 0.2.3 → 0.3.1

package/src/lib/result.ts

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
-import { DEFAULT_COMMAND_TIMEOUT_MS, killProcessGroup, safeNoninteractiveEnv, type GtRunResult } from "./exec";
+import { shellJoin } from "./argv";
+import { DEFAULT_COMMAND_TIMEOUT_MS, killProcessGroup, runGt, safeNoninteractiveEnv, type GtRunResult } from "./exec";
 
 /**
  * Structured failure hints. Only populated when the underlying `gt` command
@@ -108,7 +109,7 @@ export function formatResult(r: GtRunResult): FormattedResult {
 export function renderText(label: string, f: FormattedResult): string {
   const r = f.result;
   const lines: string[] = [];
-  lines.push(`$ gt ${r.args.join(" ")}`);
+  lines.push(`$ gt ${shellJoin(r.args)}`);
   lines.push(
     `# cwd=${r.cwd}  exit=${r.exitCode}${r.timedOut ? "  (aborted)" : ""}${
       r.spawnError ? `  (spawn-error: ${r.spawnError})` : ""
@@ -176,7 +177,11 @@ async function detectCurrentBranch(cwd: string): Promise<string | undefined> {
 }
 
 async function detectTrunk(cwd: string): Promise<string | undefined> {
-  const out = await execText("gt", ["--cwd", cwd, "--no-interactive", "trunk"], cwd);
+  // Route through the hardened runner so cwd resolve, forbidden-token scan,
+  // trailing --no-interactive injection, and env scrubbing all apply.
+  const r = await runGt(["trunk"], { cwd }).catch(() => undefined);
+  if (!r || r.exitCode !== 0) return undefined;
+  const out = r.stdout;
   // gt trunk prints the trunk name on its own line. Take last non-empty line.
   const cleaned = out
     .replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "")
@@ -204,28 +209,28 @@ export async function enrichFailure(cwd: string, f: FormattedResult): Promise<vo
     const b = branch ?? "<current-branch>";
     const p = trunk ?? "<trunk>";
     parts.push(
-      `Current branch (${b}) is not tracked by Graphite. To track it, call: ` +
-        `graphite_branch_tracking({ action: "track", branch: "${b}", parent: "${p}" }). ` +
-        `Verify parent is correct before applying.`,
+      `Current branch (${b}) is not tracked by Graphite. To track it after verifying the intended parent, call: ` +
+        `graphite_setup({ action: "track_branch", branch: "${b}", parent: "${p}", confirmParent: true }). ` +
+        `Do not guess the parent if unclear; ask the user first.`,
     );
   }
   if (f.hints.notInitialized) {
     parts.push(
-      `Graphite not initialized in this repo. Call: graphite_repo({ action: "init", trunk: "<trunk-branch>" }).`,
+      `Graphite not initialized in this repo. Call: graphite_setup({ action: "init_repo", trunk: "<trunk-branch>" }).`,
     );
   }
   if (f.hints.conflictHalted) {
     parts.push(
       `A Graphite command is halted by a conflict. After resolving in git, call: ` +
-        `graphite_recovery({ action: "continue" }) (or "abort").`,
+        `graphite_recover({ action: "continue" }) (or "abort").`,
     );
   }
   if (f.hints.restackNeeded) {
-    parts.push(`Stack is out of date. Call: graphite_stack_restack().`);
+    parts.push(`Stack is out of date. Call: graphite_sync() to sync and restack.`);
   }
   if (f.hints.trunkOutOfSync) {
     parts.push(
-      `Trunk is out of sync with remote. Call: graphite_remote_sync({ action: "sync" }) first.`,
+      `Trunk is out of sync with remote. Call: graphite_sync() first.`,
     );
   }
   if (f.hints.notAuthenticated) {
@@ -237,7 +242,7 @@ export async function enrichFailure(cwd: string, f: FormattedResult): Promise<vo
     const b = f.hints.checkedOutElsewhere.branch ?? "<branch>";
     parts.push(
       `Branch ${b} is checked out in another worktree. Switch to that worktree, or use ` +
-        `\`graphite_branch_create({ onto: "${b}", ... })\` to stack a new branch on top.`,
+        `switch to a different branch with graphite_navigate before mutating the stack.`,
     );
   }
   if (f.hints.invalidArgument) {
@@ -247,7 +252,7 @@ export async function enrichFailure(cwd: string, f: FormattedResult): Promise<vo
   }
   if (f.hints.operatingOnTrunk) {
     parts.push(
-      `Operation refused on the trunk branch. Check out a non-trunk branch first (graphite_branch_navigate).`,
+      `Operation refused on the trunk branch. Check out a non-trunk branch first with graphite_navigate.`,
     );
   }
 

package/src/tools/change.ts

@@ -0,0 +1,140 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { runGt } from "../lib/exec";
+import { assertSafeRef, flagEq, shellJoin } from "../lib/argv";
+import { ensureSuccess, renderText } from "../lib/result";
+import {
+  CwdParam,
+  StringEnum,
+  Type,
+  type ToolReturn,
+} from "../lib/schema";
+
+/**
+ * graphite_change — the only blessed branch-mutation path.
+ *
+ *   action=create        gt create -am "<message>"   (new branch on top of current)
+ *   action=amend         gt modify -am "<message>"   (amend current branch's commit)
+ *   action=amend_into    gt modify --into <branch> -am "<message>"
+ *   action=absorb        gt absorb (dry-run by default)
+ *
+ * Always stages all changes (matches the golden-path `-am`). No editor, no
+ * patch/hunk picker, no AI metadata.
+ */
+export function registerChange(pi: ExtensionAPI) {
+  pi.registerTool({
+    name: "graphite_change",
+    label: "Graphite: change",
+    description:
+      "Create or amend a branch commit in the Graphite stack. action=create stacks a new branch on top of the current one. action=amend updates the current branch's commit. action=amend_into pushes staged hunks into a downstack branch. action=absorb auto-routes staged hunks to the correct commits (dry-run by default).",
+    promptSnippet:
+      "graphite_change: create | amend | amend_into | absorb — the only branch mutation tool",
+    promptGuidelines: [
+      "Use graphite_change action=create to start a new PR branch on top of the current branch. Always provide `message`.",
+      "Use graphite_change action=amend to update the current PR's commit. Always provide `message`.",
+      "Run graphite_status first to confirm you are on the intended branch.",
+      "graphite_change always stages all changes (matches `gt create -am` / `gt modify -am`). Stage selectively with `git add -p` outside this tool if you need a partial commit, then call graphite_change.",
+    ],
+    parameters: Type.Object({
+      cwd: CwdParam,
+      action: StringEnum([
+        "create",
+        "amend",
+        "amend_into",
+        "absorb",
+      ] as const),
+      message: Type.Optional(
+        Type.String({
+          description:
+            "Commit message. Required for create/amend/amend_into.",
+        }),
+      ),
+      name: Type.Optional(
+        Type.String({
+          description: "action=create: branch name (default generated from message).",
+        }),
+      ),
+      insert: Type.Optional(
+        Type.Boolean({
+          description:
+            "action=create: insert between current branch and its child, rebasing children (--insert).",
+        }),
+      ),
+      includeUntracked: Type.Optional(
+        Type.Boolean({
+          description:
+            "action=create|amend|amend_into: include untracked files (--update). Default false; staged + tracked-modified are always included via --all.",
+        }),
+      ),
+      into: Type.Optional(
+        Type.String({
+          description: "action=amend_into: target downstack branch to amend into.",
+        }),
+      ),
+      apply: Type.Optional(
+        Type.Boolean({
+          description:
+            "action=absorb: false (default) => --dry-run; true => --force (apply).",
+        }),
+      ),
+    }),
+    async execute(_id, p, signal): Promise<ToolReturn> {
+      let args: string[];
+      switch (p.action) {
+        case "create": {
+          if (!p.message) {
+            throw new Error("graphite_change action=create requires `message`.");
+          }
+          args = ["create"];
+          if (p.name) args.push(assertSafeRef(p.name, "name"));
+          args.push(flagEq("--message", p.message));
+          // `-am` semantics: always stage tracked modifications.
+          args.push("--all");
+          if (p.includeUntracked) args.push("--update");
+          if (p.insert) args.push("--insert");
+          args.push("--no-ai");
+          break;
+        }
+        case "amend": {
+          if (!p.message) {
+            throw new Error("graphite_change action=amend requires `message`.");
+          }
+          args = ["modify", "--all"];
+          if (p.includeUntracked) args.push("--update");
+          args.push(flagEq("--message", p.message));
+          break;
+        }
+        case "amend_into": {
+          if (!p.into) {
+            throw new Error("graphite_change action=amend_into requires `into`.");
+          }
+          if (!p.message) {
+            throw new Error(
+              "graphite_change action=amend_into requires `message`.",
+            );
+          }
+          args = ["modify", "--all"];
+          if (p.includeUntracked) args.push("--update");
+          args.push(flagEq("--into", assertSafeRef(p.into, "into")));
+          args.push(flagEq("--message", p.message));
+          break;
+        }
+        case "absorb": {
+          const apply = p.apply === true;
+          args = ["absorb"];
+          if (!apply) args.push("--dry-run");
+          else args.push("--force");
+          // Match `-am` style: include tracked modifications for absorb too.
+          args.push("--all");
+          break;
+        }
+      }
+      const label = `gt ${shellJoin(args)}`;
+      const r = await runGt(args, { cwd: p.cwd, signal });
+      const f = await ensureSuccess(label, r, p.cwd);
+      return {
+        content: [{ type: "text", text: renderText(label, f) }],
+        details: { action: p.action, result: f },
+      };
+    },
+  });
+}

package/src/tools/navigate.ts

@@ -0,0 +1,99 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { runGt } from "../lib/exec";
+import { assertSafeRef, flagEq, shellJoin } from "../lib/argv";
+import { ensureSuccess, renderText } from "../lib/result";
+import {
+  CwdParam,
+  StringEnum,
+  Type,
+  type ToolReturn,
+} from "../lib/schema";
+
+/**
+ * graphite_navigate — move around the current stack.
+ *
+ * Stacked PRs encode "which branch you are on = which PR you will modify",
+ * so navigation is a core part of the workflow. Use this before
+ * graphite_change to make sure you are on the right branch:
+ *   - to update an existing PR, checkout that PR's branch
+ *   - to add a child PR, navigate to its intended parent first
+ *   - to add a base PR, navigate to trunk
+ */
+export function registerNavigate(pi: ExtensionAPI) {
+  pi.registerTool({
+    name: "graphite_navigate",
+    label: "Graphite: navigate",
+    description:
+      "Move around the current Graphite stack: checkout a specific branch, jump to trunk, or step up/down/top/bottom. Use this before graphite_change so you are mutating the right PR.",
+    promptSnippet:
+      "graphite_navigate: checkout / trunk / up / down / top / bottom in the current stack",
+    promptGuidelines: [
+      "Before any graphite_change, confirm you are on the intended branch via graphite_status or graphite_navigate.",
+      "To create a child PR, navigate to its intended parent first. To create a base PR, navigate to trunk.",
+    ],
+    parameters: Type.Object({
+      cwd: CwdParam,
+      action: StringEnum([
+        "checkout",
+        "trunk",
+        "up",
+        "down",
+        "top",
+        "bottom",
+      ] as const),
+      branch: Type.Optional(
+        Type.String({ description: "action=checkout: branch to checkout." }),
+      ),
+      steps: Type.Optional(
+        Type.Integer({
+          minimum: 1,
+          description: "action=up|down: step count.",
+        }),
+      ),
+      to: Type.Optional(
+        Type.String({
+          description:
+            "action=up: target descendant when the current branch has multiple children (--to).",
+        }),
+      ),
+    }),
+    async execute(_id, p, signal): Promise<ToolReturn> {
+      let args: string[];
+      switch (p.action) {
+        case "checkout":
+          if (!p.branch) {
+            throw new Error(
+              "action=checkout requires `branch` (interactive selector disabled). Use action=trunk to jump to trunk.",
+            );
+          }
+          args = ["checkout", assertSafeRef(p.branch, "branch")];
+          break;
+        case "trunk":
+          args = ["checkout", "--trunk"];
+          break;
+        case "up":
+          args = ["up"];
+          if (p.steps != null) args.push(flagEq("--steps", p.steps));
+          if (p.to) args.push(flagEq("--to", assertSafeRef(p.to, "to")));
+          break;
+        case "down":
+          args = ["down"];
+          if (p.steps != null) args.push(flagEq("--steps", p.steps));
+          break;
+        case "top":
+          args = ["top"];
+          break;
+        case "bottom":
+          args = ["bottom"];
+          break;
+      }
+      const label = `gt ${shellJoin(args)}`;
+      const r = await runGt(args, { cwd: p.cwd, signal });
+      const f = await ensureSuccess(label, r, p.cwd);
+      return {
+        content: [{ type: "text", text: renderText(label, f) }],
+        details: { action: p.action, result: f },
+      };
+    },
+  });
+}

package/src/tools/{recovery.ts → recover.ts}

@@ -1,7 +1,13 @@
 import { spawn, type ChildProcessByStdio } from "node:child_process";
 import type { Readable } from "node:stream";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { DEFAULT_COMMAND_TIMEOUT_MS, killProcessGroup, runGt, safeNoninteractiveEnv } from "../lib/exec";
+import {
+  DEFAULT_COMMAND_TIMEOUT_MS,
+  killProcessGroup,
+  runGt,
+  safeNoninteractiveEnv,
+} from "../lib/exec";
+import { shellJoin } from "../lib/argv";
 import { ensureSuccess, renderText } from "../lib/result";
 import { CwdParam, StringEnum, Type, type ToolReturn } from "../lib/schema";
 
@@ -45,53 +51,62 @@ function runGit(
     child.on("close", (code) => {
       clearTimeout(timeout);
       signal?.removeEventListener("abort", onAbort);
-      resolve({ exitCode: killed ? -1 : (code ?? -1), stdout: out, stderr: err });
+      resolve({
+        exitCode: killed ? -1 : (code ?? -1),
+        stdout: out,
+        stderr: err,
+      });
     });
   });
 }
 
-/** Return list of tracked files that still contain conflict markers. */
 async function findUnresolvedConflictMarkers(
   cwd: string,
   signal?: AbortSignal,
 ): Promise<string[]> {
-  // grep for the canonical 7-char start marker at line start across tracked files.
-  // `git grep` is cheap and respects gitignore / tracked-only by default.
-  const r = await runGit(
-    ["grep", "-l", "-E", "^<{7} "],
-    cwd,
-    signal,
-  );
-  if (r.exitCode > 1) return []; // git grep returns 1 for no matches, >1 is real error
+  const r = await runGit(["grep", "-l", "-E", "^<{7} "], cwd, signal);
+  if (r.exitCode > 1) return [];
   return r.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
 }
 
-export function registerRecovery(pi: ExtensionAPI) {
+/**
+ * graphite_recover — `gt continue` / `gt abort` / `gt undo`.
+ *
+ * After a conflict during sync/restack/create/modify, resolve the files
+ * (and `git add` them), then call action=continue. Never use
+ * `git rebase --continue` — Graphite needs to propagate the resolution to
+ * dependent branches.
+ */
+export function registerRecover(pi: ExtensionAPI) {
   pi.registerTool({
-    name: "graphite_recovery",
-    label: "Graphite: recovery",
+    name: "graphite_recover",
+    label: "Graphite: recover",
     description:
-      "Recover from conflicts or mistakes: continue a halted command, abort it, or undo the most recent Graphite mutation in this worktree.",
+      "Recover from a halted Graphite operation or a recent mistake: continue (resume a paused gt command after resolving conflicts), abort (cancel the in-flight operation), or undo (revert the most recent gt mutation in this worktree). Always prefer this over `git rebase --continue`.",
     promptSnippet:
-      "graphite_recovery: continue / abort / undo Graphite commands",
+      "graphite_recover: continue / abort / undo — never use `git rebase --continue`",
     promptGuidelines: [
-      "After resolving a rebase conflict, run graphite_recovery action=continue to resume the original gt command.",
-      "graphite_recovery action=undo only undoes commands run from the current worktree.",
+      "After resolving a rebase or cherry-pick conflict from a gt command, call graphite_recover action=continue (not `git rebase --continue`) so Graphite propagates the fix to dependent branches.",
+      "graphite_recover action=undo only undoes commands run from the current worktree.",
     ],
     parameters: Type.Object({
       cwd: CwdParam,
       action: StringEnum(["continue", "abort", "undo"] as const),
       stageAll: Type.Optional(
-        Type.Boolean({ description: "action=continue: stage all changes first (--all)." }),
+        Type.Boolean({
+          description: "action=continue: stage all changes first (--all).",
+        }),
       ),
       allowConflictMarkers: Type.Optional(
         Type.Boolean({
           description:
-            "action=continue: bypass the pre-flight check that refuses to continue when tracked files still contain `<<<<<<<` conflict markers. Default false. Only set true if you know the markers are intentional (e.g. tests).",
+            "action=continue: bypass the pre-flight check that refuses to continue when tracked files still contain `<<<<<<<` markers. Default false.",
         }),
       ),
       force: Type.Optional(
-        Type.Boolean({ description: "action=abort|undo: skip confirmation prompt (--force)." }),
+        Type.Boolean({
+          description: "action=abort|undo: skip confirmation (--force).",
+        }),
       ),
     }),
     async execute(_id, p, signal): Promise<ToolReturn> {
@@ -102,10 +117,9 @@ export function registerRecovery(pi: ExtensionAPI) {
             const dirty = await findUnresolvedConflictMarkers(p.cwd, signal);
             if (dirty.length) {
               throw new Error(
-                `graphite_recovery: refusing to continue — ${dirty.length} tracked file(s) still contain conflict markers (\`<<<<<<<\`):\n` +
+                `graphite_recover: refusing to continue — ${dirty.length} tracked file(s) still contain conflict markers (\`<<<<<<<\`):\n` +
                   dirty.map((f) => `  - ${f}`).join("\n") +
-                  `\n\nResolve each file (remove <<<<<<< / ======= / >>>>>>> blocks), then re-run. ` +
-                  `If markers are intentional, pass allowConflictMarkers:true.`,
+                  `\n\nResolve each file, then re-run. If markers are intentional, pass allowConflictMarkers:true.`,
               );
             }
           }
@@ -122,7 +136,7 @@ export function registerRecovery(pi: ExtensionAPI) {
           if (p.force) args.push("--force");
           break;
       }
-      const label = `gt ${args.join(" ")}`;
+      const label = `gt ${shellJoin(args)}`;
       const r = await runGt(args, { cwd: p.cwd, signal });
       const f = await ensureSuccess(label, r, p.cwd);
       return {

package/src/tools/setup.ts

@@ -0,0 +1,121 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { runGt } from "../lib/exec";
+import { assertSafeRef, flagEq, shellJoin } from "../lib/argv";
+import { ensureSuccess, renderText } from "../lib/result";
+import {
+  CwdParam,
+  StringEnum,
+  Type,
+  requireConfirm,
+  type ToolReturn,
+} from "../lib/schema";
+
+/**
+ * graphite_setup — initialize a repo or adopt an existing git branch into
+ * Graphite tracking.
+ *
+ * This is a precondition tool, not a daily workflow tool. Use it only when
+ * graphite_status / graphite_change reports that Graphite is not initialized
+ * or the current branch is not tracked.
+ */
+export function registerSetup(pi: ExtensionAPI) {
+  pi.registerTool({
+    name: "graphite_setup",
+    label: "Graphite: setup",
+    description:
+      "Initialize Graphite in a repo or track an existing Git branch with an explicit Graphite parent. Use only when a repo/branch is not Graphite-ready. Tracking requires an explicit branch, explicit parent, and confirmParent:true.",
+    promptSnippet:
+      "graphite_setup: init_repo | track_branch for Graphite preconditions",
+    promptGuidelines: [
+      "Use graphite_setup only when graphite_status or another tool reports notInitialized or branchNotTracked.",
+      "For track_branch, never infer the parent silently. Ask the user if the intended parent is unclear, then pass confirmParent:true.",
+      "Do not use graphite_setup for untrack/freeze/unfreeze; those are outside the core workflow.",
+    ],
+    parameters: Type.Object({
+      cwd: CwdParam,
+      action: StringEnum(["init_repo", "track_branch"] as const),
+      trunk: Type.Optional(
+        Type.String({
+          description: "action=init_repo: trunk branch name (for example main or master).",
+        }),
+      ),
+      reset: Type.Optional(
+        Type.Boolean({
+          description:
+            "action=init_repo: pass --reset and untrack existing Graphite branches. Requires confirmDestructive:true.",
+        }),
+      ),
+      branch: Type.Optional(
+        Type.String({ description: "action=track_branch: existing Git branch to track." }),
+      ),
+      parent: Type.Optional(
+        Type.String({
+          description:
+            "action=track_branch: explicit Graphite parent branch. Required; do not guess if unclear.",
+        }),
+      ),
+      confirmParent: Type.Optional(
+        Type.Boolean({
+          description:
+            "action=track_branch: required true to confirm the supplied parent is intentional.",
+        }),
+      ),
+      force: Type.Optional(
+        Type.Boolean({
+          description:
+            "action=track_branch: pass --force to overwrite existing tracking metadata. Requires confirmDestructive:true.",
+        }),
+      ),
+      confirmDestructive: Type.Optional(Type.Boolean()),
+    }),
+    async execute(_id, p, signal): Promise<ToolReturn> {
+      let args: string[];
+
+      if (p.action === "init_repo") {
+        if (!p.trunk) {
+          throw new Error("graphite_setup action=init_repo requires `trunk`.");
+        }
+        if (p.reset) {
+          requireConfirm(
+            p.confirmDestructive,
+            "gt init --reset (untracks existing Graphite branches)",
+          );
+        }
+        args = ["init", flagEq("--trunk", assertSafeRef(p.trunk, "trunk"))];
+        if (p.reset) args.push("--reset");
+      } else {
+        if (!p.branch) {
+          throw new Error("graphite_setup action=track_branch requires `branch`.");
+        }
+        if (!p.parent) {
+          throw new Error("graphite_setup action=track_branch requires `parent`.");
+        }
+        if (p.confirmParent !== true) {
+          throw new Error(
+            "graphite_setup action=track_branch requires confirmParent:true. Confirm the intended Graphite parent with the user if unclear.",
+          );
+        }
+        if (p.force) {
+          requireConfirm(
+            p.confirmDestructive,
+            "gt track --force (overwrites existing tracking metadata)",
+          );
+        }
+        args = [
+          "track",
+          assertSafeRef(p.branch, "branch"),
+          flagEq("--parent", assertSafeRef(p.parent, "parent")),
+        ];
+        if (p.force) args.push("--force");
+      }
+
+      const label = `gt ${shellJoin(args)}`;
+      const r = await runGt(args, { cwd: p.cwd, signal });
+      const f = await ensureSuccess(label, r, p.cwd);
+      return {
+        content: [{ type: "text", text: renderText(label, f) }],
+        details: { action: p.action, result: f },
+      };
+    },
+  });
+}

package/src/tools/status.ts

@@ -0,0 +1,55 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { runGt } from "../lib/exec";
+import { ensureAllSuccess, renderText } from "../lib/result";
+import { CwdParam, Type, type ToolReturn } from "../lib/schema";
+
+/**
+ * graphite_status — single read-only entry point.
+ *
+ * Always returns:
+ *   gt log --stack    -> current stack tree
+ *   gt info           -> current branch summary (parent, PR url, restack hint)
+ *
+ * Run this before touching the stack.
+ */
+export function registerStatus(pi: ExtensionAPI) {
+  pi.registerTool({
+    name: "graphite_status",
+    label: "Graphite: status",
+    description:
+      "Read-only Graphite snapshot. Runs `gt log --stack` and `gt info` so you can see the current stack, the current branch's parent + PR, and any restack/conflict hints. Use this before any other graphite_* tool.",
+    promptSnippet:
+      "graphite_status: inspect current stack + current branch before mutating",
+    promptGuidelines: [
+      "Run graphite_status at the start of any Graphite workflow, and again whenever you are unsure where you are in the stack.",
+    ],
+    parameters: Type.Object({
+      cwd: CwdParam,
+    }),
+    async execute(_id, p, signal): Promise<ToolReturn> {
+      const [log, info] = await Promise.all([
+        runGt(["log", "--stack"], { cwd: p.cwd, signal }),
+        runGt(["info"], { cwd: p.cwd, signal }),
+      ]);
+      const [fl, fi] = await ensureAllSuccess(
+        [
+          { label: "gt log --stack", result: log },
+          { label: "gt info", result: info },
+        ],
+        p.cwd,
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: [
+              renderText("gt log --stack", fl),
+              renderText("gt info", fi),
+            ].join("\n\n"),
+          },
+        ],
+        details: { log: fl, info: fi },
+      };
+    },
+  });
+}