@jwilger/pi-development-system 0.89.0 → 0.90.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jwilger/pi-development-system",
-  "version": "0.89.0",
+  "version": "0.90.0",
   "description": "A pi extension package representing a seasoned approach to software development using a full AI SDLC.",
   "keywords": [
     "pi-package"

package/src/subagents/VENDORED.md

@@ -41,4 +41,4 @@ SOFTWARE.
 6. Empty scope (I5 review): `orch/runtime.ts` `availableScopedModels` treats an empty `/scoped-models` as no restriction (pi's meaning) instead of "matches nothing", because every devsys agent declares `models:` and would otherwise be unspawnable by default. Pinned models are also re-applied on resume (`resolveInitialSettings`), since a restored session may hold only inherited history.
 7. Bundled agents outside `src/subagents`: `agents/researcher.md` (devsys `models:` family list) and `agents/reviewer.md` (devsys `models:` list and packet format; description rewritten; upstream `icon` and `modelSuggestions` removed) differ from upstream; `agents/{advisor,implementer,lens-*}.md` are new. The agent file format itself is unchanged.
 8. Thread cap (I7b.1): `orch/manager.ts` `archiveFinished` replaces the hard "Total thread limit reached" check. At `maxThreads` the oldest finished (completed/failed/stopped) thread without a retained descendant is dropped from the registry to make room; the limit is refused only when every kept thread is live, paused or a parent of one. Upstream kept finished threads forever, so long autonomous runs stalled on their own history. A dropped thread cannot be resumed with `agent_steer` (its session file stays on disk).
-9. Registry writes (OOM fix): `index.ts` `persist` signs the registry with `orch/persist-signature.ts` `registrySignature`, which leaves a starting or running thread's status line and partial output out of the change signature. Upstream wrote the whole registry (every thread, about 12 KB each) on every status change; pi never rewrites session entries, so one session grew to 2.3 GB (5,909 snapshots) and pi died loading it. Writes now happen when a thread is added or removed, starts, settles, pauses or is stopped.
+9. Registry writes (OOM fix): `index.ts` `persist` signs the registry with `orch/persist-signature.ts` `registrySignature`, which leaves a starting or running thread's status line and partial output out of the change signature. Upstream wrote the whole registry (every thread, about 12 KB each) on every status change; pi never rewrites session entries, so one session grew to 2.3 GB (5,909 snapshots) and pi died loading it. Writes now happen when a thread is added or removed, starts, settles, pauses or is stopped. A second session still reached 2.0 GB (5,552 snapshots) because a live thread's `sessionLeafId`, `inputTokens`, `outputTokens` and `elapsedMs` change every turn too, so the signature now keeps only a live thread's identity, task and state; `orch/manager.ts` `saved()` omits `sessionLeafId` for a live thread (it would be stale by the time a reload restored it) so a resumed thread opens its session file at the latest leaf.

package/src/subagents/orch/manager.ts

@@ -162,7 +162,10 @@ export class ThreadManager {
         inputTokens: record.view.inputTokens ?? 0,
         outputTokens: record.view.outputTokens ?? 0,
       };
-      const sessionLeafId = this.sessionLeafId(record);
+      // A live thread is not written per turn (see orch/persist-signature.ts), so its saved
+      // leaf would be stale by the time a reload restores it; without one, resuming opens
+      // the session file at its latest leaf, which is the right place.
+      const sessionLeafId = active(view) ? undefined : this.sessionLeafId(record);
       if (sessionLeafId !== undefined) view.sessionLeafId = sessionLeafId;
       if (active(view)) view.status = view.state === "running" ? "Working" : "Starting";
       return {

package/src/subagents/orch/persist-signature.ts

@@ -6,19 +6,31 @@ const LIVE = new Set(["starting", "running"]);
  * What decides whether the registry needs writing again.
  *
  * pi appends every `appendEntry` to the session file and never rewrites it, and each
- * registry entry holds every thread (about 12 KB each). A running thread changes its
- * status line on every tool call, so signing the full snapshot wrote hundreds of
- * kilobytes per tool call: one session reached 2.3 GB and pi ran out of memory loading
- * it. A live thread's status and output are not needed to restore it (a reload marks it
- * interrupted), so they stay out of the signature. Starting, settling, pausing and
- * adding or removing a thread still write.
+ * registry entry holds every thread (hundreds of kilobytes once a session has dozens).
+ * A running thread changes on every turn: its status line, partial output, session leaf
+ * id and token totals. Signing those wrote a snapshot per tool call: one session
+ * reached 2.3 GB, a second 2.0 GB after only the status and output were excluded, and
+ * pi ran out of memory loading them. None of it is needed to restore a live thread (a
+ * reload marks it interrupted and resumes its session file at the latest leaf), so the
+ * signature of a live thread is its identity, task and state only. Starting, settling,
+ * pausing and adding or removing a thread still write, and a settled thread's leaf,
+ * output and totals are signed in full.
  */
 export function registrySignature(threads: readonly SavedThread[]): string {
   return JSON.stringify(
-    threads.map((thread) =>
-      LIVE.has(thread.view.state)
-        ? { ...thread, view: { ...thread.view, status: "", output: undefined } }
-        : thread,
-    ),
+    threads.map((thread) => {
+      if (!LIVE.has(thread.view.state)) return thread;
+      const {
+        status,
+        output,
+        error,
+        sessionLeafId,
+        inputTokens,
+        outputTokens,
+        elapsedMs,
+        ...stable
+      } = thread.view;
+      return { ...thread, view: stable };
+    }),
   );
 }