@fitchmultz/pi-subagents 0.49.0 → 0.50.0

package/dist/history/canonical-selection.js

@@ -1,40 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { getRunMetadataDir } from "../runs/shared/supervisor-questions.js";
-import { HistoryIndexError } from "./types.js";
-import { exactTextDigest, hasText } from "./text.js";
-import { readCanonicalOutput, readSavedOutput } from "./canonical-result.js";
-function output(view, child) {
-    const result = child.result;
-    if (!result) {
-        return "";
-    }
-    if (hasText(result.fullOutputPath)) {
-        return readSavedOutput(result.fullOutputPath);
-    }
-    const file = view.resultPath ?? path.join(getRunMetadataDir(view.runId), "contracts", `${child.index}.json`);
-    const preview = result.finalOutput ?? "";
-    return fs.existsSync(file) ? (readCanonicalOutput(file, child.index) ?? preview) : preview;
-}
-/** Saved full output takes precedence over canonical detail, which precedes the projected preview. */
-export function selectCanonicalResult(view, index, queries) {
-    const child = view.children.find((candidate) => candidate.index === index);
-    if (!child) {
-        throw new HistoryIndexError("OWNERSHIP", "Child is not admitted by this owner.");
-    }
-    if (!child.result) {
-        return null;
-    }
-    const body = output(view, child);
-    if (Buffer.byteLength(body) > 16 * 1024 * 1024) {
-        throw new HistoryIndexError("RECORD_TOO_LARGE", "Selected canonical output exceeds the 16 MiB detail budget.");
-    }
-    const boundary = child.state === "live"
-        ? {}
-        : {
-            terminalEntryId: child.result.terminalEntryId,
-            endedAt: hasText(child.result.terminalEntryId) ? undefined : view.updatedAt,
-        };
-    const finalResultId = queries.finalResultId({ runId: view.runId, index, ...boundary }, exactTextDigest(body));
-    return { text: body, timestamp: view.updatedAt, finalResultId };
-}

package/dist/history/database-generation.js

@@ -1,82 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { randomUUID } from "node:crypto";
-import { historyDirectory, openHistoryDatabase } from "./database.js";
-import { createHistorySchema, HISTORY_SCHEMA_VERSION } from "./schema.js";
-import { hash } from "./text.js";
-import { HistoryIndexError } from "./types.js";
-import { object, errorMessage } from "./values.js";
-import { hasErrorCode } from "../shared/unknown.js";
-function manifestFile(manifest) {
-    try {
-        const input = JSON.parse(fs.readFileSync(manifest, "utf8"));
-        const saved = object(input);
-        if (typeof saved.file === "string" && /^[a-f0-9-]+\.sqlite$/.test(saved.file)) {
-            return saved.file;
-        }
-    }
-    catch (error) {
-        if (!hasErrorCode(error, "ENOENT") && !(error instanceof SyntaxError)) {
-            throw error;
-        }
-    }
-    return undefined;
-}
-function isCorruption(error) {
-    return ((error instanceof HistoryIndexError && error.code === "CORRUPT") ||
-        /malformed|not a database|no such table|corrupt/i.test(errorMessage(error)));
-}
-function existingGeneration(file) {
-    let db;
-    try {
-        if (!fs.existsSync(file) || fs.lstatSync(file).isSymbolicLink()) {
-            throw new HistoryIndexError("CORRUPT", "Invalid index generation.");
-        }
-        db = openHistoryDatabase(file);
-        if (db.prepare("PRAGMA user_version").get()?.user_version !== HISTORY_SCHEMA_VERSION) {
-            throw new HistoryIndexError("CORRUPT", "Invalid index schema.");
-        }
-        db.prepare("SELECT value FROM meta WHERE key='generation'").get();
-        return db;
-    }
-    catch (error) {
-        db?.close();
-        if (!isCorruption(error)) {
-            throw error;
-        }
-        return undefined;
-    }
-}
-/** Manifest replacement selects a fresh projection without unlinking another connection's WAL. */
-export function openGeneration(agentDir, owner) {
-    const directory = historyDirectory(agentDir);
-    const manifest = path.join(directory, `${hash(owner)}.json`);
-    let name = manifestFile(manifest);
-    let db = name === undefined ? undefined : existingGeneration(path.join(directory, name));
-    try {
-        if (!db) {
-            name = `${randomUUID()}.sqlite`;
-            db = openHistoryDatabase(path.join(directory, name));
-            createHistorySchema(db);
-            const temporary = `${manifest}.${process.pid}.${randomUUID()}`;
-            fs.writeFileSync(temporary, JSON.stringify({ file: name }), { mode: 0o600 });
-            fs.renameSync(temporary, manifest);
-        }
-        if (name === undefined) {
-            throw new HistoryIndexError("CORRUPT", "Missing index generation name.");
-        }
-        const file = path.join(directory, name);
-        fs.chmodSync(file, 0o600);
-        for (const suffix of ["-wal", "-shm"]) {
-            if (fs.existsSync(file + suffix)) {
-                fs.chmodSync(file + suffix, 0o600);
-            }
-        }
-        return { db, file };
-    }
-    catch (error) {
-        // Ownership transfers to HistoryStore only after schema, manifest and permissions succeed.
-        db?.close();
-        throw error;
-    }
-}

package/dist/history/database.js

@@ -1,96 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { DatabaseSync } from "node:sqlite";
-import { HistoryIndexError } from "./types.js";
-import { errorMessage } from "./values.js";
-import { hasErrorCode } from "../shared/unknown.js";
-export function historyDirectory(agentDir, create = true) {
-    const directory = path.join(fs.realpathSync(agentDir), "history-index");
-    if (create) {
-        fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
-    }
-    if (fs.lstatSync(directory).isSymbolicLink()) {
-        throw new HistoryIndexError("UNSAFE_PATH", "History directory must not be a symbolic link.");
-    }
-    if (create) {
-        fs.chmodSync(directory, 0o700);
-    }
-    if ([0x6969, 0x517b, 0xff534d42].includes(fs.statfsSync(directory).type)) {
-        throw new HistoryIndexError("UNSAFE_PATH", "SQLite history requires a local filesystem.");
-    }
-    return directory;
-}
-function sidecarPermissions(file) {
-    for (const suffix of ["", "-wal", "-shm"]) {
-        try {
-            fs.chmodSync(file + suffix, 0o600);
-        }
-        catch (error) {
-            // SQLite may remove sidecars as its last attached connection closes.
-            if (suffix === "" || !hasErrorCode(error, "ENOENT")) {
-                throw error;
-            }
-        }
-    }
-}
-function initialize(db, file, readOnly) {
-    const version = db.prepare("SELECT sqlite_version() AS version").get()?.version;
-    if (typeof version !== "string") {
-        throw new HistoryIndexError("CORRUPT", "SQLite did not report its version.");
-    }
-    if (version !== "3.53.4") {
-        throw new HistoryIndexError("UNSUPPORTED_SQLITE", `History requires qualified SQLite 3.53.4; found ${version}.`);
-    }
-    db.exec("PRAGMA foreign_keys=ON; PRAGMA trusted_schema=OFF");
-    if (!readOnly) {
-        if (db.prepare("PRAGMA journal_mode").get()?.journal_mode !== "wal") {
-            // WAL conversion upgrades without waiting for a writer. Admit that writer natively first.
-            db.exec("BEGIN IMMEDIATE; COMMIT; PRAGMA journal_mode=WAL");
-        }
-        db.exec("PRAGMA synchronous=FULL");
-        sidecarPermissions(file);
-    }
-}
-export function openHistoryDatabase(file, readOnly = false) {
-    if (fs.existsSync(file) && fs.lstatSync(file).isSymbolicLink()) {
-        throw new HistoryIndexError("UNSAFE_PATH", "History database must not be a symbolic link.");
-    }
-    for (let attempt = 0;; attempt++) {
-        const db = new DatabaseSync(file, {
-            timeout: 100,
-            defensive: true,
-            allowExtension: false,
-            readOnly,
-        });
-        try {
-            initialize(db, file, readOnly);
-            return db;
-        }
-        catch (error) {
-            db.close();
-            if (readOnly || attempt >= 2 || !/locked|busy/i.test(errorMessage(error))) {
-                throw error;
-            }
-            // Concurrent first-open WAL conversion may return BUSY without the native timeout.
-            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
-        }
-    }
-}
-export function historyTransaction(db, work) {
-    for (let attempt = 0;; attempt++) {
-        try {
-            db.exec("BEGIN IMMEDIATE");
-            const result = work();
-            db.exec("COMMIT");
-            return result;
-        }
-        catch (error) {
-            if (db.isTransaction) {
-                db.exec("ROLLBACK");
-            }
-            if (attempt >= 2 || !/locked|busy/i.test(errorMessage(error))) {
-                throw error;
-            }
-        }
-    }
-}

package/dist/history/entry-ingestion.js

@@ -1,61 +0,0 @@
-import { compactEntry, visibleId } from "./preview.js";
-import { object, objects, string } from "./values.js";
-import { text } from "./rows.js";
-function model(value) {
-    if (value.type === "model_change" && typeof value.modelId === "string") {
-        return `${string(value.provider) ?? "undefined"}/${value.modelId}`;
-    }
-    const message = object(value.message);
-    if (value.type === "message" &&
-        message.role === "assistant" &&
-        typeof message.model === "string") {
-        return `${string(message.provider) ?? "undefined"}/${message.model}`;
-    }
-    return null;
-}
-function messageFacts(value) {
-    const message = object(value.message);
-    const assistantText = message.role === "assistant" &&
-        objects(message.content).some((part) => part.type === "text" && typeof part.text === "string" && part.text.length > 0);
-    const humanId = object(object(value.details).message).id;
-    return [
-        string(message.role) ?? null,
-        assistantText ? 1 : 0,
-        value.type === "custom_message" && value.customType === "subagent-human-message"
-            ? (string(humanId) ?? null)
-            : null,
-        model(value),
-        value.type === "thinking_level_change" ? (string(value.thinkingLevel) ?? null) : null,
-    ];
-}
-function parentId(store, source, value) {
-    if (source.format_version !== 1) {
-        return string(value.parentId) ?? null;
-    }
-    const previous = store.get("SELECT id FROM entries WHERE source_id=? AND generation=? AND published=1 ORDER BY start DESC LIMIT 1", source.id, source.generation);
-    return previous ? text(previous, "id") : null;
-}
-/** Preview and ancestry facts are staged first, never query-visible before the final publication transaction. */
-export function stageEntry(store, source, record) {
-    const value = record.value;
-    const nativeId = string(value.id) ?? null;
-    const id = nativeId ?? `legacy-${record.start}`;
-    const parent = parentId(store, source, value);
-    const timestamp = typeof value.timestamp === "number"
-        ? value.timestamp
-        : Date.parse(string(value.timestamp) ?? "");
-    const preview = { ...compactEntry(value), id, parentId: parent };
-    const [role, assistantText, humanId, configurationModel, thinking] = messageFacts(value);
-    return Number(store.run("INSERT INTO entries(source_id,generation,id,native_id,parent_id,start,end,digest,timestamp,type,preview,role,assistant_text,visible_id,human_id,configuration_model,configuration_thinking) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", source.id, source.generation, id, nativeId, parent, record.start, record.end, record.digest, Number.isFinite(timestamp) ? timestamp : null, string(value.type) ?? "unknown", JSON.stringify(preview), role, assistantText, visibleId(value, id), humanId, configurationModel, thinking).lastInsertRowid);
-}
-export function publishTools(store, source, rowid, value) {
-    const message = object(value.message);
-    for (const part of objects(message.content)) {
-        if (part.type === "toolCall" && typeof part.id === "string") {
-            store.run("INSERT INTO tools VALUES (?,?,?,?,?)", rowid, source.id, source.generation, part.id, "call");
-        }
-    }
-    if (message.role === "toolResult" && typeof message.toolCallId === "string") {
-        store.run("INSERT INTO tools VALUES (?,?,?,?,?)", rowid, source.id, source.generation, message.toolCallId, "result");
-    }
-}

package/dist/history/index.js

@@ -1,344 +0,0 @@
-import { fork } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import * as path from "node:path";
-import { HistoryIndexError, } from "./types.js";
-import { requirePiPackageRoot } from "../runs/shared/pi-spawn.js";
-import { isRecord } from "../shared/unknown.js";
-import { parseRunPage, parsePage, parseSearchPage, parseStatus, parseEntry, parseResult, parseNothing, parseBoolean, parseResponse, } from "./wire-models.js";
-export * from "./types.js";
-/** Disposable browse process. Authoritative ownership/control/receipt checks stay outside this engine. */
-export class SubagentHistoryIndex {
-    process;
-    children = new Map();
-    owner;
-    ready;
-    unavailable;
-    closed = false;
-    closing;
-    sequence = 0;
-    pending = new Map();
-    listeners = new Set();
-    agentDir;
-    constructor(agentDir) {
-        this.agentDir = path.resolve(agentDir);
-    }
-    get failure() {
-        return this.unavailable;
-    }
-    track(child) {
-        const completed = new Promise((resolve) => {
-            const exited = () => {
-                child.removeListener("exit", exited);
-                child.removeListener("close", exited);
-                this.children.delete(child);
-                resolve();
-            };
-            // Disconnected IPC can exit without close; failed spawn instead reports close.
-            child.once("exit", exited);
-            child.once("close", exited);
-        });
-        this.children.set(child, completed);
-    }
-    message(child, value) {
-        if (child !== this.process) {
-            return;
-        }
-        try {
-            const response = parseResponse(value);
-            if ("changed" in response) {
-                this.notify();
-                return;
-            }
-            const pending = this.pending.get(response.id);
-            if (!pending) {
-                return;
-            }
-            this.pending.delete(response.id);
-            pending.cleanup();
-            if (response.error) {
-                pending.reject(new HistoryIndexError(response.error.code, response.error.message));
-            }
-            else {
-                pending.resolve(response.value);
-            }
-        }
-        catch {
-            this.stop(new HistoryIndexError("INVALID", "Invalid history IPC response."), child);
-        }
-    }
-    notify() {
-        for (const listener of this.listeners) {
-            try {
-                listener();
-            }
-            catch {
-                // Consumer failure cannot strand IPC requests.
-            }
-        }
-    }
-    spawn() {
-        const child = fork(fileURLToPath(new URL(`worker${import.meta.url.endsWith(".ts") ? ".ts" : ".js"}`, import.meta.url)), [this.agentDir], {
-            execArgv: [],
-            stdio: ["ignore", "ignore", "ignore", "ipc"],
-            serialization: "advanced",
-            env: {
-                ...process.env,
-                PI_PACKAGE_DIR: requirePiPackageRoot(),
-                PI_CODING_AGENT_DIR: this.agentDir,
-            },
-        });
-        this.unavailable = undefined;
-        this.process = child;
-        this.track(child);
-        child.on("message", (message) => {
-            this.message(child, message);
-        });
-        child.on("error", () => {
-            this.stop(new HistoryIndexError("UNAVAILABLE", "History process could not start."), child);
-        });
-        child.on("exit", () => {
-            this.stop(new HistoryIndexError("UNAVAILABLE", "History process exited; retry to reopen the disposable index."), child);
-        });
-    }
-    stop(error, child = this.process, kill = true) {
-        if (!child || child !== this.process) {
-            return;
-        }
-        this.unavailable = error;
-        this.process = undefined;
-        this.ready = undefined;
-        for (const pending of this.pending.values()) {
-            pending.cleanup();
-            pending.reject(error);
-        }
-        this.pending.clear();
-        if (kill && child.exitCode === null && child.signalCode === null) {
-            child.kill("SIGKILL");
-        }
-    }
-    send(method, input, decode, options = {}) {
-        if (this.closed) {
-            return Promise.reject(new HistoryIndexError("CLOSED", "History index is closed."));
-        }
-        if (options.signal?.aborted === true) {
-            return Promise.reject(new HistoryIndexError("CANCELLED", "History request cancelled."));
-        }
-        const child = this.process;
-        if (!child || !child.connected) {
-            return Promise.reject(new HistoryIndexError("UNAVAILABLE", "History process is unavailable."));
-        }
-        return new Promise((resolve, reject) => {
-            const id = ++this.sequence;
-            const cancel = () => {
-                this.stop(new HistoryIndexError("CANCELLED", "History request cancelled; the process was stopped and can be reopened."), child);
-            };
-            const timer = setTimeout(() => {
-                this.stop(new HistoryIndexError("DEADLINE", "History request exceeded its process deadline; retry or narrow the query."), child);
-            }, options.timeout ?? 3000);
-            timer.unref();
-            this.pending.set(id, {
-                resolve: (value) => {
-                    try {
-                        resolve(decode(value));
-                    }
-                    catch (error) {
-                        reject(error instanceof Error
-                            ? error
-                            : new HistoryIndexError("INVALID", "History IPC decoding failed."));
-                    }
-                },
-                reject,
-                cleanup: () => {
-                    clearTimeout(timer);
-                    options.signal?.removeEventListener("abort", cancel);
-                },
-            });
-            options.signal?.addEventListener("abort", cancel, { once: true });
-            child.send({ id, method, input }, (error) => {
-                if (error) {
-                    this.stop(new HistoryIndexError("UNAVAILABLE", "History IPC failed."), child);
-                }
-            });
-        });
-    }
-    async ensure() {
-        if (this.closed) {
-            throw new HistoryIndexError("CLOSED", "History index is closed.");
-        }
-        if (this.unavailable) {
-            throw this.unavailable;
-        }
-        if (!this.owner) {
-            throw new HistoryIndexError("NO_OWNER", "Set genuine restored ownership before querying history.");
-        }
-        if (!this.process) {
-            await Promise.all(this.children.values());
-            // close() and setOwner() can change lifecycle state while old children exit.
-            // oxlint-disable-next-line typescript/no-unnecessary-condition
-            if (this.closed) {
-                throw new HistoryIndexError("CLOSED", "History index is closed.");
-            }
-            // setOwner() may install a replacement while this ensure() waits for child exit.
-            // oxlint-disable-next-line typescript/no-unnecessary-condition
-            if (this.process === undefined) {
-                this.spawn();
-                this.ready = this.send("setOwner", this.owner, parseNothing, { timeout: 15_000 });
-            }
-        }
-        await this.ready;
-    }
-    /** Arms an ordinary deadline only in the continuation that saw the current admission and worker settle, never behind a replacement admission. */
-    async admitted(method, input, decode, options = {}) {
-        await this.ensure();
-        const ready = this.ready;
-        const child = this.process;
-        await ready;
-        // setOwner() or a restart may have replaced readiness during either await; wait for the replacement.
-        if (!child || ready !== this.ready || child !== this.process) {
-            return this.admitted(method, input, decode, options);
-        }
-        return this.send(method, input, decode, options);
-    }
-    async setOwner(input) {
-        if (this.closed) {
-            throw new HistoryIndexError("CLOSED", "History index is closed.");
-        }
-        if (!this.process) {
-            await Promise.all(this.children.values());
-        }
-        // close() may run while the previous child is exiting.
-        // oxlint-disable-next-line typescript/no-unnecessary-condition
-        if (this.closed) {
-            throw new HistoryIndexError("CLOSED", "History index is closed.");
-        }
-        const snapshot = structuredClone(input);
-        if (snapshot.ownerSessionId.length === 0 ||
-            snapshot.runs.some((run) => run.ownerSessionId !== snapshot.ownerSessionId)) {
-            throw new HistoryIndexError("OWNERSHIP", "Every run must belong to the current owner session.");
-        }
-        if (new Set(snapshot.runs.map((run) => run.runId)).size !== snapshot.runs.length) {
-            throw new HistoryIndexError("INVALID", "Duplicate owned run IDs.");
-        }
-        this.owner = snapshot;
-        if (!this.process) {
-            this.spawn();
-        }
-        this.ready = this.send("setOwner", snapshot, parseNothing, { timeout: 15_000 });
-        await this.ready;
-    }
-    async updateRun(run, foreground) {
-        await this.ensure();
-        const owner = this.owner;
-        if (!owner ||
-            run.ownerSessionId !== owner.ownerSessionId ||
-            (foreground && foreground.runId !== run.runId)) {
-            throw new HistoryIndexError("OWNERSHIP", "Run does not belong to the current owner.");
-        }
-        const copy = structuredClone(run);
-        const fg = foreground === undefined ? undefined : structuredClone(foreground);
-        await this.admitted("updateRun", { run: copy, foreground: fg }, parseNothing);
-        const current = this.owner;
-        if (!current || current.ownerSessionId !== owner.ownerSessionId) {
-            throw new HistoryIndexError("OWNER_CHANGED", "History owner changed during run update.");
-        }
-        this.owner = {
-            ...current,
-            runs: [...current.runs.filter((entry) => entry.runId !== run.runId), copy],
-            ...(fg
-                ? {
-                    foregroundRuns: [
-                        ...(current.foregroundRuns ?? []).filter((entry) => entry.runId !== run.runId),
-                        fg,
-                    ],
-                }
-                : {}),
-        };
-    }
-    async query(method, input, decode) {
-        const { signal, ...wire } = input;
-        return this.admitted(method, wire, decode, { signal });
-    }
-    async needsControls() {
-        return this.admitted("needsControls", undefined, parseBoolean, { timeout: 15_000 });
-    }
-    listRuns(options = {}) {
-        return this.query("listRuns", options, parseRunPage);
-    }
-    historyPage(input) {
-        return this.query("historyPage", input, parsePage);
-    }
-    search(input) {
-        return this.query("search", input, parseSearchPage);
-    }
-    status() {
-        return this.query("status", {}, parseStatus);
-    }
-    entry(input) {
-        return this.query("entry", input, parseEntry);
-    }
-    record(input) {
-        return this.query("record", input, (value) => {
-            if (value === null) {
-                return null;
-            }
-            if (!isRecord(value)) {
-                throw new HistoryIndexError("INVALID", "Invalid history detail response.");
-            }
-            return value;
-        });
-    }
-    result(input) {
-        return this.query("result", input, parseResult);
-    }
-    async refresh(runId, options = {}) {
-        if (!this.closed) {
-            this.unavailable = undefined;
-        }
-        return this.admitted("refresh", { runId }, parseNothing, {
-            signal: options.signal,
-            timeout: 120_000,
-        });
-    }
-    onChanged(listener) {
-        this.listeners.add(listener);
-        return () => {
-            this.listeners.delete(listener);
-        };
-    }
-    cancel() {
-        this.stop(new HistoryIndexError("CANCELLED", "History process cancelled; explicitly refresh or retry to reopen it."));
-    }
-    async waitForChildren(timers) {
-        await Promise.all(this.children.values());
-        for (const timer of timers) {
-            clearTimeout(timer);
-        }
-    }
-    close() {
-        if (this.closing) {
-            return this.closing;
-        }
-        const child = this.process;
-        this.closed = true;
-        this.listeners.clear();
-        this.unavailable ??= new HistoryIndexError("CLOSED", "History index closed.");
-        const timers = [...this.children.keys()].map((owned) => {
-            const timer = setTimeout(() => {
-                owned.kill("SIGKILL");
-            }, 1000);
-            timer.unref();
-            return timer;
-        });
-        this.closing = this.waitForChildren(timers);
-        if (child) {
-            this.stop(new HistoryIndexError("CLOSED", "History index closed."), child, false);
-            if (child.connected) {
-                child.disconnect();
-            }
-            else {
-                child.kill("SIGKILL");
-            }
-        }
-        return this.closing;
-    }
-}