pi-ptc-subagents 7.5.0 → 7.6.0

package/CHANGELOG.md

@@ -0,0 +1,513 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [7.6.0] - 2026-11-02
+
+### Added
+
+- **Persistent subagent status panel** (above the pi TUI editor): the state of dispatched
+  subagents moves out of the model context into the human's line of sight. The panel lists every
+  in-flight subagent (glyph + status color + start time) under the title
+  `Tasks · N running · M succeeded · K failed`, and disappears when nothing is in flight.
+  **Panel text is English by default** — the same language as the pi host UI.
+  Refresh rides the registry's existing transition callback, so the panel changes exactly when a
+  record changes. The guard is `ctx.mode === "tui"` (`hasUI` is also true in RPC mode, so it
+  cannot serve as the guard); a plain string array is enough — the host caps widgets at 10 rows,
+  and pi-tui's `Text` keeps ANSI, so the colors come straight from the theme.
+  Two frozen limits (ADR-0022 §8): the row count is derived from the host cap, and the label
+  truncation stays at the 48 chars of the old ADR-0022 §11.
+  Panel text (written by the model, often copied verbatim from the user) is stripped of ANSI and
+  control characters, then whitespace is collapsed, and only then is it truncated — in the other
+  order escape sequences would be cut in half and a newline would split one task into two lines.
+  The wiring lives in `packages/tui/pi`'s `createTaskPanel`, which subscribes to the registry
+  itself; `entry` only creates and disposes it.
+  The panel survives `/reload` with no leftover and no duplicate: the same widget key overwrites,
+  and the reloaded instance re-subscribes and follows the state.
+
+### Changed
+
+- **`packages/tui` is now the display layer** (ADR-0022): the root entry is still the
+  zero-dependency shared text primitives (`output` / `search` / `task` are unchanged), while the
+  pi picture — the collapsible result rendering plus the panel above — moves behind the `./pi`
+  subpath. `entry` goes back to assembly only, and the repository's single pi-tui **import site**
+  is gone from `entry`'s sources. `entry` keeps declaring `@earendil-works/pi-tui`, though: its
+  built `dist/index.js` still imports it, so the declaration follows the artifact, not just the
+  source (a clean install that cannot resolve it breaks the extension — caught by the
+  pre-release clean-worktree check).
+  The root entry **must not** re-export the pi face: `kimi-mcp`'s build alias points at
+  `src/index.ts`, so a re-export would bundle pi host code into the Kimi artifact. `build:kimi`
+  therefore gained a gate — the artifact throws if `@earendil-works` shows up in it. The
+  published shape is unchanged (still only `pi-coding-agent` and `pi-tui` as external imports)
+  and the Kimi artifact is byte-identical.
+
+### Verification
+
+- Real pi TUI over a real pty (120×40): the panel draws right above the editor, updates as
+  tasks finish (`Tasks · 2 running · 0 succeeded · 0 failed` → `Tasks · 1 running · 1 succeeded
+  · 0 failed`), and vanishes when they are all done. Floor 0.86.0 renders it too (`setWidget`
+  has the same signature on both — no version gate).
+- 16-version real-machine smoke (`scripts/version-smoke.sh`): **16/16, fails=0** — 0.86.0 /
+  0.86.1 / 0.87.0 / 0.87.1 / 0.99.0 / 0.99.1 / 0.99.2 / 1.0.0–1.0.4 / 1.1.0 / 1.2.0 / 1.3.0 plus
+  1.4.0 on PATH.
+- Repository tests: **172 pass, 0 fail** (139 pi / 6 output / 17 Kimi / 10 standalone); the panel
+  probe is 12/12 (9 for the pure renderer, 3 for the wiring).
+
+## [7.5.0] - 2026-11-01
+
+### Added
+
+- **Program-internal task output** (`tools.task_output({ taskId })`): a PTC program can now fetch
+  the prose answer a dispatched child wrote. Measured gap (real pi 1.4.0): a `wait:false`
+  dispatch returns only a handle, and the in-program task records carry metadata only
+  (`delivery,finishedAt,id,outputPath,outputTruncated,ownerBootMs,ownerPid,reportChannel,
+  startedAt,status,task,whySuppressed` — no `text`, no `output`), so the child's answer was
+  unreachable from a program. The new binding uses the same reduction layer as the model-facing
+  `ptc_task_output` (the child's prose, not the raw event stream), never throws (unknown id →
+  `{error}`), and returns `status` so a program can tell "not finished yet" from "finished
+  without an answer". It also finds records that were pushed out of memory into the compressed
+  archive (decision 29).
+
+### Changed
+
+- **The route-index token gate now measures the real install path.** It used a short relative
+  path, which was green at 555 tokens while the real installed index was 625–632 against a 560
+  ceiling — the model saw a `> WARNING: index over token budget` line on every turn. The gate now
+  uses a 100-character path (the longest realistic install), route prose was trimmed of text
+  duplicated at runtime, and an inaccurate tool list in the index was corrected
+  (`tools.read/grep/find/ls/edit/write` → "the same-named tools"; pi 1.4.0's active table has no
+  grep/find/ls). The index now measures 558 at the gate path, 552 for an nvm install, 541 in the
+  repo.
+- **`RouteEntry.fact` removed.** The field was never rendered (dead weight) and it contradicted
+  ADR-0015's own decision that the index carries no fact section; facts live in the detail files
+  now. ADR-0015's gate table was amended accordingly (gate 5 now guards the `how` section).
+- The web-search detail file now says plainly that the `webDsSearch` switch is the user's own
+  configuration — don't flip it, say that search is unavailable. Measured (real pi 1.4.0, four
+  arms): sessions that read "default off" and went hunting for the switch to change it were 4×
+  slower than sessions that simply said it could not be done.
+
+### Fixed
+
+- The program-internal binding accepted only `taskId`, while the model-facing tool spells it
+  `task_id`; a model copying the model-facing spelling got an error naming a parameter it never
+  used. Both spellings are accepted now.
+
+## [7.4.0] - 2026-11-01
+
+### Added
+
+- **PTC as a standalone, host-neutral package** (`packages/ptc`): the engine — run cell, wire
+  protocol, worker pool, compiler, file bindings — now depends on nothing and imports no host.
+  The model-facing surface moved out to `packages/entry`, so `packages/ptc` is the engine alone
+  (zero dependencies, no `peerDependencies`). It ships as a subpath of the existing root package
+  (`pi-ptc-subagents/ptc`) and as a `ptc` binary, so installing it needs no second package and no
+  extra dependency — verified by a real `npm pack` into a clean directory: one package, zero
+  transitive dependencies, both the subpath import and the binary work.
+- **`ptc <program.ts>` CLI**: runs a program file without a model and without pi. The program's
+  tool surface is the file four (`read` / `write` / `grep` / `glob` / `edit`), confined to the
+  work directory. The published `dist/index.js` stays one self-contained 244 KB file — the
+  published shape did not change.
+- **Program tools on pi 0.86 / 0.87** (entry): the nested call channel (`ctx.executeTool`) only
+  exists from 0.99. On the floor versions the extension now builds pi's own tool definitions
+  (its public `create*ToolDefinition` factories) and calls them directly, so the program tool
+  set and parameter shapes are byte-identical to 0.99 — including `edit`'s
+  `{path, edits:[{oldText,newText}]}`. That path is gated on the pi version: on 0.99+ a missing
+  channel is an error, never a silent bypass of pi's tool pipeline (which would hide the call
+  from other extensions' `tool_call` hooks and from usage accounting).
+
+### Changed
+
+- **Package layout**: `packages/ptc/src/{tools,render,bindings,task-binding}.ts` moved to
+  `packages/entry/src/{ptc-tools,ptc-render,ptc-bindings,task-binding}.ts`; the file bindings
+  moved the other way (`packages/kimi-mcp/src/fs-tools.ts` → `packages/ptc/src/fs-bindings.ts`),
+  because they are host-neutral. The engine's zero-host-dependency rule is now a test
+  (`tests/standalone/standalone-engine.test.mjs`).
+- **Kimi bundle**: 785 KB → 592 KB after pi-tui left the engine.
+
+### Fixed
+
+- The floor versions' file-binding fallback was unreachable — all four of them ship the tool
+  factories — and its `edit` shape (`{path, old_string, new_string}`) differed from pi's, so a
+  program written for 0.99+ would break on the floor. It is gone.
+- Two dead exports (`HostToWorkerFrame`, `WorkerToHostFrame`) and a stale
+  `external: [/^@earendil-works\//]` in the engine's rolldown config (the engine has no
+  dependencies any more).
+
+### Verification
+
+- 16-version real-machine smoke (`scripts/version-smoke.sh`): **16/16, fails=0** — 0.86.0 /
+  0.86.1 / 0.87.0 / 0.87.1 / 0.99.0 / 0.99.1 / 0.99.2 / 1.0.0–1.0.4 / 1.1.0 / 1.2.0 / 1.3.0 plus
+  1.4.0 on PATH. The floor versions and 0.99+ return the same `READ=2216`.
+- Repository tests: **144 pass, 0 fail** (111 pi / 6 output / 17 Kimi / 10 standalone).
+
+## [7.3.0] - 2026-11-01
+
+### Added
+
+- **Task-surface recall** (task + entry + dispatch + routes): the parent can find its old
+  tasks again and read what the child actually said. `ptc_task_list` takes `scope`
+  (recent / all — "all" lists the compaction archive too), `limit` (default 50, max 200),
+  `status` and `session`, and answers `{scope, total, tasks[]}` — `total` is the candidate
+  count, so a `total` larger than `tasks.length` means older records exist that were not
+  listed. Every field is capped (task 80 chars, summary 100, label 120) and the response is
+  trimmed entry by entry against a byte budget, so it is always valid JSON (text-level
+  truncation would cut JSON in half and `JSON.parse` would throw). Measured: 520 records
+  were 104,781 tokens in the old shape; the capped shape stays under 48 KB. Reading the
+  whole archive is not the bottleneck either — 3,000 archived records scan in 57 ms (their
+  bulk, 1,137 KB ≈ 291k tokens, is what costs).
+- **The child's prose is the deliverable** (`ptc_task_output`): the response now carries
+  `text` — the child's own answer, computed from the event stream on the fly — while the
+  report is only a summary. With no prose, the raw tail and the layered guidance are
+  returned as before, and the full stream stays reachable through `outputPath`.
+- **Task blood-line** (dispatch + entry): every task record carries the host session id
+  (`TaskRecord.sessionId`, taken from `ctx.sessionManager.getSessionId()` — present since
+  floor 0.86.0, so no version gate), so the parent can filter its own tasks by session.
+- **Re-injection after compaction** (entry + routes): a compaction drops the messages that
+  started the tasks, but the tasks keep running. On `session_compact` the host re-injects the
+  in-flight tasks and the five most recently completed ones as a `<compacted-tasks>` block on
+  the next LLM call. Verified on real pi at both ends — floor 0.86.0 and 1.4.0 both compact
+  successfully and inject the list (28→7 and 13→6 messages). No version gate: the `context`
+  event payload is byte-identical on 0.86.0.
+- **Stall guard** (dispatch): a child that has produced nothing for the threshold and has
+  no tool call in flight is reaped by the host (default 5 minutes — an engine-side constant,
+  not a model-facing knob; `timeoutMs` keeps its wall-clock meaning). `stopReason` records
+  `stalled: no activity for Nms`, so the parent can see that the child was killed rather
+  than finished.
+- **`tools.task_records` in-program binding** (ptc + entry): a program can pull the task
+  records itself (`{scope: "all"}` includes the compaction archive) — the mechanical scan
+  stays on the host, filtering and reduction happen in the program, and only the few
+  records the program returns enter the context. Regular expressions run inside the worker
+  cell, which terminates a runaway one: a pathological `(a+)+$` really hangs Node v24 for
+  over 120 s, but inside a program it is reaped (`canceled: timeout after 1000ms`) while the
+  host keeps running and can start another program afterwards.
+- **`scripts/compact-inject-smoke.mjs`**: real-machine probe for the compaction
+  re-injection. Assertions need no model cooperation — the compaction is triggered by the
+  rpc `compact` command while the agent is idle, and the injection is checked by a second
+  extension reading the request context. Passes on floor 0.86.0 and 1.4.0.
+
+### Changed
+
+- **Task-surface responses are objects, not arrays**: `ptc_task_list` answers
+  `{scope, total, tasks[]}` and `ptc_task_output` answers the record plus the reduced
+  `text`. Nothing in this repository parsed the old array shape, and the version smoke's
+  task-face leg stays green on 1.4.0, 0.86.0 and the current PATH (`task_face=OK`, no
+  `isError`).
+
+### Fixed
+
+- **The child now inherits the parent session's model** (entry): `buildPiArgv` already
+  resolved `input.model ?? input.agentModel ?? context.sessionModel`, but the entry never
+  passed `sessionModel` — children ran pi's default model instead of the parent's. The
+  model is now read at dispatch time through a live getter, so switching models mid
+  session switches the child's model too. Verified on eight pi versions 0.86.0–1.4.0, with
+  a negative control that goes red when the wiring is removed.
+
+## [7.2.0] - 2026-10-31
+
+### Added
+
+- **`timeoutMs` and `projectContext` knobs on task dispatch** (dispatch). `timeoutMs` arms a
+  timer only when given: timeout goes through the normal stop path (SIGTERM → SIGKILL),
+  `stopReason` records the timeout, terminal state `canceled` — no host-side default; whether
+  to use it is the model's call. `projectContext: "none"` loads no AGENTS.md/CLAUDE.md into
+  the child (`--no-context-files`, present since pi 0.86.0, so no version gate; default
+  `auto` unchanged). Engine-level real-machine probe `scripts/knobs-smoke.mjs` (assertions
+  need no model cooperation — timeout reaping, auto/none A/B, report channel, usage fallback)
+  passes on eight pi versions 0.86.0 / 0.87.1 / 0.99.0 / 1.0.0 / 1.1.0 / 1.2.0 / 1.3.0 / 1.4.0.
+- **Delivery check** (dispatch + entry + routes): the engine extracts the child's real tool
+  trajectory from `tool_execution_start/end` into `ChildDelivery` {tool counts, paths
+  touched, tool errors, text chars} — measured from the stream, not model self-report —
+  attaches it to the task record alongside the report, and the task surface renders a
+  one-line check; when the child delivered nothing, the parent is told to re-dispatch or
+  name the gap rather than fill in numbers. Verified against real print-mode streams on pi
+  0.86.0 and 1.4.0 (parser on real events yields e.g. `tools={read:1}`,
+  `paths=["/etc/hosts"]`).
+- **`write` — a fifth fs tool in the Kimi face** (`ptc_run_code`): programs can now create
+  files, closing the "can't create a file in-program" capability gap found in A/B. Shape
+  `{path, content}`, overwrite allowed, parent directory must already exist (clean error, no
+  implicit mkdir), 2MB cap counted in bytes, atomic tmp+rename, same realpath jail.
+- **Kimi-face adoption guidance from A/B benching**: SKILL.md gains a two-column "when to
+  write a program" checklist (≥5 same-shape calls / ≥20-file read-then-reduce / known-anchor
+  batch edits, plus four negative examples); when a fulfilled program made calls, the result
+  footer shows "N in-program tool calls reduced to 1"; tool mentions use the full-name
+  pattern (`mcp__` prefix + `__ptc_run_code` suffix) after the "skill says write a program
+  but the tool isn't in my list" perception break; `ptc_run_code`'s description gains a
+  quantified trigger line; `web_ds_search` loses its "in-program" demotion box.
+
+### Changed
+
+- **Env pass-through fix, with measured child cost**: the default spawn dropped `env`, so
+  `PI_PTC_DEPTH` / `PI_PTC_TASK_ID` never reached the child — children fully assembled as
+  depth 0 (whole route book injected, recursion gate ineffective). After the fix children
+  take the depth>0 early exit: per-child input −43% (ptc 2830→1607, both 3121→1766).
+  Model-side cost multiple corrected to "about 10×" (measured 9–12×; the old 15–22× was
+  from before this fix).
+- **Report contract**: the old contract block said `"summary" is your deliverable`, so
+  children stuffed facts into self-invented JSON blocks that were then dropped (3/12
+  affected; parent recomputed → grader flagged hallucinations). Reworded: the report is the
+  summary, the deliverable goes in the task's own format, and the parent-side briefing now
+  names the child-report JSON block shape. Measured: named shape → 12/12 reports delivered;
+  self-invented formats → 0/4.
+- **Usage fallback**: a child self-reporting all-empty/zero usage no longer masks the
+  host-observed value (the task surface was permanently showing 0).
+- **`projectContext: none` docs corrected by measurement** (2026-10-31): none only removes
+  the injection — children still read AGENTS.md on their own and apply its conventions
+  (none-vs-auto input diff ≈15%, not the "about half" previously claimed; in 6/6 rounds the
+  model chose none unprompted).
+- **Parent-side route book**: new first guidance section — dispatch criteria and cost
+  ("lots of material / disjoint topics / each piece needs reading ⇒ dispatch; one computable
+  job ⇒ don't"); briefing discipline adds "parent writes it wrong → child executes it
+  wrong, consistently".
+
+### Fixed
+
+- `scripts/version-smoke.sh` installed the wrong package: npm's `pi` is
+  IonicaBizau/pi-number (no `pi` bin exists), so every shim install failed — the real
+  package is `@earendil-works/pi-coding-agent`.
+- Kimi-face review round: partial run-ab runs no longer wipe `results.jsonl`; arm-restore
+  validates its backup (missing or identical-to-arm → refuse to run); the batch-read grader
+  verifies per-file line counts; the `write` cap counts `Buffer.byteLength` (1M CJK chars ≈
+  3MB slipped through the character count).
+
+## [7.1.0] - 2026-10-29
+
+### Added
+
+- **Kimi Code plugin face (`ptc-tools`, MCP)** (ADR-0020). One repo now ships two install
+  faces: the pi extension (this npm package, unchanged name) and a Kimi Code plugin that
+  exposes `ptc_run_code` over MCP — the model writes one TypeScript program, batch-calls a
+  fixed fs toolset (read/grep/glob/edit) inside a vm cell, and gets one reduced result back
+  (measured context economy 1:138 on a 100-file fan-out). `workdir` is a real trust boundary
+  (realpath-jailed; symlink escapes rejected). Verified end-to-end in real Kimi Code: skill
+  guidance auto-triggers program writing, both Kimi (K2.8) and MiniMax (M3.1-Flash) models
+  answered 12/12 deterministic cases with zero unnecessary tool calls and full jail
+  compliance. Ships as `release/kimi/` committed at the tag plus `kimi.plugin.json`; update
+  detection verified against the official `MoonshotAI/kimi-code` source (GitHub-source-only,
+  needs a GitHub Release object per version).
+- **`web_ds_search` in the Kimi face** (P2): the DeepSeek-backed search core (search/open/find)
+  is now fully host-neutral and exposed as a second MCP tool; per-process quota with
+  fail-soft missing-key behavior. DeepSeek API key resolves env-first, then reuses the key
+  already configured in Kimi Code's own `config.toml` (commented-out keys are honored as
+  disabled).
+- **Kimi-face quality gates** (`tests/kimi`): mechanical registry gates (tools/list ↔ route
+  registry bidirectional with verbatim description match, description token budget, argument
+  matrix), plus `scripts/kimi-bench.mjs` (21-case diversity/stress probe; floor Node 22.21.0
+  verified 21/21) and `scripts/kimi-model-ab.sh` (model A/B harness).
+
+### Changed
+
+- **Host-neutral output core** (`@pi-ptc/output`): run-result shaping (model-visible text,
+  ADR-0012 layout + ADR-0015 truncation) split out of the ptc package so both faces share it;
+  pi-tui rendering stays pi-side. Test suite split three ways: `tests/pi` / `tests/output` /
+  `tests/kimi` (87 cases total, all green).
+- **Worker `execArgv` is now empty** — worker threads no longer inherit the host's exec
+  flags. Found by real-machine testing: the Kimi Code host passes `--max-semi-space-size=16`,
+  which Node's worker flag validation rejects, killing every program run. Blacklist
+  filtering (pi's eval flags) could never keep up with host-specific flags.
+- **Truncation temp files now self-clean**: first truncation in a process sweeps own-prefix
+  temp files older than 24h (previously only grew forever).
+- SKILL.md documents exact argument/return shapes for the four fs tools (removes the #1
+  model-side friction found in A/B testing); README explains the npm-name vs plugin-name
+  split.
+
+### Fixed
+
+- `grep` with a file path (`ENOTDIR`), unreadable files killing the whole grep, stale build
+  chunks leaking into shipped plugin artifacts, raw `ENOENT` for missing workdir, and
+  commented-out DeepSeek keys being picked up as active.
+
+## [7.0.0] - 2026-10-28
+
+### Changed
+
+- **BREAKING: PTC programs run in a dedicated vm cell** (spec 决策 30, ADR-0019). Each run
+  now executes inside a fresh `vm.createContext`. The host injects only three thin bridges;
+  an **IIFE preamble** builds `tools` / `console` / `args` (frozen) / the four `workflow.*`
+  helpers **inside the cell (context realm)** and then drops the bridges — the IIFE matters:
+  script-level `var` in a vm context lands on the cell's global, and a leaked bridge name
+  (`__bridge`) was empirically reachable and escapable during review (fixed, regression-tested).
+  Prototype-chain escapes of the `x.constructor.constructor("return process")()` class find
+  no host object, and tool results cross the boundary as JSON strings so no host
+  Promise/object is ever exposed. `process`, `fetch`, `require`, dynamic `import()`, and all
+  `node:*` modules are unreachable — previously a program could `await import("node:fs")`
+  and bypass pi's tool pipeline (permissions/approvals) entirely. Programs that used those
+  escape hatches will break; programs that only use `tools.*` and `Date`/`Math` are
+  unaffected. Worker reset is now "drop the cell" — the globalThis baseline sweep, its known
+  prototype-pollution shortcut, and the console patch/restore dance are all gone.
+  Tool-call arguments and results are now pure JSON at the cell boundary: `undefined` values
+  in arguments are dropped, a `BigInt` argument rejects the call (old structured-clone
+  semantics differed; pinned by tests).
+- **Changed: `console.log` of objects prints JSON** (`{"a":1}`) instead of `util.inspect`
+  (`{ a: 1 }`) — deterministic, and a side effect of the cell's no-host-object rule.
+  Measured cost: none measurable (n=50, fresh-spawn medians ~35–37ms, same as before the
+  cell). Accident-surface reduction, **not** a security boundary (trust posture unchanged;
+  Node's `vm` is not a sandbox against determined adversaries — see ADR-0019 for the
+  residual cosmetic leaks). Deliberately not adopted from the reference designs: determinism
+  bans (no replay/journal to serve), process-per-run (warm pool is an asset), QuickJS (WASM
+  dependency with no matching gain). 35 new test cases cover visibility, the escape battery
+  (13 cases, incl. preamble-internal names), cross-realm semantics, isolation, and protocol
+  edges — each proven live by mutation probes (3 mutations, each turning exactly its own
+  cases red).
+
+## [6.2.0] - 2026-10-28
+
+### Added
+
+- **Lean child process argv**: children are now spawned with `--no-extensions --no-skills`
+  (extension discovery noise — user skills, host-side prose, discovered extensions — no longer
+  rides into every child), and `--no-mcp` when the host pi is ≥ 1.1.0 (the flag first appears
+  there; `EngineContext.piVersion` is resolved once at session start). Measured on real
+  children: worst-case per-child input drops 86% (32524 → 4356 tokens).
+- **Cache-aware usage observation**: the JSONL stream parser now carries pi ≥ 1.4.0's
+  `usage.cacheRead` / `usage.cacheWrite` into the observed usage (absent on older pi, floor-safe).
+
+### Changed
+
+- **Tighter child report contract prose**: summary is the deliverable, findings carry
+  load-bearing evidence only, no recapping read content, no report .md files. JSON shape
+  unchanged. Measured output reduction: -57% on recap-prone tasks, -9~23% on mixed tasks.
+- `create-a-task.md` gains briefing discipline (exact paths, state what the final message
+  must carry, merge same-domain work into one serial child).
+- `docs/pi-version-matrix.md`: `--no-mcp` first-appearance (1.1.0) and 1.4.0 usage cache
+  fields recorded.
+
+## [6.1.0] - 2026-10-27
+
+### Added
+
+- **Task traces have a capacity boundary and a compressed archive** (spec decision 29).
+  Terminal records are capped at the newest 500 (`taskTraceKeep`, evicted oldest-first
+  by `(finishedAt, taskId)`; non-terminal records are never evicted). Runtime evictions
+  are archived — record and output gzip-compressed (3.4x measured on real child
+  streams) on an async event-loop chain the main path never waits on; boot-time
+  history is deleted directly. Archived traces stay retrievable by exact id through
+  `ptc_task_output` for 30 days from archival (`archiveTtlDays`; archive files are
+  purged at boot, 500 per pass). All three knobs live in `~/.pi/agent/ptc.json`;
+  `archiveEnabled: false` restores immediate delete.
+- **`outputTruncated` on task records and results.** Child stdout now has a 16MB
+  tail cap (the stderr cap's long-missing twin), so a runaway child can no longer
+  exhaust the host's memory; the record says when the trace is tail-only.
+
+### Fixed
+
+- **The task door no longer advertises a `cwd` parameter nothing consumed** (audit F1).
+  It was pre-planted in the shared parameter table, but neither entry point forwarded
+  it and no engine layer accepted it; the schema now tells the truth.
+- **Search memory keeps pages opened directly** (audit F5). `open` on a URL that
+  never appeared in search results previously had its text silently dropped, so a
+  later `find` on the same page re-fetched and double-spent quota; a fallback bucket
+  (same 400K budget) now holds it.
+- **Value-tree rendering enforces the frozen contract** (audit F7, ADR-0016): at most
+  6 children per level with an explicit `…（余 N 项）` marker, and line width back to
+  the contracted 120 — previously a 100k-element array rendered in full before the
+  downstream truncator threw the work away.
+- **Pooled workers drop their per-run listeners when returned** (audit F8); dozens of
+  programs in one turn no longer pile dead closures on the reused workers.
+- **The task face no longer removes user-pinned tools** (audit F9): visibility sweeps
+  with zero records now retract only tools the session added itself.
+- **Dead code removed** (audit F6): `listAgentNames`, `drainGraceMs`, a duplicated
+  `pi-tui` devDependency; three rich-row renderer bounds formally de-registered via
+  [ADR-0016](docs/adr/0016-render-bounds-cleanup.md) instead of being deleted as junk.
+
+### Changed
+
+- **Value-tree lines narrow from 200 to the contracted 120 characters** — a
+  model-visible shortening of oversized render lines.
+
+## [6.0.3] - 2026-10-26
+
+### Fixed
+
+- **The route index fits its token budget again.** Every route line carried the
+  detail file's absolute path; in an installed package that pushed the index to 695
+  tokens against the 560 ceiling, so every turn's system prompt ended with a
+  `> WARNING: index over token budget` line — and the warning told the model to
+  move the details into the directory they were already in. The directory is now
+  stated once and each line keeps only the file name: 481 tokens.
+- **`/ptc mode` no longer claims it is narrowing.** PTC mode stopped narrowing the
+  tool loadout in 6.0.1, but the command's reply still read `mode=on（收窄中）`.
+  It now reads `on（引导层）`.
+- **A tool result that is an image no longer carries its base64 into the program.**
+  pi's `read` returns `{type:"image", data:<base64>}` for image files, so the whole
+  image ended up in the program's return value as text — while the image itself was
+  already handed to the model as an image block. The bridge now returns the
+  readable note instead.
+- **The binding scope no longer lists tools the session cannot call.** The fallback
+  to "every registered tool" now applies only to the pi versions without a
+  nested-call channel (0.86/0.87). On 0.99+ the session's own active set is used,
+  so a session that narrowed its tools no longer sees bindings that would be
+  rejected on the first call.
+
+### Changed
+
+- The seven route detail files live in one place now
+  (`packages/routes/docs/routes/`); the identical copy at the repository root is
+  gone, and the copy `prepack` drops there is now git-ignored.
+- ADR-0015 records the reversal of its "no absolute path in the index" decision,
+  the token ruler it actually uses, and the cost of the PTC-mode switch.
+
+## [6.0.2] - 2026-10-26
+
+### Fixed
+
+- **Program-internal tool calls work across the whole supported range.** The tool
+  execution context sits in a different argument slot on older pi releases, so the
+  bridge now identifies it by "whoever carries `executeTool`" instead of a fixed position.
+- **Tools return text to programs on every version.** pi 0.99–1.0.3 hand back a
+  content-block array where 1.0.4+ hands back a string; the bridge normalises both into
+  text, so `tools.read` reads the same way everywhere.
+- **The binding scope is read from the session's own tool set.** On pi 0.86 and 0.87
+  `getActiveTools()` lists only an extension's own tools, so the built-in tools are taken
+  from `getAllTools()` there; on 0.99+ the active set is the declared set and is used as is.
+- **A clear message where the platform has no channel at all.** pi 0.86 and 0.87 expose no
+  nested tool execution API; a program's `tools.*` call now says so — "this pi version has
+  no in-program tool channel (needs pi ≥ 0.99)" — instead of failing vaguely.
+
+## [6.0.1] - 2026-10-26
+
+### Fixed
+
+- **Programs can call the session's tools again.** The binding bridge looked for
+  `ctx.executeTool` on the session context. pi 1.4.0 exposes it on the **tool execution
+  context** — `execute(toolCallId, params, signal, onUpdate, ctx)` — with the signature
+  `executeTool(name, args, options)`. Every `tools.*` call inside a program failed with
+  "executeTool 不可用". Measured on a real pi: a program that reads `/etc/hosts` now gets
+  its length back.
+- **Route details ship with the package and resolve.** The seven `docs/routes/*.md` files
+  are in the npm tarball now, and the route index points at their absolute path inside the
+  installed package, so the model's `read` finds them instead of a path relative to the
+  user's project.
+
+### Changed
+
+- **PTC mode no longer narrows the tool loadout.** On pi 1.4.0 a tool is callable from a
+  program only while it is active, so narrowing took `tools.read` away from programs too
+  ("Tool read not found"). A built-in tool's exposure is not an extension's to set, so the
+  two cannot both hold. PTC mode is now a routing lead in the system prompt: the built-in
+  tools stay visible and callable, from the model and from programs.
+
+## [6.0.0] - 2026-10-26
+
+### Changed
+
+- **Clean-room rewrite.** The package is rebuilt as seven packages — `entry`, `ptc`,
+  `dispatch`, `task`, `tui`, `routes`, `search` — and ships as one self-contained
+  artifact. The previous implementation is preserved on `backup/main-legacy-20261026`.
+- **Two surfaces, detected.** `full_ptc` keeps the PTC pair model-facing; `codemode_ptc`
+  registers underneath pi's codemode and exposes the task door to scripts. There is no
+  setting.
+- **Subagent dispatch is a task engine.** Every dispatch gets a record, a slot, and its
+  own `pi` process. Busy means queue, not reject. Reports arrive through
+  `ptc_child_report` first, with the trailing-JSON channel as fallback.
+- **The task face** (`ptc_task_list` / `ptc_task_output` / `ptc_task_stop`) appears only
+  while there is a task to see.
+- **Web search lives in children.** `web_ds_search` registers only inside dispatched
+  children and is off by default.
+
+### Compatibility
+
+- pi `>= 0.86.0`. Real-machine smoke tests cover 0.86.0, 0.87, 0.99, 1.0, 1.1, 1.2,
+  1.3, and 1.4 — including a program that dispatches a real child process.

package/README.md

@@ -81,6 +81,26 @@ URL tracks the latest GitHub Release (pinned URLs get no update checks); run `/r
 activate. A bundled `ptc` skill teaches the model when to write a program instead of
 fanning out tool calls one by one.
 
+**Update badges need a marketplace entry.** Kimi Code only offers "update 7.1.0 → 7.5.0" in
+`/plugins` for plugins the marketplace catalog can match by id — a bare GitHub install is
+installed but never listed, so it never gets a badge. This repo ships the catalog; point
+Kimi Code at it:
+
+```bash
+/plugins marketplace https://raw.githubusercontent.com/a1121611810/pi-ptc-subagents/main/plugin-marketplace.json
+```
+
+or keep it for every session (desktop app included):
+
+```bash
+export KIMI_CODE_PLUGIN_MARKETPLACE_URL=https://raw.githubusercontent.com/a1121611810/pi-ptc-subagents/main/plugin-marketplace.json
+```
+
+The entry deliberately omits `version`: Kimi Code resolves it from the latest GitHub
+Release, so the catalog never goes stale. A custom catalog **replaces** the official one
+rather than adding to it, and updates stay one keystroke (`Enter` in `/plugins`) — Kimi
+Code has no auto-download path.
+
 ## The engine on its own (no model, no pi)
 
 The PTC runtime is a zero-dependency engine inside this package. Install it and run programs

package/dist/index.js

@@ -1,7 +1,7 @@
 import * as piHost from "@earendil-works/pi-coding-agent";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { execSync, spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { mkdir, open, readFile, readdir, rename, writeFile } from "node:fs/promises";
@@ -9,8 +9,8 @@ import { gunzipSync, gzip } from "node:zlib";
 import { promisify } from "node:util";
 import { fileURLToPath } from "node:url";
 import { tmpdir } from "node:os";
-import { Worker } from "node:worker_threads";
 import { Box, Text } from "@earendil-works/pi-tui";
+import { Worker } from "node:worker_threads";
 // ../../node_modules/.pnpm/typebox@1.3.27/node_modules/typebox/build/system/memory/metrics.mjs
 /** TypeBox instantiation metrics */
 const Metrics = {
@@ -4294,6 +4294,118 @@ async function readTaskOutput(source, record) {
 		})
 	};
 }
+// ../tui/src/pi/render.ts
+function renderPtcResult(surface) {
+	return (result, options, _theme, context) => {
+		const args = context.args;
+		const box = new Box();
+		const title = surface === "workflow" ? `workflow · ${args.meta?.name ?? ""}` : args.description ?? "程序";
+		box.addChild(new Text(options.isPartial ? `${title} …` : title));
+		const details = result.details;
+		if (!options.isPartial && details) {
+			const flags = [
+				details.status,
+				details.truncated ? "已截断" : "",
+				details.fullOutputPath ? `全文在 ${details.fullOutputPath}` : ""
+			].filter(Boolean).join(" · ");
+			box.addChild(new Text(flags));
+		}
+		if (options.expanded && !options.isPartial) for (const block of result.content) {
+			if (block.type !== "text") continue;
+			const lines = block.text.split("\n");
+			const kept = lines.slice(0, RENDER_BOUNDS.MAX_LOG_LINES_EXPANDED);
+			for (const line of kept) box.addChild(new Text(line));
+			if (lines.length > kept.length) box.addChild(new Text(`…（共 ${lines.length} 行，省略 ${lines.length - kept.length} 行）`));
+		}
+		return box;
+	};
+}
+// ../tui/src/pi/task-panel.ts
+/** 面板的宿主 widget key——同 key 覆盖 ⇒ /reload 与重复注册都幂等（pi 的 setExtensionWidget 先删旧再设新） */
+const TASK_PANEL_KEY = "ptc-tasks";
+const STATUS_STYLE = {
+	queued: {
+		glyph: "○",
+		color: "muted"
+	},
+	running: {
+		glyph: "●",
+		color: "accent"
+	},
+	stopping: {
+		glyph: "◐",
+		color: "warning"
+	},
+	succeeded: {
+		glyph: "✓",
+		color: "success"
+	},
+	failed: {
+		glyph: "✗",
+		color: "error"
+	},
+	canceled: {
+		glyph: "⊘",
+		color: "muted"
+	},
+	lost: {
+		glyph: "?",
+		color: "dim"
+	}
+};
+const IN_FLIGHT = [
+	"queued",
+	"running",
+	"stopping"
+];
+function clockOf(startedAt) {
+	const d = new Date(startedAt);
+	return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+}
+/**
+* 面板行（纯函数）：本会话进行中的子代理逐条 + 计数标题；没有进行中的任务 ⇒ 空数组（宿主据此卸载面板）。
+* 只出字符串数组——宿主自带 10 行上限，pi-tui 的 Text 保留 ANSI ⇒ 颜色直接由 theme.fg 上。
+*
+* 只看本会话的记录：registry 启动时会把磁盘上的历史会话记录一并恢复（真机实测：标题一度写「succeeded 180」——
+* 那是上一轮会话攒下的）。sessionId 缺失时不筛（老记录没有这个字段）。
+*/
+function renderTaskPanel(records, theme, sessionId) {
+	const mine = sessionId ? records.filter((record) => record.sessionId === sessionId) : records;
+	const inFlight = mine.filter((record) => IN_FLIGHT.includes(record.status));
+	if (inFlight.length === 0) return [];
+	const count = (status) => mine.filter((record) => record.status === status).length;
+	const lines = [theme.fg("accent", `Tasks · ${inFlight.length} running · ${count("succeeded")} succeeded · ${count("failed")} failed`)];
+	const shown = inFlight.slice(0, 6);
+	for (const [index, record] of shown.entries()) {
+		const style = STATUS_STYLE[record.status];
+		const label = truncateLine(sanitizeText(record.label || record.task).replace(/\s+/g, " ").trim(), 48);
+		const last = index === shown.length - 1 && inFlight.length <= 6;
+		lines.push(theme.fg("dim", last ? "└─ " : "├─ ") + theme.fg(style.color, `${style.glyph} ${label}`) + (record.startedAt ? theme.fg("dim", ` · ${clockOf(record.startedAt)}`) : ""));
+	}
+	if (inFlight.length > 6) lines.push(theme.fg("dim", `└─ …${inFlight.length - 6} more`));
+	return lines;
+}
+// ../tui/src/pi/panel-widget.ts
+/**
+* 常驻面板的接线（ADR-0022）：登记 widget、记录一变就重画、退出时卸载。
+* 没有 ui（print/json 模式）⇒ 什么都不做——那两种模式下 pi 的 ctx.ui 是空实现。
+*/
+function createTaskPanel(options) {
+	const { ui, source, sessionId } = options;
+	if (!ui) return { dispose() {} };
+	let disposed = false;
+	const refresh = () => {
+		if (disposed) return;
+		const lines = renderTaskPanel(source.list(), ui.theme, sessionId);
+		ui.setWidget(TASK_PANEL_KEY, lines.length > 0 ? lines : void 0);
+	};
+	source.subscribe(refresh);
+	refresh();
+	return { dispose() {
+		disposed = true;
+		ui.setWidget(TASK_PANEL_KEY, void 0);
+	} };
+}
 // ../search/src/provider.ts
 const SEARCH_COUNT_RANGE = {
 	min: 1,
@@ -4685,6 +4797,184 @@ function createWebDsSearchTool(context) {
 		}
 	};
 }
+// src/upgrade-notice.ts
+const PACKAGE_NAME = "pi-ptc-subagents";
+const BULLET_LIMIT = 5;
+const SUMMARY_MAX = 200;
+/** Keep a Changelog 里只有这三段是"变了什么"；Verification/Compatibility 是测试与兼容矩阵，不是要点 */
+const CHANGE_SECTIONS = [
+	"Added",
+	"Changed",
+	"Fixed"
+];
+/** x.y.z → 可比整数；非 semver → undefined */
+function versionNumber(version) {
+	if (typeof version !== "string" || !/^\d+\.\d+\.\d+$/.test(version)) return void 0;
+	const parts = version.split(".").map(Number);
+	return (parts[0] ?? 0) * 0xe8d4a51000 + (parts[1] ?? 0) * 1e6 + (parts[2] ?? 0);
+}
+/** CHANGELOG.md → 版本段（文件里新版本在前） */
+function parseChangelog(text) {
+	const sections = [];
+	for (const raw of text.split(/^## /m).slice(1)) {
+		const version = /^\[(\d+\.\d+\.\d+)\]/.exec(raw)?.[1];
+		if (!version) continue;
+		const bullets = [];
+		let inChangeSection = false;
+		let current = [];
+		const flush = () => {
+			if (current.length > 0) bullets.push(current.join(" "));
+			current = [];
+		};
+		for (const line of raw.split("\n")) {
+			const heading = /^###\s+(.+)$/.exec(line);
+			if (heading) {
+				flush();
+				inChangeSection = CHANGE_SECTIONS.includes(heading[1]?.trim() ?? "");
+				continue;
+			}
+			if (!inChangeSection) continue;
+			if (line.startsWith("- ")) {
+				flush();
+				current = [line.slice(2).trim()];
+				continue;
+			}
+			if (current.length > 0 && line.trim().length > 0) {
+				current.push(line.trim());
+				continue;
+			}
+			flush();
+		}
+		flush();
+		sections.push({
+			version,
+			bullets
+		});
+	}
+	return sections;
+}
+/** bullet → 一行要点：粗体标题是作者自己的摘要，优先用它；否则取首句。列表项统一不带句点 */
+function summarize(bullet) {
+	const title = /^\*\*(.+?)\*\*/.exec(bullet);
+	if (title) return truncate(stripMarkdown(title[1] ?? "").replace(/\.$/, ""));
+	const sentence = /(?<!\d)\.(?=\s)/.exec(bullet);
+	return truncate(stripMarkdown(sentence ? bullet.slice(0, sentence.index + 1) : bullet).replace(/\.$/, ""));
+}
+/** (previous, current] 区间的要点，新版本在前 */
+function pickBullets(sections, previous, current) {
+	const low = versionNumber(previous);
+	const high = versionNumber(current);
+	if (low === void 0 || high === void 0) return [];
+	const bullets = [];
+	for (const section of sections) {
+		const value = versionNumber(section.version);
+		if (value === void 0 || value <= low || value > high) continue;
+		for (const bullet of section.bullets) bullets.push(summarize(bullet));
+	}
+	return bullets;
+}
+function showUpgradeNotice(ctx, environment) {
+	if (!ctx.hasUI) return;
+	if (typeof ctx.ui?.notify !== "function") return;
+	const env = environment ?? resolveEnvironment();
+	if (!env) return;
+	const current = versionNumber(env.version);
+	if (current === void 0) return;
+	const previous = readSeenVersion(env.statePath);
+	const previousNumber = versionNumber(previous);
+	if (previousNumber === current) return;
+	if (previousNumber !== void 0 && previousNumber > current) return;
+	if (!writeSeenVersion(env.statePath, env.version)) return;
+	const sections = parseChangelog(readText(env.changelogPath));
+	const baseline = previousNumber === void 0 ? newestOlderVersion(sections, env.version) : previous;
+	if (baseline === void 0) return;
+	const bullets = pickBullets(sections, baseline, env.version);
+	ctx.ui.notify(compose(previousNumber === void 0 ? void 0 : previous, env.version, bullets, changelogUrl(env.repository)), "info");
+}
+/** 已安装包：bundle 往上找 package.json，name 对上就是它——发布形态 <pkg>/dist/index.js，开发形态仓库根 */
+function findInstalledPackage(bundleUrl = import.meta.url) {
+	for (const relative of ["..", "../../.."]) try {
+		const dir = fileURLToPath(new URL(`${relative}/`, bundleUrl)).replace(/[\\/]+$/, "");
+		const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+		if (pkg.name !== PACKAGE_NAME || !pkg.version) continue;
+		return {
+			dir,
+			version: pkg.version,
+			repository: typeof pkg.repository === "string" ? pkg.repository : pkg.repository?.url
+		};
+	} catch {}
+}
+function resolveEnvironment() {
+	const pkg = findInstalledPackage();
+	if (!pkg) return void 0;
+	return {
+		version: pkg.version,
+		repository: pkg.repository,
+		changelogPath: join(pkg.dir, "CHANGELOG.md"),
+		statePath: join(getAgentDir(), PACKAGE_NAME, "last-seen-version.json")
+	};
+}
+/** CHANGELOG 里比当前版本小的最新一节——没有历史记录时用它当基线 */
+function newestOlderVersion(sections, current) {
+	const high = versionNumber(current);
+	if (high === void 0) return void 0;
+	let best;
+	for (const section of sections) {
+		const value = versionNumber(section.version);
+		if (value === void 0 || value >= high) continue;
+		if (best === void 0 || value > (versionNumber(best) ?? 0)) best = section.version;
+	}
+	return best;
+}
+function compose(previous, version, bullets, url) {
+	const lines = [`${PACKAGE_NAME} ${version}`];
+	if (previous !== void 0) lines.push(`Updated from ${previous}.`);
+	if (bullets.length > 0) {
+		lines.push("", "What's new:");
+		for (const bullet of bullets.slice(0, BULLET_LIMIT)) lines.push(`- ${bullet}`);
+		if (bullets.length > BULLET_LIMIT) lines.push(`...and ${bullets.length - BULLET_LIMIT} more`);
+	}
+	if (url) lines.push("", `Changelog: ${url}`);
+	return lines.join("\n");
+}
+function changelogUrl(repository) {
+	if (!repository) return void 0;
+	const url = repository.replace(/^git\+/, "").replace(/\.git$/, "");
+	return url.startsWith("https://github.com/") ? `${url}/blob/main/CHANGELOG.md` : void 0;
+}
+function readSeenVersion(statePath) {
+	try {
+		const parsed = JSON.parse(readFileSync(statePath, "utf8"));
+		return typeof parsed.version === "string" ? parsed.version : void 0;
+	} catch {
+		return;
+	}
+}
+function writeSeenVersion(statePath, version) {
+	try {
+		mkdirSync(dirname(statePath), { recursive: true });
+		writeFileSync(statePath, JSON.stringify({ version }));
+		return true;
+	} catch {
+		return false;
+	}
+}
+function readText(path) {
+	try {
+		return readFileSync(path, "utf8");
+	} catch {
+		return "";
+	}
+}
+function stripMarkdown(text) {
+	return text.replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/\*\*/g, "").trim();
+}
+function truncate(text) {
+	if (text.length <= SUMMARY_MAX) return text;
+	const cut = text.slice(0, SUMMARY_MAX);
+	const space = cut.lastIndexOf(" ");
+	return `${cut.slice(0, space > 0 ? space : SUMMARY_MAX).trimEnd()}…`;
+}
 // ../ptc/src/limits.ts
 const DEFAULT_LIMITS = {
 	timeoutMs: 12e4,
@@ -5026,32 +5316,6 @@ function renderToolResult(outcome) {
 		fullOutputPath
 	};
 }
-// src/ptc-render.ts
-function renderPtcResult(surface) {
-	return (result, options, _theme, context) => {
-		const args = context.args;
-		const box = new Box();
-		const title = surface === "workflow" ? `workflow · ${args.meta?.name ?? ""}` : args.description ?? "程序";
-		box.addChild(new Text(options.isPartial ? `${title} …` : title));
-		const details = result.details;
-		if (!options.isPartial && details) {
-			const flags = [
-				details.status,
-				details.truncated ? "已截断" : "",
-				details.fullOutputPath ? `全文在 ${details.fullOutputPath}` : ""
-			].filter(Boolean).join(" · ");
-			box.addChild(new Text(flags));
-		}
-		if (options.expanded && !options.isPartial) for (const block of result.content) {
-			if (block.type !== "text") continue;
-			const lines = block.text.split("\n");
-			const kept = lines.slice(0, RENDER_BOUNDS.MAX_LOG_LINES_EXPANDED);
-			for (const line of kept) box.addChild(new Text(line));
-			if (lines.length > kept.length) box.addChild(new Text(`…（共 ${lines.length} 行，省略 ${lines.length - kept.length} 行）`));
-		}
-		return box;
-	};
-}
 // src/ptc-tools.ts
 const RUN_CODE_PARAMETERS = _Object_({
 	code: String$1({ description: "要执行的 TypeScript 程序体，可用顶层 await 和 return" }),
@@ -5345,6 +5609,9 @@ function piPtcEntry(pi) {
 			registerChildToolsOnly(pi);
 			return;
 		}
+		try {
+			showUpgradeNotice(ctx);
+		} catch {}
 		const surface = pi.getActiveTools().includes("codemode") ? "codemode_ptc" : FALLBACK_SURFACE_MODE;
 		let modeEnabled = readDefaultModeConfig(getAgentDir());
 		let modeActive = false;
@@ -5447,8 +5714,14 @@ function piPtcEntry(pi) {
 				cmdCtx.ui.notify(`/ptc：dispatchEnabled=${dispatchEnabled}，mode=${modeActive ? "on（引导层）" : "off"}，whyEnabled=${whyEnabledOverride ?? whyEnabledPersisted}（在飞任务不受影响）`, "info");
 			}
 		});
+		const taskPanel = createTaskPanel({
+			ui: ctx.mode === "tui" ? ctx.ui : void 0,
+			source: session.registry,
+			sessionId: session.sessionId
+		});
 		pi.on("session_shutdown", () => {
 			sessionEnding = true;
+			taskPanel.dispose();
 			pool.drain();
 			session.shutdown();
 		});
@@ -5784,4 +6057,4 @@ function registerTaskDoor(registerTool, session, surface) {
 		}
 	});
 }
-export { assemblePtcSession, buildEngineContext, createTaskOutputBinding, piPtcEntry as default, withDeliveryNote };
+export { assemblePtcSession, buildEngineContext, createTaskOutputBinding, piPtcEntry as default, findInstalledPackage, parseChangelog, pickBullets, showUpgradeNotice, summarize, versionNumber, withDeliveryNote };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ptc-subagents",
-  "version": "7.5.0",
+  "version": "7.6.0",
   "description": "Programmable tool calling (PTC) and subagent fan-out for pi",
   "keywords": [
     "pi",
@@ -24,6 +24,7 @@
   "files": [
     "dist/**/*.js",
     "docs/routes/**/*.md",
+    "CHANGELOG.md",
     "README.md",
     "LICENSE"
   ],