@henryqw/pi-subagent 27.4.4 → 27.4.5

package/dist/direct-herdr.d.ts

@@ -32,6 +32,8 @@ export declare function directSessionUsage(jsonl: string, prompt: string): {
 };
 /** The last `maxChars` of assistant text in the exact prompt's turn; ignores a partial trailing entry. */
 export declare function directPartialText(jsonl: string, prompt: string, maxChars: number): string | undefined;
+/** One reader per handle; only complete, valid lines advance the byte offset. */
+export declare function createDirectSessionReader(sessionFile: string, prompt: string): Pick<DirectHandle, "usageTokens" | "partialText" | "activity">;
 /** `turn` is the prompt's random turn identity; it proves which session turn a record owns.
  * `workspaceId` and `cwd` bind the record to its launching Herdr workspace and checkout. */
 export type DirectTab = Pick<DirectHandle, "name" | "tabId" | "paneId" | "sessionFile"> & {

package/dist/direct-herdr.js

@@ -1,6 +1,6 @@
 import { randomBytes } from "node:crypto";
 import { realpathSync } from "node:fs";
-import { readFile, mkdtemp, stat, writeFile } from "node:fs/promises";
+import { open, readFile, mkdtemp, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
@@ -122,99 +122,150 @@ export function exactDirectAnswer(jsonl, prompt, maxBytes = ANSWER_LIMIT, requir
         throw new Error(`Direct task reported ${completion.outcome}: ${completion.answer}`);
     return completion.answer;
 }
-// Ignore a partial trailing JSONL entry while the child is writing it.
-export function directSessionUsage(jsonl, prompt) {
-    let active = false;
-    let total = 0;
-    let observed = false;
-    const pending = new Map();
-    let latest;
-    for (const line of jsonl.split("\n")) {
+class DirectSessionState {
+    active = false;
+    total = 0;
+    observed = false;
+    pending = new Map();
+    latest;
+    texts = [];
+    prompt;
+    constructor(prompt) { this.prompt = prompt; }
+    consume(line) {
         if (!line.trim())
-            continue;
+            return true;
         let entry;
         try {
             entry = JSON.parse(line);
         }
         catch {
-            break;
+            return false;
         }
         if (!entry || entry.type !== "message" || !entry.message || typeof entry.message !== "object")
-            continue;
+            return true;
         const message = entry.message;
         if (message.role === "user") {
-            active = Array.isArray(message.content) && message.content.length === 1
-                && message.content[0]?.text === prompt;
-            if (active) {
-                total = 0;
-                observed = false;
-                pending.clear();
-                latest = undefined;
+            this.active = Array.isArray(message.content) && message.content.length === 1
+                && message.content[0]?.text === this.prompt;
+            if (this.active) {
+                this.total = 0;
+                this.observed = false;
+                this.pending.clear();
+                this.latest = undefined;
+                this.texts = [];
             }
         }
-        else if (active && message.role === "assistant") {
+        else if (this.active && message.role === "assistant") {
             if (message.usage && typeof message.usage === "object") {
                 const usage = message.usage;
                 const values = [usage.input, usage.output];
                 if (values.every((value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0)) {
-                    total += values.reduce((sum, value) => sum + value, 0);
-                    observed = true;
+                    this.total += values.reduce((sum, value) => sum + value, 0);
+                    this.observed = true;
                 }
             }
             if (Array.isArray(message.content))
                 for (const part of message.content) {
                     if (part?.type === "toolCall" && typeof part.id === "string" && typeof part.name === "string") {
-                        pending.set(part.id, part.name);
+                        this.pending.set(part.id, part.name);
+                    }
+                    else if (part?.type === "text" && typeof part.text === "string" && part.text.trim()) {
+                        this.texts.push(part.text);
                     }
                 }
         }
-        else if (active && message.role === "toolResult" && typeof message.toolCallId === "string") {
-            const name = pending.get(message.toolCallId);
-            if (name === undefined)
-                continue;
-            pending.delete(message.toolCallId);
-            latest = { name };
-            if (typeof message.durationMs === "number" && Number.isFinite(message.durationMs) && message.durationMs >= 0) {
-                latest.durationMs = message.durationMs;
+        else if (this.active && message.role === "toolResult" && typeof message.toolCallId === "string") {
+            const name = this.pending.get(message.toolCallId);
+            if (name !== undefined) {
+                this.pending.delete(message.toolCallId);
+                this.latest = { name };
+                if (typeof message.durationMs === "number" && Number.isFinite(message.durationMs) && message.durationMs >= 0) {
+                    this.latest.durationMs = message.durationMs;
+                }
             }
         }
+        return true;
+    }
+    usage() {
+        return { tokens: this.observed ? this.total : undefined,
+            activity: this.pending.size || this.latest ? { pending: [...this.pending.values()], latest: this.latest } : undefined };
+    }
+    partialText(maxChars) {
+        const chars = Array.from(this.texts.join("\n").trim());
+        if (!chars.length)
+            return undefined;
+        return chars.length <= maxChars ? chars.join("") : `…${chars.slice(-maxChars).join("")}`;
     }
-    return { tokens: observed ? total : undefined,
-        activity: pending.size || latest ? { pending: [...pending.values()], latest } : undefined };
+}
+function parseDirectSession(jsonl, prompt) {
+    const state = new DirectSessionState(prompt);
+    for (const line of jsonl.split("\n"))
+        if (!state.consume(line))
+            break;
+    return state;
+}
+// Ignore a partial trailing JSONL entry while the child is writing it.
+export function directSessionUsage(jsonl, prompt) {
+    return parseDirectSession(jsonl, prompt).usage();
 }
 /** The last `maxChars` of assistant text in the exact prompt's turn; ignores a partial trailing entry. */
 export function directPartialText(jsonl, prompt, maxChars) {
-    let active = false;
-    let texts = [];
-    for (const line of jsonl.split("\n")) {
-        if (!line.trim())
-            continue;
-        let entry;
+    return parseDirectSession(jsonl, prompt).partialText(maxChars);
+}
+/** One reader per handle; only complete, valid lines advance the byte offset. */
+export function createDirectSessionReader(sessionFile, prompt) {
+    let offset = 0;
+    let previous;
+    let state = new DirectSessionState(prompt);
+    let lastUsage = {};
+    let reading;
+    const read = async () => {
+        const file = await open(sessionFile, "r");
         try {
-            entry = JSON.parse(line);
-        }
-        catch {
-            break;
-        }
-        if (!entry || entry.type !== "message" || !entry.message || typeof entry.message !== "object")
-            continue;
-        const message = entry.message;
-        if (message.role === "user") {
-            active = Array.isArray(message.content) && message.content.length === 1
-                && message.content[0]?.text === prompt;
-            if (active)
-                texts = [];
+            const info = await file.stat();
+            if (info.size > SESSION_LIMIT) {
+                previous = info;
+                return false;
+            }
+            if (previous && (info.dev !== previous.dev || info.ino !== previous.ino || info.size < previous.size
+                || (info.size === previous.size && (info.mtimeMs !== previous.mtimeMs || info.ctimeMs !== previous.ctimeMs)))) {
+                offset = 0;
+                state = new DirectSessionState(prompt);
+            }
+            previous = info;
+            const buffer = Buffer.alloc(info.size - offset);
+            let length = 0;
+            while (length < buffer.length) {
+                const { bytesRead } = await file.read({ buffer, offset: length, length: buffer.length - length, position: offset + length });
+                if (!bytesRead)
+                    break;
+                length += bytesRead;
+            }
+            let start = 0;
+            for (let end = buffer.indexOf(10); end >= 0 && end < length; end = buffer.indexOf(10, start)) {
+                if (!state.consume(buffer.toString("utf8", start, end)))
+                    break;
+                offset += end + 1 - start;
+                start = end + 1;
+            }
+            return true;
         }
-        else if (active && message.role === "assistant" && Array.isArray(message.content)) {
-            for (const part of message.content)
-                if (part?.type === "text" && typeof part.text === "string" && part.text.trim())
-                    texts.push(part.text);
+        finally {
+            await file.close();
         }
-    }
-    const chars = Array.from(texts.join("\n").trim());
-    if (!chars.length)
-        return undefined;
-    return chars.length <= maxChars ? chars.join("") : `…${chars.slice(-maxChars).join("")}`;
+    };
+    // Timer samples and failure evidence can request the same file at the same time.
+    const sample = () => reading ??= read().finally(() => { reading = undefined; });
+    return {
+        get activity() { return lastUsage.activity; },
+        async usageTokens() {
+            lastUsage = await sample() ? state.usage() : {};
+            return lastUsage.tokens;
+        },
+        async partialText(maxChars) {
+            return await sample() ? state.partialText(maxChars) : undefined;
+        },
+    };
 }
 export class DirectAllocationError extends Error {
     allocation;
@@ -371,28 +422,12 @@ export function createDirectHerdr(pi, cwd, idleMs) {
                 const state = inspect(accepted, "agent_prompted", name, paneId, tabId);
                 if (state === "blocked" || state === "unknown")
                     throw new Error(`Herdr agent became ${state}; inspect it before retrying.`);
-                let lastUsageSize = -1;
-                let lastUsage = {};
+                const session = createDirectSessionReader(sessionFile, prompt);
                 return {
                     name, tabId, paneId, sessionFile, prompt,
-                    get activity() { return lastUsage.activity; },
-                    async usageTokens() {
-                        const info = await stat(sessionFile);
-                        if (info.size > SESSION_LIMIT) {
-                            lastUsage = {};
-                            return undefined;
-                        }
-                        if (info.size !== lastUsageSize) {
-                            lastUsage = directSessionUsage(await readFile(sessionFile, "utf8"), prompt);
-                            lastUsageSize = info.size;
-                        }
-                        return lastUsage.tokens;
-                    },
-                    async partialText(maxChars) {
-                        if ((await stat(sessionFile)).size > SESSION_LIMIT)
-                            return undefined;
-                        return directPartialText(await readFile(sessionFile, "utf8"), prompt, maxChars);
-                    },
+                    get activity() { return session.activity; },
+                    usageTokens: session.usageTokens,
+                    partialText: session.partialText,
                     async answer(maxBytes) {
                         const readAnswer = async () => {
                             const info = await stat(sessionFile);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-subagent",
-  "version": "27.4.4",
+  "version": "27.4.5",
   "description": "Delegate bounded direct work or durable checked isolated task graphs to Pi roles.",
   "keywords": [
     "pi-package",