@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/dist/extension/tool-input.js

@@ -1,20 +1,35 @@
 import { Compile } from "../shared/native-typebox.js";
+import { isRecord } from "../shared/unknown.js";
 import { AgentRunsValidationParams } from "./schemas.js";
 const runArguments = Compile(AgentRunsValidationParams);
+function normalizeVerificationEnvironment(verify) {
+    if (!isRecord(verify) || !Array.isArray(verify.env)) {
+        return verify;
+    }
+    const entries = verify.env.map((entry) => {
+        if (!isRecord(entry) || typeof entry.name !== "string" || typeof entry.value !== "string") {
+            throw new Error("Verification environment entries require string names and values.");
+        }
+        return [entry.name, entry.value];
+    });
+    if (new Set(entries.map(([name]) => name)).size !== entries.length) {
+        throw new Error("Verification environment contains duplicate names.");
+    }
+    return { ...verify, env: Object.fromEntries(entries) };
+}
 export function normalizeEverydayParams(params, control = false) {
     const acceptance = params.acceptance;
-    const normalized = acceptance?.verify ? {
-        ...params,
-        acceptance: { ...acceptance, verify: acceptance.verify.map((verify) => {
-                if (!Array.isArray(verify.env))
-                    return verify;
-                const names = verify.env.map(({ name }) => name);
-                if (new Set(names).size !== names.length)
-                    throw new Error("Verification environment contains duplicate names.");
-                return { ...verify, env: Object.fromEntries(verify.env.map(({ name, value }) => [name, value])) };
-            }) },
-    } : params;
-    if (control && !runArguments.Check(normalized))
+    const normalized = isRecord(acceptance) && Array.isArray(acceptance.verify)
+        ? {
+            ...params,
+            acceptance: {
+                ...acceptance,
+                verify: acceptance.verify.map((verify) => normalizeVerificationEnvironment(verify)),
+            },
+        }
+        : params;
+    if (control && !runArguments.Check(normalized)) {
         throw new Error(`Invalid agent_runs arguments: ${[...runArguments.Errors(normalized)].map((error) => error.message).join("; ")}`);
+    }
     return normalized;
 }

package/dist/extension/tool-result.js

@@ -1,14 +1,29 @@
+import { isRecord } from "../shared/unknown.js";
+import { copyExecutionResult } from "./result-snapshot.js";
+import { finalizedChildUsage } from "../runs/shared/parent-usage.js";
+/** Only completed, directly owned waits carry accounting intent to the native result boundary. */
+export function adaptFinalizedToolResult(result, ctx, parentUsage, adapt) {
+    const attached = result.details.wait?.status === "completed" &&
+        result.details.run?.ownerSessionId === ctx.sessionManager.getSessionId()
+        ? parentUsage.attach(result, finalizedChildUsage(result.details.run.children, result.details.wait.index), ctx)
+        : result;
+    return adapt(attached);
+}
 export function registerToolResultAdapter(pi, toolNames) {
     pi.on("tool_result", (event) => {
         const details = event.details;
-        if (!toolNames.includes(event.toolName) || details?.isError !== true)
+        if (!toolNames.includes(event.toolName) || !isRecord(details) || details.isError !== true) {
             return;
+        }
         const { isError, ...originalDetails } = details;
         return { isError, details: originalDetails };
     });
     // Native execute ignores returned isError; throwing discards content/details.
     // Carry the flag to its native result hook, which restores the original details.
-    return (result) => result.isError
-        ? { ...result, details: { ...result.details, isError: true } }
-        : result;
+    return (result) => {
+        const snapshot = copyExecutionResult(result);
+        return result.isError === true
+            ? { ...snapshot, details: { ...snapshot.details, isError: true } }
+            : snapshot;
+    };
 }

package/dist/history/answer-texts.js

@@ -0,0 +1,57 @@
+import { stripTerminalSequences } from "../shared/native-tui.js";
+import { stripAcceptanceReport } from "../runs/shared/acceptance-reports.js";
+import { exactTextDigest } from "./store.js";
+import { object, objects, string } from "./values.js";
+/** Exact matches never use previews. Oversized selected text has no fingerprint. */
+export class AnswerTexts {
+    fields = new Map();
+    length = 0;
+    unavailable = false;
+    write(keys, text) {
+        if (this.unavailable ||
+            keys.length !== 4 ||
+            keys[0] !== "message" ||
+            keys[1] !== "content" ||
+            !["text", "thinking"].includes(String(keys[3]))) {
+            return;
+        }
+        this.length += text.length;
+        if (this.length > 16 * 1024 * 1024 || Number(keys[2]) >= 4096) {
+            this.unavailable = true;
+            this.fields.clear();
+            return;
+        }
+        const index = Number(keys[2]);
+        this.fields.set(index, (this.fields.get(index) ?? "") + text);
+    }
+    partText(part, index) {
+        if (part.type === "text" || part.type === "thinking") {
+            return stripTerminalSequences(this.fields.get(index) ?? "");
+        }
+        return part.type === "image" ? `[Image: ${string(part.mimeType) ?? "image"}]` : "";
+    }
+    fingerprints(value, id) {
+        const message = object(value.message);
+        if (this.unavailable || value.type !== "message" || message.role !== "assistant") {
+            return [];
+        }
+        const content = objects(message.content);
+        const first = content.findIndex((part, index) => (part.type === "text" || part.type === "thinking") &&
+            (this.fields.get(index)?.length ?? 0) > 0);
+        if (first < 0 ||
+            !content.some((part, index) => part.type === "text" && (this.fields.get(index)?.length ?? 0) > 0)) {
+            return [];
+        }
+        const item = `${id}:${first}`;
+        const parts = content
+            .map((part, index) => this.partText(part, index))
+            .filter((text) => text.length > 0);
+        const texts = [
+            parts.join("\n"),
+            ...content.flatMap((part, index) => part.type === "text" ? [stripTerminalSequences(this.fields.get(index) ?? "")] : []),
+        ];
+        return [
+            ...new Set(texts.map((text) => stripAcceptanceReport(text).trim()).filter((text) => text.length > 0)),
+        ].map((text) => [exactTextDigest(text), item]);
+    }
+}

package/dist/history/canonical-result.js

@@ -2,78 +2,111 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { JsonProjection, readJsonProjection } from "../shared/journal-reader.js";
 import { HistoryIndexError } from "./types.js";
+import { at, object, objects } from "./values.js";
 const budget = 16 * 1024 * 1024;
+function unchanged(file, fd, before) {
+    const after = fs.fstatSync(fd, { bigint: true });
+    const current = fs.statSync(file, { bigint: true });
+    if (before.size !== after.size ||
+        before.ctimeNs !== after.ctimeNs ||
+        before.dev !== current.dev ||
+        before.ino !== current.ino) {
+        throw new HistoryIndexError("SOURCE_CHANGED", "Selected output changed; retry details.");
+    }
+}
 export function readSavedOutput(file) {
     const fd = fs.openSync(file, "r");
     try {
         const before = fs.fstatSync(fd, { bigint: true });
-        if (!before.isFile() || before.size > BigInt(budget))
+        if (!before.isFile() || before.size > BigInt(budget)) {
             throw new HistoryIndexError("RECORD_TOO_LARGE", "Selected saved output exceeds the 16 MiB detail budget.");
+        }
         const bytes = Buffer.alloc(Number(before.size));
         for (let offset = 0; offset < bytes.length;) {
             const count = fs.readSync(fd, bytes, offset, bytes.length - offset, offset);
-            if (!count)
+            if (count === 0) {
                 throw new HistoryIndexError("SOURCE_CHANGED", "Selected saved output was truncated.");
+            }
             offset += count;
         }
-        const after = fs.fstatSync(fd, { bigint: true }), current = fs.statSync(file, { bigint: true });
-        if (before.size !== after.size || before.ctimeNs !== after.ctimeNs || before.dev !== current.dev || before.ino !== current.ino)
-            throw new HistoryIndexError("SOURCE_CHANGED", "Selected saved output changed; retry details.");
+        unchanged(file, fd, before);
         return new TextDecoder("utf8", { fatal: true }).decode(bytes);
     }
     finally {
         fs.closeSync(fd);
     }
 }
-/** Explicit legacy/compact owner detail: retain only this child's output, never transcript arrays. */
-export function readCanonicalOutput(file, index) {
-    let prefix;
-    if (path.basename(file) === "foreground.json") {
-        const metadata = readJsonProjection(file, (keys) => !keys.length || keys[0] === "children" && (keys.length <= 2 || keys.length === 3 && keys[2] === "index"));
-        const position = metadata.children?.findIndex((child) => child?.index === index);
-        if (position === undefined || position < 0)
-            return;
-        prefix = ["children", position, "result"];
+function childPrefix(file, index) {
+    if (path.basename(file) !== "foreground.json") {
+        return path.basename(file) === "result.json" ? ["results", index] : ["result"];
     }
-    else
-        prefix = path.basename(file) === "result.json" ? ["results", index] : ["result"];
+    const metadata = readJsonProjection(file, (keys) => keys.length === 0 ||
+        (keys[0] === "children" && (keys.length <= 2 || (keys.length === 3 && keys[2] === "index"))));
+    const position = objects(object(metadata).children).findIndex((child) => child.index === index);
+    return position < 0 ? undefined : ["children", position, "result"];
+}
+function isOutput(keys, prefix) {
+    return (keys.length === prefix.length + 1 &&
+        prefix.every((key, position) => key === keys[position]) &&
+        ["finalOutput", "output"].includes(String(keys.at(-1))));
+}
+function outputProjection(prefix) {
     let length = 0;
-    const projection = new JsonProjection((keys) => {
-        if (prefix[0] === "children" && keys.length === 3 && keys[0] === "children" && keys[1] === prefix[1] && keys[2] === "index")
+    return new JsonProjection((keys) => {
+        if (prefix[0] === "children" &&
+            keys.length === 3 &&
+            keys[0] === "children" &&
+            keys[1] === prefix[1] &&
+            keys[2] === "index") {
             return true;
-        if (keys.length <= prefix.length)
+        }
+        if (keys.length <= prefix.length) {
             return keys.every((key, position) => key === prefix[position]);
-        return keys.length === prefix.length + 1 && prefix.every((key, position) => key === keys[position]) && ["finalOutput", "output"].includes(String(keys.at(-1))) ? budget : false;
+        }
+        return isOutput(keys, prefix) ? budget : false;
     }, (keys, text) => {
-        if (keys.length === prefix.length + 1 && prefix.every((key, position) => key === keys[position]) && ["finalOutput", "output"].includes(String(keys.at(-1)))) {
+        if (isOutput(keys, prefix)) {
             length += Buffer.byteLength(text);
-            if (length > budget)
+            if (length > budget) {
                 throw new HistoryIndexError("RECORD_TOO_LARGE", "Selected canonical output exceeds the 16 MiB detail budget.");
+            }
         }
     });
-    const fd = fs.openSync(file, "r"), decoder = new TextDecoder("utf8", { fatal: true });
-    try {
-        const before = fs.fstatSync(fd, { bigint: true }), bytes = Buffer.allocUnsafe(64 * 1024);
-        for (let offset = 0; offset < Number(before.size);) {
-            const count = fs.readSync(fd, bytes, 0, Math.min(bytes.length, Number(before.size) - offset), offset);
-            if (!count)
-                throw new HistoryIndexError("SOURCE_CHANGED", "Selected canonical output was truncated.");
-            projection.write(decoder.decode(bytes.subarray(0, count), { stream: true }));
-            offset += count;
+}
+function readProjection(fd, size, projection) {
+    const decoder = new TextDecoder("utf8", { fatal: true });
+    const bytes = Buffer.allocUnsafe(64 * 1024);
+    for (let offset = 0; offset < size;) {
+        const count = fs.readSync(fd, bytes, 0, Math.min(bytes.length, size - offset), offset);
+        if (count === 0) {
+            throw new HistoryIndexError("SOURCE_CHANGED", "Selected canonical output was truncated.");
         }
-        projection.write(decoder.decode());
-        const value = projection.finish(), after = fs.fstatSync(fd, { bigint: true }), current = fs.statSync(file, { bigint: true });
-        if (prefix[0] === "children" && value?.children?.[prefix[1]]?.index !== index)
+        projection.write(decoder.decode(bytes.subarray(0, count), { stream: true }));
+        offset += count;
+    }
+    projection.write(decoder.decode());
+    return projection.finish();
+}
+/** Explicit legacy/compact owner detail: retain only this child's output, never transcript arrays. */
+export function readCanonicalOutput(file, index) {
+    const prefix = childPrefix(file, index);
+    if (!prefix) {
+        return;
+    }
+    const projection = outputProjection(prefix);
+    const fd = fs.openSync(file, "r");
+    try {
+        const before = fs.fstatSync(fd, { bigint: true });
+        const value = readProjection(fd, Number(before.size), projection);
+        if (prefix[0] === "children" && at(value, ["children", Number(prefix[1]), "index"]) !== index) {
             throw new HistoryIndexError("SOURCE_CHANGED", "Selected canonical child changed; retry details.");
-        if (before.size !== after.size || before.ctimeNs !== after.ctimeNs || before.dev !== current.dev || before.ino !== current.ino)
-            throw new HistoryIndexError("SOURCE_CHANGED", "Selected canonical output changed; retry details.");
-        let child = value;
-        for (const key of prefix)
-            child = child && typeof child === "object" ? child[key] : undefined;
-        if (!child || typeof child !== "object")
-            return;
-        const result = child;
-        return typeof result.finalOutput === "string" ? result.finalOutput : typeof result.output === "string" ? result.output : undefined;
+        }
+        unchanged(file, fd, before);
+        const result = object(at(value, prefix));
+        if (typeof result.finalOutput === "string") {
+            return result.finalOutput;
+        }
+        return typeof result.output === "string" ? result.output : undefined;
     }
     finally {
         fs.closeSync(fd);

package/dist/history/canonical-selection.js

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,82 @@
+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

@@ -2,54 +2,76 @@ 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)
+    if (create) {
         fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
-    if (fs.lstatSync(directory).isSymbolicLink())
+    }
+    if (fs.lstatSync(directory).isSymbolicLink()) {
         throw new HistoryIndexError("UNSAFE_PATH", "History directory must not be a symbolic link.");
-    if (create)
+    }
+    if (create) {
         fs.chmodSync(directory, 0o700);
-    const filesystem = fs.statfsSync(directory).type;
-    if ([0x6969, 0x517b, 0xff534d42].includes(filesystem))
+    }
+    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())
+    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 });
+        const db = new DatabaseSync(file, {
+            timeout: 100,
+            defensive: true,
+            allowExtension: false,
+            readOnly,
+        });
         try {
-            const version = String(db.prepare("SELECT sqlite_version() AS version").get().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 a read lock without waiting for an existing writer.
-                    // Wait for that writer through native transaction admission before converting.
-                    db.exec("BEGIN IMMEDIATE; COMMIT; PRAGMA journal_mode=WAL");
-                }
-                db.exec("PRAGMA synchronous=FULL");
-                for (const suffix of ["", "-wal", "-shm"]) {
-                    try {
-                        fs.chmodSync(file + suffix, 0o600);
-                    }
-                    catch (error) {
-                        // SQLite can remove its sidecars when the last attached connection closes.
-                        if (!suffix || !(error instanceof Error) || !("code" in error) || error.code !== "ENOENT")
-                            throw error;
-                    }
-                }
-            }
+            initialize(db, file, readOnly);
             return db;
         }
         catch (error) {
             db.close();
-            if (readOnly || attempt >= 2 || !/locked|busy/i.test(String(error.message)))
+            if (readOnly || attempt >= 2 || !/locked|busy/i.test(errorMessage(error))) {
                 throw error;
-            // Concurrent first-open WAL conversion can return BUSY without honoring the native timeout.
+            }
+            // Concurrent first-open WAL conversion may return BUSY without the native timeout.
             Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
         }
     }
@@ -63,10 +85,12 @@ export function historyTransaction(db, work) {
             return result;
         }
         catch (error) {
-            if (db.isTransaction)
+            if (db.isTransaction) {
                 db.exec("ROLLBACK");
-            if (attempt >= 2 || !/locked|busy/i.test(String(error.message)))
+            }
+            if (attempt >= 2 || !/locked|busy/i.test(errorMessage(error))) {
                 throw error;
+            }
         }
     }
 }

package/dist/history/entry-ingestion.js

@@ -0,0 +1,61 @@
+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");
+    }
+}