pi-pstack-adapter 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to this project are documented here. release-please writes new entries from Conventional Commit PR titles.
 
+## [0.4.0](https://github.com/elderfo/pi-pstack-adapter/compare/v0.3.0...v0.4.0) (2026-10-14)
+
+
+### Features
+
+* **delegation:** delegate through T3 Code's delegate_task, with pi-subagents as fallback ([#11](https://github.com/elderfo/pi-pstack-adapter/issues/11)) ([4f9c8e8](https://github.com/elderfo/pi-pstack-adapter/commit/4f9c8e8bef690885c37cb0d215473db11a5e9049))
+* **pstack:** certify pstack 0.15.23 with in-your-own-words, ketchup, and poteto-help ([#9](https://github.com/elderfo/pi-pstack-adapter/issues/9)) ([73bb412](https://github.com/elderfo/pi-pstack-adapter/commit/73bb4125fcd470e5f8990e1953e7de80a05a0485))
+
 ## [0.3.0](https://github.com/elderfo/pi-pstack-adapter/compare/v0.2.0...v0.3.0) (2026-10-05)
 
 

package/README.md

@@ -46,17 +46,34 @@ counts as Linux.
 
 ### Add optional providers for delegating workflows
 
-Some workflows hand work to subagents or ask you multiple-choice questions. Install these two
-packages to enable them:
+Some workflows hand work to subagents or ask you multiple-choice questions. Two providers can run
+the subagents:
+
+- **T3 Code.** When Pi runs inside [T3 Code](https://github.com/pingdotgg/t3code), workflows
+  delegate through T3's `delegate_task` tool. Each child appears in T3, can run on any provider
+  and model T3 offers, and can work in its own worktree. You install nothing extra.
+- **pi-subagents.** Outside T3 Code, install `pi-subagents`. The upstream agents register as
+  `pistack-comment-sicko` and `pistack-poteto-agent`.
+
+For multiple-choice questions, install `pi-ask-user`:
 
 ```bash
 pi install npm:pi-subagents
 pi install npm:pi-ask-user
 ```
 
-With `pi-subagents` installed, the upstream agents register as `pistack-comment-sicko` and
-`pistack-poteto-agent`. The adapter turns on the `subagent` tool when a delegating workflow
-starts, whether you run its `/skill:` command or the agent opens the skill itself. While Poteto
+The adapter uses T3 Code first and falls back to `pi-subagents`. To reverse that order, set
+`"delegation": "pi-subagents"` in the adapter config, or set `PISTACK_DELEGATION=pi-subagents`.
+Restart Pi or run `/reload` after changing it. `/pistack-status` shows the order and the
+provider the session resolved.
+
+The adapter counts T3's tools, including `task_status` and `orchestrator_capabilities`, only
+when T3 Code's own bridge registered them. A tool that another extension or MCP server registers
+under the same name is ignored, and `/pistack-check <skill>` names the one tool to delegate with.
+
+When a delegating workflow starts, the adapter turns on that provider's tool, even if you turned
+it off in the tool selector. This happens
+whether you run the workflow's `/skill:` command or the agent opens the skill itself. While Poteto
 Mode is on, the adapter turns it on for every prompt.
 
 To find missing providers or executables before you start a workflow, run
@@ -172,6 +189,7 @@ settings to `.pi/pi-pstack-adapter.json`. Environment variables override both fi
 | `PISTACK_ALLOW_BOOTSTRAP` | Allows a noninteractive first download. |
 | `PISTACK_CACHE_DIR` | Changes the cache directory. |
 | `PISTACK_MODELS` | Assigns models as comma-separated `role=provider/model` pairs. |
+| `PISTACK_DELEGATION` | Sets the delegation provider to try first: `t3` (default) or `pi-subagents`. The config file key is `delegation`. |
 
 ## Security and trust
 

package/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.0

package/adapter-skills/setup.md

@@ -4,7 +4,7 @@ Upstream pstack ships a `setup-pstack` skill that writes `~/.cursor/rules/pstack
 a Cursor-only always-applied rule full of Cursor model slugs. Pi has neither that file nor
 those models, so this adapter replaces the body with the Pi equivalent.
 
-Two things are configurable. Model roles, and the upstream source.
+Three things are configurable. Model roles, the upstream source, and the delegation order.
 
 ## Model roles
 
@@ -61,6 +61,14 @@ plain words before you call it, and report a refusal as a refusal.
 
 Regeneration happens on the next Pi start. Tell the user to restart Pi, or run `/reload`.
 
+## Delegation order
+
+Delegating workflows try T3 Code's `delegate_task` first, then pi-subagents' `subagent`. A user
+who wants `subagent` first sets `"delegation": "pi-subagents"` in the adapter config file, or
+`PISTACK_DELEGATION=pi-subagents`. The adapter tool has no action for this. Tell the user which
+file to edit: the `config layers` row of the status report lists them. Regeneration happens on
+the next Pi start.
+
 ## Finish
 
 End by reporting, in your own words, which roles were set, which still inherit, the resolved

package/docs/compatibility.md

@@ -4,7 +4,7 @@ The compatibility registry in `src/registry.ts` assigns one support tier to ever
 certified pstack revision. Generation reads it, the wrapper frontmatter publishes it, and
 `/pistack-status` reports it.
 
-Certified revision: pstack `0.15.9` at `e43c7ee26e0038c6c1fa8380dd34ce86ff94cb2a` in
+Certified revision: pstack `0.15.23` at `dbf49813a39c1a5389c5e28cb8e4c1c2379e2454` in
 `https://github.com/cursor/plugins`.
 
 ## Platforms
@@ -21,21 +21,37 @@ executables in the shell the skills run in, with Pi's `shellCommandPrefix` appli
 that matters most, because Git Bash adds `/usr/bin` and `/mingw64/bin` to the `PATH` Pi
 started with. A shell that is missing, inactive, or cannot run a command blocks every workflow.
 
-Windows evidence at the certified revision, on Windows 11 with Git for Windows 2.53, Node 22,
-and Pi 1.0.2:
-
-- The unit suite passes, and `npm run test:isolated` passes against the adapter commit that
-  introduced Windows support. Pi registers all 51 skills, and a later run reuses the cache
-  without the network. CI runs the unit suite on Windows for every change.
-- Every upstream helper script ran in Git Bash: `show-me-your-work/scripts/log.sh`,
-  `poteto-mode/scripts/check-plan.mjs`, `worktree-audit.sh`, `watch-pr`, and `orch.ts`.
+Windows evidence at the certified revision, pstack `0.15.23`, on Windows 11 with Git for
+Windows 2.53, Node 22, Bun 1.3, and Pi 1.2.0:
+
+- The unit suite and the type check pass. `npm run test:isolated` passes from Git Bash: Pi
+  registers all 54 skills, and a later run reuses the cache without the network. CI runs the
+  unit suite on Windows for every change.
+- The certification probe passes on an LF export of the tree: no diagnostics, 52 bodies
+  byte-identical, and none mismatched. The adapter's cache checkout matches that export byte for
+  byte.
+- `in-your-own-words`, `ketchup`, and `poteto-help` ran end to end in the isolated install, with
+  no `subagent` or `ask_user` tool. `ketchup` reported a commit and a pending decision with
+  Mermaid diagrams and changed nothing. `poteto-help` answered with `/pistack-mode on` and read
+  the guide from the `plugin directory` row, whose Windows path it resolved.
+- The status report's `plugin directory` and `generated skills` rows give native Windows paths.
+  `/pistack-check` clears `ketchup`, and still reports `uptime` missing for `benchmark-checklist`.
+- The helpers changed in `0.15.23` ran in Git Bash. `worktree-audit.sh` handled `-b <ref>`,
+  `--help`, an unknown base, and the `origin/HEAD` fallback, and classified a linked worktree.
+  `check-plan.mjs` ran on Node. Upstream's helper suite passed 61 of 63 tests under Bun. The two
+  failures fake the Graphite `gt` CLI with a shell script, which Bun cannot spawn on Windows.
+  Both fail at `0.15.9` too, and the adapter does not gate on `gt`.
+- At pstack `0.15.9`, `show-me-your-work/scripts/log.sh`, `watch-pr`, and `orch.ts` also ran
+  in Git Bash. None of them changed in a way that adds an executable or a path assumption.
 - Git for Windows bundles `git`, `curl`, `nproc`, and the POSIX tools the skill bodies call,
   but not `uptime`, so `benchmark-checklist` reports it missing. `gh`, `tailscale`, and `sudo`
   are separate installs on Windows, as on the other platforms.
 - The adapter checks out upstream with `core.autocrlf=false`. Git for Windows enables
   `autocrlf` system-wide, which would otherwise rewrite every upstream file to CRLF. A cache
   written before that setting existed is repaired on the next start, or refused with a recovery
-  step when it cannot be written.
+  step when it cannot be written. `git archive` follows the same setting, so a certification
+  export on Windows needs `-c core.autocrlf=false`. Without it, 155 upstream text files at
+  `0.15.23` come out as CRLF and no longer match what Pi loads.
 
 A session that replaces the `bash` tool with `powershell` cannot run the skills.
 `/pistack-status` reports it, and `/pistack-check` refuses to clear any workflow.
@@ -66,11 +82,12 @@ Lowering a tier needs one reproduction of the failure and a note saying what bro
 
 ## Registry
 
-### native (30)
+### native (31)
 
 | upstream skill | Pi skill | capabilities | executables | why |
 | --- | --- | --- | --- | --- |
 | `bro` | `/skill:pistack-bro` | - | - | - |
+| `in-your-own-words` | `/skill:pistack-in-your-own-words` | - | - | - |
 | `principle-attack-the-premise` | `/skill:pistack-principle-attack-the-premise` | - | - | - |
 | `principle-boundary-discipline` | `/skill:pistack-principle-boundary-discipline` | - | - | - |
 | `principle-build-the-lever` | `/skill:pistack-principle-build-the-lever` | - | - | - |
@@ -101,11 +118,12 @@ Lowering a tier needs one reproduction of the failure and a note saying what bro
 | `typescript-best-practices` | `/skill:pistack-typescript-best-practices` | - | - | - |
 | `unslop` | `/skill:pistack-unslop` | - | - | - |
 
-### adapted (1)
+### adapted (2)
 
 | upstream skill | Pi skill | capabilities | executables | why |
 | --- | --- | --- | --- | --- |
 | `create-verification-skill` | `/skill:pistack-create-verification-skill` | - | - | Only the generated skill's output path needs remapping to Pi's skill directory. |
+| `ketchup` | `/skill:pistack-ketchup` | - | - | Read-only. Pi has no `/visualize` skill or image generation, so its visuals are Mermaid diagrams and screenshots that already exist. It checks PR and CI state only for work the chat touched. |
 
 ### dependency-gated (13)
 
@@ -120,16 +138,17 @@ Lowering a tier needs one reproduction of the failure and a note saying what bro
 | `how` | `/skill:pistack-how` | `delegation` | - | Every path spawns explorer or explainer subagents; nothing runs inline. |
 | `interrogate` | `/skill:pistack-interrogate` | `delegation` | `git` | Multi-model adversarial review is entirely one subagent per configured model. |
 | `maintain-verification-skill` | `/skill:pistack-maintain-verification-skill` | `delegation` | - | Source wave launches one read-only subagent per feature file. |
-| `no-comments` | `/skill:pistack-no-comments` | `delegation` | `git` | Step 1 must spawn the named Comment Sicko agent; the skill only triages its report. |
+| `no-comments` | `/skill:pistack-no-comments` | `delegation` | `git` | Step 1 must spawn the comment-sicko agent; the skill only triages its report. |
 | `show-me-your-work` | `/skill:pistack-show-me-your-work` | `delegation` | - | The mandatory cross-model review of the trail requires spawning a different-family subagent. |
 | `teach` | `/skill:pistack-teach` | `delegation` | - | It runs the how and why skills, both of which need subagents. |
 | `why` | `/skill:pistack-why` | `delegation` | `git`, `gh` | Default posture spawns one investigator subagent per evidence category plus a synthesizer. |
 
-### experimental (5)
+### experimental (6)
 
 | upstream skill | Pi skill | capabilities | executables | why |
 | --- | --- | --- | --- | --- |
 | `automate-me` | `/skill:pistack-automate-me` | `delegation`, `structured-question` | `git`, `gh` | Mining step depends on Cursor transcript files and the built-in create-skill skill, with no Pi equivalent. |
+| `poteto-help` | `/skill:pistack-poteto-help` | - | - | Its answers describe Cursor setup, the slash menu, and Custom Modes. A request for work runs poteto-mode, which is experimental. It asks a multiple-choice question only when the need is unclear. Its README and guide links resolve under the status report's plugin directory. |
 | `poteto-mode` | `/skill:pistack-poteto-mode` | `delegation`, `structured-question` | `git`, `gh` | Sticky-mode hosting plus references to Cursor built-in and plugin skills only partially map to Pi. |
 | `recall` | `/skill:pistack-recall` | `delegation` | `git`, `gh` | Core corpus is Cursor's on-disk transcript JSONL, so only the git/gh and shared-record half survives. |
 | `reflect` | `/skill:pistack-reflect` | `delegation` | - | Transcript mining and create-skill routing are Cursor-specific, though the digest fallback partly works. |
@@ -145,12 +164,40 @@ Lowering a tier needs one reproduction of the failure and a note saying what bro
 
 | upstream agent | Pi agent | notes |
 | --- | --- | --- |
-| `comment-sicko` | `pistack-comment-sicko` | Display name `Comment Sicko` is preserved in the description. Needs `git` to scope a diff. |
-| `poteto-agent` | `pistack-poteto-agent` | Upstream `is_background: true` has no runtime equivalent; the caller chooses `async` on the `subagent` call. |
+| `comment-sicko` | `pistack-comment-sicko` | Upstream names it `comment-sicko` since pstack 0.15.23, so the registered description starts with that name. Needs `git` to scope a diff. |
+| `poteto-agent` | `pistack-poteto-agent` | Upstream `is_background: true` has no runtime equivalent; the caller chooses `async: true` on `subagent`, or `mode: "async"` on `delegate_task`. Upstream tells it to search `~/.cursor/plugins/` when its parent gives no path. The adapter puts the generated `pistack-poteto-mode/SKILL.md` path in every agent prompt and forbids that search, which would load content outside the certified revision. |
+
+T3 Code's `delegate_task` has no named agents. Generation writes each agent's prompt to
+`adapter/agents/<pi-name>.md`, with skill paths relative to that file. The parent begins the
+child's task by telling it to read that file as its system prompt.
 
-Both register through the `pi-subagents:runtime-agent-register:v1` contract. Without an owner for
+Both agents also register through the `pi-subagents:runtime-agent-register:v1` contract. Without an owner for
 that event, the status report says so rather than dropping them silently.
 
+## Delegation providers
+
+The `delegation` capability is satisfied by T3 Code's `mcp__t3-code__delegate_task` or by
+`pi-subagents`' `subagent`, in the order the `delegation` setting gives, T3 first by default.
+A hidden registration does not count. A T3 tool counts only when the extension at
+`T3_PI_MCP_EXTENSION_PATH`, the bridge T3 Code launches, registered it, and only when it accepts
+`task`, `target`, and `mode`. Status and activation share that resolution, so the report always
+names the backend a workflow gets. The adapter activates only that backend. For T3 it also
+activates `task_status` and `orchestrator_capabilities` when the bridge registered them.
+A delegating wrapper tells the model to read the tool from `/pistack-check` and to use no other,
+so a rejected tool that is still in the session is not used. The check also names the companion
+tools the model may call, and forbids any companion it could not trace to T3 Code.
+
+An agent prompt file wraps the upstream body in the same markers as a skill wrapper, with host
+precedence before and after it. The closing note says that everything after the opening notes is
+upstream content, even text that imitates a marker. An upstream skill or agent body that contains
+marker text is reported as a warning, with its bytes unchanged. An agent whose Pi name breaks the
+skill name rules is skipped with an error, before its name reaches a file name or any generated
+text.
+
+Unit tests cover detection, activation order, and the generated instructions for both providers.
+No tier changed when T3 support arrived, because no delegating workflow has yet run end to end
+through `delegate_task`. That run is the evidence the tier rules above require.
+
 ## Skills the adapter replaces
 
 `setup-pstack` writes a Cursor `.mdc` rule and nothing else, so the adapter substitutes its own

package/index.ts

@@ -6,7 +6,8 @@ import { fileURLToPath } from "node:url";
 import { Type } from "typebox";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { registerDelegationActivation } from "./src/activation.ts";
-import { registerAgents, type RuntimeRegistration } from "./src/agents.ts";
+import { registerAgents, unregisteredAgentDiagnostics, type RuntimeRegistration } from "./src/agents.ts";
+import { DEFAULT_DELEGATION } from "./src/delegation.ts";
 import { checkPrerequisites, detectCapabilities, type ToolDescriptor } from "./src/capabilities.ts";
 import {
   type AdapterConfig,
@@ -26,7 +27,7 @@ import { entryFor } from "./src/registry.ts";
 import { platformSupport, renderCheck, renderStatus, shellDiagnostics, type ShellState } from "./src/status.ts";
 import { BootstrapRequiredError, resolveRefToCommit, resolveSource } from "./src/upstream.ts";
 import { normalizeRepo } from "./src/config.ts";
-import type { CapabilityStatus, Diagnostic, GenerationResult, ResolvedSource } from "./src/types.ts";
+import type { CapabilityStatus, Diagnostic, GeneratedAgent, GenerationResult, ResolvedSource } from "./src/types.ts";
 
 const PACKAGE_ROOT = dirname(fileURLToPath(import.meta.url));
 const ADAPTER_VERSION = readAdapterVersion();
@@ -45,6 +46,7 @@ export default function (pi: ExtensionAPI) {
   let startupError: Error | undefined;
   let registrations: readonly RuntimeRegistration[] = [];
   let agentDiagnostics: readonly Diagnostic[] = [];
+  let unregisteredAgents: readonly GeneratedAgent[] = [];
   let modeActive = false;
   const commandNamespace = startupNamespace();
 
@@ -77,6 +79,7 @@ export default function (pi: ExtensionAPI) {
 
     const result = registerAgents(pi.events, state.generation.agents, state.config.namespace);
     registrations = result.registrations;
+    unregisteredAgents = result.unregistered;
     const diagnostics: Diagnostic[] = [...result.diagnostics];
     if (result.registrations.length > 0) {
       diagnostics.push({
@@ -100,6 +103,7 @@ export default function (pi: ExtensionAPI) {
   registerDelegationActivation(pi, {
     skills: () => state?.generation.skills ?? [],
     modeActive: () => modeActive && state !== undefined,
+    preferred: () => state?.config.delegation ?? DEFAULT_DELEGATION,
   });
 
   pi.on("before_agent_start", async (event) => {
@@ -202,21 +206,29 @@ export default function (pi: ExtensionAPI) {
     if (!state) return "The pstack adapter has not resolved its upstream checkout yet.";
 
     switch (params.action) {
-      case "status":
+      case "status": {
+        const current = capabilities();
+        const delegation = current.find((capability) => capability.id === "delegation");
         return renderStatus({
           adapterVersion: ADAPTER_VERSION,
           config: state.config,
           source: state.source,
           upstreamVersion: state.upstreamVersion,
           generation: state.generation,
-          capabilities: capabilities(),
+          capabilities: current,
           platform: platformSupport(platform()),
           platformName: platform(),
           modeActive,
           cacheRoot: state.cacheRoot,
           bootstrapped: state.bootstrapped,
-          runtimeDiagnostics: [...agentDiagnostics, ...shellDiagnostics(probedShellState(ctx, pi.getActiveTools()))],
+          runtimeDiagnostics: [
+            ...agentDiagnostics,
+            // Judged now, because T3's tools can connect after the agents were registered.
+            ...unregisteredAgentDiagnostics(unregisteredAgents, delegation?.backend, state.generation.agentPromptsDir),
+            ...shellDiagnostics(probedShellState(ctx, pi.getActiveTools())),
+          ],
         });
+      }
       case "check":
         return checkSkill(params.skill ?? "", ctx);
       case "models":
@@ -231,7 +243,7 @@ export default function (pi: ExtensionAPI) {
   }
 
   function capabilities(): CapabilityStatus[] {
-    return detectCapabilities(pi.getAllTools() as unknown as ToolDescriptor[]);
+    return detectCapabilities(pi.getAllTools() as unknown as ToolDescriptor[], state?.config.delegation);
   }
 
   function checkSkill(requested: string, ctx: ExtensionContext): string {
@@ -250,10 +262,12 @@ export default function (pi: ExtensionAPI) {
     const executables = probeExecutables(skill.executables, usable ? () => sessionBashContext(ctx) : undefined);
     const shell: ShellState = { ...resolved, runError: executables.shellFailure };
     const shellProblems = shellDiagnostics(shell).map((diagnostic) => `${diagnostic.message} ${diagnostic.action ?? ""}`.trim());
+    const current = capabilities();
     return renderCheck(
       skill,
       entryFor(skill.upstreamName, skill.generatedName.slice(prefix.length)),
-      checkPrerequisites(skill.capabilities, capabilities(), skill.executables, executables.has, shellProblems),
+      checkPrerequisites(skill.capabilities, current, skill.executables, executables.has, shellProblems),
+      current.find((capability) => capability.id === "delegation"),
     );
   }
 
@@ -336,6 +350,7 @@ export default function (pi: ExtensionAPI) {
       }
     }
     registrations = [];
+    unregisteredAgents = [];
   }
 }
 
@@ -418,6 +433,7 @@ function buildState(
     namespace: config.namespace,
     cacheRoot: root,
     adapterVersion: ADAPTER_VERSION,
+    delegation: config.delegation,
     // A local checkout has uncommitted edits the digest cannot see, so never reuse its output.
     force: source.selection.kind === "local",
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-pstack-adapter",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Run Cursor's official pstack plugin inside Pi from an unmodified upstream checkout",
   "type": "module",
   "license": "MIT",

package/src/activation.ts

@@ -2,23 +2,26 @@ import { homedir } from "node:os";
 import { posix, win32 } from "node:path";
 import { fileURLToPath } from "node:url";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { GeneratedSkill } from "./types.ts";
-
-/** The pi-subagents tool a delegation skill calls. */
-export const DELEGATION_TOOL = "subagent";
-/** The pi-subagents loader that exposes a registered but inactive `subagent` tool. */
-export const DELEGATION_LOADER = "subagents_enable";
+import {
+  DEFAULT_DELEGATION,
+  type DelegationHost,
+  type ToolPresence,
+  callableTool,
+  delegationHost,
+  resolveDelegation,
+} from "./delegation.ts";
+import type { DelegationProvider, GeneratedSkill } from "./types.ts";
 
 /** The slice of Pi's tool registry that activation reads and writes. */
 export interface ToolLoadout {
-  getAllTools(): readonly { readonly name: string }[];
+  getAllTools(): readonly ToolPresence[];
   getActiveTools(): string[];
   setActiveTools(toolNames: string[]): void;
 }
 
 export type ActivationResult =
-  | { readonly kind: "already-active" }
-  | { readonly kind: "activated" }
+  | { readonly kind: "already-active"; readonly backend: DelegationProvider }
+  | { readonly kind: "activated"; readonly backend: DelegationProvider }
   | { readonly kind: "unavailable" };
 
 export function needsDelegation(skill: GeneratedSkill): boolean {
@@ -54,37 +57,51 @@ export function skillFromReadPath(
 }
 
 /**
- * Adds `subagent` to the active tools, the same selection `subagents_enable` makes, so a
- * delegation skill never depends on the model remembering to call the loader first.
- * Pi applies the new loadout on the next model request.
+ * Adds the delegation backend that capability detection resolves to the active tools, with its
+ * companion tools, so a delegation skill never depends on the model loading it first. For
+ * pi-subagents that is the selection `subagents_enable` makes; T3's `delegate_task` may be
+ * deferred behind `tool_search`. Pi applies the new loadout on the next model request.
  */
-export function activateDelegation(loadout: ToolLoadout): ActivationResult {
-  if (!loadout.getAllTools().some((tool) => tool.name === DELEGATION_TOOL)) return { kind: "unavailable" };
+export function activateDelegation(
+  loadout: ToolLoadout,
+  preferred: DelegationProvider = DEFAULT_DELEGATION,
+  host: DelegationHost = delegationHost(),
+): ActivationResult {
+  const registered = loadout.getAllTools();
+  const resolution = resolveDelegation(registered, preferred, host);
+  if (resolution.kind === "unavailable") return { kind: "unavailable" };
+  const { backend, companions } = resolution;
+  const wanted = [backend.tool, ...companions];
   const active = loadout.getActiveTools();
-  if (active.includes(DELEGATION_TOOL)) return { kind: "already-active" };
-  loadout.setActiveTools([...active, DELEGATION_TOOL]);
-  return { kind: "activated" };
+  const missing = wanted.filter((name) => !active.includes(name));
+  if (missing.length === 0) return { kind: "already-active", backend: backend.id };
+  loadout.setActiveTools([...active, ...missing]);
+  return { kind: "activated", backend: backend.id };
 }
 
 export interface ActivationSources {
   /** Generated skills, or none while the adapter has no upstream checkout. */
   readonly skills: () => readonly GeneratedSkill[];
   readonly modeActive: () => boolean;
+  /** The configured backend preference, read at activation time. */
+  readonly preferred: () => DelegationProvider;
+  /** Defaults to the running process's T3 Code bridge, if any. */
+  readonly host?: DelegationHost;
 }
 
 type ActivationHost = Pick<ExtensionAPI, "on" | "getAllTools" | "getActiveTools" | "setActiveTools">;
 
 /**
- * A delegation skill must not depend on the model remembering to call `subagents_enable`,
- * so a slash command, a model-initiated SKILL.md read, and Poteto Mode each activate
- * `subagent` in code.
+ * A delegation skill must not depend on the model remembering to load its delegation tool,
+ * so a slash command, a model-initiated SKILL.md read, and Poteto Mode each activate it in code.
  */
 export function registerDelegationActivation(pi: ActivationHost, sources: ActivationSources): void {
+  const activate = () => activateDelegation(pi, sources.preferred(), sources.host ?? delegationHost());
   // `input` runs before Pi copies the tool list for the prompt, so the first model request
-  // already carries `subagent`. It also covers messages queued while the agent is streaming.
+  // already carries the tool. It also covers messages queued while the agent is streaming.
   pi.on("input", async (event) => {
     const skill = skillFromPrompt(event.text, sources.skills());
-    if (sources.modeActive() || (skill && needsDelegation(skill))) activateDelegation(pi);
+    if (sources.modeActive() || (skill && needsDelegation(skill))) activate();
   });
 
   pi.on("tool_call", async (event, ctx) => {
@@ -92,12 +109,12 @@ export function registerDelegationActivation(pi: ActivationHost, sources: Activa
     const path = (event.input as { path?: unknown }).path;
     if (typeof path !== "string") return;
     const skill = skillFromReadPath(path, ctx.cwd, sources.skills());
-    if (skill && needsDelegation(skill)) activateDelegation(pi);
+    if (skill && needsDelegation(skill)) activate();
   });
 
   // Backstop for prompts that reach the agent without an `input` event.
   pi.on("before_agent_start", async () => {
-    if (sources.modeActive()) activateDelegation(pi);
+    if (sources.modeActive()) activate();
   });
 }
 

package/src/agents.ts

@@ -1,4 +1,6 @@
-import type { Diagnostic, GeneratedAgent } from "./types.ts";
+import { join } from "node:path";
+import { T3_DELEGATE_TOOL } from "./delegation.ts";
+import type { DelegationProvider, Diagnostic, GeneratedAgent } from "./types.ts";
 
 export const RUNTIME_AGENT_REGISTER_EVENT = "pi-subagents:runtime-agent-register:v1";
 
@@ -19,6 +21,9 @@ export interface EventBus {
 
 export interface AgentRegistrationResult {
   readonly registrations: readonly RuntimeRegistration[];
+  /** Agents no installed extension accepted as named agents. */
+  readonly unregistered: readonly GeneratedAgent[];
+  /** Registrations a provider refused. */
   readonly diagnostics: readonly Diagnostic[];
 }
 
@@ -32,6 +37,7 @@ export function registerAgents(
   namespace: string,
 ): AgentRegistrationResult {
   const registrations: RuntimeRegistration[] = [];
+  const unregistered: GeneratedAgent[] = [];
   const diagnostics: Diagnostic[] = [];
 
   for (const agent of agents) {
@@ -45,12 +51,7 @@ export function registerAgents(
     };
     bus.emit(RUNTIME_AGENT_REGISTER_EVENT, request);
     if (!request.result) {
-      diagnostics.push({
-        level: "warning",
-        resource: `agent:${agent.upstreamName}`,
-        message: `No installed delegation provider accepted \`${agent.generatedName}\`, so pstack workflows cannot delegate to it.`,
-        action: `Install a provider that owns ${RUNTIME_AGENT_REGISTER_EVENT}, for example \`pi install npm:pi-subagents\`.`,
-      });
+      unregistered.push(agent);
       continue;
     }
     if (!request.result.ok) {
@@ -65,5 +66,32 @@ export function registerAgents(
     registrations.push(request.result.registration);
   }
 
-  return { registrations, diagnostics };
+  return { registrations, unregistered, diagnostics };
+}
+
+/**
+ * T3 Code children have no named agents and load an agent from its prompt file, so a missing
+ * pi-subagents registration only blocks delegation when T3 is not the resolved backend.
+ */
+export function unregisteredAgentDiagnostics(
+  unregistered: readonly GeneratedAgent[],
+  backend: DelegationProvider | undefined,
+  promptsDir: string,
+): Diagnostic[] {
+  return unregistered.map((agent) => {
+    const promptPath = join(promptsDir, `${agent.generatedName}.md`);
+    if (backend === "t3") {
+      return {
+        level: "info",
+        resource: `agent:${agent.upstreamName}`,
+        message: `\`${agent.generatedName}\` is not a named agent here. T3 Code children run it by reading ${promptPath} as their system prompt.`,
+      };
+    }
+    return {
+      level: "warning",
+      resource: `agent:${agent.upstreamName}`,
+      message: `No installed delegation provider accepted \`${agent.generatedName}\` as a named agent, so pstack workflows cannot delegate to it through \`subagent\`.`,
+      action: `Install a provider that owns ${RUNTIME_AGENT_REGISTER_EVENT}, for example \`pi install npm:pi-subagents\`, or run Pi inside T3 Code, whose \`${T3_DELEGATE_TOOL}\` loads the agent from ${promptPath}.`,
+    };
+  });
 }