pi-t3-bridge 0.7.2 → 0.8.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Change log
 
+## 0.8.1, 6 November 2026
+
+Version 0.8.1 lets a delegated child run `pnpm install` and `git commit` in a pnpm and lefthook repo, under `bwrap` on Linux and `sandbox-exec` on macOS. Each child gets its own `XDG_RUNTIME_DIR` in the temp folder, where pnpm 12 takes its store lock. The sandbox can now write to the store that `pnpm store path` names for the workdir, and the child uses that store, so it shares the parent's store and does not build a second one in the workdir.
+
+Children now skip install scripts, so a root `prepare` such as `lefthook install` no longer fails on the read-only git hooks. With this setting npm also skips the pre and post scripts of `npm run`, while pnpm still runs them. A brief that needs a postinstall step, such as `next typegen`, should name the build or typecheck that runs it.
+
+## 0.8.0, 5 November 2026
+
+Version 0.8.0 removes the pi-amplike adapter (`amplike.ts`). The package no longer loads pi-amplike or changes its `/mode`, `/btw`, `/handoff`, and `subagent` for T3. Use T3's own `/btw`, `/side`, model picker, and `delegate_task` instead. If you set `{"source":"npm:pi-amplike","extensions":[]}` for the adapter, remove that entry from `~/.pi/agent/settings.json`.
+
+The bridge no longer rewrites the "- Subagents:" bullet in T3's "## T3 Code orchestration" section, so Pi sends T3's system prompt unchanged. The rewrite broke pi-cached-compaction, which rebuilds the last request and compares it byte for byte before it reuses the prompt cache. Every cached compaction in T3 failed with `request field "system" differs`. Pi now sees T3's original bullet, which names Claude's `Agent` and Codex's `spawn_agent`. Pi has neither tool.
+
 ## 0.7.2, 5 November 2026
 
 Version 0.7.2 stops pi-amplike's permission prompt in T3 threads. T3 has its own permission system, so the bridge no longer loads amplike's `permissions` extension inside T3, and Pi no longer asks "Permission required ... Allow?" before bash commands there. Outside T3, amplike's `/permissions` and its prompts work as before.

package/README.md

@@ -1,6 +1,6 @@
 # pi-t3-bridge
 
-pi-t3-bridge is a [Pi](https://pi.dev) package that lets Pi run as an agent inside [T3 Code](https://github.com/pingdotgg/t3code). It also ships the pstack and tstack skill sets, and it adapts [pi-amplike](https://github.com/pasky/pi-amplike) so that amplike's commands work in a T3 thread.
+pi-t3-bridge is a [Pi](https://pi.dev) package that lets Pi run as an agent inside [T3 Code](https://github.com/pingdotgg/t3code). It also ships the pstack and tstack skill sets.
 
 ```mermaid
 flowchart LR
@@ -10,15 +10,12 @@ flowchart LR
         Bridge[bridge.ts<br/>T3 tools, cards, limits]
         Pstack[pstack.ts<br/>pstack skills, model routing]
         Tstack[tstack.ts<br/>tstack skills]
-        Amplike[amplike.ts<br/>pi-amplike in T3]
     end
     Pi --> Bridge
     Pi --> Pstack
     Pi --> Tstack
-    Pi --> Amplike
     Bridge -->|MCP| T3
     Pstack -->|delegate_task| T3
-    Amplike -->|t3_thread_launch, delegate_task| T3
     T3 -->|child threads| Children[Claude, GPT, and other models]
 ```
 
@@ -32,6 +29,8 @@ You need the following programs:
 
 A delegated child runs its shell commands in a sandbox, which is `sandbox-exec` on macOS and `bwrap` (bubblewrap) on Linux and WSL2. On Linux you need the `bubblewrap` package and unprivileged user namespaces. The Ubuntu `bubblewrap` package ships an AppArmor profile that lets `bwrap` run (checked on 26.04). If AppArmor still blocks `bwrap`, run `sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0`.
 
+Inside the sandbox a child can write only to its workdir, its git directory, the tool caches, the pnpm store, and the system temp folder. The git hooks and git config stay read-only, because the parent runs them later outside the sandbox. Each child gets its own `XDG_RUNTIME_DIR` in the temp folder, where pnpm takes its store lock. The child also gets `pnpm_config_store_dir` set to the store that `pnpm store path` names for the workdir outside the sandbox, so it shares the parent's store. Under `bwrap`, pnpm copies packages from the store, because Linux refuses hardlinks across the sandbox's mounts. Children skip install scripts (`npm_config_ignore_scripts` and `pnpm_config_ignore_scripts` are `true`), so a root `prepare` such as `lefthook install` does not run. With this setting npm also skips the pre and post scripts of `npm run` and `npm test`, while pnpm still runs them. Steps that only a postinstall runs must run through the build or typecheck the brief names.
+
 Native Windows and WSL1 have no sandbox. Where no sandbox can run, the bridge blocks a child's shell commands, unless you set `childSandbox` to `"off"` in the settings file.
 
 ## Install
@@ -46,18 +45,16 @@ Pi loads every extension in the package on the next start. To try the package fo
 
 ## What is in the package
 
-The package has four Pi extensions, and you can turn off any of them. None of the extensions needs another one to be loaded, although `pstack.ts` and `amplike.ts` reuse code from `src/bridge`.
+The package has three Pi extensions, and you can turn off any of them. None of the extensions needs another one to be loaded, although `pstack.ts` reuses code from `src/bridge`.
 
 ```text
 pi-t3-bridge/
 ├── bridge.ts       # connects Pi to T3 Code
 ├── pstack.ts       # serves pstack skills and picks models for subagents
 ├── tstack.ts       # serves tstack skills
-├── amplike.ts      # loads pi-amplike and adapts it for T3 threads
 ├── src/
 │   ├── bridge/     # code for bridge.ts
-│   ├── pstack/     # code for pstack.ts
-│   └── amplike/    # code for amplike.ts
+│   └── pstack/     # code for pstack.ts
 ├── pstack/         # upstream pstack skills, agents, and model defaults
 ├── overlay/        # the changes Pi needs on top of pstack/
 └── tstack/         # Theo Browne's tstack skills
@@ -255,61 +252,6 @@ sequenceDiagram
 
 The tstack extension serves Theo Browne's tstack skills from `tstack/skills`, which are babysit-pr, council, file-pr, full-send, full-stop, leaving-pr-comments, modernize, sol-loop, and takeover. It imports no other code from the package, so the skills stay available when you turn the other extensions off.
 
-## pi-amplike in T3 threads
-
-pi-amplike adds handoff, `/btw`, subagents, and prompt modes to Pi, but T3 can't show most of them. T3 shows Pi's `notify`, `select`, `confirm`, `input`, and `editor` calls, and it drops widgets, status lines, custom UI, and key presses. T3 also resumes a thread from the session file it first recorded, so a handoff that moves Pi to a new session file breaks the thread.
-
-To use the adapter, keep pi-amplike installed and turn off its own extensions in `~/.pi/agent/settings.json`. The adapter then loads amplike's extension files itself.
-
-```diff
- "packages": [
-   "npm:pi-t3-bridge",
--  "npm:pi-amplike"
-+  { "source": "npm:pi-amplike", "extensions": [] }
- ]
-```
-
-```text
-on(Pi start)
-  find pi-amplike with Pi's package manager
-  if amplike still loads its own extensions
-    do nothing, and in a T3 thread show a notice with the settings change
-  else if Pi runs inside a T3 thread
-    load amplike's extensions with the T3 changes below
-  else
-    load amplike's extensions unchanged
-```
-
-In a T3 thread, the adapter changes the following parts of amplike:
-
-| amplike | In a T3 thread |
-| --- | --- |
-| `subagent` tool | The adapter turns it off, so subagents run through T3's `delegate_task` and show up in T3. |
-| `/btw <prompt>` | Starts a `delegate_task` child that reads the parent thread's session with `session_query`. The child's answer wakes the parent thread. |
-| `handoff` tool and `/handoff <goal>` | Writes a summary with the session model, then starts a new T3 thread. The current thread keeps its own session file. |
-| `/mode` | Works as in the terminal, and sends each model and thinking change to T3, so T3's model picker shows the same model. |
-| Shortcuts | The adapter turns them off, because T3 sends Pi no key presses. |
-| `/permissions` and its bash prompts | The adapter doesn't load them, because T3 has its own permission system and amplike's prompt would ask a second time. |
-
-`session_query` and amplike's skills work unchanged. The diagram below shows the three commands that talk to T3.
-
-```mermaid
-sequenceDiagram
-    participant You
-    participant Pi as Pi (amplike.ts)
-    participant T3
-    You->>Pi: /handoff fix the failing tests
-    Pi->>Pi: summarize the chat with the session model
-    Pi->>T3: t3_thread_launch(goal, summary, parent session file)
-    T3-->>You: link to the new thread
-    You->>Pi: /btw which file holds the parser?
-    Pi->>T3: delegate_task(question, parent session file)
-    T3-->>Pi: child's answer wakes the thread
-    You->>Pi: /mode rush
-    Pi->>Pi: set model and thinking level
-    Pi->>T3: t3_thread_configure(modelSelection)
-```
-
 ## Settings
 
 The bridge reads one JSON file per machine, at `~/.config/pi-t3/config.json`. Every key is optional. The bridge reads the file again on each prompt, so an edit applies on the next prompt. When a value is invalid, only the invalid key falls back to its default, and the bridge tells you once.

package/bridge.ts

@@ -3,7 +3,6 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { registerAccounts } from "./src/bridge/accounts.ts";
 import { registerAsk } from "./src/bridge/ask.ts";
 import { registerBashTimeout } from "./src/bridge/bash-timeout.ts";
-import { registerBridgeTrim } from "./src/bridge/bridge-trim.ts";
 import { registerUnlessTaken } from "./src/bridge/claim.ts";
 import { registerConfig } from "./src/bridge/config.ts";
 import { registerPlanGate } from "./src/bridge/plan.ts";
@@ -30,7 +29,6 @@ const piT3Bridge = (pi: ExtensionAPI): void => {
   registerPlanGate(pi);
   registerAsk(pi);
   registerT3Mcp(pi);
-  registerBridgeTrim(pi);
   registerUsage(pi);
   registerSteer(pi);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-t3-bridge",
-  "version": "0.7.2",
+  "version": "0.8.1",
   "description": "Pi extension adapter for t3-pstack inside T3 Code.",
   "keywords": [
     "pi-extension",
@@ -39,7 +39,6 @@
     "LICENSE",
     "tstack.ts",
     "tstack",
-    "amplike.ts",
     "CHANGELOG.md"
   ],
   "type": "module",
@@ -82,8 +81,7 @@
     "extensions": [
       "./bridge.ts",
       "./tstack.ts",
-      "./pstack.ts",
-      "./amplike.ts"
+      "./pstack.ts"
     ]
   },
   "upstreams": {

package/pstack/skills/poteto-mode/brief.md

@@ -60,7 +60,8 @@ ISSUES or BLOCKED: one line each with file:line and the command that shows it
 
 The child's own pstack extension reads this brief from its first message and enforces it, whatever the model does:
 
-- Every shell command runs in a macOS sandbox that can write only to the workdir, its git directory, the tool caches and the system temp folder.
+- Every shell command runs in a sandbox (`sandbox-exec` on macOS, `bwrap` on Linux) that can write only to the workdir, its git directory, the tool caches, the pnpm store and the system temp folder. Git hooks and git config stay read-only.
+- Install scripts are skipped, so `pnpm install` or `npm install` runs no `prepare` or `postinstall`. Don't ask for `prepare` to pass. If a postinstall generates something, such as `next typegen`, name the build or typecheck that runs it in the acceptance command. npm also skips `pre` and `post` scripts of `npm run` and `npm test`, so name those too, as in `npm run prebuild && npm test`.
 - `write` and `edit` only touch the listed files and `.scratch/`.
 - Shell timeouts stop at the time limit. After it, or past the disk limit, every tool is refused and the child can only report.
 - When the child ends its turn, the extension reruns the acceptance command, `git status` and `du`, and appends a "Checked by t3-pstack" block with the real exit codes and STATUS. It also writes a ledger line to `~/.local/state/t3-pstack/ledger.jsonl`.

package/src/pstack/child.ts

@@ -297,7 +297,7 @@ export const registerChild = (pi: ExtensionAPI): void => {
       state.gitDir = undefined;
     }
 
-    state.sandbox = await chooseSandbox(state.gitDir);
+    state.sandbox = await chooseSandbox(ctx.cwd, state.gitDir);
 
     state.baselineKb = await duKb(ctx.cwd);
 

package/src/pstack/sandbox.ts

@@ -1,5 +1,5 @@
 import { execFile } from "node:child_process";
-import { existsSync, mkdirSync, realpathSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, realpathSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import path from "node:path";
 import { promisify } from "node:util";
@@ -34,10 +34,17 @@ const isProbeFailure = compile(
   )
 ).check;
 
+// Settled once per child: its own XDG_RUNTIME_DIR, and the pnpm store it
+// shares with the parent.
+interface ChildEnv {
+  readonly pnpmStore: string | undefined;
+  readonly runtimeDir: string;
+}
+
 export type Sandbox =
-  | { kind: "bubblewrap"; bwrap: string }
-  | { kind: "off" }
-  | { kind: "sandbox-exec" }
+  | { kind: "bubblewrap"; bwrap: string; env: ChildEnv }
+  | { kind: "off"; env: ChildEnv }
+  | { kind: "sandbox-exec"; env: ChildEnv }
   | { kind: "unavailable"; reason: string };
 
 const quote = (text: string): string => `'${text.replaceAll("'", `'\\''`)}'`;
@@ -50,8 +57,30 @@ export const real = (target: string): string => {
   }
 };
 
-// Tool caches and installs stay writable, so uv, npm and mise work.
-const cacheRoots = (): string[] => {
+// The store pnpm picks for this workdir outside the sandbox, from project and
+// user config alike. Undefined when pnpm isn't installed. A store at or above
+// home would open all of home, so it stays unbound.
+const pnpmStore = async (workdir: string): Promise<string | undefined> => {
+  try {
+    const { stdout } = await run("pnpm", ["store", "path"], {
+      cwd: workdir,
+      timeout: PROBE_TIMEOUT_MS,
+    });
+
+    const store = path.dirname(stdout.trim());
+    const fromHome = path.relative(store, homedir());
+
+    return path.isAbsolute(store) && fromHome.startsWith("..")
+      ? store
+      : undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+// Tool caches, installs and the pnpm store stay writable, so uv, npm, pnpm
+// and mise work.
+const cacheRoots = (store: string | undefined): string[] => {
   const home = homedir();
 
   return [
@@ -59,14 +88,19 @@ const cacheRoots = (): string[] => {
     path.join(home, ".npm"),
     path.join(home, ".local", "share", "uv"),
     path.join(home, ".local", "share", "mise"),
+    ...(store === undefined ? [] : [store]),
   ];
 };
 
-const writableRoots = (workdir: string, gitDir: string | undefined) =>
+const writableRoots = (
+  workdir: string,
+  gitDir: string | undefined,
+  store: string | undefined
+) =>
   [
     workdir,
     gitDir,
-    ...cacheRoots(),
+    ...cacheRoots(store),
     path.join(homedir(), "Library", "Caches"),
     "/private/var/folders",
     tmpdir(),
@@ -114,7 +148,8 @@ const bwrapArgs = (
   bwrap: string,
   command: string,
   workdir: string,
-  gitDir: string | undefined
+  gitDir: string | undefined,
+  store: string | undefined
 ): string[] => [
   bwrap,
   "--ro-bind",
@@ -125,7 +160,7 @@ const bwrapArgs = (
   "/dev",
   "--proc",
   "/proc",
-  ...existing(writableRoots(workdir, gitDir)).flatMap((root) =>
+  ...existing(writableRoots(workdir, gitDir, store)).flatMap((root) =>
     root === "/dev" ? [] : ["--bind", root, root]
   ),
   ...existing(
@@ -158,10 +193,18 @@ const probeBwrap = async (bwrap: string): Promise<string | undefined> => {
 
 // A missing root can't be bound, and a missing hooks directory could be
 // created by the child, so both are made on the host first. They are empty
-// directories, so git and the tools see no change.
-const prepareBinds = (gitDir: string | undefined): void => {
-  for (const root of cacheRoots()) {
-    mkdirSync(root, { recursive: true });
+// directories, so git and the tools see no change. A root the user can't
+// create stays unbound.
+const prepareBinds = (
+  gitDir: string | undefined,
+  store: string | undefined
+): void => {
+  for (const root of cacheRoots(store)) {
+    try {
+      mkdirSync(root, { recursive: true });
+    } catch {
+      continue;
+    }
   }
 
   if (gitDir !== undefined) {
@@ -169,17 +212,23 @@ const prepareBinds = (gitDir: string | undefined): void => {
   }
 };
 
+const childEnv = async (workdir: string): Promise<ChildEnv> => ({
+  pnpmStore: await pnpmStore(workdir),
+  runtimeDir: mkdtempSync(path.join(tmpdir(), "pi-t3-child-")),
+});
+
 // Run once per child, before its first command. "childSandbox": "off" in the
 // config wins on every platform.
 export const chooseSandbox = async (
+  workdir: string,
   gitDir: string | undefined
 ): Promise<Sandbox> => {
   if (readConfig().childSandbox === "off") {
-    return { kind: "off" };
+    return { env: await childEnv(workdir), kind: "off" };
   }
 
   if (process.platform === "darwin" && existsSync(SANDBOX)) {
-    return { kind: "sandbox-exec" };
+    return { env: await childEnv(workdir), kind: "sandbox-exec" };
   }
 
   if (process.platform !== "linux") {
@@ -204,11 +253,24 @@ export const chooseSandbox = async (
     return { kind: "unavailable", reason: problem };
   }
 
-  prepareBinds(gitDir);
+  const env = await childEnv(workdir);
 
-  return { bwrap, kind: "bubblewrap" };
+  prepareBinds(gitDir, env.pnpmStore);
+
+  return { bwrap, env, kind: "bubblewrap" };
 };
 
+// pnpm 12 takes its store lock in $XDG_RUNTIME_DIR, which the sandbox keeps
+// read-only, so each child gets its own. Each bwrap bind is its own mount, and
+// Linux refuses a hardlink between mounts, so pnpm would build a second store
+// in the workdir. Naming the store keeps the one pnpm picked for the parent,
+// and pnpm copies from it. Install scripts stay off, so a `prepare` such as `lefthook install`
+// doesn't fail on the read-only hooks. npm and yarn read npm_config_*, pnpm 11
+// and later read pnpm_config_*. npm also skips pre and post scripts of
+// `npm run` then.
+const exportEnv = (env: ChildEnv, command: string): string =>
+  `export XDG_RUNTIME_DIR=${quote(env.runtimeDir)}${env.pnpmStore === undefined ? "" : ` pnpm_config_store_dir=${quote(env.pnpmStore)}`} npm_config_ignore_scripts=true pnpm_config_ignore_scripts=true; ${command}`;
+
 // Undefined when no sandbox runs: the caller must not run the command.
 export const wrap = (
   sandbox: Sandbox | undefined,
@@ -218,17 +280,29 @@ export const wrap = (
 ): string | undefined => {
   switch (sandbox?.kind) {
     case "sandbox-exec": {
-      return `${SANDBOX} -p ${quote(sandboxProfile(writableRoots(workdir, gitDir), gitDenies(gitDir)))} /bin/bash -c ${quote(command)}`;
+      return exportEnv(
+        sandbox.env,
+        `${SANDBOX} -p ${quote(sandboxProfile(writableRoots(workdir, gitDir, sandbox.env.pnpmStore), gitDenies(gitDir)))} /bin/bash -c ${quote(command)}`
+      );
     }
 
     case "bubblewrap": {
-      return bwrapArgs(sandbox.bwrap, command, workdir, gitDir)
-        .map(quote)
-        .join(" ");
+      return exportEnv(
+        sandbox.env,
+        bwrapArgs(
+          sandbox.bwrap,
+          command,
+          workdir,
+          gitDir,
+          sandbox.env.pnpmStore
+        )
+          .map(quote)
+          .join(" ")
+      );
     }
 
     case "off": {
-      return command;
+      return exportEnv(sandbox.env, command);
     }
 
     default: {

package/amplike.ts

@@ -1,58 +0,0 @@
-import path from "node:path";
-
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-
-import {
-  findAmplike,
-  loadFactory,
-  loadModeSpecFrom,
-} from "./src/amplike/package.ts";
-import { t3View } from "./src/amplike/t3-view.ts";
-import { insideT3 } from "./src/bridge/t3-http.ts";
-
-// T3 asks the user before risky tool calls itself, so amplike's bash prompt
-// would ask a second time.
-const T3_SKIPPED_EXTENSIONS: ReadonlySet<string> = new Set(["permissions"]);
-
-// Loads pi-amplike's extensions in place of Pi, so a T3 thread gets T3's
-// versions of the parts T3 can't show. Outside T3 amplike loads unchanged.
-// It runs only when the settings entry for amplike turns its extensions off.
-const amplikeExtension = async (pi: ExtensionAPI): Promise<void> => {
-  const amplike = await findAmplike(process.cwd());
-
-  if (amplike === undefined) {
-    return;
-  }
-
-  if (amplike.selfLoaded) {
-    if (insideT3()) {
-      pi.on("session_start", (_event, ctx) => {
-        if (ctx.hasUI) {
-          ctx.ui.notify(
-            `pi-t3 can't adapt pi-amplike for T3 while pi-amplike loads its own extensions. In ~/.pi/agent/settings.json, change "${amplike.source}" to {"source":"${amplike.source}","extensions":[]}.`,
-            "warning"
-          );
-        }
-      });
-    }
-
-    return;
-  }
-
-  const inT3 = insideT3();
-
-  const host = inT3 ? t3View(pi, await loadModeSpecFrom(amplike.root)) : pi;
-
-  const files = inT3
-    ? amplike.extensions.filter(
-        (file) => !T3_SKIPPED_EXTENSIONS.has(path.parse(file).name)
-      )
-    : amplike.extensions;
-
-  const factories = await Promise.all(files.map(loadFactory));
-
-  // Each call starts in file order, as when Pi loads the files itself.
-  await Promise.all(factories.map((factory) => factory(host)));
-};
-
-export default amplikeExtension;

package/src/amplike/btw.ts

@@ -1,89 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { compile, nullable, obj, opt, str } from "@earendil-works/pi-schema";
-
-import { callT3Tool } from "../bridge/t3-http.ts";
-import type { LoadModeSpec } from "./package.ts";
-import {
-  changeFromFlags,
-  currentSelection,
-  isEmptyChange,
-  parseFlags,
-} from "./selection.ts";
-import type { SelectionChange } from "./selection.ts";
-
-type Command = Parameters<ExtensionAPI["registerCommand"]>[1];
-
-const isDelegated = compile(
-  obj({ link: opt(nullable(str())), taskId: str() }, { open: true })
-).check;
-
-const TITLE_LENGTH = 80;
-
-const USAGE = "Usage: /btw [-mode <name>] [-model <provider/id>] <prompt>";
-
-// delegate_task's target for a Pi child: model as "provider/modelId", and the
-// thinking level as an option. A flag that names only one keeps the other.
-const targetFor = async (change: SelectionChange) => {
-  const current = await currentSelection();
-  const options: Record<string, string> = {};
-
-  if (change.thinking !== undefined) {
-    options.thinking = change.thinking;
-  }
-
-  return { model: change.model ?? current.model, options };
-};
-
-// In T3, /btw is a delegate_task child. The child shows up in T3, and its
-// result wakes this thread when it finishes.
-export const btwCommand = (loadModeSpec: LoadModeSpec): Command => ({
-  description:
-    "Ask a side question in a T3 child thread: /btw [-mode <name>] [-model <provider/id>] <prompt>",
-  handler: async (args, ctx) => {
-    try {
-      const { flags, text } = parseFlags(args);
-
-      if (text.length === 0) {
-        throw new Error(USAGE);
-      }
-
-      const change = await changeFromFlags(flags, ctx.cwd, loadModeSpec);
-      const parent = ctx.sessionManager.getSessionFile();
-
-      const task = [
-        "The user asked this side question while working in another thread. Answer it. Inspect only, change no file.",
-        text,
-        ...(parent === undefined
-          ? []
-          : [
-              `The other thread's Pi session file is \`${parent}\`. Call session_query on it for any context the question needs.`,
-            ]),
-      ].join("\n\n");
-
-      const delegate = {
-        mode: "async",
-        role: "research",
-        task,
-        title: `btw: ${text}`.slice(0, TITLE_LENGTH),
-      };
-
-      const delegated = isEmptyChange(change)
-        ? await callT3Tool("delegate_task", delegate)
-        : await callT3Tool("delegate_task", {
-            ...delegate,
-            target: await targetFor(change),
-          });
-
-      if (!isDelegated(delegated)) {
-        throw new Error("delegate_task returned no task.");
-      }
-
-      ctx.ui.notify(
-        `btw started: ${delegated.link ?? delegated.taskId}`,
-        "info"
-      );
-    } catch (error) {
-      ctx.ui.notify(`btw failed: ${String(error)}`, "error");
-    }
-  },
-});

package/src/amplike/handoff.ts

@@ -1,200 +0,0 @@
-import type { Message } from "@earendil-works/pi-ai";
-import {
-  convertToLlm,
-  defineTool,
-  serializeConversation,
-} from "@earendil-works/pi-coding-agent";
-import type {
-  ExtensionAPI,
-  ExtensionContext,
-} from "@earendil-works/pi-coding-agent";
-import { compile, nullable, obj, opt, str } from "@earendil-works/pi-schema";
-import type { Static } from "@earendil-works/pi-schema";
-
-import { callT3Tool } from "../bridge/t3-http.ts";
-import type { LoadModeSpec } from "./package.ts";
-import {
-  applyChange,
-  changeFromFlags,
-  currentSelection,
-  isEmptyChange,
-  parseFlags,
-} from "./selection.ts";
-import type { Flags } from "./selection.ts";
-
-type Command = Parameters<ExtensionAPI["registerCommand"]>[1];
-
-const SUMMARY_PROMPT = `You write the first message of a new thread that continues work from a conversation. Given the conversation and the user's goal for the new thread, write a self-contained prompt with:
-
-## Context
-The decisions made, approaches taken, and key findings that matter for the goal.
-
-Files involved:
-- each relevant file that was discussed or changed
-
-## Task
-What the new thread should do next, based on the goal.
-
-Output only the prompt, with no preamble.`;
-
-const TITLE_LENGTH = 80;
-
-const isLaunched = compile(
-  obj({ link: opt(nullable(str())), threadId: str() }, { open: true })
-).check;
-
-const HandoffSchema = obj(
-  {
-    goal: str({ description: "The goal/task for the new thread" }),
-    mode: opt(
-      str({
-        description:
-          "Amplike mode name to start the new thread with (e.g. 'rush', 'smart', 'deep')",
-      })
-    ),
-    model: opt(
-      str({
-        description:
-          "Model to start the new thread with, as provider/modelId (e.g. 'anthropic/claude-haiku-4-5')",
-      })
-    ),
-  },
-  { open: true }
-);
-
-const summarize = async (
-  ctx: ExtensionContext,
-  goal: string,
-  signal: AbortSignal | undefined
-): Promise<string> => {
-  const { model } = ctx;
-
-  if (model === undefined) {
-    throw new Error("No model selected.");
-  }
-
-  const messages = ctx.sessionManager
-    .getBranch()
-    .flatMap((entry) => (entry.type === "message" ? [entry.message] : []));
-
-  if (messages.length === 0) {
-    throw new Error("No conversation to hand off.");
-  }
-
-  const request: Message = {
-    content: [
-      {
-        text: `## Conversation\n\n${serializeConversation(convertToLlm(messages))}\n\n## Goal for the new thread\n\n${goal}`,
-        type: "text",
-      },
-    ],
-    role: "user",
-    timestamp: Date.now(),
-  };
-
-  const response = await ctx.modelRegistry
-    .streamSimple(
-      model,
-      { messages: [request], systemPrompt: SUMMARY_PROMPT },
-      { signal }
-    )
-    .result();
-
-  if (response.stopReason === "aborted" || response.stopReason === "error") {
-    throw new Error(
-      response.errorMessage ?? `The summary ${response.stopReason}.`
-    );
-  }
-
-  return response.content
-    .flatMap((part) => (part.type === "text" ? [part.text] : []))
-    .join("\n");
-};
-
-// In T3 a handoff is a new T3 thread. Pi keeps its own session file, which is
-// the one T3 resumes this thread from.
-const handoff = async (
-  ctx: ExtensionContext,
-  goal: string,
-  flags: Flags,
-  loadModeSpec: LoadModeSpec,
-  signal: AbortSignal | undefined
-): Promise<string> => {
-  const change = await changeFromFlags(flags, ctx.cwd, loadModeSpec);
-  const summary = await summarize(ctx, goal, signal);
-  const parent = ctx.sessionManager.getSessionFile();
-
-  const message = [
-    goal,
-    ...(parent === undefined
-      ? []
-      : ["/skill:session-query", `**Parent session:** \`${parent}\``]),
-    summary,
-  ].join("\n\n");
-
-  const launch = { message, title: goal.slice(0, TITLE_LENGTH) };
-
-  const launched = isEmptyChange(change)
-    ? await callT3Tool("t3_thread_launch", launch)
-    : await callT3Tool("t3_thread_launch", {
-        ...launch,
-        modelSelection: { ...applyChange(await currentSelection(), change) },
-      });
-
-  if (!isLaunched(launched)) {
-    throw new Error("t3_thread_launch returned no thread.");
-  }
-
-  return launched.link ?? launched.threadId;
-};
-
-export const handoffTool = (loadModeSpec: LoadModeSpec) =>
-  defineTool({
-    description:
-      "Transfer context to a new focused T3 thread. ONLY use this when the user explicitly asks for a handoff. Provide a goal describing what the new thread should focus on. The result is the new thread's link, which you show the user verbatim.",
-    execute: async (
-      _toolCallId,
-      params: Static<typeof HandoffSchema>,
-      signal,
-      _onUpdate,
-      ctx
-    ) => {
-      const link = await handoff(
-        ctx,
-        params.goal,
-        { mode: params.mode, model: params.model },
-        loadModeSpec,
-        signal
-      );
-
-      return {
-        content: [{ text: `Handoff thread started: ${link}`, type: "text" }],
-        details: { link },
-      };
-    },
-    label: "Handoff",
-    name: "handoff",
-    parameters: HandoffSchema,
-  });
-
-export const handoffCommand = (loadModeSpec: LoadModeSpec): Command => ({
-  description:
-    "Start a new T3 thread with a summary of this one: /handoff [-mode <name>] [-model <provider/id>] <goal>",
-  handler: async (args, ctx) => {
-    try {
-      const { flags, text } = parseFlags(args);
-
-      if (text.length === 0) {
-        throw new Error(
-          "Usage: /handoff [-mode <name>] [-model <provider/id>] <goal>"
-        );
-      }
-
-      const link = await handoff(ctx, text, flags, loadModeSpec, ctx.signal);
-
-      ctx.ui.notify(`Handoff thread started: ${link}`, "info");
-    } catch (error) {
-      ctx.ui.notify(`Handoff failed: ${String(error)}`, "error");
-    }
-  },
-});

package/src/amplike/package.ts

@@ -1,136 +0,0 @@
-import { readFileSync } from "node:fs";
-import path from "node:path";
-
-import {
-  DefaultPackageManager,
-  getAgentDir,
-  SettingsManager,
-} from "@earendil-works/pi-coding-agent";
-import type {
-  ExtensionFactory,
-  ResolvedResource,
-} from "@earendil-works/pi-coding-agent";
-import { compile, obj, opt, str, unknown } from "@earendil-works/pi-schema";
-import type { Static } from "@earendil-works/pi-schema";
-
-const PACKAGE_NAME = "pi-amplike";
-
-const isManifest = compile(obj({ name: str() }, { open: true })).check;
-
-// JSON Schema has no function type, so these check that the export exists and
-// isFunction checks that it is a function. Like TypeBox's Type.Function, the
-// check can't see the function's parameters, so the caller names them.
-const isFunction = <F extends (...args: never[]) => void>(
-  value: unknown
-): value is F => typeof value === "function";
-
-const isFactoryModule = compile(
-  obj({ default: unknown() }, { open: true })
-).check;
-
-const isModeUtils = compile(
-  obj({ loadModeSpec: unknown() }, { open: true })
-).check;
-
-const ModeSpecSchema = obj(
-  {
-    modelId: opt(str()),
-    provider: opt(str()),
-    thinkingLevel: opt(str()),
-  },
-  { open: true }
-);
-
-const isModeSpec = compile(ModeSpecSchema).check;
-
-export type ModeSpec = Static<typeof ModeSpecSchema>;
-
-export type LoadModeSpec = (
-  cwd: string,
-  name: string
-) => Promise<ModeSpec | undefined>;
-
-export interface Amplike {
-  readonly extensions: readonly string[];
-  readonly root: string;
-  // True when Pi loads amplike's extensions itself, so this adapter must not.
-  readonly selfLoaded: boolean;
-  readonly source: string;
-}
-
-const isAmplikeRoot = (root: string): boolean => {
-  try {
-    const manifest: unknown = JSON.parse(
-      readFileSync(path.join(root, "package.json"), "utf-8")
-    );
-
-    return isManifest(manifest) && manifest.name === PACKAGE_NAME;
-  } catch {
-    return false;
-  }
-};
-
-const isAmplike = (resource: ResolvedResource): boolean =>
-  resource.metadata.packageRoot !== undefined &&
-  isAmplikeRoot(resource.metadata.packageRoot);
-
-// Pi's own package manager gives the extension files amplike's manifest names,
-// and whether the settings entry for amplike turns them off.
-export const findAmplike = async (
-  cwd: string
-): Promise<Amplike | undefined> => {
-  const agentDir = getAgentDir();
-
-  const manager = new DefaultPackageManager({
-    agentDir,
-    cwd,
-    settingsManager: SettingsManager.create(cwd, agentDir),
-  });
-
-  const resolved = await manager.resolve(async () => "skip");
-  const own = resolved.extensions.filter(isAmplike);
-  const [first] = own;
-
-  if (first?.metadata.packageRoot === undefined) {
-    return undefined;
-  }
-
-  return {
-    extensions: own.map((resource) => resource.path),
-    root: first.metadata.packageRoot,
-    selfLoaded: own.some((resource) => resource.enabled),
-    source: first.metadata.source,
-  };
-};
-
-export const loadFactory = async (file: string): Promise<ExtensionFactory> => {
-  const module: unknown = await import(file);
-
-  if (
-    !isFactoryModule(module) ||
-    !isFunction<ExtensionFactory>(module.default)
-  ) {
-    throw new TypeError(`${file} has no default extension factory.`);
-  }
-
-  return module.default;
-};
-
-// amplike's handoff and subagent read -mode through this helper, so the T3
-// replacements read it the same way.
-export const loadModeSpecFrom = async (root: string): Promise<LoadModeSpec> => {
-  const file = path.join(root, "extensions", "lib", "mode-utils.ts");
-  const module: unknown = await import(file);
-
-  if (!isModeUtils(module) || !isFunction<LoadModeSpec>(module.loadModeSpec)) {
-    throw new TypeError(`${file} has no loadModeSpec export.`);
-  }
-
-  const { loadModeSpec } = module;
-
-  return async (cwd, name) => {
-    const spec: unknown = await loadModeSpec(cwd, name);
-
-    return isModeSpec(spec) ? spec : undefined;
-  };
-};

package/src/amplike/selection.ts

@@ -1,144 +0,0 @@
-import {
-  arr,
-  bool,
-  compile,
-  obj,
-  opt,
-  str,
-  union,
-} from "@earendil-works/pi-schema";
-import type { Static } from "@earendil-works/pi-schema";
-
-import { callT3Tool } from "../bridge/t3-http.ts";
-import type { LoadModeSpec } from "./package.ts";
-
-const OptionSchema = obj(
-  { id: str(), value: union([str(), bool()]) },
-  { open: true }
-);
-
-const SelectionSchema = obj(
-  {
-    instanceId: opt(str()),
-    model: str(),
-    options: opt(arr(OptionSchema)),
-  },
-  { open: true }
-);
-
-const isConfigured = compile(
-  obj({ modelSelection: SelectionSchema }, { open: true })
-).check;
-
-// T3's modelSelection for a Pi thread: model is "provider/modelId", and the
-// thinking level is the "thinking" option.
-export type Selection = Static<typeof SelectionSchema>;
-
-export interface SelectionChange {
-  model?: string;
-  thinking?: string;
-}
-
-export interface Flags {
-  mode?: string;
-  model?: string;
-}
-
-export interface ParsedArgs {
-  readonly flags: Flags;
-  readonly text: string;
-}
-
-const THINKING = "thinking";
-
-export const isEmptyChange = (change: SelectionChange): boolean =>
-  change.model === undefined && change.thinking === undefined;
-
-export const currentSelection = async (): Promise<Selection> => {
-  const result = await callT3Tool("t3_thread_configure", {});
-
-  if (!isConfigured(result)) {
-    throw new Error("t3_thread_configure returned no modelSelection.");
-  }
-
-  return result.modelSelection;
-};
-
-export const applyChange = (
-  current: Selection,
-  change: SelectionChange
-): Selection => {
-  const next: Selection = { ...current, model: change.model ?? current.model };
-
-  if (change.thinking !== undefined) {
-    next.options = [
-      ...(current.options ?? []).filter((option) => option.id !== THINKING),
-      { id: THINKING, value: change.thinking },
-    ];
-  }
-
-  return next;
-};
-
-export const configureThread = async (selection: Selection): Promise<void> => {
-  await callT3Tool("t3_thread_configure", { modelSelection: { ...selection } });
-};
-
-// amplike's commands take `-mode <name>` and `-model <provider/id>` before the
-// text, in either order.
-export const parseFlags = (args: string): ParsedArgs => {
-  const words = args.trim().split(/\s+/u);
-  const flags: Flags = {};
-
-  while (words[0] === "-mode" || words[0] === "-model") {
-    const [flag, value] = words.splice(0, 2);
-
-    if (value === undefined) {
-      throw new Error(`${flag} needs a value.`);
-    }
-
-    if (flag === "-mode") {
-      flags.mode = value;
-    } else {
-      flags.model = value;
-    }
-  }
-
-  return { flags, text: words.join(" ") };
-};
-
-// Same order as amplike: the mode sets model and thinking, then -model
-// overrides the model.
-export const changeFromFlags = async (
-  flags: Flags,
-  cwd: string,
-  loadModeSpec: LoadModeSpec
-): Promise<SelectionChange> => {
-  const change: SelectionChange = {};
-
-  if (flags.mode !== undefined) {
-    const spec = await loadModeSpec(cwd, flags.mode);
-
-    if (spec === undefined) {
-      throw new Error(`Unknown mode "${flags.mode}".`);
-    }
-
-    if (spec.provider !== undefined && spec.modelId !== undefined) {
-      change.model = `${spec.provider}/${spec.modelId}`;
-    }
-
-    change.thinking = spec.thinkingLevel;
-  }
-
-  if (flags.model !== undefined) {
-    if (!flags.model.includes("/")) {
-      throw new Error(
-        `Model "${flags.model}" must be written as provider/modelId.`
-      );
-    }
-
-    change.model = flags.model;
-  }
-
-  return change;
-};

package/src/amplike/t3-view.ts

@@ -1,88 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-
-import { btwCommand } from "./btw.ts";
-import { handoffCommand, handoffTool } from "./handoff.ts";
-import type { LoadModeSpec } from "./package.ts";
-import { applyChange, configureThread, currentSelection } from "./selection.ts";
-import type { SelectionChange } from "./selection.ts";
-
-type Tool = Parameters<ExtensionAPI["registerTool"]>[0];
-
-type Command = Parameters<ExtensionAPI["registerCommand"]>[1];
-
-// What a T3 thread gets for each name amplike registers. A missing name is
-// registered as amplike wrote it. null drops it.
-interface Rules {
-  readonly commands: Readonly<Record<string, Command | null>>;
-  readonly tools: Readonly<Record<string, Tool | null>>;
-}
-
-const t3Rules = (loadModeSpec: LoadModeSpec): Rules => ({
-  commands: {
-    btw: btwCommand(loadModeSpec),
-    handoff: handoffCommand(loadModeSpec),
-  },
-  tools: {
-    handoff: handoffTool(loadModeSpec),
-    // T3's delegate_task runs subagents as T3 threads.
-    subagent: null,
-  },
-});
-
-// T3 owns the thread's model. When amplike's /mode switches Pi's model or
-// thinking level, the same change goes to T3, so T3's model picker matches and
-// T3's next set_model keeps it. amplike awaits setModel before it sets the
-// thinking level, so the two calls reach T3 in order.
-const mirror = async (change: SelectionChange): Promise<void> => {
-  await configureThread(applyChange(await currentSelection(), change));
-};
-
-const mirrorThinking = async (thinking: string): Promise<void> => {
-  try {
-    await mirror({ thinking });
-  } catch (error) {
-    console.error(`pi-t3: T3 kept its thinking level: ${String(error)}`);
-  }
-};
-
-// Pi's extension API is a plain object of closures, so a copy with some
-// methods replaced behaves like the original for everything else.
-export const t3View = (
-  pi: ExtensionAPI,
-  loadModeSpec: LoadModeSpec
-): ExtensionAPI => {
-  const rules = t3Rules(loadModeSpec);
-
-  return {
-    ...pi,
-    registerCommand: (name, options) => {
-      const rule = rules.commands[name];
-
-      if (rule !== null) {
-        pi.registerCommand(name, rule ?? options);
-      }
-    },
-    // T3 sends Pi no key presses.
-    registerShortcut: () => null,
-    registerTool: (tool) => {
-      const rule = rules.tools[tool.name];
-
-      if (rule !== null) {
-        pi.registerTool(rule ?? tool);
-      }
-    },
-    setModel: async (model) => {
-      const ok = await pi.setModel(model);
-
-      if (ok) {
-        await mirror({ model: `${model.provider}/${model.id}` });
-      }
-
-      return ok;
-    },
-    setThinkingLevel: (level) => {
-      pi.setThinkingLevel(level);
-      void mirrorThinking(level);
-    },
-  };
-};

package/src/bridge/bridge-trim.ts

@@ -1,104 +0,0 @@
-import {
-  getCurrentSystemMessage,
-  getCurrentSystemPrompt,
-} from "@earendil-works/pi-ai";
-import type {
-  BeforeAgentStartEvent,
-  ExtensionAPI,
-  ExtensionContext,
-} from "@earendil-works/pi-coding-agent";
-
-// T3 shares its orchestration instructions across providers. Pi has neither
-// Claude's Agent tool nor Codex's spawn_agent, so route its subagents through T3.
-// Match the bullet by its label, so a reworded bullet still matches.
-const T3_MARKER = "## T3 Code orchestration";
-
-// The section ends at the next h2 heading or closing tag.
-const SECTION = /## T3 Code orchestration[\s\S]*?(?=\n## |\n<\/|$)/gu;
-
-const SUBAGENTS_BULLET = /^- Subagents:.*$/gmu;
-
-const SUBAGENTS_LABEL = /^- Subagents:/mu;
-
-const REPLACEMENT =
-  "- Subagents: use `delegate_task` for subagent work. Workflow only when asked.";
-
-const trim = (text: string): string =>
-  text.replaceAll(SECTION, (section) =>
-    section.replaceAll(SUBAGENTS_BULLET, REPLACEMENT)
-  );
-
-export const registerBridgeTrim = (pi: ExtensionAPI): void => {
-  let warned = false;
-  let runOptions: BeforeAgentStartEvent["systemPromptOptions"] | undefined;
-
-  const warnOnDrift = (text: string, ctx: ExtensionContext): void => {
-    if (!(text.includes(T3_MARKER) && ctx.hasUI) || warned) {
-      return;
-    }
-
-    const found = (text.match(SECTION) ?? []).some((section) =>
-      SUBAGENTS_LABEL.test(section)
-    );
-
-    if (!found) {
-      warned = true;
-      ctx.ui.notify(
-        "pi-t3: T3's orchestration text has no '- Subagents:' bullet, so Pi cannot route subagents through T3. Update src/bridge/bridge-trim.ts.",
-        "warning"
-      );
-    }
-  };
-
-  pi.on("before_agent_start", (event) => {
-    runOptions = event.systemPromptOptions;
-
-    if (runOptions.forceSystemPrompt !== undefined) {
-      runOptions.forceSystemPrompt = trim(runOptions.forceSystemPrompt);
-    }
-  });
-
-  pi.on("context_with_system", (event, ctx) => {
-    // Pi projects a forced prompt after this hook, including one set by a
-    // later before_agent_start handler such as T3's bridge.
-    const forced = runOptions?.forceSystemPrompt;
-
-    const section = getCurrentSystemMessage(event.messages)?.sections
-      ?.t3_code_orchestration;
-
-    warnOnDrift(
-      forced ?? section ?? getCurrentSystemPrompt(event.messages),
-      ctx
-    );
-
-    if (runOptions !== undefined && forced !== undefined) {
-      runOptions.forceSystemPrompt = trim(forced);
-    }
-
-    return {
-      messages: event.messages.map((message) => {
-        if (message.role !== "system") {
-          return message;
-        }
-
-        const content = Array.isArray(message.content)
-          ? message.content.map((part) => ({
-              ...part,
-              text: trim(part.text),
-            }))
-          : trim(message.content);
-
-        const sections =
-          message.sections &&
-          Object.fromEntries(
-            Object.entries(message.sections).map(([key, text]) => [
-              key,
-              text === null ? null : trim(text),
-            ])
-          );
-
-        return { ...message, content, sections };
-      }),
-    };
-  });
-};