pi-t3-bridge 0.7.2 → 0.8.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Change log
 
+## 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]
 ```
 
@@ -46,18 +43,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 +250,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.0",
   "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/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 };
-      }),
-    };
-  });
-};