@justjoshn/pi-pstack 0.15.36-pi.14 → 0.15.36-pi.16

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [0.15.36-pi.16] - 2026-11-04
+
+Each item below is checked against the Cursor CLI 2026.10.22 bundle, Cursor's built-in skills, or Cursor's docs. `parity/pstack-parity-2026-11-05/` in the repository records the evidence, the decisions, and the behavior inventory.
+
+- Attach every skill a message names, as Cursor's `findSkillReferences` does: a `/name` after the start of the message attaches its skill too, and several skills ride one message, each once, in order. Before, only a leading `/name` attached a skill.
+- Return Cursor's reject reason from `AskQuestion` when nobody can answer: `Questions skipped by the user, continue with the information you already have`, or `Subagent cannot ask questions` in a subagent.
+- Inject the two always-applied team-kit rules with their exact bodies. The port had added a heading to each.
+- Keep a `/loop` running when one of its runs is interrupted. Cursor's loop is a background shell that a turn interrupt leaves running, so only `/loop stop` or the `Loop` tool's `stop` ends it.
+- Run the built-in `explore` subagent on the parent model's `-fast` variant when Pi lists one, as Cursor's explore uses a faster model by default.
+
+## [0.15.36-pi.15] - 2026-11-04
+
+- Match watched shell output before a newline or process exit. Count every occurrence within a chunk and retain matches across chunk boundaries.
+- Match the captured observer's batching, minimum debounce, completion flush, and 100-occurrence limit notice.
+- Decode stdout and stderr independently so split UTF-8 characters reach the output file and monitor intact.
+- Pin `re2js` 1.2.2 for output-watch patterns. Invalid patterns warn without stopping the command. A missing dependency leaves unrelated tools available but rejects a valid requested watch before the command runs.
+- Record the pinned reference, original-component comparisons, and open requirements in `parity/pstack-full-parity-2026-11-04/`. Whole-plugin parity remains `NOT VERIFIED`.
+
 ## [0.15.36-pi.14] - 2026-11-04
 
 Each item below was checked against Cursor CLI 2026.10.22 with pstack and cursor-team-kit loaded, through live captures. `parity/pstack-native-parity-2026-11-04/` in the repository records the evidence and the decisions.

package/README.md

@@ -26,10 +26,10 @@ Remove the package with `pi remove ./extensions/pi-pstack`. Its state lives in `
 
 | You type | What happens |
 |---|---|
-| `/poteto-mode <task>` | The skill attaches to that one message. Every skill Pi loaded works this way: pstack's (`/how`, `/why`, `/arena`, `/interrogate`, `/principle-prove-it-works`, `/deslop`) and your own, such as a `/<handle>-mode` skill from `/automate-me`. `/skill:<name>` works too. |
+| `/poteto-mode <task>` | The skill attaches to that one message. Every skill Pi loaded works this way: pstack's (`/how`, `/why`, `/arena`, `/interrogate`, `/principle-prove-it-works`, `/deslop`) and your own, such as a `/<handle>-mode` skill from `/automate-me`. A `/name` later in the message attaches its skill too, such as `design the metrics. /architect this first.`, and every skill a message names attaches once, in order. `/skill:<name>` works too and attaches only that skill. |
 | `/mode poteto-mode [task]` | Keeps the skill in context on every turn until you leave the mode: the skill rides every request in its own system-prompt section, which Pi re-sends only when it changes. The first request after entry says the user entered the mode, later requests carry a reminder that names the skill file, and the request after `/mode off` or a switch to another mode says the user left it. The footer shows a badge with the skill's `icon` and `color` metadata, such as a yellow `♛ mode: poteto-mode` (other skills get `⚡`). `/mode off` exits and `/mode` reports. Any loaded skill can back a mode. |
 | `/plan [task]` | Plan mode: the agent researches with read-only tools (`read`, `grep`, `find`, `ls`, the sandboxed `bash_readonly`, `AskQuestion`, `TodoWrite`, `agent_status`, `Task`, whose launches run readonly: a fresh one runs here with no worktree, and a resume or fork stays where its agent ran, and `stop_agent`), asks its clarifying questions early, and presents the plan with `CreatePlan` (`plan`, `name`, `overview`, `todos`, `is_project`, `phases`). `CreatePlan` writes the plan file under `<pstack dir>/plans/` (`<name>-<8 hex>.plan.md`: the chat id in a comment, the todos as front matter, then the plan), one file per plan name in a chat. Todo dependencies and project phases stay in the file. Building imports the file's unfinished root todos into the session, including edits made during review. Worktree builders import their own lists before the first model request and retain the associated plan on resume. Later writable `TodoWrite` status updates synchronize those root todos without rewriting other metadata or the plan body. An omitted status imports as pending and is inserted when the todo is updated. A readonly resume keeps its todo changes inside the session. `edit` and `write` work on markdown files only, so the agent refines the plan in its file. After a run that saved a plan, an interactive session asks `Yes, build locally`, `Yes, build in cloud` (in a git repository: a background isolated worker builds it on its own branch), or `No, propose changes`. `/plan build` builds the saved plan too, and `/plan off` restores your tools. A bare `/plan` enters plan mode. The footer shows `plan`. |
-| `/loop 30m <prompt>` | Runs the prompt now, then again every 30 minutes from each fire, so a long run does not push the next tick out. A tick that comes due while a run is still going fires once when that run settles; several missed ticks still fire once. The interval can come first or last, written as `30m`, `10 minutes`, or `every 10 minutes`. Without an interval the agent picks each wake with the `Loop` tool, and the loop ends when it picks none and no background subagent or background shell is still running. A run that waits on an event (CI finishing, a ref moving, a log line) starts a watcher with `bash_background`, whose notification wakes the agent, and keeps a long wake as the fallback. Different prompts create independent loops. The same prompt replaces its schedule. `/loop` lists them. `/loop stop` ends the only loop, or `/loop stop <id>` selects one when several are running. Escape during a run ends the session's loops. `Loop` results include the loop ID in text and details; pass `loop_id` to wake, stop, or replace one of several loops. The prompt can be a skill command, such as `/loop 1h /poteto-mode run the audit tick`. When a playbook says to arm `/loop`, the agent runs the prompt once in that turn and starts the loop with the `Loop` tool, whose first scheduled run comes after the interval or wake. Intervals go up to 24 days. |
+| `/loop 30m <prompt>` | Runs the prompt now, then again every 30 minutes from each fire, so a long run does not push the next tick out. A tick that comes due while a run is still going fires once when that run settles; several missed ticks still fire once. The interval can come first or last, written as `30m`, `10 minutes`, or `every 10 minutes`. Without an interval the agent picks each wake with the `Loop` tool, and the loop ends when it picks none and no background subagent or background shell is still running. A run that waits on an event (CI finishing, a ref moving, a log line) starts a watcher with `bash_background`, whose notification wakes the agent, and keeps a long wake as the fallback. Different prompts create independent loops. The same prompt replaces its schedule. `/loop` lists them. `/loop stop` ends the only loop, or `/loop stop <id>` selects one when several are running. Escape interrupts one run and leaves the loop running. `Loop` results include the loop ID in text and details; pass `loop_id` to wake, stop, or replace one of several loops. The prompt can be a skill command, such as `/loop 1h /poteto-mode run the audit tick`. When a playbook says to arm `/loop`, the agent runs the prompt once in that turn and starts the loop with the `Loop` tool, whose first scheduled run comes after the interval or wake. Intervals go up to 24 days. |
 | `/routines` | Lists webhook routines with their URL, credential file, and status. |
 | `/setup-pstack` | Configures the per-role models. |
 | `/poteto-help <question>` | Answers a question about pstack and hands you a prompt to send. |
@@ -45,12 +45,12 @@ Remove the package with `pi remove ./extensions/pi-pstack`. Its state lives in `
 | `fork` | Starts a new agent whose transcript begins as a copy of an idle agent's transcript, in that agent's directory (its worktree for an isolated worker), so it sees the built checkout and uncommitted changes. Type, model, and readonly default from the source; readonly can be added, never lifted. `fork_turns: N` (only with `fork`) copies just the first N user turns. `fork` excludes `resume`, `environment`, and `cloud_base_branch`. Pi's own `/fork` command branches the chat session instead. |
 | `stop_agent` | `agent_id`. Stops a running subagent. One this Pi process owns gets an RPC abort, then a kill after a grace period. One another of your Pi processes owns gets a signal to the live pid in its run lock. An idle or finished agent is left alone, and the result says so. |
 | `agent_status` | Reads a subagent's state (`running` while its run lock names a live pid, `idle`, or `missing`), type, model, directory, branch, times, and last reply, without waking it. It also shows whether the agent is readonly, the agent it was forked from, its pid while running, and its transcript. Without `agent_id` it lists the workspace's 20 newest agents. In the root chat that includes every descendant, isolated workers too. |
-| Subagent types | The built-in `generalPurpose` (default) and `explore` (a file-search specialist the caller tells how thorough to be, with `grep`, `find`, and `ls` on and no `Task`), then `poteto-agent` (a background delegate that reads poteto-mode first), `ci-watcher` (a background PR check watcher), `comment-sicko`, and `thermo-nuclear-code-quality-review`, the last four read from `agents/*.md`. Unknown types fail with the list. |
+| Subagent types | The built-in `generalPurpose` (default) and `explore` (a file-search specialist the caller tells how thorough to be, with `grep`, `find`, and `ls` on and no `Task`, that runs on the parent model's `-fast` variant when Pi lists one), then `poteto-agent` (a background delegate that reads poteto-mode first), `ci-watcher` (a background PR check watcher), `comment-sicko`, and `thermo-nuclear-code-quality-review`, the last four read from `agents/*.md`. Unknown types fail with the list. |
 | Models | A Pi model spec such as `claude-opus-5-5:xhigh` or `xai/grok-4.7:high`, model parameters such as `claude-opus-5-5[effort=high]` or `grok-4.7[fast=true]` (picks a listed `-fast` id of that model), `fast` for the parent model's listed `-fast` variant when it has one, else the parent model, or `inherit`, `inherit-parent`, `auto`, or nothing for the parent model. A model Pi does not list, or a thinking level the model does not support, fails with the allowed list. A bare model id that several providers offer resolves to the parent chat's provider when it offers that id, and otherwise fails with the choices. Older rules that wrote `claude-opus-5-5-xhigh` still resolve. The system prompt's `pstack_subagents` section lists the types, the parent model, and the models with their levels. |
 | Isolated workers (`environment: "cloud"`) | The subagent runs in a new git worktree at `<pstack dir>/workspaces/<workspace folder>/worktrees/<agent id>` on branch `pstack/<agent id>`, from `cloud_base_branch` (`origin/<branch>` when that remote-tracking ref exists, else a local branch or other ref) or your HEAD commit, so uncommitted changes do not reach it. The result and the card name the branch to merge, and `resume` and `fork` run in the same worktree. It fails clearly outside a git repository, in a repository with no commits, or when the base does not resolve. The worker shares the root chat's workspace state, so it sees the same projects, stores, and subagent transcripts. It also shares this machine's ports, processes, writable caches, simulators, and credentials. Assign separate ports, output directories, and writable caches to concurrent runtime lanes. `swarm` and `orchestrate` spawn worktree workers by default. |
 | `readonly: true` | The child gets `read`, `grep`, `find`, `ls`, `TodoWrite`, and a read-only `bash`, and no MCP or background shell. That shell runs each command in an OS sandbox that blocks every file write, all network access, and Unix sockets, so `git log` works and `touch` or `curl` fail. On Linux it is `bubblewrap` with every namespace unshared, the filesystem bound read-only, and a seccomp filter that refuses `socket(AF_UNIX)` and `io_uring_setup`; on macOS it is [`@anthropic-ai/sandbox-runtime`](https://github.com/anthropics/sandbox-runtime)'s `sandbox-exec` policy. Where no sandbox can start, the command fails rather than running unsandboxed. Readonly is not credential isolation. The child still inherits environment variables and can read credential files through its read tools. |
 | `TodoWrite` | `todos` with `id`, `content`, `status`, and `merge`. Its description says when to keep a list, the four states, and one task in progress at a time. The list follows the session branch, shows above the editor, and rides every request's system prompt. Plan-imported lists persist as branch entries. Their dependencies survive status-only updates, and matching plan-file statuses are synchronized. |
-| `AskQuestion` | `title`, and per question `id`, `prompt`, `options` (at least two, each `id`, `label`, optional `description`), and `allow_multiple`, through Pi's select dialog. It is for decisions only the user can make, and a recommended option goes first with `(Recommended)`. Every question ends with `Other: (type to answer)`; a typed answer comes back as `other` with its text. In print and JSON runs each question comes back skipped. Subagents have no `AskQuestion`. |
+| `AskQuestion` | `title`, and per question `id`, `prompt`, `options` (at least two, each `id`, `label`, optional `description`), and `allow_multiple`, through Pi's select dialog. It is for decisions only the user can make, and a recommended option goes first with `(Recommended)`. Every question ends with `Other: (type to answer)`; a typed answer comes back as `other` with its text. In print and JSON runs the call comes back as `Questions skipped by the user, continue with the information you already have`. Subagents have no `AskQuestion`. |
 | Always-applied rules | The two team-kit rules are in `pstack_host` as their shipped text on every request, alongside the same rules as hidden skills. |
 | The model rule | `<pstack dir>/pstack-models.md`, plain Markdown with one line per role, added to every request's system prompt. A `pstack-models.mdc` from an earlier version is moved there once, without its frontmatter, and kept as `pstack-models.mdc.migrated`. |
 | Subscriptions | `subscribe_github_pr` (`scope` `pr` with `prUrl`, `repo` with `repo`, or `author` with `author` and `repo`) polls with `gh` every 60 seconds and wakes the chat when a PR's state, head, mergeability, review decision, reviews, or comments change, or when a check concludes or its conclusion changes; the first poll is a baseline. `subscribe_timer` takes a `name`, a `prompt`, and a 5-field `cron` or `delaySeconds`, either with `once`; `sessionStrategy` `wake_self` queues a wake for this owning session. With `new_session`, a live owner starts a background Task and receives its notification. An offline owner permits a detached run with a recorded outcome. Both reuse the model, thinking level, and project-trust decision the timer was created with. Re-subscribing an existing timer name returns `created: false`. `list_subscriptions` and `unsubscribe` manage them. The authoritative registry is `<pstack dir>/durable/<workspace>/subscriptions.json`. Any session in that workspace can list or cancel subscriptions. Session history does not recreate cancelled or completed subscriptions. Owner-directed events wait for the creating session rather than waking another workspace session. A detached run records its own final message, shown by `list_subscriptions`. A timer does not expire unless `expiresInHours` says so (at most 30 days); `0` means no expiry. A GitHub watch keeps a 7-day default because it is this port's own surface. |

package/docs/parity-status.md

@@ -14,7 +14,7 @@ A path and byte comparison of the tracked trees shows every pstack skill, both p
 
 | Cursor dependency | Pi mechanism |
 | --- | --- |
-| Skill invocation and the slash menu | `pi.getCommands()` plus `/name` to `/skill:name` input rewriting, with TUI completions |
+| Skill invocation and the slash menu | `pi.getCommands()` plus an input transform that attaches every `/name` a message names, the first through Pi's `/skill:name` expansion and the rest as skill blocks, with TUI completions |
 | Custom Mode | `/mode <skill>`, a branch-persisted entry, the skill in a `pstack_mode_skill` prompt section on every request while the mode is on, and Cursor's entered, reminder, and exit or switch notices in `pstack_mode` |
 | Plan mode | `/plan` and `SwitchMode`, Cursor's plan-mode instructions in `pstack_plan`, a reduced tool set with `bash_readonly` in an OS sandbox and markdown-only `edit` and `write`, `CreatePlan` writing Cursor's plan file under `plans/`, and a build prompt after a saved plan (`/plan build` too) |
 | Always-applied model rule | `pstack-models.md` read before every request and injected as `pstack_models` |
@@ -45,6 +45,16 @@ A live Cursor CLI session with both plugins loaded produced these contracts.
 
 Pi returns the child's final text with a transcript path and usage, and reports background completion as a `pstack/task` notification. The payload shape differs because the hosts are different; the observable workflow, a subagent result arriving after the parent turn, is preserved.
 
+## Repairs in 0.15.36-pi.16
+
+A run on 2026-11-05 (UTC) compared pi-pstack with the Cursor CLI 2026.10.22 bundle, Cursor's built-in skills, and Cursor's docs, without starting any Cursor or Pi model session. The repository's `parity/pstack-parity-2026-11-05/` holds the decision trail, the behavior inventory (`inventory.md`, `inventory.json`), and the scripts that rebuild them.
+
+- **Skill references anywhere in a message.** The CLI's `findSkillReferences` scans the whole submitted message with `(?:^|\s)/([a-zA-Z0-9_-]+)` and attaches every skill it names, each once, on both the interactive and headless submit paths. pi-pstack attached only a leading `/name`, so the README's `design this instrumentation ... /architect this first.` lost the skill. Every referenced skill now attaches, in order of first reference.
+- **AskQuestion without a person.** The CLI's headless path rejects with `Questions skipped by the user, continue with the information you already have`, and its subagent runner with `Subagent cannot ask questions`. pi-pstack now returns those reasons.
+- **Rule text.** The two always-applied team-kit rule bodies are injected exactly. The port had added a heading above each.
+- **Interrupted loop runs.** Cursor's local `/loop` is a background shell that echoes a sentinel. The interactive CLI never aborts background work when the user interrupts a turn (`abortAllWork` runs only in `src/headless.ts`), so the loop keeps ticking. pi-pstack had stopped every loop on Escape. A loop now keeps running until `/loop stop` or the `Loop` tool's `stop`.
+- **Explore model.** Cursor's docs state that the built-in explore subagent uses a faster model by default. pi-pstack's `explore` now defaults to the parent model's `-fast` variant when Pi lists one, the same rule as `ci-watcher`'s `model: fast`.
+
 ## Repairs in 0.15.36-pi.14
 
 An independent audit on 2026-11-04 compared every reference file and probed Cursor CLI 2026.10.22 live. The repository's `parity/pstack-native-parity-2026-11-04/` holds the notes, decision log, inventory, and the scripts; `.audit/pstack-native-parity-2026-11-04/cursor/` holds the raw Cursor captures.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@justjoshn/pi-pstack",
-  "version": "0.15.36-pi.14",
+  "version": "0.15.36-pi.16",
   "description": "pstack 0.15.36 for Pi with its soft-dependency team-kit skills vendored in: rigorous agent workflows and principles as Pi skills, with the host features they use: subagents, todos, modes, plan mode, the model rule, /loop, subscriptions and routines, AskQuestion, SwitchMode, image generation, and visualize",
   "type": "module",
   "license": "MIT",
@@ -65,6 +65,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "0.0.79",
+    "re2js": "1.2.2",
     "yaml": "2.9.0"
   },
   "peerDependencies": {

package/skills/no-inline-imports/SKILL.md

@@ -4,8 +4,6 @@ description: Keep imports at top of file and avoid inline imports
 disable-model-invocation: true
 ---
 
-# No Inline Imports
-
 # No inline imports
 
 Always place imports at the top of the module. Avoid inline imports in function bodies, type annotations, or interface fields unless there is a strict circular-dependency reason and it is documented.

package/skills/poteto-mode/playbooks/multi-phase-plan.md

@@ -5,7 +5,7 @@
 1. When the change is one or two files with an obvious approach, skip the plan. Say so and stop.
 2. Settle open questions by prototype before you write. Run `playbooks/prototype.md` for each. Keep the branch, the SHA, and the screenshots for Appendix A. Ask the operator only about a product or preference call that no run can settle. Give options (the **never-block-on-the-human** principle skill).
 3. Explore in subagents with `subagent_type: "poteto-agent"` and an explicit model per the Subagents section (the **guard-the-context-window** principle skill). Pick each subagent's reasoning level (the `:<level>` suffix), and fast or standard speed when the model has a `-fast` variant, for the job, per the Subagents section. Each returns file pointers, conventions, test commands, and entry points. No inlined dumps.
-4. Copy the skeleton below into the plan file and fill every placeholder. `<SKILLS>` is the pi-pstack skills directory the system prompt names. Fill `<pi-pstack path>` with the program repository's path to its pi-pstack copy. If the repository has none, write each `git show origin/main:<pi-pstack path>/...` box as a `read` of the same file under `<SKILLS>`. Unless the operator names a path, write the file under the agent store's `docs/`. Keep every heading and every sub-block in the order shown. One section per PR. One PR is one change with its own evidence (the **sequence-verifiable-units** principle skill). Name the execution playbook in **How to read this**. Pick `playbooks/autopilot-full.md` when the run may merge. Pick `playbooks/autopilot-stack.md` when the operator lands the PRs. A standing program takes `playbooks/orchestrate.md`.
+4. Copy the skeleton below into the plan file and fill every placeholder. `<SKILLS>` is the pi-pstack skills directory the system prompt names. Fill `<pi-pstack path>` with the program repository's path to its pi-pstack copy. Unless the operator names a path, write the file under the agent store's `docs/`. Keep every heading and every sub-block in the order shown. One section per PR. One PR is one change with its own evidence (the **sequence-verifiable-units** principle skill). Name the execution playbook in **How to read this**. Pick `playbooks/autopilot-full.md` when the run may merge. Pick `playbooks/autopilot-stack.md` when the operator lands the PRs. A standing program takes `playbooks/orchestrate.md`.
 5. Write under `/technical-writing` in full, then `/unslop`. The body is one Diátaxis mode, how-to. Appendices hold explanation and reference. Each heading states the task or the finding. No long dashes. No mid-sentence colons.
 6. Run `node <SKILLS>/poteto-mode/scripts/check-plan.mjs <plan.md>` and fix every line it prints (the **encode-lessons-in-structure** principle skill).
 7. Hand back. Post the plan path and the script's output, then stop. Execution starts on the operator's explicit go, under the execution playbook the plan names.

package/skills/typescript-exhaustive-switch/SKILL.md

@@ -4,7 +4,5 @@ description: Use exhaustive switch handling for TypeScript unions and enums
 disable-model-invocation: true
 ---
 
-# Typescript Exhaustive Switch
-
 typescript-exhaustive-switch: In switch statements over discriminated unions or enums, use a `never` check in the default case so newly added variants cause compile-time failures until handled.
 

package/src/aliases.ts

@@ -4,19 +4,27 @@ import { sep } from 'node:path';
 import type { ImageContent } from '@earendil-works/pi-ai';
 import type { SlashCommandInfo } from '@earendil-works/pi-coding-agent';
 import { SKILLS_DIR } from './paths.ts';
+import { skillBlock } from './skill-block.ts';
 
 const ALIAS = /^\/([a-z0-9]+(?:-[a-z0-9]+)*)(?=\s|$)/;
+// Cursor CLI `findSkillReferences`: every `/name` at the start or after whitespace that names a skill attaches it.
+const REFERENCE = /(?:^|\s)\/([a-zA-Z0-9_-]+)/g;
 const SKILL_PREFIX = 'skill:';
 
 const isSkill = (command: SlashCommandInfo) => command.source === 'skill' && command.name.startsWith(SKILL_PREFIX);
 
+/** Names that prompt templates and extension commands own. Pi expands a leading template after the input event. */
+export function commandNames(commands: readonly SlashCommandInfo[]): ReadonlySet<string> {
+  return new Set(commands.filter((command) => command.source !== 'skill').map((command) => command.name));
+}
+
 /**
  * `/name` aliases with their descriptions: every skill Pi loaded, so any skill attaches by name
  * (pstack itself creates skills such as `/<handle>-mode`), minus any name a prompt template or extension command owns.
  * Settings that filter a skill out also drop its alias. Pi handles its built-in commands before the input event.
  */
 export function aliasTable(commands: readonly SlashCommandInfo[]): ReadonlyMap<string, string> {
-  const taken = new Set(commands.filter((command) => command.source !== 'skill').map((command) => command.name));
+  const taken = commandNames(commands);
   const table = new Map<string, string>();
   for (const command of commands.filter(isSkill)) {
     const name = command.name.slice(SKILL_PREFIX.length);
@@ -25,6 +33,14 @@ export function aliasTable(commands: readonly SlashCommandInfo[]): ReadonlyMap<s
   return table;
 }
 
+/** A loaded skill's block by name, read when a message names it. */
+export const loadedSkillBlock =
+  (commands: readonly SlashCommandInfo[]) =>
+  (name: string): string | undefined => {
+    const path = commands.find((command) => isSkill(command) && command.name === `${SKILL_PREFIX}${name}`)?.sourceInfo.path;
+    return path === undefined ? undefined : skillBlock(name, path);
+  };
+
 // Pi records a skill path as configured, which can run through a symlink; realpaths are cached per runtime.
 const realPaths = new Map<string, string | undefined>();
 function realPath(path: string): string | undefined {
@@ -41,24 +57,36 @@ export function packageSkillNames(commands: readonly SlashCommandInfo[], skillsD
     .toSorted();
 }
 
+/** The aliased skills a message names, each once, in order of first reference. */
+export function skillReferences(text: string, names: ReadonlySet<string>): string[] {
+  const found: string[] = [];
+  for (const [, name = ''] of text.matchAll(REFERENCE)) if (names.has(name) && !found.includes(name)) found.push(name);
+  return found;
+}
+
 /**
- * Rewrites `/name args` to Pi's native `/skill:name args` for an aliased skill, keeping the argument text.
- * Pi splits the skill name at the first space and trims the arguments, so a space always follows the name.
+ * Attaches every skill the message names, as Cursor does, and keeps the message. The first skill rides Pi's native
+ * `/skill:name args` expansion; a leading `/name` becomes that command, as Pi's own syntax drops it. Each further skill
+ * is a block at the head of the arguments. Pi splits the skill name at the first space and trims the arguments.
+ * An explicit `/skill:` command is Pi's own and stays as typed, and so does a message that starts with a prompt
+ * template, which Pi can expand only while the message still starts with it.
  */
-export function aliasTransform(text: string, names: ReadonlySet<string>): string | undefined {
-  const match = ALIAS.exec(text);
-  const name = match?.[1];
-  if (match === null || name === undefined || !names.has(name)) return undefined;
-  const rest = text.slice(match[0].length);
-  if (rest.length === 0) return `/skill:${name}`;
-  return `/skill:${name} ${rest.startsWith(' ') ? rest.slice(1) : rest}`;
+export function aliasTransform(text: string, names: ReadonlySet<string>, blockFor: (name: string) => string | undefined, commands: ReadonlySet<string> = new Set()): string | undefined {
+  if (text.startsWith(`/${SKILL_PREFIX}`) || commands.has(/^\/(\S+)/.exec(text)?.[1] ?? '')) return undefined;
+  const [first, ...others] = skillReferences(text, names);
+  if (first === undefined) return undefined;
+  const leading = ALIAS.exec(text);
+  const rest = leading?.[1] === first ? text.slice(leading[0].length) : undefined;
+  const body = rest === undefined ? text : rest.startsWith(' ') ? rest.slice(1) : rest;
+  const args = [...others.flatMap((name) => blockFor(name) ?? []), ...(body === '' ? [] : [body])].join('\n\n');
+  return args === '' ? `/skill:${first}` : `/skill:${first} ${args}`;
 }
 
 export type AliasInputResult = { action: 'continue' } | { action: 'transform'; text: string; images?: ImageContent[] };
 
-/** The `input` handler result: Pi's native skill command for an aliased skill, otherwise continue unchanged. */
-export function aliasInputResult(event: { text: string; images?: ImageContent[] }, names: ReadonlySet<string>): AliasInputResult {
-  const text = aliasTransform(event.text, names);
+/** The `input` handler result: Pi's native skill command carrying every referenced skill, otherwise continue unchanged. */
+export function aliasInputResult(event: { text: string; images?: ImageContent[] }, names: ReadonlySet<string>, blockFor: (name: string) => string | undefined, commands: ReadonlySet<string> = new Set()): AliasInputResult {
+  const text = aliasTransform(event.text, names, blockFor, commands);
   if (text === undefined) return { action: 'continue' };
   return { action: 'transform', text, ...(event.images === undefined ? {} : { images: event.images }) };
 }

package/src/ask.ts

@@ -7,7 +7,9 @@ export const DONE_LABEL = '✓ Done selecting';
 // Every question ends with a typed-answer option.
 export const OTHER_LABEL = 'Other: (type to answer)';
 export const OTHER_ID = 'other';
-const SKIPPED = 'skipped (no one can answer questions in this session; decide yourself and say what you chose)';
+// Cursor CLI's reject reasons: src/headless.ts for a run with nobody to answer, the local subagent runner for a subagent.
+const SKIPPED = 'Questions skipped by the user, continue with the information you already have';
+const SUBAGENT_SKIPPED = 'Subagent cannot ask questions';
 
 export const AskParams = Type.Object({
   title: Type.Optional(Type.String({ description: 'Optional title for the questions form' })),
@@ -130,7 +132,7 @@ export function registerAskQuestion(pi: ExtensionAPI): void {
       validateQuestions(params.questions);
       // Print and JSON runs and subagents have no one to answer, so the questions come back skipped.
       if (!canAsk(ctx)) {
-        const text = params.questions.map((question) => `${question.id}: ${SKIPPED}`).join('\n');
+        const text = childIdentity.depth > 0 ? SUBAGENT_SKIPPED : SKIPPED;
         return { content: [{ type: 'text', text }], details: { answers: {}, skipped: params.questions.map((question) => question.id) } };
       }
       const answers: Record<string, string[]> = {};

package/src/background-shell.ts

@@ -5,12 +5,14 @@ import { type ChildProcess, spawn } from 'node:child_process';
 import { closeSync, existsSync, fstatSync, mkdirSync, openSync, readSync, statSync, writeSync } from 'node:fs';
 import { constants } from 'node:os';
 import { join, resolve } from 'node:path';
+import { StringDecoder } from 'node:string_decoder';
 
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';
 import { getShellConfig, truncateTail } from '@earendil-works/pi-coding-agent';
 import { Text } from '@earendil-works/pi-tui';
 import { Type } from 'typebox';
 import { isOneShot } from './modes.ts';
+import { OutputWatchDependencyError, type OutputWatchRequest, ShellOutputWatch } from './shell-output-watch.ts';
 
 export const SHELL_NOTICE_TYPE = 'pstack/shell';
 const BACKGROUND_TOOL = 'bash_background';
@@ -18,7 +20,6 @@ const AWAIT_TOOL = 'AwaitShell';
 
 const FIELD_WIDTH = 9;
 const HEADER_REFRESH_MS = 5_000;
-const MIN_DEBOUNCE_MS = 5_000;
 const DEFAULT_AWAIT_MS = 30_000;
 const MAX_AWAIT_MS = 7_140_000;
 const KILL_GRACE_MS = 2_000;
@@ -27,20 +28,6 @@ const FOLLOW_UP = 'Briefly inform the user about the task result and perform any
 type JobStatus = 'running' | 'succeeded' | 'failed' | 'aborted';
 type NoticeStatus = 'success' | 'error' | 'aborted';
 
-interface OutputWatch {
-  readonly regex: RegExp;
-  readonly source: string;
-  readonly reason: string;
-  readonly debounceMs: number;
-  occurrences: number;
-  /** Matches since the last notification, sent when the debounce window closes. */
-  unreported: number;
-  latest: string;
-  notices: number;
-  window: ReturnType<typeof setTimeout> | undefined;
-  partial: string;
-}
-
 interface ShellJob {
   readonly id: string;
   readonly pid: number;
@@ -55,7 +42,7 @@ interface ShellJob {
   readonly statusOffset: number;
   readonly runningOffset: number;
   readonly child: ChildProcess;
-  readonly watch: OutputWatch | undefined;
+  readonly watch: ShellOutputWatch | undefined;
   readonly listeners: Set<() => void>;
   readonly done: Promise<void>;
   /** Where the next output byte goes; the header is rewritten in place, so the file is never opened for append. */
@@ -145,9 +132,6 @@ export function noticeText(notice: ShellNotice): string {
   ].join('\n');
 }
 
-const firstMatchDetail = (watch: OutputWatch) => `Shell output has pattern /${watch.source}/. This is occurrence number ${watch.occurrences}. Matched text: ${watch.latest}. The title message is being displayed to the user.`;
-const laterMatchesDetail = (watch: OutputWatch) => `Shell output matched /${watch.source}/ ${watch.unreported} more times since the previous notification. The title message is being displayed to the user. Latest match: ${watch.latest}.`;
-
 function exitStatus(code: number | null, signal: NodeJS.Signals | null): { status: JobStatus; exitCode: number } {
   if (signal !== null) return { status: 'aborted', exitCode: 128 + (constants.signals[signal] ?? 0) };
   const exitCode = code ?? 1;
@@ -215,7 +199,7 @@ export interface StartRequest {
   cwd: string;
   title: string;
   toolCallId: string;
-  watch?: { pattern: string; reason: string; debounceMs?: number };
+  watch?: OutputWatchRequest;
 }
 
 /** Every background shell this runtime started, and the notifications they owe the agent. */
@@ -245,50 +229,6 @@ export function createShellJobs(options: ShellJobsOptions, deliver: (notice: She
     for (const listener of [...job.listeners]) listener();
   };
 
-  const sendProgress = (job: ShellJob, watch: OutputWatch, detail: string) => {
-    watch.notices += 1;
-    deliver({ kind: 'progress', status: 'success', taskId: `${job.id}:task_progress:${watch.notices}`, shellId: job.id, title: watch.reason, toolCallId: job.toolCallId, detail, outputPath: job.path });
-  };
-  /** Trailing-edge debounce: the first match notifies at once, later ones in the window are counted and sent when it closes. */
-  const openWindow = (job: ShellJob, watch: OutputWatch) => {
-    watch.window = setTimeout(() => {
-      watch.window = undefined;
-      if (watch.unreported === 0) return;
-      sendProgress(job, watch, laterMatchesDetail(watch));
-      watch.unreported = 0;
-      openWindow(job, watch);
-    }, watch.debounceMs);
-    watch.window.unref();
-  };
-  const matchLine = (job: ShellJob, watch: OutputWatch, line: string) => {
-    const match = watch.regex.exec(line);
-    if (match === null) return;
-    watch.occurrences += 1;
-    watch.latest = match[0];
-    if (watch.window !== undefined) {
-      watch.unreported += 1;
-      return;
-    }
-    sendProgress(job, watch, firstMatchDetail(watch));
-    openWindow(job, watch);
-  };
-  const scan = (job: ShellJob, chunk: string, final: boolean) => {
-    const watch = job.watch;
-    if (watch === undefined) return;
-    const lines = (watch.partial + chunk).split('\n');
-    watch.partial = final ? '' : (lines.pop() ?? '');
-    for (const line of lines) if (line !== '' || final) matchLine(job, watch, line.replace(/\r$/, ''));
-  };
-  const flushWatch = (job: ShellJob) => {
-    const watch = job.watch;
-    if (watch === undefined) return;
-    scan(job, '', true);
-    if (watch.window !== undefined) clearTimeout(watch.window);
-    watch.window = undefined;
-    if (watch.unreported > 0) sendProgress(job, watch, laterMatchesDetail(watch));
-    watch.unreported = 0;
-  };
-
   const finish = (job: ShellJob, status: JobStatus, exitCode: number, announce: boolean) => {
     if (job.status !== 'running') return;
     const endedAt = Date.now();
@@ -299,8 +239,8 @@ export function createShellJobs(options: ShellJobsOptions, deliver: (notice: She
     job.bodyEnd = job.size;
     append(job, terminalFooter(exitCode, endedAt - job.startedAt, endedAt));
     closeSync(job.fd);
+    job.watch?.finish(announce);
     if (announce) {
-      flushWatch(job);
       if (!job.observed) {
         const noticeStatus: NoticeStatus = status === 'succeeded' ? 'success' : status === 'failed' ? 'error' : 'aborted';
         deliver({
@@ -313,17 +253,27 @@ export function createShellJobs(options: ShellJobsOptions, deliver: (notice: She
           ...(noticeStatus === 'error' ? { detail: `exit_code=${exitCode}` } : {}),
         });
       }
-    } else if (job.watch?.window !== undefined) clearTimeout(job.watch.window);
+    }
     notify(job);
   };
 
   const start = (ctx: ExtensionContext, request: StartRequest): ShellJob => {
     if (!existsSync(request.cwd) || !statSync(request.cwd).isDirectory()) throw new Error(`Working directory ${request.cwd} does not exist.`);
-    const watchRegex = request.watch === undefined ? undefined : compile(request.watch.pattern);
     const dir = options.terminalsDir(ctx);
     mkdirSync(dir, { recursive: true });
     const id = allocateId(dir);
     const path = join(dir, `${id}.txt`);
+    let watch: ShellOutputWatch | undefined;
+    if (request.watch !== undefined && request.watch.pattern.trim() !== '') {
+      try {
+        watch = new ShellOutputWatch(request.watch, (notice) => {
+          deliver({ kind: 'progress', status: 'success', taskId: `${id}:task_progress:${notice.sequence}`, shellId: id, title: notice.title, toolCallId: request.toolCallId, detail: notice.detail, outputPath: path });
+        });
+      } catch (error) {
+        if (error instanceof OutputWatchDependencyError) throw error;
+        console.warn('Invalid shell output notification pattern', { shellId: id, error: error instanceof Error ? error.message : String(error) });
+      }
+    }
     const config = getShellConfig(options.shellPath());
     const viaStdin = config.commandTransport === 'stdin';
     const child = spawn(config.shell, viaStdin ? config.args : [...config.args, request.command], {
@@ -357,21 +307,7 @@ export function createShellJobs(options: ShellJobsOptions, deliver: (notice: She
       statusOffset: header.statusOffset,
       runningOffset: header.runningOffset,
       child,
-      watch:
-        request.watch === undefined || watchRegex === undefined
-          ? undefined
-          : {
-              regex: watchRegex,
-              source: request.watch.pattern,
-              reason: request.watch.reason,
-              debounceMs: Math.max(MIN_DEBOUNCE_MS, request.watch.debounceMs ?? MIN_DEBOUNCE_MS),
-              occurrences: 0,
-              unreported: 0,
-              latest: '',
-              notices: 0,
-              window: undefined,
-              partial: '',
-            },
+      watch,
       listeners: new Set(),
       done: new Promise<void>((resolveDone) => {
         release = resolveDone;
@@ -388,14 +324,24 @@ export function createShellJobs(options: ShellJobsOptions, deliver: (notice: She
     append(job, header.text);
     job.refresh = setInterval(() => refreshRunning(job), HEADER_REFRESH_MS);
     job.refresh.unref();
-    const onData = (chunk: Buffer) => {
-      if (job.status !== 'running') return;
-      append(job, chunk);
-      scan(job, chunk.toString('utf8'), false);
-      notify(job);
-    };
-    child.stdout?.on('data', onData);
-    child.stderr?.on('data', onData);
+    for (const stream of [child.stdout, child.stderr]) {
+      if (stream === null) continue;
+      const decoder = new StringDecoder('utf8');
+      stream.on('data', (chunk: Buffer) => {
+        if (job.status !== 'running') return;
+        const text = decoder.write(chunk);
+        append(job, text);
+        job.watch?.observe(text);
+        notify(job);
+      });
+      stream.on('end', () => {
+        if (job.status !== 'running') return;
+        const text = decoder.end();
+        append(job, text);
+        job.watch?.observe(text);
+        notify(job);
+      });
+    }
     child.on('error', (error) => {
       if (job.status === 'running') append(job, `${error.message}\n`);
       finish(job, 'failed', 127, true);

package/src/index.ts

@@ -2,7 +2,7 @@ import { basename } from 'node:path';
 
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';
 import { getAgentDir } from '@earendil-works/pi-coding-agent';
-import { aliasInputResult, aliasTable, packageSkillNames } from './aliases.ts';
+import { aliasInputResult, aliasTable, commandNames, loadedSkillBlock, packageSkillNames } from './aliases.ts';
 import { registerAskQuestion } from './ask.ts';
 import { aliasAutocomplete } from './autocomplete.ts';
 import { registerBackgroundShell } from './background-shell.ts';
@@ -100,7 +100,10 @@ function watchParent(pi: ExtensionAPI, parentPid: number): void {
 export default function piPstack(pi: ExtensionAPI): void {
   const agents = loadAgentDefinitions();
 
-  pi.on('input', (event) => aliasInputResult(event, new Set(aliasTable(pi.getCommands()).keys())));
+  pi.on('input', (event) => {
+    const commands = pi.getCommands();
+    return aliasInputResult(event, new Set(aliasTable(commands).keys()), loadedSkillBlock(commands), commandNames(commands));
+  });
   pi.on('session_start', (_event, ctx) => {
     if (ctx.mode === 'tui') ctx.ui.addAutocompleteProvider((current) => aliasAutocomplete(current, aliasTable(pi.getCommands())));
   });

package/src/loop.ts

@@ -119,10 +119,13 @@ function createLoopController(pi: ExtensionAPI, options: LoopOptions) {
     if (lastCtx !== undefined && !lastCtx.isIdle()) loop = { ...loop, due: true };
     else run();
   };
-  const settled = (ctx: ExtensionContext, aborted: boolean) => {
+  /**
+   * A run settled. An aborted run is no stop: Cursor's loop is a background shell that a turn interrupt leaves
+   * running, so the user or the agent stops a loop explicitly.
+   */
+  const settled = (ctx: ExtensionContext) => {
     lastCtx = ctx;
     if (loop === undefined) return;
-    if (aborted) return stop(ctx, 'the run was aborted.');
     if (loop.due === true) return run();
     if (loop.timer !== undefined) return;
     if (loop.intervalMs !== undefined) {
@@ -276,8 +279,8 @@ export function registerLoop(pi: ExtensionAPI, options: LoopOptions): { section:
   pi.on('session_start', (_event, ctx) => {
     if (isOneShot(ctx.mode)) pi.setActiveTools(pi.getActiveTools().filter((name) => name !== 'Loop'));
   });
-  pi.on('agent_settled', (event, ctx) => {
-    for (const [, controller] of registry.entries()) controller.settled(ctx, event.aborted);
+  pi.on('agent_settled', (_event, ctx) => {
+    for (const [, controller] of registry.entries()) controller.settled(ctx);
   });
   pi.on('session_shutdown', () => {
     for (const [, controller] of registry.entries()) controller.clear();

package/src/mode.ts

@@ -1,8 +1,8 @@
 import { existsSync, readFileSync } from 'node:fs';
-import { dirname } from 'node:path';
 
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, ThemeColor } from '@earendil-works/pi-coding-agent';
-import { parseFrontmatter, stripFrontmatter } from '@earendil-works/pi-coding-agent';
+import { parseFrontmatter } from '@earendil-works/pi-coding-agent';
+import { skillBlock } from './skill-block.ts';
 
 export const MODE_ENTRY = 'pstack/mode';
 const STATUS_KEY = 'pstack-mode';
@@ -100,10 +100,8 @@ export function modeNotice(state: ModeState): string | undefined {
  * through compaction and restarts, and Pi re-sends a section only when it changes.
  */
 export function modeSkill(mode: ActiveMode): string | undefined {
-  if (mode.path === undefined || !existsSync(mode.path)) return undefined;
   // The frontmatter stays out of the model's context in a mode (MODE-004).
-  const body = stripFrontmatter(readFileSync(mode.path, 'utf8')).trim();
-  return [`<skill name="${mode.skill}" location="${mode.path}">`, `References are relative to ${dirname(mode.path)}.`, '', body, '</skill>'].join('\n');
+  return mode.path === undefined ? undefined : skillBlock(mode.skill, mode.path);
 }
 
 // A mode's badge shows the skill's `icon` (default: lightning) and `color`. Icon names map to terminal glyphs and

package/src/shell-output-watch.ts

@@ -0,0 +1,126 @@
+import { createRequire } from 'node:module';
+
+import type { RE2JS } from 're2js';
+
+const require = createRequire(import.meta.url);
+let regexEngine: typeof RE2JS | undefined;
+try {
+  regexEngine = (require('re2js') as { RE2JS: typeof RE2JS }).RE2JS;
+} catch {}
+
+export class OutputWatchDependencyError extends Error {}
+
+export interface OutputWatchRequest {
+  pattern: string;
+  reason: string;
+  debounceMs?: number;
+}
+
+export interface OutputMatchNotice {
+  sequence: number;
+  title: string;
+  detail: string;
+}
+
+interface MatchBatch {
+  start: number;
+  count: number;
+  matchedText: string;
+}
+
+const MATCH_LIMIT = 100;
+const MAX_CHUNK = 65_536;
+const MIN_DEBOUNCE_MS = 5_000;
+
+export class ShellOutputWatch {
+  private readonly request: OutputWatchRequest;
+  private readonly notify: (notice: OutputMatchNotice) => void;
+  private readonly regex: RE2JS;
+  private readonly title: string;
+  private readonly debounceMs: number;
+  private state: 'watching' | 'limited' | 'finished' = 'watching';
+  private carryover = '';
+  private occurrences = 0;
+  private notices = 0;
+  private batch: MatchBatch | undefined;
+  private timer: ReturnType<typeof setTimeout> | undefined;
+
+  constructor(request: OutputWatchRequest, notify: (notice: OutputMatchNotice) => void) {
+    this.request = request;
+    this.notify = notify;
+    if (request.pattern.length > 500) throw new Error('Output notification pattern exceeds 500 characters');
+    if (regexEngine === undefined) throw new OutputWatchDependencyError('Shell output monitoring needs the re2js dependency. Run bun install in the pi-pstack package directory, then reload Pi.');
+    this.regex = regexEngine.compile(request.pattern, regexEngine.MULTILINE);
+    const title = request.reason.trim() || `Shell output contains /${request.pattern}/`;
+    this.title = title.length <= 500 ? title : `${title.slice(0, 500)}...`;
+    this.debounceMs = Math.max(request.debounceMs ?? MIN_DEBOUNCE_MS, MIN_DEBOUNCE_MS);
+  }
+
+  observe(chunk: string): void {
+    if (this.state !== 'watching' || chunk.length === 0) return;
+    for (let offset = 0; offset < chunk.length && this.state === 'watching'; offset += MAX_CHUNK) {
+      const previous = this.carryover.length;
+      const text = this.carryover + chunk.slice(offset, offset + MAX_CHUNK);
+      const matcher = this.regex.matcher(text);
+      while (this.state === 'watching' && matcher.find()) {
+        if (matcher.end() > previous) this.match(matcher.group() ?? '');
+      }
+      this.carryover = text.slice(-1_024);
+    }
+  }
+
+  finish(announce = true): void {
+    if (this.state === 'finished') return;
+    this.state = 'finished';
+    if (announce) this.flush();
+    this.batch = undefined;
+    this.clearTimer();
+  }
+
+  private match(text: string): void {
+    this.occurrences += 1;
+    const label = this.occurrences === 1 ? 'Matched text' : 'Latest match';
+    const matchedText = text.length <= 5_000 ? `${label}: ${text}` : `${label} is ${text.length} characters; omitted from notification detail.`;
+    if (this.occurrences === 1) {
+      this.emit({ start: 1, count: 1, matchedText });
+    } else {
+      this.batch = this.batch === undefined ? { start: this.occurrences, count: 1, matchedText } : { start: this.batch.start, count: this.batch.count + 1, matchedText };
+      if (this.occurrences < MATCH_LIMIT && this.timer === undefined) {
+        this.timer = setTimeout(() => this.flush(), this.debounceMs);
+        this.timer.unref();
+      }
+    }
+    if (this.occurrences === MATCH_LIMIT) {
+      this.state = 'limited';
+      this.flush();
+      this.notices += 1;
+      this.notify({
+        sequence: this.notices,
+        title: `Notification limit reached (${MATCH_LIMIT})`,
+        detail: `Shell output matched /${this.request.pattern}/ ${MATCH_LIMIT} times and has reached the notification limit. No further notifications will be sent for this pattern. To continue monitoring, read the output file directly at the output path.`,
+      });
+    }
+  }
+
+  private clearTimer(): void {
+    if (this.timer !== undefined) clearTimeout(this.timer);
+    this.timer = undefined;
+  }
+
+  private flush(): void {
+    const batch = this.batch;
+    this.batch = undefined;
+    this.clearTimer();
+    if (batch !== undefined) this.emit(batch);
+  }
+
+  private emit(batch: MatchBatch): void {
+    this.notices += 1;
+    const pattern = this.request.pattern;
+    const detail =
+      batch.count === 1
+        ? `Shell output has pattern /${pattern}/. This is occurrence number ${batch.start}. ${batch.matchedText}. The title message is being displayed to the user.`
+        : `Shell output matched /${pattern}/ ${batch.count} more times since the previous notification. The title message is being displayed to the user. ${batch.matchedText}.`;
+    this.notify({ sequence: this.notices, title: this.title, detail });
+  }
+}

package/src/skill-block.ts

@@ -0,0 +1,14 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+import { stripFrontmatter } from '@earendil-works/pi-coding-agent';
+
+/**
+ * A skill's body in the block Pi's own `/skill:name` expansion builds (`AgentSession._expandSkillCommand`), or
+ * undefined when the file is gone. Pi exports no formatter for one block.
+ */
+export function skillBlock(name: string, path: string): string | undefined {
+  if (!existsSync(path)) return undefined;
+  const body = stripFrontmatter(readFileSync(path, 'utf8')).trim();
+  return [`<skill name="${name}" location="${path}">`, `References are relative to ${dirname(path)}.`, '', body, '</skill>'].join('\n');
+}

package/src/task/agents.ts

@@ -29,10 +29,11 @@ export const GENERAL_PURPOSE: AgentDefinition = {
 
 /**
  * Cursor's built-in codebase explorer: a file-search specialist that the caller tells how thorough to be, and that has
- * no Task tool of its own.
+ * no Task tool of its own. Cursor documents that it uses a faster model by default; here that is the parent's -fast variant.
  */
 export const EXPLORE: AgentDefinition = {
   type: 'explore',
+  model: 'fast',
   description:
     'Fast agent specialized for exploring codebases. Use it to find files by pattern (such as "src/components/**/*.tsx"), search code for keywords (such as "API endpoints"), or answer questions about the codebase (such as "how do API endpoints work?"). When you call it, name the thoroughness you want: "quick" for basic searches, "medium" for moderate exploration, or "very thorough" for a comprehensive search across many locations and naming conventions.',
   readonly: false,