@fitchmultz/pi-subagents 0.46.1 → 0.46.2

package/src/pi-intercom/broker/snapshot-reader.ts

@@ -1,5 +1,11 @@
 import { isRecord, isUnknownArray, type UnknownRecord } from "../../shared/unknown.ts";
-import { normalizeSessionInfo, type SessionInfo, type SessionSnapshot } from "../types.ts";
+import {
+  normalizeSessionInfo,
+  type SessionInfo,
+  type SessionSnapshot,
+  type TopicSubscription,
+  type TopicUpdate,
+} from "../types.ts";
 
 type Receipt = SessionSnapshot["receipts"][number];
 
@@ -46,9 +52,30 @@ function receipt(value: unknown): Receipt {
   };
 }
 
+interface SessionParts {
+  readonly info: SessionInfo;
+  readonly topics: TopicUpdate[] | undefined;
+  readonly subscriptions: TopicSubscription[] | undefined;
+}
+
+function appendRows<T>(
+  previous: T[] | undefined,
+  rows: readonly T[] | undefined,
+  supplied: boolean,
+): T[] | undefined {
+  if (rows === undefined) {
+    return supplied ? undefined : previous;
+  }
+  const result = previous ?? [];
+  for (const row of rows) {
+    result.push(row);
+  }
+  return result;
+}
+
 /** Multipart frames build a private cache; only a complete validated snapshot escapes. */
 export class SnapshotReader {
-  private readonly sessions = new Map<string, SessionInfo>();
+  private readonly sessions = new Map<string, SessionParts>();
   private readonly receipts: Receipt[] = [];
 
   private addSession(row: unknown): void {
@@ -59,17 +86,20 @@ export class SnapshotReader {
     const subscriptions = optionalArray(row.subscriptions);
     const previous = this.sessions.get(row.id);
     const info = normalizeSessionInfo({
-      ...previous,
+      ...previous?.info,
       ...row,
-      ...(topics !== undefined ? { topics: [...(previous?.topics ?? []), ...topics] } : {}),
-      ...(subscriptions !== undefined
-        ? { subscriptions: [...(previous?.subscriptions ?? []), ...subscriptions] }
-        : {}),
+      ...(topics !== undefined ? { topics } : {}),
+      ...(subscriptions !== undefined ? { subscriptions } : {}),
     });
     if (!info) {
       throw new Error("Invalid session snapshot");
     }
-    this.sessions.set(info.id, info);
+    const { topics: newTopics, subscriptions: newSubscriptions, ...identity } = info;
+    this.sessions.set(info.id, {
+      info: identity,
+      topics: appendRows(previous?.topics, newTopics, "topics" in row),
+      subscriptions: appendRows(previous?.subscriptions, newSubscriptions, "subscriptions" in row),
+    });
   }
 
   append(sessions: readonly unknown[], receipts: unknown): void {
@@ -86,6 +116,14 @@ export class SnapshotReader {
   }
 
   finish(): SessionSnapshot {
-    return { sessions: [...this.sessions.values()], receipts: this.receipts };
+    const sessions: SessionInfo[] = [];
+    for (const { info, topics, subscriptions } of this.sessions.values()) {
+      sessions.push({
+        ...info,
+        ...(topics !== undefined ? { topics } : {}),
+        ...(subscriptions !== undefined ? { subscriptions } : {}),
+      });
+    }
+    return { sessions, receipts: this.receipts };
   }
 }

package/src/pi-intercom/broker/snapshots.ts

@@ -10,7 +10,11 @@ import {
   type TopicSubscription,
   type SendResult,
 } from "../types.ts";
-import { validateIntercomMessageSize } from "./framing.ts";
+import {
+  intercomMessageSizeBytes,
+  MAX_FRAME_SIZE_BYTES,
+  validateIntercomMessageSize,
+} from "./framing.ts";
 
 /** Direct messages and old clients receive identity, not potentially large topic state. */
 export function messageSender(info: SessionInfo): SessionInfo {
@@ -124,72 +128,201 @@ function publicationUpdate(
   return { ...topic, revision };
 }
 
-class TopicSnapshot {
-  private readonly info: SessionInfo;
-  private readonly topics: Map<string, TopicUpdate>;
-  private readonly subscriptions: Map<string, TopicSubscription>;
+class SnapshotRecords<T extends { readonly topic: string }> {
+  private readonly records = new Map<string, { readonly value: T; readonly bytes: number }>();
+  private largest = 0;
+  private initial: readonly T[] | undefined;
+  private present: boolean;
 
-  constructor(info: SessionInfo) {
-    this.info = info;
-    this.topics = new Map((info.topics ?? []).map((topic) => [topic.topic, topic]));
-    this.subscriptions = new Map((info.subscriptions ?? []).map((entry) => [entry.topic, entry]));
+  constructor(values: readonly T[] | undefined) {
+    this.initial = values;
+    this.present = values !== undefined;
+    for (const value of values ?? []) {
+      this.set(value, intercomMessageSizeBytes(value));
+    }
   }
 
-  apply(mutation: TopicMutation): TopicUpdate | undefined {
-    switch (mutation.kind) {
-      case "publication": {
-        const previous = this.topics.get(mutation.topic.topic);
-        const update = publicationUpdate(mutation.topic, previous, mutation.publish);
-        if (mutation.publish || (previous?.revision ?? 0) < update.revision) {
-          this.topics.set(update.topic, update);
-        }
-        if (mutation.publish) {
-          return update;
-        }
+  get(topic: string, first = false): T | undefined {
+    if (first && this.initial !== undefined) {
+      return this.initial.find((record) => record.topic === topic);
+    }
+    return this.records.get(topic)?.value;
+  }
+
+  maximumAfter(topic?: string, bytes = 0): number {
+    const previous = topic === undefined ? undefined : this.records.get(topic);
+    if (previous?.bytes !== this.largest || bytes >= this.largest) {
+      return Math.max(this.largest, bytes);
+    }
+    // ponytail: shrinking the largest record scans cached sizes; index sizes if churn warrants it.
+    let largest = bytes;
+    for (const [key, record] of this.records) {
+      if (key !== topic) {
+        largest = Math.max(largest, record.bytes);
+      }
+    }
+    return largest;
+  }
+
+  set(value: T, bytes: number): void {
+    this.largest = this.maximumAfter(value.topic, bytes);
+    this.records.set(value.topic, { value, bytes });
+  }
+
+  delete(topic: string): void {
+    this.largest = this.maximumAfter(topic);
+    this.records.delete(topic);
+  }
+
+  accept(): void {
+    this.initial = undefined;
+    this.present = true;
+  }
+
+  valuesAfter(topic?: string, value?: T, changed = false): readonly T[] | undefined {
+    if (!changed) {
+      if (this.initial !== undefined) {
+        return this.initial;
+      }
+      if (!this.present) {
         return;
       }
+    }
+    const values: T[] = [];
+    for (const [key, record] of this.records) {
+      const next = key === topic ? value : record.value;
+      if (next !== undefined) {
+        values.push(next);
+      }
+    }
+    if (value !== undefined && !this.records.has(value.topic)) {
+      values.push(value);
+    }
+    return values;
+  }
+}
+
+interface PreparedTopicChange {
+  readonly topic?: TopicUpdate;
+  readonly subscription?: TopicSubscription;
+  readonly unsubscribe?: string;
+  readonly publication?: TopicUpdate;
+  readonly restore: boolean;
+  readonly changed: boolean;
+  readonly bytes: number;
+}
+
+const UNCHANGED: PreparedTopicChange = { restore: false, changed: false, bytes: 0 };
+
+/** Keep committed records indexed; restores validate only new bytes and cached envelope maxima. */
+export class TopicSnapshot {
+  private readonly topics: SnapshotRecords<TopicUpdate>;
+  private readonly subscriptions: SnapshotRecords<TopicSubscription>;
+
+  constructor(info: SessionInfo) {
+    this.topics = new SnapshotRecords(info.topics);
+    this.subscriptions = new SnapshotRecords(info.subscriptions);
+  }
+
+  subscription(topic: string): TopicSubscription | undefined {
+    return this.subscriptions.get(topic, true);
+  }
+
+  prepare(change: unknown, supported: boolean): PreparedTopicChange {
+    if (change === undefined) {
+      return UNCHANGED;
+    }
+    if (!supported || !isRecord(change)) {
+      throw new Error("Topic snapshots unavailable for this client");
+    }
+    const mutation = topicMutation(change);
+    const base = { restore: change.action === "restore", changed: true, bytes: 0 };
+    switch (mutation.kind) {
+      case "publication":
+        return this.preparePublication(mutation, base);
       case "subscription":
-        this.subscriptions.set(mutation.subscription.topic, mutation.subscription);
-        return;
+        return {
+          ...base,
+          subscription: mutation.subscription,
+          bytes: intercomMessageSizeBytes(mutation.subscription),
+        };
       case "unsubscribe":
-        this.subscriptions.delete(mutation.topic);
-        return;
+        return { ...base, unsubscribe: mutation.topic };
+    }
+  }
+
+  private preparePublication(
+    mutation: Extract<TopicMutation, { readonly kind: "publication" }>,
+    base: PreparedTopicChange,
+  ): PreparedTopicChange {
+    const previous = this.topics.get(mutation.topic.topic);
+    const update = publicationUpdate(mutation.topic, previous, mutation.publish);
+    if (!mutation.publish && (previous?.revision ?? 0) >= update.revision) {
+      return base;
     }
+    return {
+      ...base,
+      topic: update,
+      bytes: intercomMessageSizeBytes(update),
+      ...(mutation.publish ? { publication: update } : {}),
+    };
   }
 
-  snapshot(publication?: TopicUpdate): SessionInfo {
+  snapshot(info: SessionInfo, prepared = UNCHANGED): SessionInfo {
+    const topics = this.topics.valuesAfter(prepared.topic?.topic, prepared.topic, prepared.changed);
+    const subscriptions = this.subscriptions.valuesAfter(
+      prepared.subscription?.topic ?? prepared.unsubscribe,
+      prepared.subscription,
+      prepared.changed,
+    );
     return {
-      ...this.info,
-      topics: [...this.topics.values()],
-      subscriptions: [...this.subscriptions.values()],
-      ...(publication ? { lastIntercomActivity: Date.now() } : {}),
+      ...info,
+      ...(topics !== undefined ? { topics } : {}),
+      ...(subscriptions !== undefined ? { subscriptions } : {}),
+      ...(prepared.publication ? { lastIntercomActivity: Date.now() } : {}),
     };
   }
-}
 
-/** Prepare a change without mutating the usable broker snapshot before frame validation. */
-export function prepareTopicChange(
-  info: SessionInfo,
-  change: unknown,
-  supported: boolean,
-): {
-  readonly info: SessionInfo;
-  readonly publication?: TopicUpdate;
-  readonly restore: boolean;
-} {
-  if (change === undefined) {
-    return { info, restore: false };
+  validateRestore(info: SessionInfo, prepared: PreparedTopicChange, requestId: string): void {
+    snapshotFrames(requestId, [{ ...info, topics: [], subscriptions: [] }], true);
+    const topicBytes = this.topics.maximumAfter(
+      prepared.topic?.topic,
+      prepared.topic ? prepared.bytes : 0,
+    );
+    const subscriptionBytes = this.subscriptions.maximumAfter(
+      prepared.subscription?.topic,
+      prepared.subscription ? prepared.bytes : 0,
+    );
+    for (const [field, bytes] of [
+      ["topics", topicBytes],
+      ["subscriptions", subscriptionBytes],
+    ] as const) {
+      const size =
+        intercomMessageSizeBytes({
+          type: "sessions",
+          requestId,
+          sessions: [{ id: info.id, [field]: [] }],
+          more: true,
+        }) + bytes;
+      if (size > MAX_FRAME_SIZE_BYTES) {
+        throw new Error(`Intercom message too large (${size} bytes; max ${MAX_FRAME_SIZE_BYTES})`);
+      }
+    }
   }
-  if (!supported || !isRecord(change)) {
-    throw new Error("Topic snapshots unavailable for this client");
+
+  commit(prepared: PreparedTopicChange): void {
+    if (prepared.changed) {
+      this.topics.accept();
+      this.subscriptions.accept();
+    }
+    if (prepared.topic) {
+      this.topics.set(prepared.topic, prepared.bytes);
+    } else if (prepared.subscription) {
+      this.subscriptions.set(prepared.subscription, prepared.bytes);
+    } else if (prepared.unsubscribe !== undefined) {
+      this.subscriptions.delete(prepared.unsubscribe);
+    }
   }
-  const pending = new TopicSnapshot(info);
-  const publication = pending.apply(topicMutation(change));
-  return {
-    info: pending.snapshot(publication),
-    restore: change.action === "restore",
-    ...(publication ? { publication } : {}),
-  };
 }
 
 export function deliveryAcknowledgement(receipt: SendResult): BrokerMessage {

package/src/pi-intercom/session-targets.ts

@@ -18,7 +18,6 @@ export interface TargetResolution<T extends TargetIdentity> {
   readonly status: "none" | "found" | "ambiguous" | "prefix_too_short";
   readonly target?: T;
   readonly matches: readonly T[];
-  readonly minLength?: number;
 }
 
 export function shortSessionId(sessionId: string): string {
@@ -180,7 +179,6 @@ function shortTargetResolution<T extends TargetIdentity>(
     return {
       status: "prefix_too_short",
       matches: prefixes,
-      minLength: MIN_SESSION_TARGET_PREFIX_LENGTH,
     };
   }
   const byId = new Map<string, T>();

package/src/runs/background/async-run-discovery.ts

@@ -6,12 +6,12 @@ import { runSynchronously } from "../../shared/cooperative.ts";
 import { asyncRunRoots, readAsyncRunRecord } from "./async-resume.ts";
 import type { AsyncRunRecord } from "./async-run-record.ts";
 import type { AsyncRunSummary } from "./async-run-summary.ts";
-import { getRunMetadataDir, readRunJson } from "../shared/supervisor-questions.ts";
+import { readQuestionOwner } from "../shared/supervisor-questions.ts";
 import { findNestedRouteForRootId } from "../shared/nested-events.ts";
 import { reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-reconciler.ts";
 import { validateStatusForSummary } from "./async-status-validation.ts";
 import { asyncStatusToSummary } from "./async-status-projection.ts";
-import { errorCode, errorMessage, hasText, isRecord } from "./async-value.ts";
+import { errorCode, errorMessage, hasText } from "./async-value.ts";
 
 interface AsyncRunListOptions {
   readonly states?: readonly AsyncRunSummary["state"][];
@@ -112,14 +112,8 @@ class AsyncRunDiscovery {
     let owner = this.owners.get(entry);
     if (!hasText(owner) && hasText(this.ownerSessionId)) {
       try {
-        const saved: unknown = readRunJson(
-          path.join(getRunMetadataDir(entry), "question-owner.json"),
-        );
-        if (
-          isRecord(saved) &&
-          typeof saved.sessionId === "string" &&
-          saved.sessionId.trim().length > 0
-        ) {
+        const saved = readQuestionOwner(entry);
+        if (saved?.sessionId !== undefined && saved.sessionId.trim().length > 0) {
           owner = saved.sessionId;
           this.owners.set(entry, owner);
         }

package/src/runs/background/completion-dedupe.ts

@@ -2,29 +2,8 @@ import { createHash } from "node:crypto";
 import { isRecord, hasText } from "./async-value.ts";
 
 interface CompletionDataLike {
-  completionId?: unknown;
-  id?: unknown;
-  agent?: unknown;
-  timestamp?: unknown;
-  sessionId?: unknown;
-  taskIndex?: unknown;
-  totalTasks?: unknown;
-  success?: unknown;
-}
-
-function asNonEmptyString(value: unknown): string | undefined {
-  if (typeof value !== "string") {
-    return undefined;
-  }
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function asFiniteNumber(value: unknown): number | undefined {
-  if (typeof value !== "number") {
-    return undefined;
-  }
-  return Number.isFinite(value) ? value : undefined;
+  completionId?: string;
+  id: string;
 }
 
 function stableStringify(value: unknown): string {
@@ -48,32 +27,11 @@ function payloadDigest(value: unknown): string {
   return createHash("sha256").update(stableStringify(value)).digest("hex").slice(0, 16);
 }
 
-export function buildCompletionKey(data: Readonly<CompletionDataLike>, fallback: string): string {
-  const completionId = asNonEmptyString(data.completionId);
-  if (hasText(completionId)) {
-    return `completion:${completionId}`;
-  }
-  const id = asNonEmptyString(data.id);
-  if (hasText(id)) {
-    return `id:${id}:${payloadDigest(data)}`;
+export function buildCompletionKey(data: Readonly<CompletionDataLike>): string {
+  if (hasText(data.completionId)) {
+    return `completion:${data.completionId.trim()}`;
   }
-  const sessionId = asNonEmptyString(data.sessionId) ?? "no-session";
-  const agent = asNonEmptyString(data.agent) ?? "unknown";
-  const timestamp = asFiniteNumber(data.timestamp);
-  const taskIndex = asFiniteNumber(data.taskIndex);
-  const totalTasks = asFiniteNumber(data.totalTasks);
-  const success = data.success === true ? "1" : "?";
-  const successIdentity = data.success === false ? "0" : success;
-  return [
-    "meta",
-    sessionId,
-    agent,
-    timestamp !== undefined ? String(timestamp) : "no-ts",
-    taskIndex !== undefined ? String(taskIndex) : "-",
-    totalTasks !== undefined ? String(totalTasks) : "-",
-    successIdentity,
-    fallback,
-  ].join(":");
+  return `id:${data.id.trim()}:${payloadDigest(data)}`;
 }
 
 /** Mutable identity store owned by the completion-admission lifecycle. */
@@ -105,24 +63,3 @@ export function markSeenWithTtl(
   seen.set(key, now);
   return false;
 }
-
-function isSeenMap(value: unknown): value is Map<string, number> {
-  if (!(value instanceof Map)) {
-    return false;
-  }
-  const entries: Map<unknown, unknown> = value;
-  return [...entries].every(
-    ([key, timestamp]) => typeof key === "string" && typeof timestamp === "number",
-  );
-}
-
-export function getGlobalSeenMap(storeKey: string): Map<string, number> {
-  const globalStore = globalThis as Record<string, unknown>;
-  const existing = globalStore[storeKey];
-  if (isSeenMap(existing)) {
-    return existing;
-  }
-  const map = new Map<string, number>();
-  globalStore[storeKey] = map;
-  return map;
-}

package/src/runs/background/notify.ts

@@ -1,6 +1,5 @@
 /** Subagent completion notifications. */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { buildCompletionKey, getGlobalSeenMap, markSeenWithTtl } from "./completion-dedupe.ts";
 import { SUBAGENT_ASYNC_COMPLETE_EVENT } from "../../shared/types.ts";
 import { hasText, isRecord } from "./async-value.ts";
 import type { ReadonlyInput } from "../../shared/types/inputs.ts";
@@ -144,7 +143,7 @@ function isUnsubscribe(value: unknown): value is () => void {
 
 export default function registerSubagentNotify(
   pi: ReadonlyInput<ExtensionAPI>,
-  onQueued?: (completionKey: string, runId?: string) => void,
+  onQueued: (completionKey: string, runId?: string) => void,
 ): () => void {
   const unsubscribeStoreKey = "__pi_subagents_notify_unsubscribe__";
   const globalStore = globalThis as Record<string, unknown>;
@@ -156,7 +155,6 @@ export default function registerSubagentNotify(
       // Best effort cleanup for stale handlers from an older reload.
     }
   }
-  const seen = getGlobalSeenMap("__pi_subagents_notify_seen__");
   const handleComplete = (data: unknown): void => {
     if (
       !isResult(data) ||
@@ -165,17 +163,9 @@ export default function registerSubagentNotify(
     ) {
       return;
     }
-    const key = buildCompletionKey(data, "notify");
-    // Owned completion keys are governed by the shared queue/journal lifecycle, not a TTL.
-    if (
-      (onQueued === undefined || !hasText(data.completionKey)) &&
-      markSeenWithTtl(seen, key, Date.now(), 10 * 60 * 1000)
-    ) {
-      return;
-    }
     pi.sendMessage(buildNotification(data), { triggerTurn: true });
     if (hasText(data.completionKey)) {
-      onQueued?.(data.completionKey, data.runId);
+      onQueued(data.completionKey, data.runId);
     }
   };
   const unsubscribe = pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, handleComplete);

package/src/runs/background/result-watcher.ts

@@ -292,7 +292,7 @@ class ResultWatcher {
       if (this.foreign(envelope)) {
         return;
       }
-      const key = buildCompletionKey({ ...envelope.data, id: envelope.runId }, "result");
+      const key = buildCompletionKey({ ...envelope.data, id: envelope.runId });
       if (this.alreadyHandled(envelope, key)) {
         return;
       }

package/src/runs/background/runner-child-observer.ts

@@ -59,6 +59,7 @@ export class RunnerChildObserver {
     this.id = config.id;
     this.hooks = hooks;
     this.mutatingFailureStates = statusPayload.steps.map(() => createMutatingFailureState());
+    this.syncTopLevelCurrentTool();
   }
 
   expandChildren(flatIndex: number, count: number): void {
@@ -69,16 +70,21 @@ export class RunnerChildObserver {
     );
   }
 
-  private syncTopLevelCurrentTool(): void {
-    const active = this.statusPayload.steps
-      .filter(
-        (step) =>
-          step.status === "running" &&
-          typeof step.currentTool === "string" &&
-          step.currentTool.length > 0,
-      )
-      .sort((left, right) => (right.currentToolStartedAt ?? 0) - (left.currentToolStartedAt ?? 0))
-      .at(0);
+  syncTopLevelCurrentTool(): void {
+    const active =
+      this.statusPayload.state === "running" || this.statusPayload.state === "queued"
+        ? this.statusPayload.steps
+            .filter(
+              (step) =>
+                step.status === "running" &&
+                typeof step.currentTool === "string" &&
+                step.currentTool.length > 0,
+            )
+            .sort(
+              (left, right) => (right.currentToolStartedAt ?? 0) - (left.currentToolStartedAt ?? 0),
+            )
+            .at(0)
+        : undefined;
     this.statusPayload.currentTool = active?.currentTool;
     this.statusPayload.currentToolStartedAt = active?.currentToolStartedAt;
     this.statusPayload.currentPath = active?.currentPath;
@@ -106,7 +112,9 @@ export class RunnerChildObserver {
     }
     step.streamingText = updateStreamingText(step.streamingText, event);
     this.recordChildActivity(flatIndex, event, toolSnapshot, now);
-    this.syncTopLevelCurrentTool();
+    if (event.type === "tool_execution_start" || event.type === "tool_execution_end") {
+      this.syncTopLevelCurrentTool();
+    }
     step.lastActivityAt = now;
     this.statusPayload.lastActivityAt = now;
     this.statusPayload.lastUpdate = now;

package/src/runs/background/runner-monitor.ts

@@ -166,6 +166,8 @@ export class RunnerMonitor {
       clearTimeout(this.statusWriteTimer);
       this.statusWriteTimer = undefined;
     }
+    // Step completion, interruption and expansion can change activity without a tool-end event.
+    this.childObserver.syncTopLevelCurrentTool();
     this.refreshWorkflowGraph();
     writeAtomicJson(this.statusPath, this.statusPayload);
     if (this.config.runtimeVersion !== 2) {

package/src/runs/background/runner-parallel.ts

@@ -2,7 +2,6 @@ import * as path from "node:path";
 import { inspect } from "node:util";
 import type { ReadonlyDeep } from "type-fest";
 import { appendJsonl } from "../../shared/artifacts.ts";
-import { writeAtomicJson } from "../../shared/atomic-json.ts";
 import { writeInitialProgressFile } from "../../shared/settings.ts";
 import { completeWorkflowStep, runParallelTasks } from "../shared/workflow-policy.ts";
 import {
@@ -194,7 +193,7 @@ export class RunnerParallelGroup {
     status.currentStep = position.flatIndex;
     status.lastUpdate = failedAt;
     status.outputFile = path.join(this.config.asyncDir, `output-${position.flatIndex}.log`);
-    writeAtomicJson(path.join(this.config.asyncDir, "status.json"), status);
+    this.monitor.writeStatusPayload();
     this.append({
       type: "subagent.parallel.completed",
       ts: failedAt,
@@ -224,7 +223,7 @@ export class RunnerParallelGroup {
     status.lastActivityAt = startedAt;
     status.lastUpdate = startedAt;
     status.outputFile = path.join(this.config.asyncDir, `output-${position.flatIndex}.log`);
-    writeAtomicJson(path.join(this.config.asyncDir, "status.json"), status);
+    this.monitor.writeStatusPayload();
     this.append({
       type: "subagent.parallel.started",
       ts: startedAt,

package/src/runs/shared/child-observation-spool.ts

@@ -51,8 +51,11 @@ export class ChildObservationSpool {
     fs.writeFileSync(this.stderr, text);
   }
   resetText(): void {
-    this.textOffset = 0;
+    if (this.textOffset === 0) {
+      return;
+    }
     fs.ftruncateSync(this.text, 0);
+    this.textOffset = 0;
   }
   appendText(text: string): void {
     const bytes = Buffer.from(text);
@@ -72,14 +75,16 @@ export class ChildObservationSpool {
     this.textOffset += bytes.length;
   }
   replayText(consume: (text: string) => void): void {
-    this.decode(this.text, 0, this.textOffset, consume);
+    if (this.textOffset > 0) {
+      this.decode(this.text, 0, this.textOffset, consume);
+    }
   }
   replayWire(start: number, end: number, consume: (text: string) => void): void {
     this.decode(this.wire, start, end, consume);
   }
 
   private copy(fd: number, start: number, end: number, consume: (bytes: Buffer) => void): void {
-    const buffer = Buffer.allocUnsafe(64 * 1024);
+    const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, end - start));
     for (let position = start; position < end;) {
       const count = fs.readSync(fd, buffer, 0, Math.min(buffer.length, end - position), position);
       if (count === 0) {