@fitchmultz/pi-subagents 0.50.0 → 0.52.0

package/dist/agent/journal-tail.js

@@ -1,12 +1,8 @@
 import * as fs from "node:fs";
-const READ_BYTES = 65536;
-const LINE_BYTES = 32768;
-const KEEP_LINES = 80;
-function record(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
+import { NativeJournal } from "../shared/native-journal.js";
+import { nativeProjection } from "../shared/journal-projections.js";
+import { isRecord, recordAt } from "../shared/unknown.js";
 export function plainText(value, length = 512) {
-    // Journal content is untrusted terminal input, never terminal control sequences.
     return Array.from(value.slice(0, length))
         .map((char) => {
         const code = char.codePointAt(0) ?? 0;
@@ -14,170 +10,133 @@ export function plainText(value, length = 512) {
     })
         .join("");
 }
-function contentLines(content) {
-    if (typeof content === "string") {
-        return [plainText(content)];
-    }
-    if (!Array.isArray(content)) {
-        return [];
-    }
-    return content.slice(0, 12).flatMap((block) => {
-        if (!record(block)) {
-            return [];
-        }
-        if (block.type === "text" && typeof block.text === "string") {
-            return [plainText(block.text)];
-        }
-        if (block.type === "toolCall" && typeof block.name === "string") {
-            return [`tool ${plainText(block.name, 80)} ${plainText(JSON.stringify(block.arguments))}`];
-        }
-        return block.type === "thinking"
-            ? []
-            : [`[${typeof block.type === "string" ? plainText(block.type, 40) : "non-text"} omitted]`];
-    });
-}
-function activity(value) {
-    if (!record(value) || value.type !== "message" || !record(value.message)) {
-        return [];
+const PAGE_CHARS = 32 * 1024;
+const callFields = new Set(["type", "id", "name"]);
+const textFields = new Set(["text", "thinking"]);
+const metadata = (keys, root) => {
+    if (keys[0] === "message" &&
+        keys[1] === "content" &&
+        keys.length > 3 &&
+        !callFields.has(String(keys[3]))) {
+        return false;
     }
-    const message = value.message;
-    if (message.role === "assistant") {
-        const lines = contentLines(message.content).map((line) => `assistant: ${line}`);
-        if (typeof message.errorMessage === "string") {
-            lines.push(`assistant error: ${plainText(message.errorMessage)}`);
-        }
-        return lines;
+    return nativeProjection(keys, root);
+};
+function contentIndex(keys) {
+    if (keys[0] !== "message" || keys[1] !== "content") {
+        return undefined;
     }
-    if (message.role === "toolResult") {
-        const label = message.isError === true ? "tool error" : "tool result";
-        const name = typeof message.toolName === "string" ? plainText(message.toolName, 80) : "unknown";
-        return [`${label} ${name}:`, ...contentLines(message.content)];
+    if (keys.length === 2) {
+        return -1;
     }
-    return [];
+    return typeof keys[2] === "number" && textFields.has(String(keys[3])) ? keys[2] : undefined;
 }
-/** A lossy display tail; the native journal remains the complete source of truth. */
-export class JournalTail {
-    lines = [];
-    notice = "Waiting for published native activity.";
-    offset = 0;
-    partial = Buffer.alloc(0);
-    dropping = false;
-    identity = "";
-    stamp = 0;
-    file;
-    sessionId;
-    constructor(file, sessionId) {
-        this.file = file;
-        this.sessionId = sessionId;
-    }
-    reset(size) {
-        this.lines.length = 0;
-        this.offset = 0;
-        this.partial = Buffer.alloc(0);
-        this.dropping = false;
-        if (size > READ_BYTES) {
-            this.skip(size);
-        }
+class TextPage {
+    chars = 0;
+    carry;
+    text = new Map();
+    start;
+    constructor(page) {
+        this.start = page * PAGE_CHARS;
     }
-    skip(size) {
-        this.offset = size - READ_BYTES;
-        this.partial = Buffer.alloc(0);
-        this.dropping = true;
-        this.lines.push("[Earlier native activity omitted; full journal retained.]");
-    }
-    header(fd) {
-        const head = Buffer.alloc(4096);
-        const count = fs.readSync(fd, head, 0, head.length, 0);
-        const lf = head.indexOf(10, 0);
-        if (lf < 0 || lf >= count) {
-            throw new Error("Native journal header is incomplete or too large.");
-        }
-        const value = JSON.parse(head.subarray(0, lf).toString("utf8"));
-        if (!record(value) || value.type !== "session" || value.id !== this.sessionId) {
-            throw new Error("Native journal identity does not match this child.");
+    add(index, chunk) {
+        const previous = this.carry;
+        this.carry = undefined;
+        if (previous && previous.index !== index) {
+            this.take(previous.index, previous.text);
+        }
+        const text = previous?.index === index ? previous.text + chunk : chunk;
+        const last = text.charCodeAt(text.length - 1);
+        const pending = last >= 0xd800 && last <= 0xdbff;
+        this.take(index, pending ? text.slice(0, -1) : text);
+        if (pending) {
+            this.carry = { index, text: text.slice(-1) };
         }
     }
-    line(line) {
-        if (line.length > LINE_BYTES) {
-            this.lines.push("[Large native entry omitted; read the full journal.]");
-            return;
-        }
-        try {
-            const value = JSON.parse(line.toString("utf8"));
-            this.lines.push(...activity(value));
-        }
-        catch {
-            this.lines.push("[Malformed published native entry omitted.]");
-        }
+    take(index, text) {
+        const points = Array.from(text);
+        const from = Math.max(0, this.start - this.chars);
+        const to = Math.min(points.length, this.start + PAGE_CHARS - this.chars);
+        if (to > from) {
+            this.text.set(index, (this.text.get(index) ?? "") + points.slice(from, to).join(""));
+        }
+        this.chars += points.length;
     }
-    consume(chunk) {
-        const bytes = Buffer.concat([this.partial, chunk]);
-        let start = 0;
-        let lf = bytes.indexOf(10);
-        while (lf >= 0) {
-            if (!this.dropping) {
-                this.line(bytes.subarray(start, lf));
+    finish(value, page) {
+        if (this.carry) {
+            this.take(this.carry.index, this.carry.text);
+        }
+        const message = { ...recordAt(value, "message") };
+        if (typeof message.content === "string") {
+            message.content = this.text.get(-1) ?? "";
+        }
+        if (Array.isArray(message.content)) {
+            for (const [index, block] of message.content.entries()) {
+                if (isRecord(block) && typeof block.type === "string" && textFields.has(block.type)) {
+                    block[block.type] = this.text.get(index) ?? "";
+                }
             }
-            this.dropping = false;
-            start = lf + 1;
-            lf = bytes.indexOf(10, start);
-        }
-        this.partial = bytes.subarray(start);
-        if (this.partial.length > LINE_BYTES) {
-            this.partial = Buffer.alloc(0);
-            this.dropping = true;
-            this.lines.push("[Large native entry omitted; read the full journal.]");
         }
-        this.lines.splice(0, Math.max(0, this.lines.length - KEEP_LINES));
-        if (this.partial.length > 0) {
-            this.notice = "Waiting for newline publication of the latest native entry.";
+        return { message, page, pages: Math.max(1, Math.ceil(this.chars / PAGE_CHARS)) };
+    }
+}
+/** Native indexing owns ancestry and publication; only requested message pages are hydrated. */
+export class ConversationJournal {
+    native;
+    branch;
+    constructor(file, sessionId) {
+        const stat = fs.lstatSync(file);
+        if (!stat.isFile() || stat.isSymbolicLink()) {
+            throw new Error("Child journal is not a regular file.");
+        }
+        this.native = new NativeJournal(file, "live", true, {
+            readBytes: 256 * 1024,
+            select: metadata,
+        });
+        if (this.native.records[0]?.value.id !== sessionId) {
+            throw new Error("Native journal identity does not match this child.");
         }
     }
-    changed(stat, identity) {
-        return (identity !== this.identity ||
-            stat.size < this.offset ||
-            (stat.size === this.offset && stat.mtimeMs !== this.stamp));
+    entries(requested) {
+        const leaf = typeof requested === "string" && !this.native.byId.has(requested) ? undefined : requested;
+        if (this.branch?.length !== this.native.records.length || this.branch.leaf !== leaf) {
+            this.branch = {
+                length: this.native.records.length,
+                leaf,
+                entries: this.native.branch(leaf).filter((entry) => entry.value.type === "message"),
+            };
+        }
+        return this.branch.entries;
     }
-    observe(fd, stat) {
-        const identity = `${stat.dev}:${stat.ino}`;
-        if (this.changed(stat, identity)) {
-            this.reset(stat.size);
-        }
-        else if (stat.size - this.offset > READ_BYTES) {
-            this.skip(stat.size);
-        }
-        this.identity = identity;
-        this.stamp = stat.mtimeMs;
-        const chunk = Buffer.alloc(Math.min(READ_BYTES, stat.size - this.offset));
-        const count = fs.readSync(fd, chunk, 0, chunk.length, this.offset);
-        this.offset += count;
-        this.notice =
-            this.offset > READ_BYTES ? "Recent journal tail only; full journal retained." : "";
-        this.consume(chunk.subarray(0, count));
-        if (this.lines.length === 0 && this.notice.length === 0) {
-            this.notice = "Waiting for published native activity.";
-        }
+    async call(id, result, signal) {
+        const contains = (entry) => {
+            const content = recordAt(entry.value, "message")?.content;
+            return (Array.isArray(content) &&
+                content.some((part) => isRecord(part) && part.type === "toolCall" && part.id === id));
+        };
+        const entries = this.branch?.entries ?? [];
+        const entry = entries
+            .slice(0, entries.findIndex((item) => item.value.id === result))
+            .findLast(contains);
+        const content = entry && (await this.page(entry, 0, { signal })).message.content;
+        return Array.isArray(content)
+            ? content.find((part) => isRecord(part) && part.type === "toolCall" && part.id === id)
+            : undefined;
     }
-    poll() {
-        let fd;
-        try {
-            fd = fs.openSync(this.file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
-            const stat = fs.fstatSync(fd);
-            if (!stat.isFile()) {
-                throw new Error("Native journal is not a regular file.");
+    async page(entry, page = 0, options = {}) {
+        const text = new TextPage(page);
+        const value = await this.native.project(entry, (keys, root) => {
+            if (contentIndex(keys) !== undefined && keys.length > 2) {
+                return 0;
             }
-            this.header(fd);
-            this.observe(fd, stat);
-        }
-        catch (error) {
-            this.lines.length = 0;
-            this.identity = "";
-            this.notice = error instanceof Error ? plainText(error.message) : "Journal unavailable.";
-        }
-        finally {
-            if (fd !== undefined) {
-                fs.closeSync(fd);
+            return nativeProjection(keys, root);
+        }, (keys, chunk) => {
+            const index = contentIndex(keys);
+            if (index === undefined || (options.hideThinking === true && keys[3] === "thinking")) {
+                return;
             }
-        }
+            text.add(index, chunk);
+        }, options.signal);
+        return text.finish(value, page);
     }
 }

package/dist/agent/launch.js

@@ -3,22 +3,34 @@ import * as path from "node:path";
 import { randomUUID } from "node:crypto";
 import { loadSDK, packageRoot, runtimeEntry } from "./host.js";
 import { runDirectory, write } from "./storage.js";
-function selectedModel(input, context) {
+function selectedModel(input, context, thinking, sdk) {
     if (input.model === undefined) {
         if (!context.model) {
             throw new Error("No selected model; no fallback was used.");
         }
-        return context.model;
+        return { model: context.model, thinking };
     }
     const slash = input.model.indexOf("/");
     if (slash < 1) {
         throw new Error("model must be an exact provider/model ID.");
     }
     const model = context.modelRegistry.find(input.model.slice(0, slash), input.model.slice(slash + 1));
-    if (!model) {
+    if (model) {
+        return { model, thinking };
+    }
+    if (typeof sdk.resolveModelReference !== "function") {
+        throw new Error(`Model ${input.model} is unavailable; no fallback was used. Check the provider/model ID. This host supports literal IDs only. If you intended a thinking suffix, update Pi for native thinking-suffix support.`);
+    }
+    const resolved = sdk.resolveModelReference({
+        text: input.model,
+        provider: input.model.slice(0, slash),
+        thinkingSuffix: "strict",
+        fuzzy: false,
+    }, context.modelRegistry.getAll(), () => true);
+    if (resolved.status !== "resolved") {
         throw new Error(`Model ${input.model} is unavailable; no fallback was used.`);
     }
-    return model;
+    return { model: resolved.model, thinking: resolved.thinkingLevel ?? thinking };
 }
 function targetTrust(sdk, cwd, context, agentDir) {
     if (fs.realpathSync(cwd) === fs.realpathSync(context.cwd)) {
@@ -43,7 +55,7 @@ export async function prepareLaunch(options) {
     if (!fs.statSync(cwd).isDirectory()) {
         throw new Error("Delegation cwd is not a directory.");
     }
-    const model = selectedModel(input, context);
+    const selection = selectedModel(input, context, thinking, sdk);
     const trusted = targetTrust(sdk, cwd, context, agentDir);
     const id = randomUUID();
     const directory = runDirectory(base, id);
@@ -73,9 +85,9 @@ export async function prepareLaunch(options) {
         sessionId: manager.getSessionId(),
         prompt: input.prompt,
         context: input.context ?? "fresh",
-        provider: model.provider,
-        model: model.id,
-        thinking,
+        provider: selection.model.provider,
+        model: selection.model.id,
+        thinking: selection.thinking,
         trusted,
         name: input.name,
         createdAt: Date.now(),

package/dist/agent/legacy.js

@@ -4,31 +4,45 @@ import { journalStamp } from "../shared/native-journal.js";
 import { receiptId } from "./receipts.js";
 import { resolveTempRootDir } from "../shared/types.js";
 import { isRecord } from "../shared/unknown.js";
-import { hold, release, isHeld } from "./notifications.js";
+import { release, isHeld } from "./notifications.js";
 import { missing } from "./storage.js";
-function legacyInput(file, owner) {
+import { errorText } from "./host.js";
+// Retain only foreign classifications, never their saved output, for each live native manager.
+const ignoredInputs = new WeakMap();
+function fileStamp(file) {
     const stat = fs.lstatSync(file, { bigint: true });
-    if (!stat.isFile() || stat.isSymbolicLink()) {
+    return stat.isFile() && !stat.isSymbolicLink() ? journalStamp(stat) : undefined;
+}
+function legacyInput(file, scan) {
+    const stamp = fileStamp(file);
+    if (stamp === undefined) {
+        return;
+    }
+    if (scan.known?.get(file) === stamp) {
+        scan.ignored.set(file, stamp);
         return;
     }
     const raw = fs.readFileSync(file, "utf8");
     const data = JSON.parse(raw);
-    if (!isRecord(data) || data.sessionId !== owner) {
+    if (!isRecord(data) || data.sessionId !== scan.owner) {
+        if (fileStamp(file) === stamp) {
+            scan.ignored.set(file, stamp);
+        }
         return;
     }
+    return ownedInput({ file, raw, stamp, owner: scan.owner }, data);
+}
+function ownedInput(source, data) {
     const id = typeof data.runId === "string" ? data.runId : data.id;
-    if (typeof id !== "string" || path.basename(file, ".json") !== id) {
+    if (typeof id !== "string" || path.basename(source.file, ".json") !== id) {
         return;
     }
     const legacy = `legacy:${id}:${typeof data.timestamp === "number" ? data.timestamp : "unknown"}`;
     const completionId = typeof data.completionId === "string" ? data.completionId : legacy;
     return {
-        file,
-        raw,
-        stamp: journalStamp(stat),
+        ...source,
         id,
         key: `completion:${completionId}`,
-        owner,
         single: data.mode === "single",
     };
 }
@@ -81,7 +95,7 @@ function published(ctx, input) {
     return (receiptId(ctx.sessionManager.getSessionFile(), input.owner, (body) => receipt(body, input)) !==
         undefined);
 }
-function deliver(pi, ctx, input) {
+function notification(ctx, input) {
     const identity = `legacy:${input.id}:${input.key}`;
     if (published(ctx, input)) {
         release(input.owner, identity);
@@ -95,24 +109,51 @@ function deliver(pi, ctx, input) {
     if (isHeld(input.owner, identity)) {
         return;
     }
-    hold(input.owner, identity);
-    try {
-        pi.sendMessage({
+    return {
+        owner: input.owner,
+        id: identity,
+        message: {
             customType: "subagent-notify",
             display: true,
             // Full saved bytes, not a replacement summary. No owner/run record is invented.
             content: input.raw,
             details: { completion: { runId: input.id, key: input.key, ownerSessionId: input.owner } },
-        }, { triggerTurn: true, deliverAs: "followUp" });
+        },
+    };
+}
+function legacyNotice(ctx, file, scan) {
+    try {
+        const input = legacyInput(file, scan);
+        return input ? notification(ctx, input) : undefined;
     }
     catch (error) {
-        release(input.owner, identity);
-        throw error;
+        console.error(`Skipped legacy completion ${file}: ${errorText(error)}`);
+        return;
     }
 }
-export function notifyLegacy(pi, ctx) {
-    const root = resolveTempRootDir();
-    const directory = path.join(root, "async-subagent-results");
+function startScan(ctx, directory) {
+    const manager = ctx.sessionManager;
+    const owner = manager.getSessionId();
+    const prior = ignoredInputs.get(manager);
+    const scan = {
+        directory,
+        owner,
+        known: prior?.directory === directory && prior.owner === owner ? prior.ignored : undefined,
+        ignored: new Map(),
+    };
+    // Replace even on a failed directory scan; vanished/unsafe inputs keep no cached decision.
+    ignoredInputs.set(manager, { directory, owner, ignored: scan.ignored });
+    return scan;
+}
+/** Retired releases created this directory at session start, before any of their runners. */
+export function legacyDirectory() {
+    return path.join(resolveTempRootDir(), "async-subagent-results");
+}
+export function legacyNotifications(ctx) {
+    const notices = [];
+    const directory = legacyDirectory();
+    const root = path.dirname(directory);
+    const scan = startScan(ctx, directory);
     let names;
     try {
         for (const candidate of [root, directory]) {
@@ -125,7 +166,7 @@ export function notifyLegacy(pi, ctx) {
     }
     catch (error) {
         if (missing(error)) {
-            return;
+            return notices;
         }
         throw error;
     }
@@ -133,9 +174,10 @@ export function notifyLegacy(pi, ctx) {
         if (!name.endsWith(".json")) {
             continue;
         }
-        const input = legacyInput(path.join(directory, name), ctx.sessionManager.getSessionId());
-        if (input) {
-            deliver(pi, ctx, input);
+        const notice = legacyNotice(ctx, path.join(directory, name), scan);
+        if (notice) {
+            notices.push(notice);
         }
     }
+    return notices;
 }