pi-graphite 0.2.2 → 0.2.3

package/README.md

@@ -34,7 +34,8 @@ pi -e /path/to/pi-graphite
 | `graphite_repo`              | repo     | `gt trunk`, `gt init`, `gt log short`             |
 | `graphite_stack_view`        | stack    | `gt log` / `gt log short` / `gt log long`         |
 | `graphite_stack_restack`     | stack    | `gt restack` (+ `--branch/--downstack/--upstack/--only`) |
-| `graphite_stack_reorganize`  | stack    | `gt move`, `gt fold`, `gt split --by-file`        |
+| `graphite_stack_reorganize`  | stack    | `gt move`, `gt fold`, `gt split --by-file` (move_branch supports `dryRun` via `git merge-tree` simulation) |
+| `graphite_stack_compose`     | stack    | linearize branches by cherry-picking `base..branch` unique commits in order, then `gt track` each |
 | `graphite_branch_inspect`    | branch   | `gt info` (+ `gt parent`, `gt children`)          |
 | `graphite_branch_create`     | branch   | `gt create`                                       |
 | `graphite_branch_update`     | branch   | `gt modify`, `gt absorb`, `gt squash`, `gt pop`, `gt rename`, `gt delete` |
@@ -42,13 +43,15 @@ pi -e /path/to/pi-graphite
 | `graphite_branch_navigate`   | branch   | `gt checkout`, `gt up`, `gt down`, `gt top`, `gt bottom` |
 | `graphite_remote_sync`       | remote   | `gt sync`, `gt get`                               |
 | `graphite_pr_submit`         | PR       | `gt submit` (dry-run by default)                  |
-| `graphite_pr_lifecycle`      | PR       | `gt pr`, `gt merge`, `gt unlink`                  |
+| `graphite_pr_lifecycle`      | PR       | `gh pr view --json url`, `gt merge`, `gt unlink`  |
 | `graphite_recovery`          | recovery | `gt continue`, `gt abort`, `gt undo`              |
 
 ## Conventions
 
 - Every tool requires an absolute `cwd`.
 - `gt` is invoked with `--cwd <cwd> --no-interactive` by default. No shell strings.
+- Editor, pager, and browser env are forced safe (`GT_EDITOR=true`, `GT_PAGER=`, `BROWSER=true`, etc.); commands have a hard timeout.
+- Interactive editor/browser/hunk paths are rejected (`edit:true`, `stage:"patch"`, `patch:true`, `editMode:"web"`, `view:true`, interactive trunk add, merge `confirm:true`).
 - Remote / destructive operations require explicit ack flags:
   - `graphite_pr_submit` defaults to `--dry-run`; `apply: true` needs `confirmRemote: true`.
   - `graphite_pr_lifecycle action=merge` defaults to `--dry-run`; `apply: true` needs `confirmRemote: true`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-graphite",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Structured pi tools for the Graphite (gt) CLI.",
   "keywords": [
     "pi",

package/src/index.ts

@@ -5,6 +5,7 @@ import {
   registerStackView,
   registerStackRestack,
   registerStackReorganize,
+  registerStackCompose,
 } from "./tools/stack";
 import {
   registerBranchInspect,
@@ -26,6 +27,7 @@ import { registerRecovery } from "./tools/recovery";
  *   graphite_stack_view
  *   graphite_stack_restack
  *   graphite_stack_reorganize
+ *   graphite_stack_compose
  *   graphite_branch_inspect
  *   graphite_branch_create
  *   graphite_branch_update
@@ -39,6 +41,7 @@ import { registerRecovery } from "./tools/recovery";
  * Conventions:
  * - Every tool requires absolute `cwd`.
  * - `gt` is invoked with --cwd <cwd> --no-interactive by default.
+ * - Editor/pager/browser env is forced safe; interactive hunk/editor/browser paths are rejected.
  * - Remote / destructive operations require explicit `confirmRemote` /
  *   `confirmDestructive` flags. Submit/merge default to dry-run.
  * - Output is ANSI-stripped and truncated to ~50KB / 2000 lines.
@@ -49,6 +52,7 @@ export default function (pi: ExtensionAPI) {
   registerStackView(pi);
   registerStackRestack(pi);
   registerStackReorganize(pi);
+  registerStackCompose(pi);
 
   registerBranchInspect(pi);
   registerBranchCreate(pi);

package/src/lib/exec.ts

@@ -5,8 +5,10 @@ import { resolve as resolvePath } from "node:path";
 export interface GtRunOptions {
   cwd: string;
   signal?: AbortSignal;
-  /** Extra env vars merged into process.env */
+  /** Extra env vars merged into process.env. Safety vars always win. */
   env?: Record<string, string>;
+  /** Hard timeout in ms. Default 120s. */
+  timeoutMs?: number;
 }
 
 export interface GtRunResult {
@@ -23,6 +25,43 @@ export interface GtRunResult {
 const ANSI = /\x1b\[[0-9;]*[a-zA-Z]/g;
 const MAX_BYTES = 50 * 1024;
 const MAX_LINES = 2000;
+export const DEFAULT_COMMAND_TIMEOUT_MS = 120_000;
+
+/** Env guardrails: disable editors, pagers, browsers. Must override caller env. */
+export const SAFE_NONINTERACTIVE_ENV: Record<string, string> = {
+  GT_EDITOR: "true",
+  TEST_GT_EDITOR: "true",
+  GIT_EDITOR: "true",
+  EDITOR: "true",
+  VISUAL: "true",
+  GIT_SEQUENCE_EDITOR: "true",
+  GT_PAGER: "",
+  GIT_PAGER: "cat",
+  PAGER: "cat",
+  LESS: "FRX",
+  BROWSER: "true",
+  GH_BROWSER: "true",
+};
+
+export function safeNoninteractiveEnv(extra?: Record<string, string>): NodeJS.ProcessEnv {
+  return {
+    ...process.env,
+    ...(extra ?? {}),
+    ...SAFE_NONINTERACTIVE_ENV,
+  };
+}
+
+export function killProcessGroup(child: { pid?: number; kill(signal?: NodeJS.Signals): boolean }, signal: NodeJS.Signals): void {
+  try {
+    if (child.pid && process.platform !== "win32") {
+      process.kill(-child.pid, signal);
+      return;
+    }
+  } catch {}
+  try {
+    child.kill(signal);
+  } catch {}
+}
 
 export function stripAnsi(s: string): string {
   return s.replace(ANSI, "");
@@ -68,8 +107,11 @@ export async function runGt(
     try {
       child = spawn("gt", args, {
         cwd,
-        env: { ...process.env, ...(opts.env ?? {}) },
+        // Force any editor/pager/browser invocation to no-op instead of
+        // hanging. Safety vars override opts.env by design.
+        env: safeNoninteractiveEnv(opts.env),
         stdio: ["ignore", "pipe", "pipe"],
+        detached: process.platform !== "win32",
       });
     } catch (e) {
       resolve({
@@ -88,6 +130,16 @@ export async function runGt(
     let stdout = "";
     let stderr = "";
     let killed = false;
+    let settled = false;
+
+    const killChild = () => {
+      killed = true;
+      killProcessGroup(child, "SIGTERM");
+      setTimeout(() => killProcessGroup(child, "SIGKILL"), 1500).unref?.();
+    };
+
+    const timeout = setTimeout(killChild, opts.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS);
+    timeout.unref?.();
 
     child.stdout?.on("data", (d) => {
       stdout += d.toString();
@@ -98,20 +150,14 @@ export async function runGt(
       if (stderr.length > MAX_BYTES * 4) stderr = stderr.slice(-MAX_BYTES * 2);
     });
 
-    const onAbort = () => {
-      killed = true;
-      try {
-        child.kill("SIGTERM");
-        setTimeout(() => {
-          try {
-            child.kill("SIGKILL");
-          } catch {}
-        }, 1500).unref?.();
-      } catch {}
-    };
+    const onAbort = killChild;
     opts.signal?.addEventListener("abort", onAbort, { once: true });
 
     child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      opts.signal?.removeEventListener("abort", onAbort);
       resolve({
         command: "gt",
         args,
@@ -119,12 +165,15 @@ export async function runGt(
         exitCode: -1,
         stdout: sanitizeBranding(stripAnsi(stdout)),
         stderr: sanitizeBranding(stripAnsi(stderr)),
-        timedOut: false,
+        timedOut: killed,
         spawnError: err.message,
       });
     });
 
     child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
       opts.signal?.removeEventListener("abort", onAbort);
       resolve({
         command: "gt",

package/src/lib/result.ts

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import type { GtRunResult } from "./exec";
+import { DEFAULT_COMMAND_TIMEOUT_MS, killProcessGroup, safeNoninteractiveEnv, type GtRunResult } from "./exec";
 
 /**
  * Structured failure hints. Only populated when the underlying `gt` command
@@ -140,17 +140,33 @@ function execText(cmd: string, args: string[], cwd: string): Promise<string> {
     let out = "";
     let child;
     try {
-      child = spawn(cmd, args, { cwd, stdio: ["ignore", "pipe", "ignore"] });
+      child = spawn(cmd, args, {
+        cwd,
+        env: safeNoninteractiveEnv(),
+        stdio: ["ignore", "pipe", "ignore"],
+        detached: process.platform !== "win32",
+      });
     } catch {
       resolve("");
       return;
     }
+    const timeout = setTimeout(() => {
+      killProcessGroup(child, "SIGTERM");
+      setTimeout(() => killProcessGroup(child, "SIGKILL"), 1500).unref?.();
+    }, DEFAULT_COMMAND_TIMEOUT_MS);
+    timeout.unref?.();
     child.stdout.on("data", (d) => {
       out += d.toString();
       if (out.length > 4096) out = out.slice(-4096);
     });
-    child.on("error", () => resolve(""));
-    child.on("close", () => resolve(out));
+    child.on("error", () => {
+      clearTimeout(timeout);
+      resolve("");
+    });
+    child.on("close", () => {
+      clearTimeout(timeout);
+      resolve(out);
+    });
   });
 }
 

package/src/lib/schema.ts

@@ -9,10 +9,11 @@ export const StageMode = StringEnum([
   "none",
   "all",
   "update",
-  "patch",
 ] as const);
 
-export function stageArgs(mode: "none" | "all" | "update" | "patch"): string[] {
+export type StageModeValue = "none" | "all" | "update";
+
+export function stageArgs(mode: StageModeValue): string[] {
   switch (mode) {
     case "none":
       return [];
@@ -20,9 +21,9 @@ export function stageArgs(mode: "none" | "all" | "update" | "patch"): string[] {
       return ["--all"];
     case "update":
       return ["--update"];
-    case "patch":
-      return ["--patch"];
   }
+  const _exhaustive: never = mode;
+  return _exhaustive;
 }
 
 /** Common cwd param. Required so we always pass an absolute path to gt. */

package/src/tools/branch.ts

@@ -13,6 +13,7 @@ import {
   Type,
   requireConfirm,
   stageArgs,
+  type StageModeValue,
   type ToolReturn,
 } from "../lib/schema";
 
@@ -175,7 +176,8 @@ export function registerBranchCreate(pi: ExtensionAPI) {
       const args = ["create"];
       if (p.name) args.push(p.name);
       if (p.message) args.push("--message", p.message);
-      args.push(...stageArgs((p.stage ?? "none") as "none" | "all" | "update" | "patch"));
+      if ((p.stage as string | undefined) === "patch") throw new Error("stage:'patch' is disabled; use stage:'all' or stage:'update'.");
+      args.push(...stageArgs((p.stage ?? "none") as StageModeValue));
       if (p.onto) args.push("--onto", p.onto);
       if (p.insert) args.push("--insert");
       args.push(p.ai ? "--ai" : "--no-ai");
@@ -203,6 +205,7 @@ export function registerBranchUpdate(pi: ExtensionAPI) {
     promptGuidelines: [
       "Use graphite_branch_update with action=absorb (dryRun:true first) to distribute staged hunks across downstack commits.",
       "graphite_branch_update with action=delete and close:true requires confirmRemote.",
+      "Editor and patch/hunk modes are disabled. Pass explicit `message` where needed.",
     ],
     parameters: Type.Object({
       cwd: CwdParam,
@@ -220,7 +223,7 @@ export function registerBranchUpdate(pi: ExtensionAPI) {
       into: Type.Optional(
         Type.String({ description: "action=amend: amend into a downstack branch (`gt modify --into`)." }),
       ),
-      edit: Type.Optional(Type.Boolean({ description: "Open editor for commit message." })),
+      edit: Type.Optional(Type.Boolean({ description: "Rejected: editor mode is disabled for agent safety." })),
       resetAuthor: Type.Optional(Type.Boolean({ description: "action=amend: reset commit author." })),
       newName: Type.Optional(Type.String({ description: "action=rename: new branch name." })),
       branch: Type.Optional(Type.String({ description: "action=delete: branch name to delete." })),
@@ -233,30 +236,32 @@ export function registerBranchUpdate(pi: ExtensionAPI) {
       dryRun: Type.Optional(
         Type.Boolean({ description: "action=absorb: dry-run only (default true)." }),
       ),
-      patch: Type.Optional(Type.Boolean({ description: "action=absorb: pick hunks (--patch)." })),
+      patch: Type.Optional(Type.Boolean({ description: "Rejected: interactive hunk mode is disabled." })),
       confirmRemote: Type.Optional(Type.Boolean()),
     }),
     async execute(_id, p, signal): Promise<ToolReturn> {
       let args: string[];
+      if (p.edit) throw new Error("edit:true is disabled; pass an explicit message instead.");
+      if (p.patch) throw new Error("patch:true is disabled; interactive hunk selection is not exposed.");
+      if ((p.stage as string | undefined) === "patch") throw new Error("stage:'patch' is disabled; use stage:'all' or stage:'update'.");
 
       switch (p.action) {
         case "amend": {
           args = ["modify"];
-          args.push(...stageArgs((p.stage ?? "none") as "none" | "all" | "update" | "patch"));
+          args.push(...stageArgs((p.stage ?? "none") as StageModeValue));
           if (p.message) args.push("--message", p.message);
-          if (p.edit) args.push("--edit");
+          else args.push("--no-edit");
           if (p.resetAuthor) args.push("--reset-author");
           if (p.into) args.push("--into", p.into);
           break;
         }
         case "new_commit": {
-          if (!p.message && !p.edit) {
-            throw new Error("action=new_commit requires `message` or edit=true.");
+          if (!p.message) {
+            throw new Error("action=new_commit requires `message` (editor mode disabled).");
           }
           args = ["modify", "--commit"];
-          args.push(...stageArgs((p.stage ?? "none") as "none" | "all" | "update" | "patch"));
-          if (p.message) args.push("--message", p.message);
-          if (p.edit) args.push("--edit");
+          args.push(...stageArgs((p.stage ?? "none") as StageModeValue));
+          args.push("--message", p.message);
           break;
         }
         case "absorb": {
@@ -264,15 +269,14 @@ export function registerBranchUpdate(pi: ExtensionAPI) {
           args = ["absorb"];
           if (dryRun) args.push("--dry-run");
           else args.push("--force");
-          const stage = (p.stage ?? "none") as "none" | "all" | "update" | "patch";
+          const stage = (p.stage ?? "none") as StageModeValue;
           if (stage === "all") args.push("--all");
-          if (p.patch) args.push("--patch");
           break;
         }
         case "squash": {
           args = ["squash"];
           if (p.message) args.push("--message", p.message);
-          if (p.edit) args.push("--edit");
+          else args.push("--no-edit");
           break;
         }
         case "pop": {

package/src/tools/pr.ts

@@ -1,5 +1,7 @@
+import { spawn, type ChildProcessByStdio } from "node:child_process";
+import type { Readable } from "node:stream";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { runGt } from "../lib/exec";
+import { DEFAULT_COMMAND_TIMEOUT_MS, killProcessGroup, runGt, safeNoninteractiveEnv } from "../lib/exec";
 import { ensureSuccess, renderText } from "../lib/result";
 import {
   CwdParam,
@@ -17,6 +19,72 @@ function shellQuote(s: string): string {
   return `'${s.replace(/'/g, `'"'"'`)}'`;
 }
 
+interface CmdResult {
+  command: string;
+  args: string[];
+  cwd: string;
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+  timedOut: boolean;
+  spawnError?: string;
+}
+
+function runGh(args: string[], cwd: string, signal?: AbortSignal): Promise<CmdResult> {
+  return new Promise((resolve) => {
+    let child: ChildProcessByStdio<null, Readable, Readable>;
+    try {
+      child = spawn("gh", args, {
+        cwd,
+        env: safeNoninteractiveEnv(),
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: process.platform !== "win32",
+      });
+    } catch (e) {
+      resolve({ command: "gh", args, cwd, exitCode: -1, stdout: "", stderr: "", timedOut: false, spawnError: (e as Error).message });
+      return;
+    }
+
+    let stdout = "";
+    let stderr = "";
+    let killed = false;
+    let settled = false;
+    const killChild = () => {
+      killed = true;
+      killProcessGroup(child, "SIGTERM");
+      setTimeout(() => killProcessGroup(child, "SIGKILL"), 1500).unref?.();
+    };
+    const timeout = setTimeout(killChild, DEFAULT_COMMAND_TIMEOUT_MS);
+    timeout.unref?.();
+    const onAbort = killChild;
+    signal?.addEventListener("abort", onAbort, { once: true });
+
+    child.stdout.on("data", (d) => (stdout += d.toString()));
+    child.stderr.on("data", (d) => (stderr += d.toString()));
+    child.on("error", (e) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      signal?.removeEventListener("abort", onAbort);
+      resolve({ command: "gh", args, cwd, exitCode: -1, stdout, stderr, timedOut: killed, spawnError: e.message });
+    });
+    child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      signal?.removeEventListener("abort", onAbort);
+      resolve({ command: "gh", args, cwd, exitCode: code ?? -1, stdout, stderr, timedOut: killed });
+    });
+  });
+}
+
+function renderGhText(label: string, r: CmdResult): string {
+  const lines = [`[${label}] fail`, `$ gh ${r.args.join(" ")}`, `# cwd=${r.cwd}  exit=${r.exitCode}${r.timedOut ? "  (aborted)" : ""}${r.spawnError ? `  (spawn-error: ${r.spawnError})` : ""}`];
+  if (r.stdout.trim()) lines.push("--- stdout ---", r.stdout.trimEnd());
+  if (r.stderr.trim()) lines.push("--- stderr ---", r.stderr.trimEnd());
+  return lines.join("\n");
+}
+
 export function registerPrSubmit(pi: ExtensionAPI) {
   pi.registerTool({
     name: "graphite_pr_submit",
@@ -39,7 +107,7 @@ export function registerPrSubmit(pi: ExtensionAPI) {
       stack: Type.Optional(
         Type.Boolean({
           description:
-            "true => --stack (include descendants). false => --no-stack. Omitted => default (gt prompts based on config).",
+            "true => --stack (include descendants). false => --no-stack. Omitted => gt default behavior.",
         }),
       ),
       branch: Type.Optional(Type.String({ description: "Run from this branch (--branch)." })),
@@ -53,9 +121,9 @@ export function registerPrSubmit(pi: ExtensionAPI) {
       comment: Type.Optional(Type.String({ description: "--comment <msg>" })),
       targetTrunk: Type.Optional(Type.String()),
       editMode: Type.Optional(
-        StringEnum(["none", "cli", "web"] as const, {
+        StringEnum(["none", "cli"] as const, {
           description:
-            "none (default) => --no-edit; cli => --edit --cli; web => --web. Affects PR metadata prompting.",
+            "none (default) => --no-edit; cli => --edit --cli. Browser/web edit mode is disabled.",
         }),
       ),
       ai: Type.Optional(
@@ -67,7 +135,7 @@ export function registerPrSubmit(pi: ExtensionAPI) {
         Type.Boolean({ description: "--force (instead of default --force-with-lease). Requires confirmRemote." }),
       ),
       ignoreOutOfSyncTrunk: Type.Optional(Type.Boolean()),
-      view: Type.Optional(Type.Boolean({ description: "--view (open PR in browser after submit)." })),
+      view: Type.Optional(Type.Boolean({ description: "Rejected: browser viewing is disabled." })),
       confirmRemote: Type.Optional(Type.Boolean()),
 
       title: Type.Optional(
@@ -87,6 +155,8 @@ export function registerPrSubmit(pi: ExtensionAPI) {
       const apply = p.apply === true;
       if (apply) requireConfirm(p.confirmRemote, "gt submit (push branches + create/update PRs)");
       if (p.forcePush) requireConfirm(p.confirmRemote, "gt submit --force");
+      if ((p.editMode as string | undefined) === "web") throw new Error("editMode:'web' is disabled; browser launch is not exposed.");
+      if (p.view) throw new Error("view:true is disabled; browser launch is not exposed. Use graphite_pr_lifecycle action='view_url'.");
 
       const wantsCustomMetadata = p.title != null || p.body != null;
 
@@ -116,13 +186,11 @@ export function registerPrSubmit(pi: ExtensionAPI) {
       const editMode = wantsCustomMetadata ? "none" : (p.editMode ?? "none");
       if (editMode === "none") args.push("--no-edit");
       else if (editMode === "cli") args.push("--edit", "--cli");
-      else if (editMode === "web") args.push("--web");
 
       args.push(p.ai ? "--ai" : "--no-ai");
 
       if (p.forcePush) args.push("--force");
       if (p.ignoreOutOfSyncTrunk) args.push("--ignore-out-of-sync-trunk");
-      if (p.view) args.push("--view");
 
       const label = `gt ${args.join(" ")}`;
       const r = await runGt(args, { cwd: p.cwd, signal });
@@ -175,15 +243,15 @@ export function registerPrLifecycle(pi: ExtensionAPI) {
     name: "graphite_pr_lifecycle",
     label: "Graphite: PR lifecycle",
     description:
-      "PR lifecycle actions: open the PR/stack page in a browser, merge the stack via Graphite, or unlink a branch from its PR.",
+      "PR lifecycle actions: return PR URL, merge the stack via Graphite, or unlink a branch from its PR.",
     promptSnippet:
-      "graphite_pr_lifecycle: open_url | merge | unlink for a PR/branch",
+      "graphite_pr_lifecycle: view_url | merge | unlink for a PR/branch",
     parameters: Type.Object({
       cwd: CwdParam,
-      action: StringEnum(["open_url", "merge", "unlink"] as const),
+      action: StringEnum(["view_url", "merge", "unlink"] as const),
       branch: Type.Optional(Type.String({ description: "Branch name or PR number." })),
       stack: Type.Optional(
-        Type.Boolean({ description: "action=open_url: open stack page (--stack)." }),
+        Type.Boolean({ description: "Rejected: stack browser page is disabled." }),
       ),
       apply: Type.Optional(
         Type.Boolean({
@@ -192,23 +260,28 @@ export function registerPrLifecycle(pi: ExtensionAPI) {
       ),
       confirm: Type.Optional(
         Type.Boolean({
-          description: "action=merge: pass --confirm so gt prompts before merging each branch.",
+          description: "Rejected: interactive confirmation prompts are disabled.",
         }),
       ),
       confirmRemote: Type.Optional(Type.Boolean()),
     }),
     async execute(_id, p, signal): Promise<ToolReturn> {
       let args: string[];
-      if (p.action === "open_url") {
-        args = ["pr"];
-        if (p.branch) args.push(p.branch);
-        if (p.stack) args.push("--stack");
+      if (p.action === "view_url") {
+        if (p.stack) throw new Error("stack:true is disabled; browser stack page is not exposed.");
+        const branchArgs = p.branch ? [p.branch] : [];
+        const r = await runGh(["pr", "view", ...branchArgs, "--json", "url", "--jq", ".url"], p.cwd, signal);
+        if (r.exitCode !== 0) throw new Error(renderGhText("gh pr view", r));
+        return {
+          content: [{ type: "text", text: r.stdout.trim() }],
+          details: { action: p.action, url: r.stdout.trim(), result: r },
+        };
       } else if (p.action === "merge") {
         const apply = p.apply === true;
         if (apply) requireConfirm(p.confirmRemote, "gt merge (merges PRs on GitHub)");
         args = ["merge"];
         if (!apply) args.push("--dry-run");
-        if (p.confirm) args.push("--confirm");
+        if (p.confirm) throw new Error("confirm:true is disabled; interactive confirmation prompts are not exposed.");
       } else {
         args = ["unlink"];
         if (p.branch) args.push(p.branch);

package/src/tools/recovery.ts

@@ -1,8 +1,71 @@
+import { spawn, type ChildProcessByStdio } from "node:child_process";
+import type { Readable } from "node:stream";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { runGt } from "../lib/exec";
+import { DEFAULT_COMMAND_TIMEOUT_MS, killProcessGroup, runGt, safeNoninteractiveEnv } from "../lib/exec";
 import { ensureSuccess, renderText } from "../lib/result";
 import { CwdParam, StringEnum, Type, type ToolReturn } from "../lib/schema";
 
+function runGit(
+  args: string[],
+  cwd: string,
+  signal?: AbortSignal,
+): Promise<{ exitCode: number; stdout: string; stderr: string }> {
+  return new Promise((resolve) => {
+    let out = "";
+    let err = "";
+    let child: ChildProcessByStdio<null, Readable, Readable>;
+    try {
+      child = spawn("git", args, {
+        cwd,
+        env: safeNoninteractiveEnv(),
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: process.platform !== "win32",
+      });
+    } catch (e) {
+      resolve({ exitCode: -1, stdout: "", stderr: (e as Error).message });
+      return;
+    }
+    child.stdout.on("data", (d) => (out += d.toString()));
+    child.stderr.on("data", (d) => (err += d.toString()));
+    let killed = false;
+    const killChild = () => {
+      killed = true;
+      killProcessGroup(child, "SIGTERM");
+      setTimeout(() => killProcessGroup(child, "SIGKILL"), 1500).unref?.();
+    };
+    const timeout = setTimeout(killChild, DEFAULT_COMMAND_TIMEOUT_MS);
+    timeout.unref?.();
+    const onAbort = killChild;
+    signal?.addEventListener("abort", onAbort, { once: true });
+    child.on("error", (e) => {
+      clearTimeout(timeout);
+      signal?.removeEventListener("abort", onAbort);
+      resolve({ exitCode: -1, stdout: out, stderr: err + e.message });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timeout);
+      signal?.removeEventListener("abort", onAbort);
+      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
+  return r.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+}
+
 export function registerRecovery(pi: ExtensionAPI) {
   pi.registerTool({
     name: "graphite_recovery",
@@ -21,6 +84,12 @@ export function registerRecovery(pi: ExtensionAPI) {
       stageAll: Type.Optional(
         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).",
+        }),
+      ),
       force: Type.Optional(
         Type.Boolean({ description: "action=abort|undo: skip confirmation prompt (--force)." }),
       ),
@@ -28,10 +97,22 @@ export function registerRecovery(pi: ExtensionAPI) {
     async execute(_id, p, signal): Promise<ToolReturn> {
       let args: string[];
       switch (p.action) {
-        case "continue":
+        case "continue": {
+          if (!p.allowConflictMarkers) {
+            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` +
+                  dirty.map((f) => `  - ${f}`).join("\n") +
+                  `\n\nResolve each file (remove <<<<<<< / ======= / >>>>>>> blocks), then re-run. ` +
+                  `If markers are intentional, pass allowConflictMarkers:true.`,
+              );
+            }
+          }
           args = ["continue"];
           if (p.stageAll) args.push("--all");
           break;
+        }
         case "abort":
           args = ["abort"];
           if (p.force) args.push("--force");

package/src/tools/repo.ts

@@ -9,13 +9,13 @@ const params = Type.Object({
   trunk: Type.Optional(
     Type.String({
       description:
-        "Trunk branch name. Required for action=set_trunk. Optional for action=init (otherwise gt prompts).",
+        "Trunk branch name. Required for action=set_trunk. Optional for action=init (gt default behavior).",
     }),
   ),
   addAdditionalTrunk: Type.Optional(
     Type.Boolean({
       description:
-        "If true with action=set_trunk, add an additional trunk via `gt trunk --add` instead of replacing.",
+        "Rejected: `gt trunk --add` is interactive and not exposed to agents.",
     }),
   ),
   reset: Type.Optional(
@@ -30,7 +30,7 @@ export function registerRepo(pi: ExtensionAPI) {
     name: "graphite_repo",
     label: "Graphite: repo",
     description:
-      "Repo-level Graphite operations: status snapshot (log + trunk), init, set/add trunk, and show config.",
+      "Repo-level Graphite operations: status snapshot (log + trunk), init, set trunk, and show config.",
     promptSnippet:
       "graphite_repo: inspect repo state, initialize Graphite, configure trunk(s)",
     parameters: params,
@@ -85,15 +85,7 @@ export function registerRepo(pi: ExtensionAPI) {
             details: { result: f },
           };
         }
-        // `gt trunk --add` is interactive (prompts for the new trunk name).
-        // With --no-interactive this will fail; surface that failure rather
-        // than silently misleading the caller.
-        const r = await runGt(["trunk", "--add"], { cwd, signal });
-        const f = await ensureSuccess("gt trunk --add", r, cwd);
-        return {
-          content: [{ type: "text", text: renderText("gt trunk --add", f) }],
-          details: { result: f },
-        };
+        throw new Error("gt trunk --add is interactive; not exposed to agents.");
       }
 
       // show_config

package/src/tools/stack.ts

@@ -1,5 +1,7 @@
+import { spawn, type ChildProcessByStdio } from "node:child_process";
+import type { Readable } from "node:stream";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { runGt } from "../lib/exec";
+import { DEFAULT_COMMAND_TIMEOUT_MS, killProcessGroup, runGt, safeNoninteractiveEnv } from "../lib/exec";
 import { ensureSuccess, renderText } from "../lib/result";
 import {
   CwdParam,
@@ -27,9 +29,9 @@ export function registerStackView(pi: ExtensionAPI) {
         }),
       ),
       scope: Type.Optional(
-        StringEnum(["all_trunks", "current_stack", "default"] as const, {
+        StringEnum(["current_stack", "default"] as const, {
           description:
-            "all_trunks adds --all (only supported on mode=full/default). current_stack adds --stack. default does neither.",
+            "current_stack adds --stack (only branches in the current stack). default shows all stacks off trunk (which is what `gt log` does by default — no separate 'all' flag is needed or supported).",
         }),
       ),
       showUntracked: Type.Optional(Type.Boolean()),
@@ -37,16 +39,6 @@ export function registerStackView(pi: ExtensionAPI) {
       steps: Type.Optional(Type.Integer({ minimum: 1 })),
     }),
     async execute(_id, p, signal): Promise<ToolReturn> {
-      // Empirically, current gt rejects `--all` on `gt log short` / `gt log long`
-      // ("Unknown argument: all"). Block that combination at the tool layer
-      // instead of exposing it to the model.
-      if (p.scope === "all_trunks" && (p.mode === "short" || p.mode === "long")) {
-        throw new Error(
-          "graphite_stack_view: scope='all_trunks' is not supported with mode='short'/'long' " +
-            "(current `gt` rejects `--all` on those forms). Omit `mode` (or use mode='full') to use --all.",
-        );
-      }
-
       const sub =
         p.mode === "short"
           ? ["log", "short"]
@@ -54,7 +46,6 @@ export function registerStackView(pi: ExtensionAPI) {
             ? ["log", "long"]
             : ["log"];
       const args = [...sub];
-      if (p.scope === "all_trunks") args.push("--all");
       if (p.scope === "current_stack") args.push("--stack");
       if (p.showUntracked) args.push("--show-untracked");
       if (p.reverse) args.push("--reverse");
@@ -121,7 +112,7 @@ export function registerStackReorganize(pi: ExtensionAPI) {
     name: "graphite_stack_reorganize",
     label: "Graphite: stack reorganize",
     description:
-      "Reorganize the stack: move a branch onto a new parent, fold a branch into its parent, or split by file pathspec. `gt reorder` is intentionally not exposed (editor-only).",
+      "Reorganize the stack: move a branch onto a new parent, fold a branch into its parent, or split by file pathspec. NOTE: move_branch auto-restacks all descendants; if either source or onto contains a merge-of-trunk with a different tip than the other, conflicts are likely — use dryRun:true first to preview. Use graphite_stack_compose to linearize branches that diverge through merges. `gt reorder` is intentionally not exposed (editor-only).",
     promptSnippet:
       "graphite_stack_reorganize: move / fold / split-by-file branches",
     parameters: Type.Object({
@@ -134,6 +125,12 @@ export function registerStackReorganize(pi: ExtensionAPI) {
       onlyMove: Type.Optional(
         Type.Boolean({ description: "action=move_branch: leave descendants behind (--only)." }),
       ),
+      dryRun: Type.Optional(
+        Type.Boolean({
+          description:
+            "action=move_branch: don't run `gt move`. Instead, run a `git merge-tree` simulation between source tip and onto tip and report whether conflicts are likely. Use before applying.",
+        }),
+      ),
       foldKeep: Type.Optional(
         Type.Boolean({ description: "action=fold: keep current branch name (--keep)." }),
       ),
@@ -154,6 +151,13 @@ export function registerStackReorganize(pi: ExtensionAPI) {
       let args: string[];
       if (p.action === "move_branch") {
         if (!p.onto) throw new Error("action=move_branch requires `onto`.");
+        if (p.dryRun) {
+          const sim = await simulateMove(p.cwd, p.onto, p.source, signal);
+          return {
+            content: [{ type: "text", text: sim.text }],
+            details: { action: "move_branch", dryRun: true, ...sim.details },
+          };
+        }
         args = ["move", "--onto", p.onto];
         if (p.source) args.push("--source", p.source);
         if (p.onlyMove) args.push("--only");
@@ -183,3 +187,386 @@ export function registerStackReorganize(pi: ExtensionAPI) {
     },
   });
 }
+
+/* ----------------------------- helpers ----------------------------- */
+
+interface RunOut {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+}
+
+function runCmd(
+  cmd: string,
+  args: string[],
+  cwd: string,
+  signal?: AbortSignal,
+): Promise<RunOut> {
+  return new Promise((resolve) => {
+    let out = "";
+    let err = "";
+    let child: ChildProcessByStdio<null, Readable, Readable>;
+    try {
+      child = spawn(cmd, args, {
+        cwd,
+        env: safeNoninteractiveEnv(),
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: process.platform !== "win32",
+      });
+    } catch (e) {
+      resolve({ exitCode: -1, stdout: "", stderr: (e as Error).message });
+      return;
+    }
+    child.stdout.on("data", (d) => {
+      out += d.toString();
+    });
+    child.stderr.on("data", (d) => {
+      err += d.toString();
+    });
+    let killed = false;
+    const killChild = () => {
+      killed = true;
+      killProcessGroup(child, "SIGTERM");
+      setTimeout(() => killProcessGroup(child, "SIGKILL"), 1500).unref?.();
+    };
+    const timeout = setTimeout(killChild, DEFAULT_COMMAND_TIMEOUT_MS);
+    timeout.unref?.();
+    const onAbort = killChild;
+    signal?.addEventListener("abort", onAbort, { once: true });
+    child.on("error", (e) => {
+      clearTimeout(timeout);
+      signal?.removeEventListener("abort", onAbort);
+      resolve({ exitCode: -1, stdout: out, stderr: err + e.message });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timeout);
+      signal?.removeEventListener("abort", onAbort);
+      resolve({ exitCode: killed ? -1 : (code ?? -1), stdout: out, stderr: err });
+    });
+  });
+}
+
+async function gitRevParse(
+  cwd: string,
+  ref: string,
+  signal?: AbortSignal,
+): Promise<string | null> {
+  const r = await runCmd("git", ["rev-parse", "--verify", ref], cwd, signal);
+  if (r.exitCode !== 0) return null;
+  return r.stdout.trim() || null;
+}
+
+async function simulateMove(
+  cwd: string,
+  onto: string,
+  source: string | undefined,
+  signal: AbortSignal | undefined,
+): Promise<{ text: string; details: Record<string, unknown> }> {
+  // Resolve source default = current branch
+  let src = source;
+  if (!src) {
+    const r = await runCmd(
+      "git",
+      ["branch", "--show-current"],
+      cwd,
+      signal,
+    );
+    src = r.stdout.trim();
+  }
+  if (!src) {
+    return {
+      text: "[move_branch dry-run] could not resolve source branch (detached HEAD?).",
+      details: { ok: false },
+    };
+  }
+  const ontoSha = await gitRevParse(cwd, onto, signal);
+  const srcSha = await gitRevParse(cwd, src, signal);
+  if (!ontoSha || !srcSha) {
+    return {
+      text: `[move_branch dry-run] unknown ref(s): onto=${onto}(${ontoSha ?? "?"}) src=${src}(${srcSha ?? "?"})`,
+      details: { ok: false, src, onto },
+    };
+  }
+  // Find merge base
+  const mb = await runCmd(
+    "git",
+    ["merge-base", ontoSha, srcSha],
+    cwd,
+    signal,
+  );
+  const base = mb.stdout.trim();
+  // Use merge-tree to simulate. Modern git: `git merge-tree --write-tree --merge-base <base> <onto> <src>`
+  const mt = await runCmd(
+    "git",
+    [
+      "merge-tree",
+      "--write-tree",
+      "--name-only",
+      "--merge-base",
+      base || ontoSha,
+      ontoSha,
+      srcSha,
+    ],
+    cwd,
+    signal,
+  );
+  // Exit code 0 = clean. Non-zero = conflicts; stdout lists conflicted paths (after tree oid on first line).
+  let conflictedFiles: string[] = [];
+  let clean = mt.exitCode === 0;
+  if (!clean) {
+    const lines = mt.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+    // First line is the merge tree oid; remaining are conflicted paths.
+    if (lines.length > 1) conflictedFiles = lines.slice(1);
+    else conflictedFiles = lines;
+  }
+  // Also count commits each side carries beyond the merge base
+  const ahead = await runCmd(
+    "git",
+    ["rev-list", "--count", `${base || ontoSha}..${srcSha}`],
+    cwd,
+    signal,
+  );
+  const behind = await runCmd(
+    "git",
+    ["rev-list", "--count", `${base || ontoSha}..${ontoSha}`],
+    cwd,
+    signal,
+  );
+  const lines = [
+    `[move_branch dry-run] source=${src} -> onto=${onto}`,
+    `merge-base = ${base || "(none)"}`,
+    `src ahead of base by ${ahead.stdout.trim() || "?"} commits; onto ahead by ${behind.stdout.trim() || "?"} commits`,
+    clean
+      ? `merge-tree: CLEAN — \`gt move\` is likely safe.`
+      : `merge-tree: CONFLICTS in ${conflictedFiles.length} path(s):`,
+  ];
+  if (!clean) lines.push(...conflictedFiles.map((f) => `  - ${f}`));
+  if (!clean) {
+    lines.push(
+      "",
+      "Suggestion: either resolve drift first (e.g. rebase source onto onto's trunk merge) or use graphite_stack_compose to linearize by cherry-picking unique commits in order.",
+    );
+  }
+  return {
+    text: lines.join("\n"),
+    details: {
+      ok: true,
+      clean,
+      src,
+      onto,
+      mergeBase: base || null,
+      srcAhead: Number(ahead.stdout.trim()) || 0,
+      ontoAhead: Number(behind.stdout.trim()) || 0,
+      conflictedFiles,
+    },
+  };
+}
+
+/* ----------------------------- stack_compose ----------------------------- */
+
+export function registerStackCompose(pi: ExtensionAPI) {
+  pi.registerTool({
+    name: "graphite_stack_compose",
+    label: "Graphite: stack compose",
+    description:
+      "Linearize a set of branches into a fresh stack by cherry-picking each branch's unique commits (base..branch, no-merges) in the given order. Each successive branch is rebuilt on top of the previous, then tracked by Graphite with the explicit parent. Use this when `gt move` would conflict because branches contain divergent merges of trunk. Halts and surfaces the failing branch on cherry-pick conflict; continue with safe git env, then call again with `resume:true`.",
+    promptSnippet:
+      "graphite_stack_compose: rebuild branches as a linear stack on top of base via cherry-pick",
+    promptGuidelines: [
+      "Run with dryRun:true first to see the commits that would be cherry-picked per branch.",
+      "If a cherry-pick halts on conflict, resolve in git, run `GIT_EDITOR=true EDITOR=true VISUAL=true git cherry-pick --continue`, then re-invoke graphite_stack_compose with resume:true to finish the remaining branches.",
+    ],
+    parameters: Type.Object({
+      cwd: CwdParam,
+      base: Type.String({
+        description:
+          "Base branch the new stack will sit on top of (e.g. 'main', 'origin/main'). Must exist.",
+      }),
+      order: Type.Array(Type.String(), {
+        description:
+          "Branch names in bottom-up order. order[0] is rebuilt on `base`, order[1] on order[0], etc.",
+      }),
+      dryRun: Type.Optional(
+        Type.Boolean({
+          description: "If true, just list commits per branch without modifying anything.",
+        }),
+      ),
+      includeMerges: Type.Optional(
+        Type.Boolean({
+          description:
+            "Include merge commits when computing unique commits (default false; merges are usually trunk-syncs you do not want to replay).",
+        }),
+      ),
+      confirmDestructive: Type.Optional(
+        Type.Boolean({
+          description:
+            "Required when dryRun is false: rewrites each branch ref to a new history. Local-only but irreversible without reflog.",
+        }),
+      ),
+      resume: Type.Optional(
+        Type.Boolean({
+          description:
+            "Skip branches whose tip already matches the expected linearized history (used after resolving a cherry-pick conflict).",
+        }),
+      ),
+    }),
+    async execute(_id, p, signal): Promise<ToolReturn> {
+      if (!p.order || p.order.length === 0) {
+        throw new Error("graphite_stack_compose requires non-empty `order`.");
+      }
+      if (!p.dryRun) requireConfirm(p.confirmDestructive, "stack_compose (rewrites local branch refs)");
+
+      // Validate base + all branches resolve.
+      const refs = [p.base, ...p.order];
+      const resolved: Record<string, string> = {};
+      for (const ref of refs) {
+        const sha = await gitRevParse(p.cwd, ref, signal);
+        if (!sha) {
+          throw new Error(`graphite_stack_compose: cannot resolve ref \`${ref}\`.`);
+        }
+        resolved[ref] = sha;
+      }
+
+      // Compute unique commit list per branch relative to base.
+      const revListArgs = (base: string, branch: string) => {
+        const a = ["rev-list", "--reverse"];
+        if (!p.includeMerges) a.push("--no-merges");
+        a.push(`${base}..${branch}`);
+        return a;
+      };
+
+      const plan: Array<{ branch: string; commits: string[]; subjects: string[] }> = [];
+      for (const br of p.order) {
+        const r = await runCmd("git", revListArgs(p.base, br), p.cwd, signal);
+        if (r.exitCode !== 0) {
+          throw new Error(
+            `git rev-list failed for ${p.base}..${br}: ${r.stderr.trim()}`,
+          );
+        }
+        const commits = r.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+        const subjects: string[] = [];
+        for (const c of commits) {
+          const s = await runCmd(
+            "git",
+            ["log", "-1", "--format=%h %s", c],
+            p.cwd,
+            signal,
+          );
+          subjects.push(s.stdout.trim());
+        }
+        plan.push({ branch: br, commits, subjects });
+      }
+
+      const planText = plan
+        .map((step, i) => {
+          const parent = i === 0 ? p.base : p.order[i - 1];
+          const lines = [`# ${step.branch}  (parent=${parent}, ${step.commits.length} commit(s))`];
+          if (step.commits.length === 0) lines.push("  (no unique commits — branch will be reset to parent)");
+          for (const s of step.subjects) lines.push(`  ${s}`);
+          return lines.join("\n");
+        })
+        .join("\n\n");
+
+      if (p.dryRun) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `[stack_compose dry-run] base=${p.base}\n\n${planText}\n\n(Re-run with dryRun:false, confirmDestructive:true to apply.)`,
+            },
+          ],
+          details: { dryRun: true, base: p.base, plan },
+        };
+      }
+
+      // Apply.
+      const log: string[] = [`base=${p.base}`];
+      let parent = p.base;
+      for (const step of plan) {
+        // Skip in resume mode if branch tip already equals expected linearized state:
+        // heuristic — if current branch's parent in graphite already equals `parent`
+        // and its commit set matches step.commits, skip. We use a simpler check:
+        // resume=true + cherry-pick state absent + branch reachable from parent
+        // with same commit subjects in order.
+        if (p.resume) {
+          const reachable = await runCmd(
+            "git",
+            ["merge-base", "--is-ancestor", parent, step.branch],
+            p.cwd,
+            signal,
+          );
+          // git returns 0 if ancestor.
+          if (reachable.exitCode === 0) {
+            // Compare commits between parent..branch and step.commits subjects.
+            const cur = await runCmd("git", revListArgs(parent, step.branch), p.cwd, signal);
+            const curCommits = cur.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+            if (curCommits.length === step.commits.length) {
+              log.push(`skip ${step.branch} (already linearized)`);
+              parent = step.branch;
+              continue;
+            }
+          }
+        }
+
+        // Reset branch to parent.
+        const reset = await runCmd(
+          "git",
+          ["checkout", "-B", step.branch, parent],
+          p.cwd,
+          signal,
+        );
+        if (reset.exitCode !== 0) {
+          throw new Error(
+            `compose: failed to checkout ${step.branch} on ${parent}: ${reset.stderr.trim()}`,
+          );
+        }
+        log.push(`reset ${step.branch} -> ${parent}`);
+        // Cherry-pick each commit.
+        for (const c of step.commits) {
+          const cp = await runCmd(
+            "git",
+            ["cherry-pick", "--allow-empty", c],
+            p.cwd,
+            signal,
+          );
+          if (cp.exitCode !== 0) {
+            const msg = [
+              `compose: cherry-pick of ${c} onto ${step.branch} halted with conflicts.`,
+              cp.stdout.trim(),
+              cp.stderr.trim(),
+              "",
+              "Resolve conflicts in git, run `GIT_EDITOR=true EDITOR=true VISUAL=true git cherry-pick --continue` until clean, then call graphite_stack_compose again with resume:true and the same order/base.",
+            ]
+              .filter(Boolean)
+              .join("\n");
+            throw new Error(msg);
+          }
+          log.push(`  cherry-pick ${c.slice(0, 7)}`);
+        }
+        // Track in graphite with explicit parent.
+        const track = await runGt(
+          ["track", step.branch, "--parent", parent, "--force"],
+          { cwd: p.cwd, signal },
+        );
+        if (track.exitCode !== 0) {
+          log.push(
+            `  warning: gt track failed for ${step.branch}: ${track.stderr.trim() || track.stdout.trim()}`,
+          );
+        } else {
+          log.push(`  tracked parent=${parent}`);
+        }
+        parent = step.branch;
+      }
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: `[stack_compose] OK\n\n${log.join("\n")}\n\n${planText}`,
+          },
+        ],
+        details: { dryRun: false, base: p.base, plan, log },
+      };
+    },
+  });
+}