@henryqw/pi-subagent 11.0.1 → 11.0.4

package/README.md

@@ -1,19 +1,18 @@
 # `@henryqw/pi-subagent`
 
-Main is the parent Pi session. It can delegate bounded single, parallel, and chained tasks, plus package-owned Git Flow work, to isolated Pi child roles.
+Main, the parent Pi session, can delegate bounded single, parallel, and chained tasks to isolated child Roles. It also provides a fixed Git Flow for independent implementation work.
 
 ![Pi showing six delegated tasks running in parallel](./example.png)
 
 ## Why
 
 - **Created for**: Delegate bounded work to isolated child Pi processes without losing Main's context.
-- **Advantage**: Generic bounded delegation and a deterministic package-owned Git Flow use reusable Role launch policies for package authors.
+- **Advantage**: Generic delegation and Git Flow use the same Role settings.
 
 ## Install
 
 ```bash
 pi install npm:@henryqw/pi-task-models
-pi install npm:@henryqw/pi-multi-codex
 pi install npm:@henryqw/pi-subagent
 ```
 
@@ -21,228 +20,131 @@ pi install npm:@henryqw/pi-subagent
 
 | Package | Why |
 | --- | --- |
-| `@henryqw/pi-multi-codex` | Required. Children can use Main's active Codex slot. |
-| `@henryqw/pi-task-models` | Required. Shared `fast` / `balanced` / `frontier` / `fav` routes. |
+| `@henryqw/pi-task-models` | Required. Supplies `fast`, `balanced`, `frontier`, and `fav` model routes. |
 
-Model routing is not configured here. Children resolve routes through shared `@henryqw/pi-task-models` config at `~/.pi/agent/config/pi-task-models/config.json`, which stores only explicit task overrides. The local `pi-subagent/delegateTask` declaration supplies the omitted-class default.
-
-The local config is optional and uses defaults quietly when missing. If shared task-model config is missing, pi-subagent warns once at session start because delegation needs a route.
+Routes come from `~/.pi/agent/config/pi-task-models/config.json`. It stores explicit task overrides. An omitted class uses pi-subagent's `pi-subagent/delegateTask` default, `fast`. Missing shared model config warns once because delegation needs a route.
 
 ## Use
 
-| Surface | Type | Purpose |
-| --- | --- | --- |
-| `delegate_task` | tool | Generic bounded delegation in one single, parallel, or chain mode. |
-| `delegate_flow` | tool | Package-owned parallel implementation and declared-order Git integration for 1–8 independent units. |
-| `delegate_flow_continue` | tool | Repair the blocked Flow unit once in its existing worktree. |
-
-All three delegation tools use Pi's built-in renderer. Its tool-execution block shows live updates and Pi's configured expansion hint; expanding shows the call and result content.
-
-### `delegate_task`
+| Tool | Purpose |
+| --- | --- |
+| `delegate_task` | Run one bounded task, independent tasks in parallel, or dependent tasks in a chain. |
+| `delegate_flow` | Implement and integrate 1–8 independent Git units. |
+| `delegate_flow_continue` | Repair the one blocked Flow unit once. |
 
-Select exactly one shape:
+Pi's built-in tool block shows each call and result. Select exactly one `delegate_task` shape:
 
 ```text
 // Single
 { role, name, task, model?, modelClass?, background? }
 
-// Parallel: 1–8 independent delegations
+// Parallel: 1–8 independent tasks
 { tasks: [{ role, name, task, model?, modelClass? }], background? }
 
-// Chain: 1–8 dependent delegations
+// Chain: 1–8 dependent tasks
 { chain: [{ role, name, task, model?, modelClass? }], background? }
 ```
 
-Main supplies every delegation's required `name`: a short description of about five words and fewer than 30 characters. Names must not contain C0/C1 control characters, including newlines and terminal escape characters.
-
-#### Model routing
+Main supplies each `name`. It must be a short description, about five words and fewer than 30 characters, with no C0/C1 control characters such as newlines or terminal escapes. `role` and an explicit `model` also reject those controls.
 
-1. `modelClass` selects a route. It is `fast`, `balanced`, `frontier`, or `fav`.
-2. An omitted class uses pi-subagent's `pi-subagent/delegateTask` declaration. Its default is `fast`.
-3. The route supplies the model and exact thinking level.
-4. An explicit `model` is `provider/modelId`. It replaces only the route model and must support its thinking level.
+`modelClass` selects `fast`, `balanced`, `frontier`, or `fav`. The route sets the model and exact thinking level. An explicit `model` (`provider/modelId`) replaces only the route model and must support that thinking level. `background` applies to the whole selected mode, never one entry.
 
-`background` applies to the whole selected mode. It is never a per-delegation field.
+Parallel tasks start together, settle together, and report in input order. Chains are sequential and fail at the first failure. `{previous}` passes only the immediately preceding successful assistant output. Foreground failures throw after keeping bounded sibling and recovery evidence.
 
-The transient status widget renders one line per child with: status glyph, bracketed uppercase role initial (`[I]` for `implementer`, `[R]` for `reviewer`, and likewise for custom Roles), Main-supplied short name, activity (thinking… or active tool with elapsed time and path basename), and metrics (completed turns, started tools, compact `model·thinking` pair, tokens, total duration). Rows are ordered active-first (working items first, stable insertion order for the rest). A hard six-physical-line maximum applies: when total items are six or fewer, all child rows render; above six, five child rows plus one status-aware overflow line render (`… N more · X working · Y complete · Z failed · W stopped`). Terminal rows clear on the next real user input; active rows persist until the child settles. It is separate from Pi's built-in tool-execution block.
+One call has one aggregate 50 KiB cap for Main-visible text. Background work belongs to its launching session; shutdown or reload aborts it and may leave only recoverable-work evidence or no follow-up message.
 
-#### Modes, limits, and isolation
+Each entry resolves its own Role, resources, route, and optional isolation. A Role with `isolation: worktree` gets a separate deterministic worktree when available. Non-Git and unborn-`HEAD` contexts can use Main's directory. Other setup failures, including unsafe submodule layouts, reject instead of falling back. Siblings and chain steps never share a created worktree.
 
-- Parallel mode starts entries concurrently, waits for every entry, and reports them in input order.
-- Chain mode is sequential and fail-fast. Each literal `{previous}` receives only the immediately preceding successful assistant output.
-- Foreground failures throw after retaining bounded sibling and recovery evidence.
-- One tool call has one aggregate 50 KiB Main-visible transport cap. It is not 50 KiB per child.
-- Background workflows are session-scoped. Session shutdown or reload aborts them and may deliver only recoverable-work evidence or no follow-up message.
-- Each delegation resolves its own Role, resources, route, and optional worktree request.
-- When available, `isolation: worktree` gives each entry a deterministic separate worktree. Non-Git or unborn-`HEAD` contexts may use Main's cwd.
-- Siblings and chain steps never implicitly share one created worktree.
+See the [orchestration guide](./docs/orchestration.md) for full delegation, transport, isolation, and UI behavior.
 
-See [Orchestration, isolation, and the public API](./docs/orchestration.md) for generic delegation, Flow behavior, and JavaScript composition examples.
+### Flow
 
-### `delegate_flow`
-
-Use Flow only for independent, commuting Git changes. Commuting changes can integrate in any order.
-
-Flow accepts 1–8 uniquely identified units. Each unit has a required Main-supplied short `name`, bounded task, optional `modelClass`, direct command/argument validation gate, and optional non-empty `review` judgment criterion. Names must not contain C0/C1 control characters, including newlines and terminal escape characters.
+Flow requires a clean Main worktree on an attached branch with a committed `HEAD`. Use it only for independent Git changes that can merge in any order. Do not split units that overlap files, APIs, schemas, generated output, package metadata, lockfiles, or invariants.
 
 ```text
 delegate_flow({ units: [{ id, name, task, modelClass?, validation: [{ command, args }], review? }] })
 delegate_flow_continue({ guidance, modelClass? })
 ```
 
-![Delegate Flow lifecycle](./docs/delegate-flow.svg)
-
-Objective verification is authoritative. Flow always inspects committed Git state and runs declared validation.
-
-A unit without `review` skips review evidence and Reviewer launch. It fast-forwards its exact validated tip through the existing guarded `git merge --ff-only` path.
-
-Add `review` only for judgment that automation cannot establish. That unit keeps the exact `{base, tip, patchPath}` protocol and requires exact `PASS` before the same integration path.
+A Flow has 1–8 units with unique non-empty IDs. It is memory-only and allows one active Flow. It freezes the effective Implementer at start and freezes the Reviewer only when a unit requests `review`.
 
-Only one memory-only Flow may be active. At start, it resolves and freezes the effective `implementer` Role, including a same-named user override. It resolves and freezes the effective `reviewer` only when at least one unit requests `review`.
+- Each unit gets one worktree. Implementers run in parallel. Flow handles units in declared order.
+- Flow runs each declared command with its arguments. That validation is authoritative for objective checks.
+- Without `review`, Flow fast-forwards the exact validated tip.
+- With `review`, the Reviewer receives the exact `{base, tip, patchPath}` packet and must return exactly `PASS` before the same integration path. Use `review` only for stated judgment that validation cannot decide.
 
-An omitted `modelClass` uses the local `pi-subagent/delegateTask` declaration, which defaults to `fast`. A selected class resolves through its shared profile model-and-thinking route for the unit's Implementer and, when applicable, Reviewer.
+One `delegate_flow_continue` can repair an Implementer, validation, or review block in the same worktree. Omitting its class keeps the unit's class; supplying one changes that repair only. A second block is terminal. Rebase and infrastructure failures are terminal. Flow has no dependency graph, saved recovery, automatic retry, aggregate review, or post-merge validation.
 
-Flow creates one Unit Worktree per unit before it launches Implementers. It runs Implementers in parallel, then processes settled results in declared order.
-
-After integration, it removes the worktree and branch non-forcibly. A refusal is a completion warning with the retained worktree path and/or branch.
-
-A rebase that drops all unit commits is a no-op. Flow validates it, skips Reviewer and merge, then cleans up ordinarily.
-
-Implementer, validation, or review blocks can be repaired once through `delegate_flow_continue` in the same worktree. An omitted continuation `modelClass` retains the blocked unit's current class. A supplied class replaces it for that one repair.
-
-Rebase and infrastructure failures are terminal. A reported fast-forward failure completes with its diagnostic as a warning only when Git left Main clean at the exact integrated tip.
-
-Otherwise it is terminal and retains the affected worktree. Flow has no graph, saved recovery, automatic retry, aggregate review, or post-merge gate.
-
-`delegate_task` keeps its generic isolation behavior. Flow uses the package-shipped Implementer by default and the package-shipped Reviewer only when a unit requests review; the built-in Scout is not part of Flow. Same-named user Roles remain supported overrides.
-
-### Delegate UI summary
-
-The transient status widget shows status glyph, role, status label, task summary, activity, and metrics for each child. Activity is `thinking…` or the active tool with elapsed time and path basename. Metrics are completed turns, started tools, model, thinking level, tokens, and total duration.
-
-| Aspect | Behavior |
-| --- | --- |
-| Tool-execution block | Pi's built-in renderer: live updates and expandable call/result content |
-| Widget rows | One line per child: glyph, `[role initial]`, short name, activity, metrics |
-| Ordering | Active-first stable (working first, then insertion order) |
-| Line cap | 6 physical lines max (≤6 items: all child rows; >6 items: 5 rows + 1 status-aware overflow) |
-| Terminal retention | Active rows persist; terminal rows clear on next user input |
-
-- Rows are active-first: working items first, then stable insertion order.
-- The hard six-physical-line maximum shows all child rows for six or fewer items.
-- Above six, it shows five child rows and one status-aware overflow line: `… N more · X working · Y complete · Z failed · W stopped`.
-- Terminal rows clear on the next real user input. Active rows persist until the child settles.
-- The final `delegate_task` block is deliberately minimal. It has bounded final summaries and role attribution for parallel and chain work. It shows only retained-worktree recovery paths.
+Flow never force-deletes recoverable work. Failed or uncertain units, and cleanup refusals after integration, retain their worktree path or branch for recovery. See [Flow mechanics and recovery](./docs/orchestration.md#delegate_flow).
 
 ## Config
 
-pi-subagent owns the extension-named config directory `~/.pi/agent/config/pi-subagent/`. It holds two kinds of user-owned configuration.
-
-One Markdown file belongs to each Role (see [Roles](#roles)). The other is its own optional JSON file below.
+pi-subagent owns `~/.pi/agent/config/pi-subagent/config.json`. It is optional. A missing file uses these defaults without a warning.
 
-`~/.pi/agent/config/pi-subagent/config.json` controls the child pool and execution limits. All fields are optional. A missing file uses defaults without a warning.
-
-| Field | Required | Possible values | Default |
-| --- | --- | --- | --- |
-| `maxSubagents` | No | Safe integer ≥ 1 | `5` |
-| `maxTurns` | No | Safe integer ≥ 1 | `50` |
-| `timeout.idleMinutes` | No | Positive number of minutes where minutes × 60 000 ms ≤ 2,147,483,647 | `10` |
-| `timeout.maxMinutes` | No | Positive number within the same ms cap that must be greater than `timeout.idleMinutes`, otherwise the whole `timeout` object falls back to defaults | `30` |
-
-- Excess children wait FIFO without consuming child timeout.
-- A terminal response on turn 50 succeeds.
-- An attempted continuation starts no model work and rejects with `turn_limit`.
-- Before a continuing turn, the child gets one warning when completed turns reach 80%.
-- It gets another warning when elapsed time reaches 80% of the maximum runtime.
-- If both thresholds are first reached together, the child gets one combined warning.
-- `PI_SUBAGENT_MAX_SUBAGENTS` overrides `maxSubagents` for the session. It must be a positive integer. An invalid value prevents the extension from loading and leaves `delegate_task` unavailable.
-
-This JSON is read leniently. Malformed JSON, a non-object root, unknown keys, or invalid values are collected into one warning.
-
-The affected settings fall back to defaults. The file is never rewritten.
-
-### Role frontmatter
+| Field | Valid value | Default |
+| --- | --- | --- |
+| `maxSubagents` | Safe integer ≥ 1 | `5` |
+| `maxTurns` | Safe integer ≥ 1 | `50` |
+| `timeout.idleMinutes` | Positive minutes; minutes × 60,000 ≤ 2,147,483,647 ms | `10` |
+| `timeout.maxMinutes` | Positive minutes greater than `idleMinutes`; minutes × 60,000 ≤ 2,147,483,647 ms | `30` |
 
-Each Role `.md` file in the same directory accepts these frontmatter fields:
+Excess children wait FIFO without using a child timeout. A terminal response on turn 50 succeeds; an attempted continuation rejects with `turn_limit`.
 
-| Field | Required | Possible values | Default |
-| --- | --- | --- | --- |
-| `name` | Yes | Non-empty text; unique across roles | — |
-| `description` | Yes | Non-empty text | — |
-| `tools` | Yes | YAML array of non-empty tool names | `[]` activates no base built-ins; trusted extension tools and caller additions still activate |
-| `isolation` | No | `worktree` | None |
-| `extensions` | Yes | YAML array of absolute paths, `~/…`, `file://`, or package sources (`npm:`, `git:`, `github:`, `https?:`, `ssh:`) | `[]` selects no Role extension bundle |
-| `skills` | Yes | YAML array of non-empty Skill names | `[]` selects no separately named Role Skills; trusted extension Skills still load |
-| body | Yes | System-prompt Markdown after the frontmatter | — |
+Malformed or unreadable JSON, a non-object root, unknown keys, and invalid values produce one warning. Invalid settings use defaults while valid settings still apply. If the effective maximum is not greater than the idle timeout, both timeout settings use defaults. The file is never rewritten.
 
-An unreadable or invalid Role file fails role loading fast. Duplicate role names are rejected.
+`PI_SUBAGENT_MAX_SUBAGENTS` overrides `maxSubagents` for the session. It must be a positive integer. An invalid value prevents the extension from loading, so `delegate_task` is unavailable.
 
 ## Roles
 
-The package ships three working built-in Roles. They are always available without configuration.
+Role Markdown files live beside the config file. They require frontmatter and a Markdown system prompt body.
 
-- `implementer`: focused edits requesting worktree isolation; commits completed scoped changes locally and never pushes or opens PRs without authorization
-- `reviewer`: read-only correctness review of supplied plans or files, or—only when a Flow unit declares `review`—of Flow's exact `{base, tip, patchPath}` packet in its Unit Worktree; never edits or commits
-- `scout`: read-only code and evidence mapping for one bounded task; never changes files
+| Field | Requirement |
+| --- | --- |
+| `name` | Required unique, non-empty text without C0/C1 controls. |
+| `description` | Required non-empty text without C0/C1 controls. |
+| `tools` | Required YAML array of non-empty tool names. `[]` selects no base built-ins. |
+| `isolation` | Optional; only `worktree`. |
+| `extensions` | Required YAML array. Entries are absolute paths, `~/…`, `file://`, or `npm:`, `git:`, `github:`, `https?:`, or `ssh:` sources. |
+| `skills` | Required YAML array of non-empty Skill names. |
+| body | Required Markdown system prompt after the frontmatter. |
+
+An unreadable or invalid Role fails loading fast. Duplicate Role names are rejected. A same-named user file overrides a built-in Role.
 
-A same-named Markdown file in `~/.pi/agent/config/pi-subagent/` explicitly overrides the built-in default. The built-in `scout` is available to generic `delegate_task`; `delegate_flow` remains limited to its fixed Implementer/Reviewer protocol.
+The package always provides these built-in Roles:
 
-The repository also includes one optional inert sample:
+| Role | Purpose | Isolation/use |
+| --- | --- | --- |
+| `implementer` | Make and validate one focused change. | Requests a worktree; commits scoped work locally. Never pushes or opens a PR without permission. |
+| `reviewer` | Review supplied plans or files for correctness. | Read-only. For Flow review, reads the exact packet in the Unit Worktree; never edits or commits. |
+| `scout` | Map code and evidence for one bounded task. | Read-only and generic `delegate_task` only; never changes files. |
 
-- [`synthesizer`](./examples/roles/synthesizer.md): reconcile supplied reports
+Flow uses the effective Implementer and, only when requested, Reviewer. The Scout is not part of Flow.
 
-Copy it manually from your installed `@henryqw/pi-subagent` package if you want a starting point. npm installs ship the `examples/roles/` directory.
+[`synthesizer`](./examples/roles/synthesizer.md) is an optional sample for reconciling supplied reports. It does nothing until you copy it:
 
 ```bash
 mkdir -p ~/.pi/agent/config/pi-subagent
 cp <package-install-dir>/examples/roles/synthesizer.md ~/.pi/agent/config/pi-subagent/
 ```
 
-Locate the install directory with `npm root` inside your project, or through Pi's package installation path.
-
-The package never installs or writes Role configuration. After copying, edit or replace `synthesizer.md` as your own Role.
-
-## Skill
-
-The bundled [`pi-subagent-delegated-development`](./skills/pi-subagent-delegated-development/SKILL.md) Skill is Main-side planner and orchestrator policy only. `delegate_flow` owns its fixed Git mechanics and validation authority.
-
-The Skill adds no runtime code, configuration, or Role installation. Generic orchestration remains outside the executor under [ADR 001](./docs/adr/001-composable-ephemeral-execution.md).
-
-## Role, Skill, and resource trust
-
-### Role resources
-
-A Role explicitly owns base tools, extensions, named Skills, instructions, and optional `isolation: worktree`. Every launch installs its Role tool policy.
+Use `npm root` in a project to find the package install directory. The package never installs or changes this file; after copying, it is yours.
 
-Named Skills resolve through Main's effective Pi Skill registry. Ambient extension and Skill discovery is disabled in children.
+## Role resources and trust
 
-### Trusted extensions are not sandboxing
+A Role selects base tools, extensions, named Skills, instructions, and optional worktree isolation. Named Skills resolve from Main's effective Pi registry; unavailable ones warn and skip.
 
-Selecting an extension explicitly selects a trusted atomic capability bundle, not just a provider path. Every tool it registers and every Skill supplied through its Pi package metadata or dynamic `resources_discover` loads alongside separately named Role Skills.
+Children disable ambient extension and Skill discovery. `tools: []` adds no base tools, but selected extension tools and caller tools still activate. `extensions: []` adds no Role extension bundle. `skills: []` adds no separately named Role Skills, but selected extension Skills still load.
 
-This is intentional. An extension may depend on its tools, Skills, lifecycle, and prompt behavior. Loading it permits that executable behavior and is not sandboxing.
+An explicitly selected extension is trusted, not sandboxed. Its tools, Skills, and executable behavior load together. Select fewer trusted extensions to reduce scope. pi-subagent does not guess or remove undocumented dependencies.
 
-Scope a child by selecting fewer trusted extensions. Finer-grained selection requires separate extension entry points or configuration, or an upstream split. pi-subagent does not infer or externally narrow undocumented dependencies.
+Parent-only delegation tools and `ask_question` are always excluded. Requested Role or caller tool names are checked after provider loading; unavailable tools fail before the first model turn.
 
-### Tool filtering
+## Skill
 
-- `tools: []` activates no base built-ins. Trusted selected extension tools and explicit caller tool additions still activate.
-- `skills: []` selects no separately named Role Skills. Trusted selected extension Skills still load.
-- `extensions: []` selects no Role extension bundle.
-- Parent-only recursive orchestration tools and interactive `ask_question` are excluded from children.
-- Explicit Role or caller tool names are verified against the child’s final filtered active registry after provider extensions finish `session_start`.
-- Unavailable tool names fail before the first model turn with provider-extension guidance. Unavailable named Skills warn and skip.
+The bundled [`pi-subagent-delegated-development`](./skills/pi-subagent-delegated-development/SKILL.md) Skill guides Main's planning and orchestration. It adds no runtime code, config, or Role installation. `delegate_flow` owns its Git mechanics and validation authority.
 
 ## Library API
 
-The package root exports Role loading and launch resolution, `createEphemeralSubagentExecutor`, and worktree helpers.
-
-The executor is for code already running inside active Pi. It does not provide standalone Node.js Pi discovery or launch support.
-
-It defaults to a hard limit of 50 turns. An attempted continuation rejects with `turn_limit` while preserving accumulated usage and bounded output.
-
-After Pi exits, the executor drains inherited stdout and stderr normally. It destroys streams held by escaped descendants after a short inactivity deadline or one-second hard deadline, so they cannot retain a pool permit.
-
-Use [`docs/orchestration.md`](./docs/orchestration.md#public-role-and-executor-api) for exact API behavior.
+The package root exports `loadRoles`, `resolveRoleSkills`, `resolveRoleLaunch`, `createRoleLaunch`, `createEphemeralSubagentExecutor`, and worktree helpers. The executor works only inside the active Pi process; it does not discover or start a standalone Node.js Pi installation.
 
-It includes a post-permit `prepare` example. The example uses `resolveRoleLaunch` with a caller-owned Model Task declaration against the latest Pi context.
+See the [public Role and executor API](./docs/orchestration.md#public-role-and-executor-api) for contracts and a `prepare` example.

package/dist/display-text.d.ts

@@ -0,0 +1,5 @@
+export declare const DISPLAY_TEXT_CONTRACT: {
+    readonly controlRanges: "\\u0000-\\u001F\\u007F-\\u009F";
+    readonly pattern: "^(?![\\s\\S]*[\\u0000-\\u001F\\u007F-\\u009F])[\\s\\S]+$";
+};
+export declare function hasDisplayControlCharacters(value: string): boolean;

package/dist/display-text.js

@@ -0,0 +1,9 @@
+const C0_C1_CONTROL_RANGES = "\\u0000-\\u001F\\u007F-\\u009F";
+export const DISPLAY_TEXT_CONTRACT = {
+    controlRanges: C0_C1_CONTROL_RANGES,
+    pattern: `^(?![\\s\\S]*[${C0_C1_CONTROL_RANGES}])[\\s\\S]+$`,
+};
+const DISPLAY_TEXT_CONTROL_PATTERN = new RegExp(`[${DISPLAY_TEXT_CONTRACT.controlRanges}]`, "u");
+export function hasDisplayControlCharacters(value) {
+    return DISPLAY_TEXT_CONTROL_PATTERN.test(value);
+}

package/dist/ephemeral.js

@@ -2,6 +2,7 @@ import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { basename } from "node:path";
 import { StringDecoder } from "node:string_decoder";
+import { hasDisplayControlCharacters } from "./display-text.js";
 const MAX_OUTPUT_BYTES = 50 * 1024;
 const MAX_JSON_EVENT_BYTES = 1024 * 1024;
 export const DEFAULT_MAX_TURNS = 50;
@@ -249,10 +250,7 @@ function activityTooLong(value) {
     return typeof value === "string" && Buffer.byteLength(value, "utf8") > MAX_ACTIVITY_TEXT_BYTES;
 }
 function hasTerminalControlChars(text) {
-    return Array.from(text).some((character) => {
-        const code = character.codePointAt(0);
-        return code <= 0x1f || code >= 0x7f && code <= 0x9f || code === 0x2028 || code === 0x2029;
-    });
+    return hasDisplayControlCharacters(text) || /[\u2028\u2029]/u.test(text);
 }
 function activityText(value) {
     return typeof value === "string" && value.trim().length > 0 && !activityTooLong(value) && !hasTerminalControlChars(value);

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { type AvailableModel, type ModelTask, type ProfileName, type ResolvedTaskRoute, type ThinkingLevel } from "@henryqw/pi-task-models";
+export { DISPLAY_TEXT_CONTRACT, hasDisplayControlCharacters } from "./display-text.ts";
 export { addUsage, capEphemeralSubagentOutput, createEphemeralSubagentExecutor, DEFAULT_MAX_TURNS, EphemeralSubagentError, EXECUTION_BUDGET_ENV, formatDuration, type EphemeralSubagentActivityEvent, type EphemeralSubagentErrorCode, type EphemeralSubagentExecutor, type EphemeralSubagentExecutorOptions, type EphemeralSubagentResult, type EphemeralSubagentRunInput, type EphemeralSubagentTimeout, } from "./ephemeral.ts";
 export { createChildWorktree, finalizeChildWorktree, inspectIndexFlags, inspectWorktreeDirty, WorktreeSetupError, worktreeContextNote, type WorktreeDirtyInspection, type WorktreeInfo, type WorktreePayload, } from "./worktree.ts";
 export { prepareExactReviewEvidence, REVIEW_MAX_PATCH_BYTES, REVIEW_MAX_PATHS, type PreparedReviewEvidence, type PrepareExactReviewEvidenceInput, } from "./review-evidence.ts";

package/dist/index.js

@@ -3,7 +3,9 @@ import { isAbsolute, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { getAgentDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
 import { extensionConfigDir } from "@henryqw/pi-config-store";
+import { hasDisplayControlCharacters } from "./display-text.js";
 import { loadTaskModelsConfig, modelReference, orderedProfileRoutes, resolveConfiguredTaskRoute, resolveTaskModelRoute, } from "@henryqw/pi-task-models";
+export { DISPLAY_TEXT_CONTRACT, hasDisplayControlCharacters } from "./display-text.js";
 export { addUsage, capEphemeralSubagentOutput, createEphemeralSubagentExecutor, DEFAULT_MAX_TURNS, EphemeralSubagentError, EXECUTION_BUDGET_ENV, formatDuration, } from "./ephemeral.js";
 export { createChildWorktree, finalizeChildWorktree, inspectIndexFlags, inspectWorktreeDirty, WorktreeSetupError, worktreeContextNote, } from "./worktree.js";
 export { prepareExactReviewEvidence, REVIEW_MAX_PATCH_BYTES, REVIEW_MAX_PATHS, } from "./review-evidence.js";
@@ -26,6 +28,12 @@ const cleanText = (value, field, source) => {
     }
     return value.trim();
 };
+const cleanDisplayText = (value, field, source) => {
+    if (typeof value === "string" && hasDisplayControlCharacters(value)) {
+        throw new Error(`${source}: ${field} must not contain C0/C1 control characters.`);
+    }
+    return cleanText(value, field, source);
+};
 const stringList = (value, field, source) => {
     if (value === undefined)
         throw new Error(`${source}: ${field} is required.`);
@@ -62,8 +70,8 @@ function parseRoleFile(file, raw) {
     if (isolation !== undefined && isolation !== "worktree")
         throw new Error(`${file}: isolation must be "worktree".`);
     return {
-        name: cleanText(frontmatter.name, "name", file),
-        description: cleanText(frontmatter.description, "description", file),
+        name: cleanDisplayText(frontmatter.name, "name", file),
+        description: cleanDisplayText(frontmatter.description, "description", file),
         tools: stringList(frontmatter.tools, "tools", file),
         isolation,
         extensions: extensionList(frontmatter.extensions, file),

package/extensions/delegate-flow.ts

@@ -19,7 +19,6 @@ import {
 } from "@henryqw/pi-subagent";
 import { Type, type Static } from "typebox";
 import { Check } from "typebox/value";
-import { runDelegation } from "./delegation.ts";
 import { MODEL_CLASS_GUIDANCE } from "./model-class-policy.ts";
 import { TASK_NAME_CONTRACT, TaskNameSchema, normalizeTaskName } from "./task-name.ts";
 
@@ -356,7 +355,7 @@ export function registerDelegateFlow(pi: ExtensionAPI, runtime: DelegateFlowRunt
 		let started = false;
 		try {
 			assertCurrent(flow);
-			const result = await runDelegation(runtime.executor, {
+			const result = await runtime.executor.run({
 				signal,
 				onTokens: (tokens) => runtime.updateWidgetTokens(widgetId, tokens),
 				onActivity: (event) => runtime.updateWidgetActivity(widgetId, event),

package/extensions/subagent.ts

@@ -34,7 +34,6 @@ import {
 } from "@henryqw/pi-subagent";
 import { DEFAULT_TIMEOUT_CONFIG, readSubagentConfig, type SubagentTimeoutConfig } from "./config.ts";
 import { registerDelegateFlow } from "./delegate-flow.ts";
-import { runDelegation } from "./delegation.ts";
 import { MODEL_CLASS_GUIDANCE } from "./model-class-policy.ts";
 import {
 	formatBackgroundWorkflowResult,
@@ -641,7 +640,7 @@ export default function subagentExtension(
 							: { ...base, status: nextStatus, assistantOutput: nextText });
 					};
 					try {
-						child = await runDelegation(executor, {
+						child = await executor.run({
 							signal: workflowSignal,
 							onUpdate: (output) => {
 								setState("running", output);

package/extensions/task-name.ts

@@ -1,7 +1,7 @@
+import { DISPLAY_TEXT_CONTRACT, hasDisplayControlCharacters } from "@henryqw/pi-subagent";
 import { Type, type Static } from "typebox";
 
 const TASK_NAME_MAX_LENGTH = 29 as const;
-const TASK_NAME_CONTROL_RANGES = "\\u0000-\\u001F\\u007F-\\u009F" as const;
 const TASK_NAME_LIMIT_WORDING = `about five words and fewer than ${TASK_NAME_MAX_LENGTH + 1} characters`;
 const TASK_NAME_WORDING = `short descriptive name of ${TASK_NAME_LIMIT_WORDING}`;
 
@@ -10,8 +10,8 @@ export const TASK_NAME_CONTRACT = {
 	maxLength: TASK_NAME_MAX_LENGTH,
 	description: `Short descriptive task name, ${TASK_NAME_LIMIT_WORDING}; C0/C1 control characters are rejected.`,
 	promptGuidance: `Use a ${TASK_NAME_WORDING} without C0/C1 control characters.`,
-	controlRanges: TASK_NAME_CONTROL_RANGES,
-	pattern: `^(?![\\s\\S]*[${TASK_NAME_CONTROL_RANGES}])[\\s\\S]+$`,
+	controlRanges: DISPLAY_TEXT_CONTRACT.controlRanges,
+	pattern: DISPLAY_TEXT_CONTRACT.pattern,
 } as const;
 
 export const TaskNameSchema = Type.String({
@@ -23,10 +23,8 @@ export const TaskNameSchema = Type.String({
 
 export type TaskName = Static<typeof TaskNameSchema>;
 
-const TASK_NAME_CONTROL_PATTERN = new RegExp(`[${TASK_NAME_CONTRACT.controlRanges}]`, "u");
-
 export function normalizeTaskName(value: TaskName, path: string): TaskName {
-	if (TASK_NAME_CONTROL_PATTERN.test(value)) throw new Error(`${path} must not contain C0/C1 control characters.`);
+	if (hasDisplayControlCharacters(value)) throw new Error(`${path} must not contain C0/C1 control characters.`);
 	const normalized = value.trim();
 	if (!normalized) throw new Error(`${path} must be non-empty text.`);
 	return normalized;

package/extensions/workflow.ts

@@ -1,4 +1,5 @@
 import { StringEnum } from "@earendil-works/pi-ai";
+import { DISPLAY_TEXT_CONTRACT } from "@henryqw/pi-subagent";
 import { PROFILE_NAMES } from "@henryqw/pi-task-models";
 import { Type, type Static } from "typebox";
 import { Check } from "typebox/value";
@@ -6,9 +7,9 @@ import { TaskNameSchema, normalizeTaskName } from "./task-name.ts";
 
 export const MAX_WORKFLOW_ENTRIES = 8;
 
-const RoleSchema = Type.String({ minLength: 1, description: "Configured Subagent role name" });
+const RoleSchema = Type.String({ minLength: 1, pattern: DISPLAY_TEXT_CONTRACT.pattern, description: "Configured Subagent role name" });
 const TaskSchema = Type.String({ minLength: 1, description: "Bounded task packet" });
-const ModelSchema = Type.String({ minLength: 1, description: "Designated model as provider/modelId; replaces the selected route model" });
+const ModelSchema = Type.String({ minLength: 1, pattern: DISPLAY_TEXT_CONTRACT.pattern, description: "Designated model as provider/modelId; replaces the selected route model" });
 const ModelClassSchema = StringEnum(PROFILE_NAMES, { description: "Task model profile" });
 
 export const DelegationSchema = Type.Object({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-subagent",
-  "version": "11.0.1",
+  "version": "11.0.4",
   "description": "Delegate bounded single, parallel, or chained tasks to isolated Pi roles.",
   "keywords": [
     "pi-package",

package/extensions/delegation.ts

@@ -1,9 +0,0 @@
-import type { EphemeralSubagentExecutor, EphemeralSubagentResult, EphemeralSubagentRunInput } from "@henryqw/pi-subagent";
-
-/** Runs one caller-prepared child launch without making lifecycle decisions. */
-export function runDelegation(
-	executor: EphemeralSubagentExecutor,
-	input: EphemeralSubagentRunInput,
-): Promise<EphemeralSubagentResult> {
-	return executor.run(input);
-}