@astrosheep/keiyaku 4.6.4 → 4.6.6

package/build/src/akuma/heart/index.js

@@ -1,7 +1,7 @@
 import { parsePublicHistoryId } from "../identity.js";
 import { answeredTurnFact, endBodyFact, finishBodyFact, deleteStopControl, insertActivityFact, insertTurnEndFact, insertTurnStartFact, insertPauseControl, insertKillFact, insertSessionFact, insertStopControl, killFactForBody, latestBodyFact, latestKillFact, latestSessionFact, latestTurnFactForBody, lastAnsweredTurnFact, pauseFact, sessionFactForCoordinate, stopFact, turnFact, } from "./rows.js";
 import { insertTellDeliveryFact, dispositionSnapshotProven, insertTellBindingFact, insertTellDispositionSnapshot, insertTellFact, insertTellReceiptFact, insertUndeliveredTellReceipts, latestOpenTellDisposition, openBoundTurns, openTellDispositionIds, pendingTellFacts, hasPendingTell, resolveTellDispositionSnapshot, tellDispositionResolved, tellFact, tellIdsForFence, turnParticipants, } from "./tells.js";
-import { activityFactSlice, statusFacts, lastActivityAt as readLastActivityAt, pruneActivityFacts, } from "./timeline.js";
+import { activityFactSlice, statusFacts, readStatusBatch, decodeTimelineBatch, lastActivityAt as readLastActivityAt, pruneActivityFacts, } from "./timeline.js";
 import { isHeartAbsent, readSealFromLeash, withHeartTransaction, withReadOnlyHeart } from "./storage.js";
 import { soulFact } from "./soul.js";
 import { AkumaBusyError, HeartAuthorityCorruptionError } from "./facts.js";
@@ -53,11 +53,56 @@ export async function appendActivity(paths, input) {
 export async function activitySlice(paths) {
     return await withReadOnlyHeart(paths, (heart) => activityFactSlice(heart));
 }
-export async function readStatusFacts(paths, input) {
-    return await withReadOnlyHeart(paths, (heart) => statusFacts(heart, input));
+export async function readStatusFacts(paths, input, signal) {
+    return await withReadOnlyHeart(paths, (heart) => statusFacts(heart, input), signal);
+}
+// Each query returns a fixed set of scalar columns; compare JSON columns as text.
+function sameRawRows(left, right) {
+    if (left.length !== right.length)
+        return false;
+    if (left.length === 0)
+        return true;
+    const columns = Object.keys(left[0]);
+    return left.every((row, index) => columns.every((column) => row[column] === right[index][column]));
+}
+function sameStatusBatch(left, right) {
+    return (left.frontier === right.frontier &&
+        sameRawRows(left.rows, right.rows) &&
+        sameRawRows(left.turns, right.turns) &&
+        sameRawRows(left.calls, right.calls) &&
+        sameRawRows(left.activity, right.activity) &&
+        sameRawRows(left.tells.rows, right.tells.rows) &&
+        sameRawRows(left.tells.deliveries, right.tells.deliveries) &&
+        sameRawRows(left.tells.bindings, right.tells.bindings));
+}
+/** One live observation's successful raw input and decoded frontier, never a connection. */
+export function createStatusFactReader(paths) {
+    let memo;
+    return {
+        clear() {
+            memo = undefined;
+        },
+        async read(input, signal) {
+            try {
+                const next = await withReadOnlyHeart(paths, (heart) => {
+                    const batch = readStatusBatch(heart, input);
+                    if (memo !== undefined && sameStatusBatch(batch, memo.batch))
+                        return memo;
+                    return { batch, facts: decodeTimelineBatch(batch) };
+                }, signal);
+                // Publication follows COMMIT, so failed reads can never supply a fallback.
+                memo = next;
+                return next.facts;
+            }
+            catch (error) {
+                memo = undefined;
+                throw error;
+            }
+        },
+    };
 }
 /** Lifecycle probes do not load narration, Tell bodies, or delivery histories. */
-export async function readLifeSnapshot(paths) {
+export async function readLifeSnapshot(paths, signal) {
     try {
         return await withReadOnlyHeart(paths, (heart) => ({
             soul: soulFact(heart),
@@ -65,7 +110,7 @@ export async function readLifeSnapshot(paths) {
             latestSession: latestSessionFact(heart),
             latestKill: latestKillFact(heart),
             hasPendingTell: hasPendingTell(heart),
-        }));
+        }), signal);
     }
     catch (error) {
         if (isHeartAbsent(error))

package/build/src/akuma/heart/tells.d.ts

@@ -1,9 +1,39 @@
 import type { DatabaseSync } from "node:sqlite";
-import { type TellDeliveryInput, type TellFact, type TellReceiptInput } from "./facts.js";
+import { type TellDelivery, type TellDeliveryInput, type TellFact, type TellReceiptInput } from "./facts.js";
+type TellRow = Readonly<{
+    sequence: number;
+    id: string;
+    body: string;
+    schema_json: string | null;
+    initiator: string | null;
+    recorded_at: string;
+    state: TellFact["state"];
+}>;
+type TellDeliveryRow = Readonly<{
+    turn_sequence: number;
+    route: TellDelivery["route"];
+    receipt: TellDelivery["receipt"] | null;
+    delivered_at: string;
+}>;
 export declare const tellStateSql = "CASE\n  WHEN EXISTS (\n    SELECT 1 FROM tell_deliveries d\n    WHERE d.tell_id = tells.id AND (d.route = 'launch' OR d.receipt = 'unavailable')\n  ) THEN 'told'\n  WHEN EXISTS (SELECT 1 FROM tell_receipts r WHERE r.evidence = 'exact' AND r.tell_id = tells.id) THEN 'told'\n  WHEN EXISTS (\n    SELECT 1 FROM tell_receipts r\n    JOIN tell_deliveries d ON d.turn_sequence = r.turn_sequence AND d.fence = r.fence\n    WHERE r.evidence = 'fence' AND d.tell_id = tells.id\n  ) THEN 'told'\n  ELSE 'pending'\nEND";
 export declare const pendingTellSequencesSql = "SELECT tells.sequence FROM tells WHERE CASE\n  WHEN EXISTS (\n    SELECT 1 FROM tell_deliveries d\n    WHERE d.tell_id = tells.id AND (d.route = 'launch' OR d.receipt = 'unavailable')\n  ) THEN 'told'\n  WHEN EXISTS (SELECT 1 FROM tell_receipts r WHERE r.evidence = 'exact' AND r.tell_id = tells.id) THEN 'told'\n  WHEN EXISTS (\n    SELECT 1 FROM tell_receipts r\n    JOIN tell_deliveries d ON d.turn_sequence = r.turn_sequence AND d.fence = r.fence\n    WHERE r.evidence = 'fence' AND d.tell_id = tells.id\n  ) THEN 'told'\n  ELSE 'pending'\nEND = 'pending'\n  UNION SELECT tells.sequence FROM tells JOIN tell_disposition_members m ON m.tell_id = tells.id";
 export declare const pendingTellProtectionSql = "SELECT d.turn_sequence FROM tell_deliveries d\n  JOIN tells ON tells.id = d.tell_id WHERE CASE\n  WHEN EXISTS (\n    SELECT 1 FROM tell_deliveries d\n    WHERE d.tell_id = tells.id AND (d.route = 'launch' OR d.receipt = 'unavailable')\n  ) THEN 'told'\n  WHEN EXISTS (SELECT 1 FROM tell_receipts r WHERE r.evidence = 'exact' AND r.tell_id = tells.id) THEN 'told'\n  WHEN EXISTS (\n    SELECT 1 FROM tell_receipts r\n    JOIN tell_deliveries d ON d.turn_sequence = r.turn_sequence AND d.fence = r.fence\n    WHERE r.evidence = 'fence' AND d.tell_id = tells.id\n  ) THEN 'told'\n  ELSE 'pending'\nEND = 'pending'\n  UNION SELECT d.turn_sequence FROM tell_deliveries d JOIN tell_disposition_members m ON m.tell_id = d.tell_id";
-export declare function tellFactsAtSequences(database: DatabaseSync, sequences: readonly number[]): readonly TellFact[];
+type TellBatch = Readonly<{
+    rows: readonly TellRow[];
+    deliveries: readonly (TellDeliveryRow & {
+        sequence: number;
+        tell_id: string;
+        fence: string;
+    })[];
+    bindings: readonly {
+        sequence: number;
+        tell_id: string;
+        turn_sequence: number;
+        bound_at: string;
+    }[];
+}>;
+export declare function decodeTellBatch(batch: TellBatch): readonly TellFact[];
+export declare function tellBatchAtSequences(database: DatabaseSync, sequences: readonly number[]): TellBatch;
 export declare function hasPendingTell(database: DatabaseSync): boolean;
 export declare function insertTellFact(database: DatabaseSync, tell: Omit<TellFact, "sequence" | "state" | "deliveries">): number;
 export declare function tellFact(database: DatabaseSync, id: string): TellFact | null;
@@ -30,3 +60,4 @@ export declare function insertTellBindingFact(database: DatabaseSync, input: Rea
 export declare function turnParticipants(database: DatabaseSync, turnSequence: number): readonly string[];
 export declare function drainPendingTells(pending: readonly TellFact[], activeTurnSequences?: readonly number[]): readonly TellFact[];
 export declare function openBoundTurns(database: DatabaseSync, bodySequence: number): readonly number[];
+export {};

package/build/src/akuma/heart/tells.js

@@ -18,16 +18,26 @@ export const pendingTellSequencesSql = `SELECT tells.sequence FROM tells WHERE $
 export const pendingTellProtectionSql = `SELECT d.turn_sequence FROM tell_deliveries d
   JOIN tells ON tells.id = d.tell_id WHERE ${tellStateSql} = 'pending'
   UNION SELECT d.turn_sequence FROM tell_deliveries d JOIN tell_disposition_members m ON m.tell_id = d.tell_id`;
-function decodeTellRows(database, rows) {
+function readTellBatch(database, rows) {
     if (rows.length === 0)
-        return [];
+        return { rows, deliveries: [], bindings: [] };
     const ids = JSON.stringify(rows.map((row) => row.id));
-    const deliveries = new Map();
-    const deliveryRows = database
-        .prepare(`SELECT tell_id, turn_sequence, route, receipt, delivered_at
+    const deliveries = database
+        .prepare(`SELECT sequence, tell_id, turn_sequence, fence, route, receipt, delivered_at
     FROM tell_deliveries WHERE tell_id IN (SELECT value FROM json_each(?)) ORDER BY sequence`)
         .all(ids);
-    for (const row of deliveryRows) {
+    const bindings = database
+        .prepare(`SELECT sequence, tell_id, turn_sequence, bound_at FROM tell_bindings
+    WHERE sequence IN (
+      SELECT MAX(sequence) FROM tell_bindings
+      WHERE tell_id IN (SELECT value FROM json_each(?)) GROUP BY tell_id
+    ) ORDER BY sequence`)
+        .all(ids);
+    return { rows, deliveries, bindings };
+}
+export function decodeTellBatch(batch) {
+    const deliveries = new Map();
+    for (const row of batch.deliveries) {
         const group = deliveries.get(row.tell_id) ?? [];
         group.push({
             turnSequence: row.turn_sequence,
@@ -38,16 +48,9 @@ function decodeTellRows(database, rows) {
         deliveries.set(row.tell_id, group);
     }
     const bindings = new Map();
-    const bindingRows = database
-        .prepare(`SELECT tell_id, turn_sequence, bound_at FROM tell_bindings
-    WHERE sequence IN (
-      SELECT MAX(sequence) FROM tell_bindings
-      WHERE tell_id IN (SELECT value FROM json_each(?)) GROUP BY tell_id
-    )`)
-        .all(ids);
-    for (const row of bindingRows)
+    for (const row of batch.bindings)
         bindings.set(row.tell_id, { turnSequence: row.turn_sequence, boundAt: row.bound_at });
-    return rows.map((row) => ({
+    return batch.rows.map((row) => ({
         kind: "tell",
         sequence: row.sequence,
         id: row.id,
@@ -60,14 +63,17 @@ function decodeTellRows(database, rows) {
         ...(bindings.has(row.id) ? { binding: bindings.get(row.id) } : {}),
     }));
 }
-export function tellFactsAtSequences(database, sequences) {
+function decodeTellRows(database, rows) {
+    return decodeTellBatch(readTellBatch(database, rows));
+}
+export function tellBatchAtSequences(database, sequences) {
     if (sequences.length === 0)
-        return [];
+        return { rows: [], deliveries: [], bindings: [] };
     const rows = database
         .prepare(`SELECT sequence, id, body, initiator, schema_json, recorded_at, ${tellStateSql} AS state
     FROM tells WHERE sequence IN (SELECT value FROM json_each(?)) ORDER BY sequence`)
         .all(JSON.stringify(sequences));
-    return decodeTellRows(database, rows);
+    return readTellBatch(database, rows);
 }
 export function hasPendingTell(database) {
     return database.prepare(`SELECT 1 FROM tells WHERE ${tellStateSql} = 'pending' LIMIT 1`).get() !== undefined;

package/build/src/akuma/heart/timeline.d.ts

@@ -1,6 +1,7 @@
 import type { DatabaseSync } from "node:sqlite";
 import type { CallFact, TellFact, TurnEndFact, TurnStartFact } from "./facts.js";
-import { type ActivityFact } from "./rows.js";
+import { type ActivityFact, type ActivityRow, type CallRow, type TurnRow } from "./rows.js";
+import { tellBatchAtSequences } from "./tells.js";
 export type TimelineFact = TurnStartFact | CallFact | ActivityFact | TellFact | TurnEndFact;
 export type ActivityFactSlice = Readonly<{
     rows: readonly TimelineFact[];
@@ -9,10 +10,31 @@ export type ActivityFactSlice = Readonly<{
 }>;
 export declare function lastActivityAt(database: DatabaseSync): string | null;
 export declare function pruneActivityFacts(database: DatabaseSync, limit: number, protectionReleased?: boolean): void;
+type TimelineRow = Readonly<{
+    sequence: number;
+    kind: "turn-start" | "call" | "activity" | "tell" | "turn-end";
+}>;
+type TimelineBatch = Readonly<{
+    rows: readonly TimelineRow[];
+    turns: readonly TurnRow[];
+    calls: readonly CallRow[];
+    activity: readonly ActivityRow[];
+    tells: ReturnType<typeof tellBatchAtSequences>;
+}>;
+export declare function decodeTimelineBatch(batch: TimelineBatch): readonly TimelineFact[];
 export type StatusFactInput = Readonly<{
     aperture: "monitoring" | "receipt";
     admittedTellId?: string;
 }>;
 /** Select the frontier and its delivered Tells, plus aperture-required Tell pins. */
+export declare function readStatusBatch(database: DatabaseSync, input: StatusFactInput): {
+    rows: readonly TimelineRow[];
+    turns: readonly TurnRow[];
+    calls: readonly CallRow[];
+    activity: readonly ActivityRow[];
+    tells: ReturnType<typeof tellBatchAtSequences>;
+    frontier: number | null;
+};
 export declare function statusFacts(database: DatabaseSync, input: StatusFactInput): readonly TimelineFact[];
 export declare function activityFactSlice(database: DatabaseSync): ActivityFactSlice;
+export {};

package/build/src/akuma/heart/timeline.js

@@ -1,5 +1,5 @@
 import { decodeActivityRow, decodeCallRow, decodeTurnRow, } from "./rows.js";
-import { tellFactsAtSequences, tellStateSql, pendingTellProtectionSql, pendingTellSequencesSql } from "./tells.js";
+import { decodeTellBatch, tellBatchAtSequences, tellStateSql, pendingTellProtectionSql, pendingTellSequencesSql, } from "./tells.js";
 export function lastActivityAt(database) {
     const row = database
         .prepare(`SELECT CASE timeline.kind
@@ -52,36 +52,40 @@ export function pruneActivityFacts(database, limit, protectionReleased = false)
     DELETE FROM timeline WHERE sequence < ? AND sequence NOT IN protected`)
         .run(cutoff.sequence, cutoff.sequence, cutoff.sequence, cutoff.sequence);
 }
-function decodeTimelineRows(database, rows) {
+function readTimelineBatch(database, rows) {
     const sequences = (kind) => JSON.stringify(rows.filter((row) => row.kind === kind).map((row) => row.sequence));
-    const facts = new Map();
     const turns = database
         .prepare(`SELECT sequence, body_sequence, started_at, end_sequence, outcome,
     history_id, session_json, answer, answer_json, schema_json, initiator, diagnostic, completed_at FROM turns
-    WHERE sequence IN (SELECT value FROM json_each(?)) OR end_sequence IN (SELECT value FROM json_each(?))`)
+    WHERE sequence IN (SELECT value FROM json_each(?)) OR end_sequence IN (SELECT value FROM json_each(?))
+    ORDER BY sequence`)
         .all(sequences("turn-start"), sequences("turn-end"));
-    for (const row of turns) {
-        const { end, ...start } = decodeTurnRow(row);
-        facts.set(start.sequence, start);
-        if (end !== undefined)
-            facts.set(end.sequence, end);
-    }
     const calls = database
         .prepare(`SELECT sequence, turn_sequence, body, at FROM calls
-    WHERE sequence IN (SELECT value FROM json_each(?))`)
+    WHERE sequence IN (SELECT value FROM json_each(?)) ORDER BY sequence`)
         .all(sequences("call"));
-    for (const row of calls)
-        facts.set(row.sequence, decodeCallRow(row));
     const activity = database
         .prepare(`SELECT sequence, turn_sequence, event_json, at FROM activity
-    WHERE sequence IN (SELECT value FROM json_each(?))`)
+    WHERE sequence IN (SELECT value FROM json_each(?)) ORDER BY sequence`)
         .all(sequences("activity"));
-    for (const row of activity)
+    const tells = tellBatchAtSequences(database, rows.filter((row) => row.kind === "tell").map((row) => row.sequence));
+    return { rows, turns, calls, activity, tells };
+}
+export function decodeTimelineBatch(batch) {
+    const facts = new Map();
+    for (const row of batch.turns) {
+        const { end, ...start } = decodeTurnRow(row);
+        facts.set(start.sequence, start);
+        if (end !== undefined)
+            facts.set(end.sequence, end);
+    }
+    for (const row of batch.calls)
+        facts.set(row.sequence, decodeCallRow(row));
+    for (const row of batch.activity)
         facts.set(row.sequence, decodeActivityRow(row));
-    const tells = tellFactsAtSequences(database, rows.filter((row) => row.kind === "tell").map((row) => row.sequence));
-    for (const fact of tells)
+    for (const fact of decodeTellBatch(batch.tells))
         facts.set(fact.sequence, fact);
-    return rows.map((row) => {
+    return batch.rows.map((row) => {
         const fact = facts.get(row.sequence);
         if (fact === undefined || fact.kind !== row.kind)
             throw new Error(`Akuma timeline references missing ${row.kind} ${row.sequence}`);
@@ -89,7 +93,7 @@ function decodeTimelineRows(database, rows) {
     });
 }
 /** Select the frontier and its delivered Tells, plus aperture-required Tell pins. */
-export function statusFacts(database, input) {
+export function readStatusBatch(database, input) {
     const frontier = database.prepare("SELECT sequence FROM turns ORDER BY sequence DESC LIMIT 1").get();
     const rows = database
         .prepare(`WITH selected(sequence) AS (
@@ -104,7 +108,10 @@ export function statusFacts(database, input) {
       UNION SELECT sequence FROM tells WHERE ? AND ${tellStateSql} = 'pending'
     ) SELECT timeline.sequence, timeline.kind FROM timeline JOIN selected USING(sequence) ORDER BY sequence`)
         .all(frontier?.sequence ?? null, frontier?.sequence ?? null, frontier?.sequence ?? null, frontier?.sequence ?? null, frontier?.sequence ?? null, input.admittedTellId ?? null, input.aperture === "monitoring" || input.admittedTellId === undefined ? 1 : 0);
-    return decodeTimelineRows(database, rows);
+    return { frontier: frontier?.sequence ?? null, ...readTimelineBatch(database, rows) };
+}
+export function statusFacts(database, input) {
+    return decodeTimelineBatch(readStatusBatch(database, input));
 }
 export function activityFactSlice(database) {
     const bounds = database.prepare("SELECT MIN(sequence) AS lowest, MAX(sequence) AS highest FROM timeline").get();
@@ -112,7 +119,7 @@ export function activityFactSlice(database) {
         .prepare("SELECT sequence, kind FROM timeline ORDER BY sequence")
         .all();
     return {
-        rows: decodeTimelineRows(database, rows),
+        rows: decodeTimelineBatch(readTimelineBatch(database, rows)),
         lowestRetained: bounds.lowest,
         highest: bounds.highest,
     };

package/build/src/akuma/projection.d.ts

@@ -41,8 +41,8 @@ export declare const tellRowSchema: z.ZodObject<{
         }>;
         turnSequence: z.ZodNumber;
         receipt: z.ZodOptional<z.ZodEnum<{
-            required: "required";
             unavailable: "unavailable";
+            required: "required";
         }>>;
     }, z.core.$strict>, z.ZodTransform<Readonly<{
         turnSequence: number;
@@ -53,7 +53,7 @@ export declare const tellRowSchema: z.ZodObject<{
         deliveredAt: string;
         route: "live" | "launch";
         turnSequence: number;
-        receipt?: "required" | "unavailable" | undefined;
+        receipt?: "unavailable" | "required" | undefined;
     }>>>>;
 }, z.core.$strict>;
 declare const outcomeSchema: z.ZodUnion<readonly [z.ZodObject<{
@@ -283,8 +283,8 @@ declare const openSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z
         }>;
         turnSequence: z.ZodNumber;
         receipt: z.ZodOptional<z.ZodEnum<{
-            required: "required";
             unavailable: "unavailable";
+            required: "required";
         }>>;
     }, z.core.$strict>, z.ZodTransform<Readonly<{
         turnSequence: number;
@@ -295,7 +295,7 @@ declare const openSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z
         deliveredAt: string;
         route: "live" | "launch";
         turnSequence: number;
-        receipt?: "required" | "unavailable" | undefined;
+        receipt?: "unavailable" | "required" | undefined;
     }>>>>;
 }, z.core.$strict>]>, z.ZodObject<{
     kind: z.ZodLiteral<"tool">;
@@ -449,8 +449,8 @@ declare const idleSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z
         }>;
         turnSequence: z.ZodNumber;
         receipt: z.ZodOptional<z.ZodEnum<{
-            required: "required";
             unavailable: "unavailable";
+            required: "required";
         }>>;
     }, z.core.$strict>, z.ZodTransform<Readonly<{
         turnSequence: number;
@@ -461,7 +461,7 @@ declare const idleSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z
         deliveredAt: string;
         route: "live" | "launch";
         turnSequence: number;
-        receipt?: "required" | "unavailable" | undefined;
+        receipt?: "unavailable" | "required" | undefined;
     }>>>>;
 }, z.core.$strict>]>, z.ZodObject<{
     kind: z.ZodLiteral<"tool">;
@@ -638,8 +638,8 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [z.ZodObject<{
                 }>;
                 turnSequence: z.ZodNumber;
                 receipt: z.ZodOptional<z.ZodEnum<{
-                    required: "required";
                     unavailable: "unavailable";
+                    required: "required";
                 }>>;
             }, z.core.$strict>, z.ZodTransform<Readonly<{
                 turnSequence: number;
@@ -650,7 +650,7 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [z.ZodObject<{
                 deliveredAt: string;
                 route: "live" | "launch";
                 turnSequence: number;
-                receipt?: "required" | "unavailable" | undefined;
+                receipt?: "unavailable" | "required" | undefined;
             }>>>>;
         }, z.core.$strict>]>, z.ZodObject<{
             kind: z.ZodLiteral<"tool">;
@@ -845,8 +845,8 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [z.ZodObject<{
                 }>;
                 turnSequence: z.ZodNumber;
                 receipt: z.ZodOptional<z.ZodEnum<{
-                    required: "required";
                     unavailable: "unavailable";
+                    required: "required";
                 }>>;
             }, z.core.$strict>, z.ZodTransform<Readonly<{
                 turnSequence: number;
@@ -857,7 +857,7 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [z.ZodObject<{
                 deliveredAt: string;
                 route: "live" | "launch";
                 turnSequence: number;
-                receipt?: "required" | "unavailable" | undefined;
+                receipt?: "unavailable" | "required" | undefined;
             }>>>>;
         }, z.core.$strict>]>, z.ZodObject<{
             kind: z.ZodLiteral<"tool">;

package/build/src/akuma/providers/pi/index.js

@@ -115,6 +115,37 @@ async function runPiPrompt(native, input, events, state, settle) {
             : { kind: "failed", diagnostic: diagnostic(error) });
     }
 }
+async function retirePiSession(native) {
+    let failure;
+    let unsubscribe;
+    try {
+        const runner = native.extensionRunner;
+        unsubscribe = runner?.onError((error) => {
+            if (error.event === "session_shutdown")
+                failure ??= new Error(error.error);
+        });
+        await runner?.emit({ type: "session_shutdown", reason: "quit" });
+    }
+    catch (error) {
+        failure ??= error;
+    }
+    finally {
+        try {
+            unsubscribe?.();
+        }
+        catch (error) {
+            failure ??= error;
+        }
+        try {
+            native.dispose();
+        }
+        catch (error) {
+            failure ??= error;
+        }
+    }
+    if (failure !== undefined)
+        throw failure;
+}
 async function drivePi(sdk, execution, input, signal, custody) {
     const created = await createPiSession(sdk, execution, input);
     const native = created.session;
@@ -144,33 +175,7 @@ async function drivePi(sdk, execution, input, signal, custody) {
     const agent = native.agent;
     let unsubscribeAgent;
     let unsubscribe;
-    try {
-        unsubscribeAgent = agent.subscribe((event) => {
-            if (event.type === "message_end") {
-                const waiter = pendingTells.get(event.message);
-                if (waiter !== undefined) {
-                    pendingTells.delete(event.message);
-                    waiter.resolve({ kind: "accepted", fence: `${native.sessionId}:${waiter.id}` });
-                }
-            }
-        });
-        unsubscribe = native.subscribe((event) => {
-            if (event.type === "agent_end" && !event.willRetry) {
-                state.terminalFailure = piTerminalFailure(event.messages);
-            }
-            for (const translated of translatePiEvent(event, eventState))
-                events.emit(translated);
-        });
-    }
-    catch (error) {
-        try {
-            unsubscribeAgent?.();
-        }
-        finally {
-            native.dispose();
-        }
-        throw error;
-    }
+    let binding;
     const settle = (result) => {
         if (state.settled)
             return closed;
@@ -178,7 +183,7 @@ async function drivePi(sdk, execution, input, signal, custody) {
         endPendingTells();
         let failure;
         try {
-            unsubscribe();
+            unsubscribe?.();
         }
         catch (error) {
             failure = error;
@@ -191,16 +196,19 @@ async function drivePi(sdk, execution, input, signal, custody) {
         }
         events.end();
         settleCompletion(result);
-        try {
-            native.dispose();
-        }
-        catch (error) {
-            failure ??= error;
-        }
-        if (failure === undefined)
-            settleRetired();
-        else
-            failRetired(failure);
+        void (async () => {
+            // Binding can create extension resources after cancellation. Shutdown must
+            // run after that work, while its contexts are still valid.
+            await binding?.catch(() => undefined);
+            try {
+                await retirePiSession(native);
+            }
+            catch (error) {
+                failure ??= error;
+            }
+            if (failure !== undefined)
+                throw failure;
+        })().then(settleRetired, failRetired);
         return closed;
     };
     const forceDispose = async () => {
@@ -209,6 +217,28 @@ async function drivePi(sdk, execution, input, signal, custody) {
         await settle({ kind: "failed", diagnostic: "Pi session force-disposed" });
     };
     custody?.own({ closed, abort: forceDispose, forceDispose });
+    try {
+        unsubscribeAgent = agent.subscribe((event) => {
+            if (event.type === "message_end") {
+                const waiter = pendingTells.get(event.message);
+                if (waiter !== undefined) {
+                    pendingTells.delete(event.message);
+                    waiter.resolve({ kind: "accepted", fence: `${native.sessionId}:${waiter.id}` });
+                }
+            }
+        });
+        unsubscribe = native.subscribe((event) => {
+            if (event.type === "agent_end" && !event.willRetry) {
+                state.terminalFailure = piTerminalFailure(event.messages);
+            }
+            for (const translated of translatePiEvent(event, eventState))
+                events.emit(translated);
+        });
+    }
+    catch (error) {
+        await settle({ kind: "failed", diagnostic: diagnostic(error) });
+        throw error;
+    }
     if (signal.aborted) {
         await settle({ kind: "failed", diagnostic: "Pi session aborted" });
         signal.throwIfAborted();
@@ -217,9 +247,12 @@ async function drivePi(sdk, execution, input, signal, custody) {
         await settle({ kind: "failed", diagnostic: "Pi session admitted without sessionFile" });
         throw new Error("Pi session admitted without sessionFile");
     }
+    binding = Promise.resolve().then(() => native.bindExtensions({}));
+    await abortable(binding, signal);
+    signal.throwIfAborted();
     events.emit({ type: "session", coordinate: { sessionFile: native.sessionFile, sessionId: native.sessionId } });
     void runPiPrompt(native, input, eventState, state, (result) => {
-        void settle(result);
+        void settle(result).catch(() => undefined);
     });
     return {
         admission: { fence: native.sessionId },