pi-ptc-subagents 0.1.2 → 0.1.3

package/CHANGELOG.md

@@ -5,6 +5,34 @@ 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).
 
+## [0.1.3] - 2026-09-23
+
+### Added
+
+- **PTC rows show what the program is doing while it runs.** Two partial-state
+  visuals on the `ptc_run_code` / `ptc_workflow` row, both absent until now:
+  - a **shimmer** on the call row — same text, one character at a time bright,
+    the highlight sweeping at 150ms — so a running row is distinguishable from a
+    settled one in a column (ADR-0020);
+  - a **sub-call tree** under it: one row per binding call the program made,
+    live from the moment the call is made, with its own five-state status
+    (`running` / `ok` / `error` / `cancelled` / `rejected`) and duration,
+    visible without expanding the row and capped at 32 with a `+N more` tail
+    (ADR-0021). A failed run shows the failure text but no sub-call tree: the
+    tool throws (pi's convention), and pi builds that error result with an empty
+    `details`, so the tracked calls are dropped with it.
+
+### Changed
+
+- **Build pipeline: minify + source-map exclusion.** `pnpm run build`
+  (`vp pack`) now produces minified `dist/*.js` (rolldown's built-in oxc
+  minifier; no new dependency). The npm tarball excludes `dist/**/*.map`
+  via the `package.json#files` whitelist — sourcemaps stay on disk for
+  local stack traces, but no longer ship. Tarball shrinks from 168.7 kB
+  packed / 548.6 kB unpacked (v0.1.2 baseline) to 40.5 kB / 113.6 kB
+  (−76% / −79%); `dist/*.js` total shrinks from 161,303 B to 53,959 B
+  (−66.5%). All 39 public exports retain their original names. ADR-0019.
+
 ## [0.1.2] - 2026-09-23
 
 ### Fixed

package/dist/index.d.ts

@@ -344,6 +344,27 @@ interface PtcErrorShape {
   message: string;
   stack?: string;
 }
+/**
+ * One binding call the program made, as the dispatcher recorded it.
+ *
+ * Host-side only: this shape never crosses the wire — the existing `call` /
+ * `call-result` frames already carry every fact, and the host reconstructs the
+ * record at the seam where the facts are known (`SubCallTracker`,
+ * `src/runtime/sub-call-tracker.ts`). A snapshot reaches the renderer
+ * via `PtcToolDetails.subCalls`.
+ */
+type SubCallStatus = "running" | "ok" | "error" | "cancelled" | "rejected";
+interface SubCallRecord {
+  callId: number;
+  name: string;
+  args: unknown;
+  status: SubCallStatus;
+  startMs: number;
+  endMs?: number;
+  durationMs?: number;
+  resultSummary?: string;
+  errorMessage?: string;
+}
 //#endregion
 //#region src/tools/text.d.ts
 /** Hard cap for one rendered line; longer lines are truncated with `…`. */
@@ -529,6 +550,18 @@ interface RunPtcProgramOptions {
    * `kind: workerExit`.
    */
   pool?: WorkerPool;
+  /**
+   * Called every time a sub-call starts or ends, so the caller can push a live partial result
+   * and have the tree visible while the run is in flight (ADR-0021 §4). Never called after the
+   * run settles — `finish` owns the terminal snapshot. Absent means "no live updates wanted"
+   * (direct library use, tests that only assert the terminal outcome).
+   *
+   * The argument is a **thunk**, not the snapshot itself: a wide `Promise.all` produces an
+   * event per call, and `snapshot()` copies every record. Building it eagerly would make N
+   * sequential calls cost O(N²) copies for pushes that the caller's throttle mostly drops.
+   * Call it only when a push is actually due.
+   */
+  onSubCallChange?: (snapshot: () => readonly SubCallRecord[]) => void;
 }
 /**
  * One image hoisted out of a successful binding result (DSH parity — see ADR-0014,
@@ -568,6 +601,15 @@ interface PtcRunOutcome {
   images?: PtcImage[];
   /** Failure details; absent on success. */
   error?: PtcErrorShape;
+  /**
+   * One record per binding call the program made (ADR-0021).
+   *
+   * Present only when the dispatcher tracked sub-calls for the surface in question (always,
+   * post-ADR-0021 — the dispatcher wires `SubCallTracker` for every run). Order is host-side
+   * dispatch order; the renderer reads it as a point-in-time snapshot. Absent for runs that settled
+   * before the tracker was constructed (the pre-`Promise` abort and pool-acquire-failed paths).
+   */
+  subCalls?: readonly SubCallRecord[];
 }
 /**
  * Run one PTC program in a fresh worker and resolve with its outcome.