@fitchmultz/pi-subagents 0.46.1 → 0.46.2

package/dist/pi-intercom/broker/framing.js

@@ -14,37 +14,87 @@ export function validateIntercomMessageSize(msg) {
  * Format: 4-byte big-endian length + JSON payload
  */
 export function writeMessage(socket, msg) {
-    const tooLarge = validateIntercomMessageSize(msg);
-    if (tooLarge) {
-        throw tooLarge;
-    }
     const json = JSON.stringify(msg);
+    const size = Buffer.byteLength(json, "utf-8");
+    if (size > MAX_FRAME_SIZE_BYTES) {
+        throw new Error(`Intercom message too large (${size} bytes; max ${MAX_FRAME_SIZE_BYTES})`);
+    }
     const payload = Buffer.from(json, "utf-8");
     const header = Buffer.alloc(4);
     header.writeUInt32BE(payload.length, 0);
     socket.write(Buffer.concat([header, payload]));
 }
+/** Retain fragments until a header or payload is complete; copy each fragmented value once. */
+class MessageBuffer {
+    chunks = [];
+    index = 0;
+    length = 0;
+    append(data) {
+        if (data.length > 0) {
+            this.chunks.push(data);
+            this.length += data.length;
+        }
+    }
+    clear() {
+        this.chunks = [];
+        this.index = 0;
+        this.length = 0;
+    }
+    read(size) {
+        const first = this.chunks[this.index];
+        if (size === 0) {
+            return Buffer.alloc(0);
+        }
+        const result = first.length >= size ? first.subarray(0, size) : Buffer.allocUnsafe(size);
+        let written = 0;
+        while (written < size) {
+            const chunk = this.chunks[this.index];
+            const count = Math.min(chunk.length, size - written);
+            if (first.length < size) {
+                chunk.copy(result, written, 0, count);
+            }
+            written += count;
+            this.length -= count;
+            if (count === chunk.length) {
+                this.index++;
+            }
+            else {
+                this.chunks[this.index] = chunk.subarray(count);
+            }
+        }
+        if (this.index === this.chunks.length) {
+            this.clear();
+        }
+        else if (this.index * 2 >= this.chunks.length) {
+            this.chunks = this.chunks.slice(this.index);
+            this.index = 0;
+        }
+        return result;
+    }
+}
 /**
  * Create a message reader that handles partial reads.
  * Calls onMessage for each complete message received.
  * Protocol or handler errors are reported to onError so the caller can close the socket.
  */
 export function createMessageReader(onMessage, onError) {
-    let buffer = Buffer.alloc(0);
+    const buffer = new MessageBuffer();
+    let length;
     return (data) => {
-        buffer = Buffer.concat([buffer, data]);
-        while (buffer.length >= 4) {
-            const length = buffer.readUInt32BE(0);
-            if (length > MAX_FRAME_SIZE_BYTES) {
-                onError(new Error(`Intercom frame too large (${length} bytes; max ${MAX_FRAME_SIZE_BYTES})`));
-                buffer = Buffer.alloc(0);
-                return;
-            }
-            if (buffer.length < 4 + length) {
-                break;
+        buffer.append(data);
+        while (buffer.length >= (length ?? 4)) {
+            if (length === undefined) {
+                length = buffer.read(4).readUInt32BE(0);
+                if (length > MAX_FRAME_SIZE_BYTES) {
+                    onError(new Error(`Intercom frame too large (${length} bytes; max ${MAX_FRAME_SIZE_BYTES})`));
+                    buffer.clear();
+                    length = undefined;
+                    return;
+                }
+                continue;
             }
-            const payload = buffer.subarray(4, 4 + length);
-            buffer = buffer.subarray(4 + length);
+            const payload = buffer.read(length);
+            length = undefined;
             let msg;
             try {
                 msg = JSON.parse(payload.toString("utf-8"));

package/dist/pi-intercom/broker/snapshot-reader.js

@@ -1,5 +1,5 @@
 import { isRecord, isUnknownArray } from "../../shared/unknown.js";
-import { normalizeSessionInfo } from "../types.js";
+import { normalizeSessionInfo, } from "../types.js";
 function optionalReceiptFields(value) {
     if ((value.queued !== undefined && typeof value.queued !== "boolean") ||
         (value.reason !== undefined && typeof value.reason !== "string")) {
@@ -36,6 +36,16 @@ function receipt(value) {
         ...optional,
     };
 }
+function appendRows(previous, rows, supplied) {
+    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 {
     sessions = new Map();
@@ -48,17 +58,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, receipts) {
         for (const row of sessions) {
@@ -73,6 +86,14 @@ export class SnapshotReader {
         this.receipts.push(...receipts.map(receipt));
     }
     finish() {
-        return { sessions: [...this.sessions.values()], receipts: this.receipts };
+        const sessions = [];
+        for (const { info, topics, subscriptions } of this.sessions.values()) {
+            sessions.push({
+                ...info,
+                ...(topics !== undefined ? { topics } : {}),
+                ...(subscriptions !== undefined ? { subscriptions } : {}),
+            });
+        }
+        return { sessions, receipts: this.receipts };
     }
 }

package/dist/pi-intercom/broker/snapshots.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { isRecord } from "../../shared/unknown.js";
 import { isTopicUpdate, isTopicSubscription, } from "../types.js";
-import { validateIntercomMessageSize } from "./framing.js";
+import { intercomMessageSizeBytes, MAX_FRAME_SIZE_BYTES, validateIntercomMessageSize, } from "./framing.js";
 /** Direct messages and old clients receive identity, not potentially large topic state. */
 export function messageSender(info) {
     const { topics: _topics, subscriptions: _subscriptions, ...identity } = info;
@@ -91,60 +91,163 @@ function publicationUpdate(topic, previous, publish) {
     }
     return { ...topic, revision };
 }
-class TopicSnapshot {
-    info;
+class SnapshotRecords {
+    records = new Map();
+    largest = 0;
+    initial;
+    present;
+    constructor(values) {
+        this.initial = values;
+        this.present = values !== undefined;
+        for (const value of values ?? []) {
+            this.set(value, intercomMessageSizeBytes(value));
+        }
+    }
+    get(topic, first = false) {
+        if (first && this.initial !== undefined) {
+            return this.initial.find((record) => record.topic === topic);
+        }
+        return this.records.get(topic)?.value;
+    }
+    maximumAfter(topic, bytes = 0) {
+        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, bytes) {
+        this.largest = this.maximumAfter(value.topic, bytes);
+        this.records.set(value.topic, { value, bytes });
+    }
+    delete(topic) {
+        this.largest = this.maximumAfter(topic);
+        this.records.delete(topic);
+    }
+    accept() {
+        this.initial = undefined;
+        this.present = true;
+    }
+    valuesAfter(topic, value, changed = false) {
+        if (!changed) {
+            if (this.initial !== undefined) {
+                return this.initial;
+            }
+            if (!this.present) {
+                return;
+            }
+        }
+        const values = [];
+        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;
+    }
+}
+const UNCHANGED = { restore: false, changed: false, bytes: 0 };
+/** Keep committed records indexed; restores validate only new bytes and cached envelope maxima. */
+export class TopicSnapshot {
     topics;
     subscriptions;
     constructor(info) {
-        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]));
+        this.topics = new SnapshotRecords(info.topics);
+        this.subscriptions = new SnapshotRecords(info.subscriptions);
     }
-    apply(mutation) {
+    subscription(topic) {
+        return this.subscriptions.get(topic, true);
+    }
+    prepare(change, supported) {
+        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": {
-                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;
-                }
-                return;
-            }
+            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 };
         }
     }
-    snapshot(publication) {
+    preparePublication(mutation, base) {
+        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 {
-            ...this.info,
-            topics: [...this.topics.values()],
-            subscriptions: [...this.subscriptions.values()],
-            ...(publication ? { lastIntercomActivity: Date.now() } : {}),
+            ...base,
+            topic: update,
+            bytes: intercomMessageSizeBytes(update),
+            ...(mutation.publish ? { publication: update } : {}),
         };
     }
-}
-/** Prepare a change without mutating the usable broker snapshot before frame validation. */
-export function prepareTopicChange(info, change, supported) {
-    if (change === undefined) {
-        return { info, restore: false };
+    snapshot(info, prepared = UNCHANGED) {
+        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 {
+            ...info,
+            ...(topics !== undefined ? { topics } : {}),
+            ...(subscriptions !== undefined ? { subscriptions } : {}),
+            ...(prepared.publication ? { lastIntercomActivity: Date.now() } : {}),
+        };
     }
-    if (!supported || !isRecord(change)) {
-        throw new Error("Topic snapshots unavailable for this client");
+    validateRestore(info, prepared, requestId) {
+        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],
+        ]) {
+            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})`);
+            }
+        }
+    }
+    commit(prepared) {
+        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) {
     if (!receipt.accepted) {

package/dist/pi-intercom/session-targets.js

@@ -104,7 +104,6 @@ function shortTargetResolution(names, prefixes) {
         return {
             status: "prefix_too_short",
             matches: prefixes,
-            minLength: MIN_SESSION_TARGET_PREFIX_LENGTH,
         };
     }
     const byId = new Map();

package/dist/runs/background/async-run-discovery.js

@@ -3,12 +3,12 @@ import * as path from "node:path";
 import { RESULTS_DIR } from "../../shared/types.js";
 import { runSynchronously } from "../../shared/cooperative.js";
 import { asyncRunRoots, readAsyncRunRecord } from "./async-resume.js";
-import { getRunMetadataDir, readRunJson } from "../shared/supervisor-questions.js";
+import { readQuestionOwner } from "../shared/supervisor-questions.js";
 import { findNestedRouteForRootId } from "../shared/nested-events.js";
 import { reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-reconciler.js";
 import { validateStatusForSummary } from "./async-status-validation.js";
 import { asyncStatusToSummary } from "./async-status-projection.js";
-import { errorCode, errorMessage, hasText, isRecord } from "./async-value.js";
+import { errorCode, errorMessage, hasText } from "./async-value.js";
 function directory(root, entry) {
     const entryPath = path.join(root, entry);
     try {
@@ -86,10 +86,8 @@ class AsyncRunDiscovery {
         let owner = this.owners.get(entry);
         if (!hasText(owner) && hasText(this.ownerSessionId)) {
             try {
-                const saved = 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/dist/runs/background/completion-dedupe.js

@@ -1,18 +1,5 @@
 import { createHash } from "node:crypto";
 import { isRecord, hasText } from "./async-value.js";
-function asNonEmptyString(value) {
-    if (typeof value !== "string") {
-        return undefined;
-    }
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : undefined;
-}
-function asFiniteNumber(value) {
-    if (typeof value !== "number") {
-        return undefined;
-    }
-    return Number.isFinite(value) ? value : undefined;
-}
 function stableStringify(value) {
     if (value === null || typeof value !== "object") {
         return JSON.stringify(value);
@@ -32,32 +19,11 @@ function stableStringify(value) {
 function payloadDigest(value) {
     return createHash("sha256").update(stableStringify(value)).digest("hex").slice(0, 16);
 }
-export function buildCompletionKey(data, fallback) {
-    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) {
+    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)}`;
 }
 function pruneSeenMap(seen, now, ttlMs) {
     for (const [key, ts] of seen.entries()) {
@@ -74,20 +40,3 @@ export function markSeenWithTtl(seen, key, now, ttlMs) {
     seen.set(key, now);
     return false;
 }
-function isSeenMap(value) {
-    if (!(value instanceof Map)) {
-        return false;
-    }
-    const entries = value;
-    return [...entries].every(([key, timestamp]) => typeof key === "string" && typeof timestamp === "number");
-}
-export function getGlobalSeenMap(storeKey) {
-    const globalStore = globalThis;
-    const existing = globalStore[storeKey];
-    if (isSeenMap(existing)) {
-        return existing;
-    }
-    const map = new Map();
-    globalStore[storeKey] = map;
-    return map;
-}

package/dist/runs/background/notify.js

@@ -1,4 +1,3 @@
-import { buildCompletionKey, getGlobalSeenMap, markSeenWithTtl } from "./completion-dedupe.js";
 import { SUBAGENT_ASYNC_COMPLETE_EVENT } from "../../shared/types.js";
 import { hasText, isRecord } from "./async-value.js";
 function isResult(value) {
@@ -95,22 +94,15 @@ export default function registerSubagentNotify(pi, onQueued) {
             // Best effort cleanup for stale handlers from an older reload.
         }
     }
-    const seen = getGlobalSeenMap("__pi_subagents_notify_seen__");
     const handleComplete = (data) => {
         if (!isResult(data) ||
             data.intercomResultDelivered === true ||
             data.suppressNotification === true) {
             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/dist/runs/background/result-watcher.js

@@ -215,7 +215,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/dist/runs/background/runner-child-observer.js

@@ -31,17 +31,20 @@ export class RunnerChildObserver {
         this.id = config.id;
         this.hooks = hooks;
         this.mutatingFailureStates = statusPayload.steps.map(() => createMutatingFailureState());
+        this.syncTopLevelCurrentTool();
     }
     expandChildren(flatIndex, count) {
         this.mutatingFailureStates.splice(flatIndex, 1, ...Array.from({ length: count }, () => createMutatingFailureState()));
     }
     syncTopLevelCurrentTool() {
-        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);
+        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;
@@ -62,7 +65,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/dist/runs/background/runner-monitor.js

@@ -120,6 +120,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/dist/runs/background/runner-parallel.js

@@ -1,7 +1,6 @@
 import * as path from "node:path";
 import { inspect } from "node:util";
 import { appendJsonl } from "../../shared/artifacts.js";
-import { writeAtomicJson } from "../../shared/atomic-json.js";
 import { writeInitialProgressFile } from "../../shared/settings.js";
 import { completeWorkflowStep, runParallelTasks } from "../shared/workflow-policy.js";
 import { createWorktrees, cleanupWorktrees, findWorktreeTaskCwdConflict, formatWorktreeTaskCwdConflict, formatParallelWorktreeSummary, WorktreeCleanupError, } from "../shared/worktree.js";
@@ -129,7 +128,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,
@@ -158,7 +157,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/dist/runs/shared/child-observation-spool.js

@@ -37,8 +37,11 @@ export class ChildObservationSpool {
         fs.writeFileSync(this.stderr, text);
     }
     resetText() {
-        this.textOffset = 0;
+        if (this.textOffset === 0) {
+            return;
+        }
         fs.ftruncateSync(this.text, 0);
+        this.textOffset = 0;
     }
     appendText(text) {
         const bytes = Buffer.from(text);
@@ -52,13 +55,15 @@ export class ChildObservationSpool {
         this.textOffset += bytes.length;
     }
     replayText(consume) {
-        this.decode(this.text, 0, this.textOffset, consume);
+        if (this.textOffset > 0) {
+            this.decode(this.text, 0, this.textOffset, consume);
+        }
     }
     replayWire(start, end, consume) {
         this.decode(this.wire, start, end, consume);
     }
     copy(fd, start, end, consume) {
-        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) {