@fitchmultz/pi-subagents 0.49.0 → 0.50.0

package/dist/history/search-queries.js

@@ -1,169 +0,0 @@
-import { HistoryIndexError, } from "./types.js";
-import { integer, pageLimit, hasText } from "./text.js";
-import { number, nullableNumber, nullableText, text } from "./rows.js";
-function searchGrammar(query) {
-    if (typeof query !== "string" || query.trim().length === 0 || query.length > 1024) {
-        throw new HistoryIndexError("INVALID_QUERY", "Search requires 1–12 tokens or one quoted phrase.");
-    }
-    const value = query.trim();
-    const phrase = value.startsWith('"') && value.endsWith('"');
-    const words = (phrase ? value.slice(1, -1) : value).trim().split(/\s+/u);
-    if (words.length === 0 ||
-        words.length > 12 ||
-        words.some((word) => !/^[\p{L}\p{N}\p{M}]{1,64}$/u.test(word) ||
-            (!phrase && ["AND", "OR", "NOT", "NEAR"].includes(word)))) {
-        throw new HistoryIndexError("INVALID_QUERY", "Only lexical tokens or one quoted phrase are supported; operators, punctuation, and prefixes are not allowed.");
-    }
-    return phrase ? [`"${words.join(" ")}"`] : [...new Set(words.map((word) => `"${word}"`))];
-}
-function match(row) {
-    return {
-        id: number(row, "document_id"),
-        runId: text(row, "run_id"),
-        index: number(row, "child_index"),
-        agent: text(row, "agent"),
-        entryId: text(row, "id"),
-        nativeId: nullableText(row, "native_id"),
-        sessionId: nullableText(row, "session_id"),
-        sessionFile: text(row, "path"),
-        timestamp: nullableNumber(row, "timestamp"),
-        ref: {
-            sourceId: text(row, "source_id"),
-            generation: number(row, "generation"),
-            start: number(row, "start"),
-            end: number(row, "end"),
-            digest: text(row, "digest"),
-        },
-        preview: text(row, "document_preview"),
-        field: text(row, "field"),
-        textStart: number(row, "text_start"),
-        textEnd: number(row, "text_end"),
-        score: number(row, "score"),
-    };
-}
-function plan(input, expression, cursor, score) {
-    const clauses = [
-        "e.published=1",
-        "e.generation=s.generation",
-        "(c.terminal_entry_id IS NULL OR e.start<=terminal.start)",
-        "(c.ended_at IS NULL OR e.timestamp<=c.ended_at)",
-    ];
-    const params = [...expression];
-    if (hasText(input.runId)) {
-        clauses.push("c.run_id=?");
-        params.push(input.runId);
-    }
-    if (input.index !== undefined) {
-        clauses.push("c.child_index=?");
-        params.push(input.index);
-    }
-    if (hasText(input.agent)) {
-        if (input.agent.length > 256) {
-            throw new HistoryIndexError("INVALID", "Agent filter is too long.");
-        }
-        clauses.push("c.agent=?");
-        params.push(input.agent);
-    }
-    // Materialized IDs reject common out-of-scope postings without per-hit entry lookups.
-    // Each source is scoped once; bm25 still uses the whole corpus.
-    const eligible = hasText(input.runId) || hasText(input.agent)
-        ? `eligible AS MATERIALIZED (SELECT e.rowid FROM entries e JOIN sources s ON s.id=e.source_id WHERE e.published=1 AND e.generation=s.generation AND e.source_id IN (SELECT c.source_id FROM children c WHERE ${clauses.slice(4).join(" AND ")})),`
-        : "";
-    const eligibleParams = eligible.length > 0 ? params.slice(expression.length) : [];
-    if (cursor) {
-        if (cursor.keys.length !== 4) {
-            throw new HistoryIndexError("INVALID_CURSOR", "Invalid search seek tuple.");
-        }
-        clauses.push(`(${score},d.id,c.run_id,c.child_index)>(?,?,?,?)`);
-        params.push(...cursor.keys);
-    }
-    return { clauses, params, eligible, eligibleParams };
-}
-function queryKey(scope, input, expression, sort) {
-    return scope.key([
-        "search",
-        expression,
-        sort,
-        input.runId ?? null,
-        input.index ?? null,
-        input.agent ?? null,
-    ]);
-}
-export class SearchQueries {
-    scope;
-    constructor(scope) {
-        this.scope = scope;
-    }
-    validateScope(input) {
-        if (input.index !== undefined && !hasText(input.runId)) {
-            throw new HistoryIndexError("INVALID", "A child search requires runId.");
-        }
-        if (!hasText(input.runId)) {
-            return;
-        }
-        if (!this.scope.store.get("SELECT id FROM runs WHERE id=?", input.runId)) {
-            throw new HistoryIndexError("OWNERSHIP", "Run is not admitted by the current owner.");
-        }
-        if (input.index !== undefined) {
-            this.scope.child(input.runId, integer(input.index, 0));
-        }
-        this.checkAttemptBoundaries(input);
-    }
-    checkAttemptBoundaries(input) {
-        for (const child of this.scope.store.all(`SELECT source_id,terminal_entry_id,ended_at FROM children WHERE run_id=?${input.index !== undefined ? " AND child_index=?" : ""}`, input.runId ?? "", ...(input.index !== undefined ? [input.index] : []))) {
-            const sourceId = nullableText(child, "source_id");
-            const source = sourceId === null ? undefined : this.scope.store.source(sourceId);
-            if (source) {
-                this.scope.boundary(source, {
-                    terminalEntryId: nullableText(child, "terminal_entry_id") ?? undefined,
-                    endedAt: nullableNumber(child, "ended_at") ?? undefined,
-                });
-            }
-        }
-    }
-    rows(expression, filter, score, limit) {
-        // Match every token across a record's visible windows; a quoted phrase cannot span fields.
-        // Relevance benefits from hit-driven attribution. Newest keeps the native join order:
-        // forcing hit order regresses newest sorting across many shared attempts.
-        const joined = score === "matched.score"
-            ? "FROM matched CROSS JOIN entries e ON e.rowid=matched.entry_rowid CROSS JOIN sources s ON s.id=e.source_id CROSS JOIN children c ON c.source_id=s.id JOIN excerpts ON excerpts.entry_rowid=matched.entry_rowid AND excerpts.choice=1 JOIN documents d ON d.id=excerpts.id"
-            : "FROM matched JOIN excerpts ON excerpts.entry_rowid=matched.entry_rowid AND excerpts.choice=1 JOIN documents d ON d.id=excerpts.id JOIN entries e ON e.rowid=matched.entry_rowid JOIN sources s ON s.id=e.source_id JOIN children c ON c.source_id=s.id";
-        // Ranking/filters precede LIMIT. The parent owns the hard deadline for a costly FTS scan.
-        return this.scope.store.all(`WITH ${filter.eligible} hits AS MATERIALIZED (
-      ${expression.map((_term, index) => `SELECT d.id,d.entry_rowid,bm25(corpus) AS score,${index} AS term FROM corpus JOIN documents d ON d.id=corpus.rowid WHERE corpus MATCH ?${filter.eligible.length > 0 ? " AND d.entry_rowid IN (SELECT rowid FROM eligible)" : ""}`).join(" UNION ALL ")}
-    ), terms AS (SELECT entry_rowid,term,MIN(score) AS score FROM hits GROUP BY entry_rowid,term),
-    matched AS (SELECT entry_rowid,SUM(score) AS score FROM terms GROUP BY entry_rowid HAVING COUNT(*)=${expression.length}),
-    excerpts AS (SELECT id,entry_rowid,ROW_NUMBER() OVER (PARTITION BY entry_rowid ORDER BY score,id) AS choice FROM hits)
-    SELECT d.*,${score} AS score,e.*,d.id AS document_id,s.path,s.session_id,c.run_id,c.child_index,c.agent,d.preview AS document_preview ${joined} LEFT JOIN entries terminal ON terminal.source_id=s.id AND terminal.generation=s.generation AND terminal.id=c.terminal_entry_id AND terminal.published=1 WHERE ${filter.clauses.join(" AND ")} ORDER BY score,d.id,c.run_id,c.child_index LIMIT ?`, ...filter.eligibleParams, ...filter.params, limit + 1);
-    }
-    search(input) {
-        const expression = searchGrammar(input.query);
-        const limit = pageLimit(input.limit, 20);
-        const sort = input.sort ?? "relevance";
-        if (!["relevance", "newest"].includes(sort)) {
-            throw new HistoryIndexError("INVALID", "Unsupported search sort.");
-        }
-        this.validateScope(input);
-        const query = queryKey(this.scope, input, expression, sort);
-        const cursor = this.scope.parseCursor(input.cursor, query);
-        const score = sort === "relevance" ? "matched.score" : "-COALESCE(e.timestamp,0)";
-        const filter = plan(input, expression, cursor, score);
-        const rows = this.rows(expression, filter, score, limit);
-        const page = rows.slice(0, limit);
-        const last = page.at(-1);
-        return {
-            ...this.scope.info(),
-            matches: page.map(match),
-            ...(rows.length > limit && last
-                ? {
-                    nextCursor: this.scope.cursor(query, [
-                        number(last, "score"),
-                        number(last, "document_id"),
-                        text(last, "run_id"),
-                        number(last, "child_index"),
-                    ], (cursor?.offset ?? 0) + page.length),
-                }
-                : {}),
-        };
-    }
-}

package/dist/history/selected-record.js

@@ -1,108 +0,0 @@
-import * as fs from "node:fs";
-import { createHash } from "node:crypto";
-import { JsonProjection } from "../shared/journal-reader.js";
-import { HistoryIndexError } from "./types.js";
-import { identity } from "./source-file.js";
-import { previewLimits, previewProjection } from "./preview.js";
-import { parseObject } from "./values.js";
-import { isRecord, hasErrorCode } from "../shared/unknown.js";
-function validateHeader(fd, source) {
-    const hash = createHash("sha256");
-    const bytes = Buffer.allocUnsafe(64 * 1024);
-    let position = 0;
-    let complete = false;
-    while (!complete && position < 1024 * 1024) {
-        const count = fs.readSync(fd, bytes, 0, bytes.length, position);
-        if (count === 0) {
-            break;
-        }
-        const newline = bytes.subarray(0, count).indexOf(10);
-        const length = newline < 0 ? count : newline + 1;
-        hash.update(bytes.subarray(0, length));
-        position += length;
-        complete = newline >= 0;
-    }
-    if (!complete || hash.digest("hex") !== source.header_digest) {
-        throw new HistoryIndexError("SOURCE_CHANGED", "Selected native header changed or exceeds its validation budget.");
-    }
-}
-function readBody(fd, row, full) {
-    const digest = createHash("sha256");
-    const parser = new JsonProjection(previewProjection, undefined, undefined, previewLimits);
-    const bytes = Buffer.allocUnsafe(64 * 1024);
-    const body = [];
-    const decoder = new TextDecoder("utf8", { fatal: true });
-    for (let position = row.start; position < row.end;) {
-        const count = fs.readSync(fd, bytes, 0, Math.min(bytes.length, row.end - position), position);
-        if (count === 0) {
-            throw new HistoryIndexError("SOURCE_CHANGED", "Selected record was truncated during validation.");
-        }
-        const chunk = bytes.subarray(0, count);
-        digest.update(chunk);
-        if (full) {
-            body.push(Buffer.from(chunk));
-        }
-        else {
-            parser.write(decoder.decode(chunk, { stream: true }));
-        }
-        position += count;
-    }
-    return {
-        digest: digest.digest("hex"),
-        finish: () => {
-            if (full) {
-                return parseObject(new TextDecoder("utf8", { fatal: true }).decode(Buffer.concat(body)));
-            }
-            parser.write(decoder.decode());
-            const projected = parser.finish();
-            if (!isRecord(projected)) {
-                throw new HistoryIndexError("SOURCE_CHANGED", "Selected record is not an object.");
-            }
-            return projected;
-        },
-    };
-}
-function validateSnapshot(fd, source, row, snapshot) {
-    const { before, digest } = snapshot;
-    const current = fs.statSync(source.path, { bigint: true });
-    const after = fs.fstatSync(fd, { bigint: true });
-    if (identity(current) !== identity(before) ||
-        current.size < BigInt(row.end) ||
-        (after.ctimeNs !== before.ctimeNs && after.size <= before.size) ||
-        digest !== row.digest) {
-        throw new HistoryIndexError("SOURCE_CHANGED", "Selected record changed; refresh history before reading details.");
-    }
-}
-/** Revalidate physical identity, native header and exact selected bytes before exposing detail. */
-export function validateRecord(source, row, full) {
-    let fd;
-    try {
-        fd = fs.openSync(source.path, "r");
-        const stat = fs.fstatSync(fd, { bigint: true });
-        if (identity(stat) !== source.identity || Number(stat.size) < row.end) {
-            throw new HistoryIndexError("SOURCE_CHANGED", "Selected conversation was replaced or truncated.");
-        }
-        validateHeader(fd, source);
-        if (full && row.end - row.start > 16 * 1024 * 1024) {
-            throw new HistoryIndexError("RECORD_TOO_LARGE", "Selected full record exceeds the 16 MiB detail budget; use its validated preview.");
-        }
-        const body = readBody(fd, row, full);
-        validateSnapshot(fd, source, row, { before: stat, digest: body.digest });
-        // Physical validation wins over full JSON/UTF-8 decode errors if the file changed during reading.
-        return body.finish();
-    }
-    catch (error) {
-        if (hasErrorCode(error, "ENOENT")) {
-            throw new HistoryIndexError("SOURCE_CHANGED", "Selected conversation is missing.");
-        }
-        if (error instanceof RangeError) {
-            throw new HistoryIndexError("RECORD_COMPLEXITY", "Selected preview exceeds bounded history structure budgets.");
-        }
-        throw error;
-    }
-    finally {
-        if (fd !== undefined) {
-            fs.closeSync(fd);
-        }
-    }
-}

package/dist/history/source-file.js

@@ -1,45 +0,0 @@
-import * as fs from "node:fs";
-import { HistoryIndexError } from "./types.js";
-export function identity(stat) {
-    return `${stat.dev}:${stat.ino}`;
-}
-export function stamp(stat) {
-    return `${identity(stat)}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
-}
-export function requireSource(store, id) {
-    const source = store.source(id);
-    if (!source) {
-        throw new HistoryIndexError("SOURCE_CHANGED", "Source was removed before ingestion.");
-    }
-    return source;
-}
-/** Acquires the writer lock before reading any cursor or clearing shared staging. */
-export function openSource(store, id) {
-    store.beginIngest();
-    let fd;
-    try {
-        let source = requireSource(store, id);
-        store.count("sourceChecks");
-        store.count("sourceOpens");
-        fd = fs.openSync(source.path, "r");
-        const initial = fs.fstatSync(fd, { bigint: true });
-        if (!initial.isFile() || initial.size > BigInt(Number.MAX_SAFE_INTEGER)) {
-            throw new Error("Journal is not a supported regular file.");
-        }
-        if (source.identity !== null &&
-            (source.identity !== identity(initial) || Number(initial.size) < source.cursor)) {
-            store.resetSource(id);
-            source = requireSource(store, id);
-        }
-        store.clearUnpublished(id);
-        store.run("DELETE FROM pending_text");
-        return { fd, initial, source };
-    }
-    catch (error) {
-        if (fd !== undefined) {
-            fs.closeSync(fd);
-        }
-        store.endIngest();
-        throw error;
-    }
-}

package/dist/history/source-watches.js

@@ -1,141 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { identity } from "./source-file.js";
-/** Owns native handles, physical-directory identity and co-located run/source subscriptions. */
-export class SourceWatches {
-    runs = new Set();
-    watchers = new Map();
-    sourceWatchers = new Map();
-    identities = new WeakMap();
-    sources = new Map();
-    root;
-    events;
-    constructor(agentDir, events) {
-        this.root = path.join(agentDir, "sessions", "subagent-runs");
-        this.events = events;
-    }
-    handle(directory, recursive, listener, source = false) {
-        const handles = source ? this.sourceWatchers : this.watchers;
-        const existing = handles.get(directory);
-        try {
-            const physical = identity(fs.statSync(directory, { bigint: true }));
-            if (existing && this.identities.get(existing) === physical) {
-                return;
-            }
-            const watcher = fs.watch(directory, { recursive }, (event, name) => {
-                const filename = name?.toString() ?? null;
-                const selfRename = event === "rename" && filename === path.basename(directory);
-                if (selfRename && handles.get(directory) === watcher) {
-                    this.identities.delete(watcher);
-                    this.handle(directory, recursive, listener, source);
-                    listener(null);
-                }
-                else {
-                    listener(filename);
-                }
-                if (!source) {
-                    this.notifySources(directory, selfRename ? null : filename);
-                }
-                this.events.schedule();
-            });
-            this.identities.set(watcher, physical);
-            this.retireOnClose(directory, watcher, source);
-            handles.set(directory, watcher);
-            // Native close fences macOS re-registration; admit the replacement first.
-            existing?.close();
-        }
-        catch {
-            if (existing && handles.get(directory) === existing) {
-                this.identities.delete(existing);
-            }
-            // Known-handle census recovers absent directories and dropped native watches.
-        }
-    }
-    retireOnClose(directory, watcher, source) {
-        const handles = source ? this.sourceWatchers : this.watchers;
-        const retire = () => {
-            if (handles.get(directory) === watcher) {
-                handles.delete(directory);
-            }
-        };
-        watcher.on("error", () => {
-            watcher.close();
-            retire();
-        });
-        watcher.on("close", retire);
-    }
-    reset(directory) {
-        for (const handles of [this.watchers, this.sourceWatchers]) {
-            const watcher = handles.get(directory);
-            if (watcher) {
-                this.identities.delete(watcher);
-            }
-        }
-        for (const id of this.sources.get(directory)?.keys() ?? []) {
-            this.events.source(id);
-        }
-    }
-    notifySources(directory, name) {
-        for (const [id, filename] of this.sources.get(directory) ?? []) {
-            if (name === null || name.length === 0 || filename === name) {
-                this.events.source(id);
-            }
-        }
-    }
-    sourceDirectory(directory) {
-        if (!this.sources.has(directory) || this.watchers.has(directory)) {
-            return;
-        }
-        this.handle(directory, false, (name) => {
-            this.notifySources(directory, name);
-        }, true);
-    }
-    install(runIds, sources) {
-        for (const id of runIds) {
-            this.runs.add(id);
-        }
-        // Observe only admitted trees. Foreign run directory churn never causes a global scan.
-        this.handle(this.root, false, (name) => {
-            let ids = this.runs;
-            if (name !== null && name.length > 0) {
-                ids = this.runs.has(name) ? [name] : [];
-            }
-            for (const id of ids) {
-                this.reset(path.join(this.root, id));
-                this.events.run(id);
-            }
-        });
-        for (const id of runIds) {
-            const directory = path.join(this.root, id);
-            this.handle(directory, true, (name) => {
-                if (name === null || name.length === 0) {
-                    this.reset(directory);
-                }
-                this.events.run(id);
-            });
-            this.sourceDirectory(directory);
-        }
-        for (const source of sources) {
-            const directory = path.dirname(source.path);
-            let linked = this.sources.get(directory);
-            if (!linked) {
-                linked = new Map();
-                this.sources.set(directory, linked);
-            }
-            linked.set(source.id, path.basename(source.path));
-            this.sourceDirectory(directory);
-        }
-    }
-    forget(source) {
-        this.sources.get(path.dirname(source.path))?.delete(source.id);
-    }
-    close() {
-        for (const watcher of [...this.watchers.values(), ...this.sourceWatchers.values()]) {
-            watcher.close();
-        }
-        this.watchers.clear();
-        this.sourceWatchers.clear();
-        this.sources.clear();
-        this.runs.clear();
-    }
-}