pi-pstack-adapter 0.3.0 → 0.5.0

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to this project are documented here. release-please writes new entries from Conventional Commit PR titles.
 
+## [0.5.0](https://github.com/elderfo/pi-pstack-adapter/compare/v0.4.0...v0.5.0) (2026-10-15)
+
+
+### Features
+
+* **models:** add a per-role thinking level ([#12](https://github.com/elderfo/pi-pstack-adapter/issues/12)) ([ae99d0c](https://github.com/elderfo/pi-pstack-adapter/commit/ae99d0cb9ab6c516a6847eb47ea44a0b5ec7c141))
+
+## [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
@@ -133,6 +150,20 @@ In a noninteractive session, set roles with `PISTACK_MODELS`:
 PISTACK_MODELS='feature=provider/model,bug-fix=provider/other-model' pi
 ```
 
+Add a thinking level to a role with a `:level` suffix. The levels are `off`, `minimal`, `low`,
+`medium`, `high`, `xhigh`, and `max`:
+
+```bash
+PISTACK_MODELS='feature=provider/model:medium,judgment=provider/other-model:high' pi
+```
+
+Role names are lowercase letters, digits, and hyphens. A model value is printable ASCII with no spaces or markup characters, at most 128 characters. A config entry that breaks these rules stops the adapter at startup with an error that names the file, so fix the key there and restart Pi.
+
+A role without a level passes none, so the delegation backend applies its own default. A role you leave unset inherits the
+session model and the session thinking level, so a session at high thinking makes every
+inheriting delegate expensive. The `pstack_adapter` tool's `set_model` action takes the same
+level in its `thinking` parameter. A level the model does not offer is clamped by Pi at run time.
+
 ## Run Pi noninteractively
 
 A noninteractive session, such as `pi --print`, cannot answer the download question. To allow
@@ -171,7 +202,8 @@ settings to `.pi/pi-pstack-adapter.json`. Environment variables override both fi
 | `PISTACK_UPSTREAM_PLUGIN_PATH` | Selects the plugin directory inside the checkout. |
 | `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_MODELS` | Assigns models as comma-separated `role=provider/model[:thinking]` 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.5.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
 
@@ -27,6 +27,13 @@ Roles used by pstack workflows.
 The status report lists the same roles, so read it back rather than trusting this table if the
 adapter has been upgraded.
 
+Each role also has a thinking level: `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, or
+`max`. Upstream pstack calls this a reasoning budget and encodes it in the model slug. A role with
+no thinking level passes none, so the delegation backend applies its own default. A role left on
+`inherit` uses the parent session's model and thinking level, so a parent at high thinking makes
+every inheriting child expensive. Model choice often affects cost more than thinking level does,
+so consider a cheaper model for the bulk roles as well.
+
 Steps.
 
 1. Call the adapter tool with `action: "models"` to list the provider and model ids this Pi
@@ -34,13 +41,40 @@ Steps.
 2. Ask the user which model each role should use. Offer the listed ids, and offer
    `inherit` for any role they do not care about. Use the structured question tool when it is
    available; otherwise ask in plain text. Only ids from step 1 are accepted.
-3. For each answered role, call the adapter tool with `action: "set_model"`, the role, and the
-   chosen `provider/model` id. Pass `scope: "project"` when the user wants the choice to apply
-   only to this repository.
-4. Read back `action: "status"` and show the user what was written.
+3. Ask for a thinking level. Do not assume the user wants none. Skip this step only when every
+   role is on `inherit`. It applies to every role that got a model in step 2. A role on
+   `inherit` cannot have a level, so tell the user that and say that those roles follow the
+   parent session's level. Ask one single-select question first. Put the whole choice in each option
+   title so the user can pick without opening anything else, for example "Balanced: code roles
+   medium, judgment high, strongest-judgment xhigh (suggested)".
+
+   | choice | code roles (`feature`, `refactoring`, `bug-fix`, `perf-issue`, `hillclimb`) | `judgment` | `strongest-judgment` |
+   | --- | --- | --- | --- |
+   | Balanced (suggest this first) | `medium` | `high` | `xhigh` |
+   | Low cost | `low` | `medium` | `high` |
+   | Maximum quality | `high` | `xhigh` | `max` |
+   | Backend default | none | none | none |
+   | Custom | ask once per column, as a single-select of level names | | |
+
+   These are starting points, not measurements. They keep the heaviest reasoning on the roles
+   that make the hardest calls. Offer Custom for a user who wants different levels. Ask once for
+   the code roles, once for `judgment`, and once for `strongest-judgment`. Ask a role on its own
+   only when the user says it should differ from its group. Backend default passes no level and
+   leaves the choice to the delegation backend. A Custom user who wants thinking disabled picks
+   `off`.
+   A model may not offer every level. A level it lacks is clamped when it runs, so say that
+   instead of asking again. The tool rejects any level other than `off` on a model that has no reasoning support.
+   When it does, set that role with no level and tell the user which role has none.
+4. For each role, call the adapter tool with `action: "set_model"`, the role, the chosen
+   `provider/model` id, and `thinking` when step 3 picked a level. Pass `scope: "project"` when
+   the user wants the choice to apply only to this repository. Calling `set_model` for a role
+   again without `thinking` clears a level set earlier, so always pass it again.
+5. Read back `action: "status"` and show the user what was written, including the thinking
+   column.
 
 For a scripted environment, set `PISTACK_MODELS` instead, for example
-`PISTACK_MODELS=feature=anthropic/claude-sonnet-4-5,bug-fix=openai/gpt-5`. The environment wins
+`PISTACK_MODELS=feature=anthropic/claude-sonnet-4-5:medium,bug-fix=openai/gpt-5:high`. The
+optional `:level` suffix sets the thinking level. The environment wins
 over both config files, so CI never needs this dialog.
 
 ## Upstream source
@@ -61,6 +95,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,19 +6,27 @@ 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,
   type ConfigFile,
   type ConfigLayer,
+  THINKING_LEVELS,
   environmentLayer,
+  invalidRoleMessage,
+  isValidModelSpec,
+  isValidRole,
+  joinModelSpec,
   mergeConfig,
+  planModelAssignment,
   readConfigFile,
   trustWarning,
   updateConfigFile,
 } from "./src/config.ts";
 import { generate } from "./src/generate.ts";
+import { safeEcho } from "./src/echo.ts";
 import { MODE_ENTRY_TYPE, modeFromEntries, modeInstruction } from "./src/mode.ts";
 import { CONFIG_FILE_NAME, agentDir, cacheRoot } from "./src/paths.ts";
 import { bashToolContext, probeExecutables } from "./src/executables.ts";
@@ -26,7 +34,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 +53,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();
 
@@ -54,9 +63,8 @@ export default function (pi: ExtensionAPI) {
     startupError = undefined;
     modeActive = modeFromEntries(ctx.sessionManager.getBranch() as never[]);
 
-    const config = loadConfig(ctx);
     try {
-      state = await bringUpUpstream(config, ctx);
+      state = await bringUpUpstream(loadConfig(ctx), ctx);
     } catch (error) {
       startupError = error as Error;
       if (ctx.hasUI) ctx.ui.notify(`pstack adapter: ${(error as Error).message}`, "error");
@@ -77,6 +85,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 +109,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) => {
@@ -131,6 +141,11 @@ export default function (pi: ExtensionAPI) {
       skill: Type.Optional(Type.String({ description: "Skill name for `check`, with or without the namespace prefix" })),
       role: Type.Optional(Type.String({ description: "pstack model role for `set_model`" })),
       model: Type.Optional(Type.String({ description: "`provider/model` id, or `inherit` to clear the role" })),
+      thinking: Type.Optional(
+        Type.String({
+          description: `Thinking level for \`set_model\`: ${THINKING_LEVELS.join(", ")}. Omit to pass no level, which also clears a level set earlier.`,
+        }),
+      ),
       repo: Type.Optional(Type.String({ description: "Upstream repository URL for `set_source`" })),
       ref: Type.Optional(Type.String({ description: "Branch, tag, or commit for `set_source`" })),
       localPath: Type.Optional(Type.String({ description: "Local pstack checkout for `set_source`" })),
@@ -191,6 +206,7 @@ export default function (pi: ExtensionAPI) {
       skill?: string;
       role?: string;
       model?: string;
+      thinking?: string;
       repo?: string;
       ref?: string;
       localPath?: string;
@@ -202,27 +218,35 @@ 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":
         return renderModels(ctx);
       case "set_model":
-        return setModel(params.role, params.model, params.scope ?? "user", ctx);
+        return setModel(params.role, params.model, params.thinking, params.scope ?? "user", ctx);
       case "set_source":
         return setSource(params, params.scope ?? "user", ctx);
       default:
@@ -231,7 +255,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 {
@@ -242,7 +266,7 @@ export default function (pi: ExtensionAPI) {
       (candidate) => candidate.generatedName === requested || candidate.generatedName === `${prefix}${bare}`,
     );
     if (!skill) {
-      return `No pstack skill named ${JSON.stringify(requested)}. Run the adapter tool with action "status" for the full list.`;
+      return `No pstack skill named ${safeEcho(requested)}. Run the adapter tool with action "status" for the full list.`;
     }
     const resolved = shellState(ctx, pi.getActiveTools());
     // An inactive bash tool or an unresolved shell is already a blocker, so do not spawn anything.
@@ -250,37 +274,48 @@ 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"),
     );
   }
 
   function renderModels(ctx: ExtensionContext): string {
     const scoped = ctx.scopedModels ?? [];
     const models = scoped.length > 0 ? scoped.map((entry) => entry.model) : ctx.modelRegistry.getAvailable();
-    const ids = models.map((model) => `${model.provider}/${model.id}`).sort();
+    const ids = models.map((model) => `${model.provider}/${model.id}`).filter(isValidModelSpec).sort();
     if (ids.length === 0) return "No models are available in this Pi installation.";
     return `Available model ids.\n\n${ids.map((id) => `- \`${id}\``).join("\n")}`;
   }
 
-  function setModel(role: string | undefined, model: string | undefined, scope: "user" | "project", ctx: ExtensionContext): string {
+  function setModel(
+    role: string | undefined,
+    model: string | undefined,
+    thinking: string | undefined,
+    scope: "user" | "project",
+    ctx: ExtensionContext,
+  ): string {
     if (!role) return "set_model needs a `role`.";
     if (!model) return "set_model needs a `model`, or `inherit` to clear the role.";
-    const clearing = model.trim().toLowerCase() === "inherit";
-    if (!clearing && !ctx.modelRegistry.getAvailable().some((candidate) => `${candidate.provider}/${candidate.id}` === model)) {
-      return `No model \`${model}\` is available in this Pi installation. Call this tool with action "models" for real ids, or pass "inherit".`;
-    }
+    if (!isValidRole(role)) return invalidRoleMessage(role);
+    const available = ctx.modelRegistry
+      .getAvailable()
+      .map((candidate) => ({ id: `${candidate.provider}/${candidate.id}`, reasoning: candidate.reasoning }));
+    const plan = planModelAssignment(model, thinking, available);
+    if (plan.kind === "rejected") return plan.message;
     const path = configPath(scope, ctx);
-    const current = readConfigFile(path)?.values.models ?? {};
-    const models = { ...current };
-    if (clearing) delete models[role];
-    else models[role] = model;
+    const stored = readConfigFile(path)?.values.models;
+    const models = typeof stored === "object" && stored !== null && !Array.isArray(stored) ? { ...stored } : {};
+    if (plan.kind === "inherit") delete models[role];
+    else models[role] = joinModelSpec(plan.spec);
     updateConfigFile(path, { models });
-    return clearing
-      ? `Role \`${role}\` now inherits the parent session model. Written to ${path}.`
-      : `Role \`${role}\` now uses \`${model}\`. Written to ${path}.`;
+    if (plan.kind === "inherit") return `Role \`${role}\` now inherits the parent session model and thinking. Written to ${path}.`;
+    return plan.spec.thinking === undefined
+      ? `Role \`${role}\` now uses \`${plan.spec.model}\` at the model's default thinking. Written to ${path}.`
+      : `Role \`${role}\` now uses \`${plan.spec.model}\` with thinking \`${plan.spec.thinking}\`. Written to ${path}.`;
   }
 
   async function setSource(
@@ -336,6 +371,7 @@ export default function (pi: ExtensionAPI) {
       }
     }
     registrations = [];
+    unregisteredAgents = [];
   }
 }
 
@@ -418,6 +454,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.5.0",
   "description": "Run Cursor's official pstack plugin inside Pi from an unmodified upstream checkout",
   "type": "module",
   "license": "MIT",