@astrosheep/keiyaku 4.5.11 → 4.5.13

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

@@ -1,4 +1,4 @@
-const HEART_SCHEMA_VERSION = 21;
+const HEART_SCHEMA_VERSION = 24;
 const LEASH_SCHEMA_VERSION = 4;
 function assertSchemaVersion(database, table, expected) {
     const row = database.prepare(`SELECT version FROM ${table} WHERE singleton = 1`).get();
@@ -53,16 +53,23 @@ export const HEART_SCHEMA = `
     body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),
     started_at TEXT NOT NULL,
     end_sequence INTEGER UNIQUE REFERENCES timeline(sequence) ON DELETE SET NULL,
-    outcome TEXT CHECK (outcome IN ('answered', 'failed')),
+    outcome TEXT CHECK (outcome IN ('answered', 'failed', 'invalid-output')),
     history_id TEXT UNIQUE,
     session_json TEXT CHECK (session_json IS NULL OR json_valid(session_json)),
     answer TEXT,
+    answer_json TEXT CHECK (answer_json IS NULL OR json_valid(answer_json)),
+    schema_json TEXT CHECK (schema_json IS NULL OR json_valid(schema_json)),
     diagnostic TEXT,
     completed_at TEXT,
     CHECK (
-      (outcome = 'answered' AND session_json IS NOT NULL AND answer IS NOT NULL AND diagnostic IS NULL)
-      OR (outcome = 'failed' AND history_id IS NULL AND session_json IS NULL AND answer IS NULL AND diagnostic IS NOT NULL)
-      OR (outcome IS NULL AND end_sequence IS NULL AND history_id IS NULL AND session_json IS NULL AND answer IS NULL AND diagnostic IS NULL AND completed_at IS NULL)
+      (outcome = 'answered' AND session_json IS NOT NULL AND answer IS NOT NULL AND diagnostic IS NULL
+        AND ((schema_json IS NULL AND answer_json IS NULL) OR (schema_json IS NOT NULL AND answer_json IS NOT NULL)))
+      OR (outcome = 'failed' AND history_id IS NULL AND session_json IS NULL AND answer IS NULL
+        AND answer_json IS NULL AND diagnostic IS NOT NULL)
+      OR (outcome = 'invalid-output' AND answer IS NOT NULL AND answer_json IS NULL
+        AND diagnostic IS NOT NULL AND schema_json IS NOT NULL)
+      OR (outcome IS NULL AND end_sequence IS NULL AND history_id IS NULL AND session_json IS NULL
+        AND answer IS NULL AND answer_json IS NULL AND diagnostic IS NULL AND completed_at IS NULL)
     )
   ) STRICT;
   CREATE TABLE IF NOT EXISTS timeline (
@@ -85,8 +92,14 @@ export const HEART_SCHEMA = `
     id TEXT PRIMARY KEY,
     sequence INTEGER NOT NULL UNIQUE REFERENCES timeline(sequence) ON DELETE CASCADE,
     body TEXT NOT NULL,
+    schema_json TEXT CHECK (schema_json IS NULL OR json_valid(schema_json)),
     recorded_at TEXT NOT NULL
   ) STRICT;
+  CREATE TABLE IF NOT EXISTS tell_bindings (
+    tell_id TEXT PRIMARY KEY REFERENCES tells(id) ON DELETE CASCADE,
+    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,
+    bound_at TEXT NOT NULL
+  ) STRICT;
   CREATE TABLE IF NOT EXISTS tell_deliveries (
     sequence INTEGER PRIMARY KEY AUTOINCREMENT,
     tell_id TEXT NOT NULL REFERENCES tells(id) ON DELETE CASCADE,
@@ -115,6 +128,13 @@ export const HEART_SCHEMA = `
     ON tell_receipts(tell_id, kind) WHERE evidence = 'exact';
   CREATE UNIQUE INDEX IF NOT EXISTS tell_receipts_fence
     ON tell_receipts(turn_sequence, fence, kind) WHERE evidence = 'fence';
+  CREATE TABLE IF NOT EXISTS tell_dispositions (
+    body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),
+    tell_id TEXT NOT NULL REFERENCES tells(id),
+    decided_at TEXT NOT NULL,
+    resolved_at TEXT,
+    PRIMARY KEY (body_sequence, tell_id)
+  ) STRICT;
   CREATE TABLE IF NOT EXISTS requests (
     sequence INTEGER PRIMARY KEY AUTOINCREMENT,
     id TEXT NOT NULL UNIQUE,
@@ -122,7 +142,7 @@ export const HEART_SCHEMA = `
     action TEXT NOT NULL,
     payload_json TEXT NOT NULL CHECK (json_valid(payload_json)),
     admitted_at TEXT NOT NULL,
-    state TEXT NOT NULL CHECK (state IN ('admitted', 'reserved', 'served', 'refused', 'voided')),
+    state TEXT NOT NULL CHECK (state IN ('admitted', 'reserved', 'begun', 'served', 'refused', 'voided', 'unproven')),
     child TEXT,
     service_json TEXT CHECK (service_json IS NULL OR json_valid(service_json)),
     diagnostic TEXT,
@@ -131,12 +151,14 @@ export const HEART_SCHEMA = `
       (state = 'admitted' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NULL)
       OR (state = 'reserved' AND child IS NOT NULL AND service_json IS NULL
         AND diagnostic IS NULL AND evidence IS NULL)
+      OR (state = 'begun' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NULL)
       OR (state = 'served'
         AND ((child IS NOT NULL AND service_json IS NULL)
           OR (child IS NULL AND service_json IS NOT NULL))
         AND diagnostic IS NULL AND evidence IS NULL)
       OR (state = 'refused' AND child IS NULL AND service_json IS NULL AND diagnostic IS NOT NULL AND evidence IS NULL)
       OR (state = 'voided' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NOT NULL)
+      OR (state = 'unproven' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NOT NULL)
     )
   ) STRICT;
   CREATE TABLE IF NOT EXISTS control (

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

@@ -39,7 +39,7 @@ export declare class HeldAkumaLeash {
         target: StopFact;
         result: "recorded" | "already-killed";
     }> | null>;
-    recordInterruptTell(paths: AkumaPaths, tell: Omit<TellFact, "sequence" | "state" | "deliveries">): Promise<Readonly<{
+    recordInterruptTell(paths: AkumaPaths, tell: Omit<TellFact, "sequence" | "state" | "deliveries" | "binding">): Promise<Readonly<{
         kind: "not-born";
     } | {
         kind: "recorded";

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

@@ -10,3 +10,32 @@ export declare function insertTellDeliveryFact(database: DatabaseSync, input: Te
 export declare function insertTellReceiptFact(database: DatabaseSync, input: TellReceiptInput): void;
 export declare function tellIdsForFence(database: DatabaseSync, turnSequence: number, fence: string): readonly string[];
 export declare function pendingTellFacts(database: DatabaseSync): readonly TellFact[];
+export declare function openTellDispositionIds(database: DatabaseSync, bodySequence: number): readonly string[] | null;
+export declare function latestOpenTellDisposition(database: DatabaseSync): Readonly<{
+    bodySequence: number;
+    tellIds: readonly string[];
+}> | null;
+export declare function insertTellDispositionSnapshot(database: DatabaseSync, bodySequence: number, tellIds: readonly string[], at: string): void;
+export declare function resolveTellDispositionSnapshot(database: DatabaseSync, bodySequence: number, at: string): void;
+/** Heart proof that a disposition snapshot is held: every frozen Tell-id left pending. */
+export declare function dispositionSnapshotProven(database: DatabaseSync, disposition: Readonly<{
+    tellIds: readonly string[];
+}>): boolean;
+/**
+ * Identify the successor Body that took a disposition snapshot by delivery.
+ * Returns that Body sequence when every frozen Tell-id has a delivery on a
+ * turn owned by one Body after `bodySequence`; otherwise null. An unqualified
+ * newer Body or held leash is not proof. A missing Tell row is Heart corruption.
+ */
+export declare function successorBodyHoldingDisposition(database: DatabaseSync, disposition: Readonly<{
+    bodySequence: number;
+    tellIds: readonly string[];
+}>): number | null;
+export declare function insertUndeliveredTellReceipts(database: DatabaseSync, tellIds: readonly string[], at: string): void;
+export declare function insertTellBindingFact(database: DatabaseSync, input: Readonly<{
+    tellId: string;
+    turnSequence: number;
+    boundAt: string;
+}>): void;
+export declare function drainPendingTells(pending: readonly TellFact[]): readonly TellFact[];
+export declare function openBoundTurns(database: DatabaseSync, bodySequence: number): readonly number[];

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

@@ -1,3 +1,4 @@
+import { AuthorityCorruptionError } from "../../core/facts/errors.js";
 export const tellStateSql = `CASE
   WHEN EXISTS (
     SELECT 1 FROM tell_deliveries d
@@ -23,20 +24,29 @@ function tellDeliveries(database, id) {
         ? { turnSequence: row.turn_sequence, route: row.route, deliveredAt: row.delivered_at }
         : { turnSequence: row.turn_sequence, route: row.route, receipt: row.receipt, deliveredAt: row.delivered_at });
 }
+function tellBinding(database, id) {
+    const row = database
+        .prepare("SELECT turn_sequence, bound_at FROM tell_bindings WHERE tell_id = ?")
+        .get(id);
+    return row === undefined ? undefined : { turnSequence: row.turn_sequence, boundAt: row.bound_at };
+}
 function decodeTellRow(database, row) {
+    const binding = tellBinding(database, row.id);
     return {
         kind: "tell",
         sequence: row.sequence,
         id: row.id,
         body: row.body,
+        ...(row.schema_json === null ? {} : { schemaJson: row.schema_json }),
         state: row.state,
         recordedAt: row.recorded_at,
         deliveries: tellDeliveries(database, row.id),
+        ...(binding === undefined ? {} : { binding }),
     };
 }
 export function decodeTellAtSequence(database, sequence) {
     const row = database
-        .prepare(`SELECT sequence, id, body, recorded_at, ${tellStateSql} AS state
+        .prepare(`SELECT sequence, id, body, schema_json, recorded_at, ${tellStateSql} AS state
     FROM tells WHERE sequence = ?`)
         .get(sequence);
     if (row === undefined)
@@ -46,13 +56,13 @@ export function decodeTellAtSequence(database, sequence) {
 export function insertTellFact(database, tell) {
     const sequence = Number(database.prepare("INSERT INTO timeline(kind) VALUES ('tell')").run().lastInsertRowid);
     database
-        .prepare("INSERT INTO tells(id, sequence, body, recorded_at) VALUES (?, ?, ?, ?)")
-        .run(tell.id, sequence, tell.body, tell.recordedAt);
+        .prepare("INSERT INTO tells(id, sequence, body, schema_json, recorded_at) VALUES (?, ?, ?, ?, ?)")
+        .run(tell.id, sequence, tell.body, tell.schemaJson ?? null, tell.recordedAt);
     return sequence;
 }
 export function tellFact(database, id) {
     const row = database
-        .prepare(`SELECT sequence, id, body, recorded_at, ${tellStateSql} AS state
+        .prepare(`SELECT sequence, id, body, schema_json, recorded_at, ${tellStateSql} AS state
     FROM tells WHERE id = ?`)
         .get(id);
     return row === undefined ? null : decodeTellRow(database, row);
@@ -89,8 +99,129 @@ export function tellIdsForFence(database, turnSequence, fence) {
 }
 export function pendingTellFacts(database) {
     const rows = database
-        .prepare(`SELECT sequence, id, body, recorded_at, ${tellStateSql} AS state FROM tells
+        .prepare(`SELECT sequence, id, body, schema_json, recorded_at, ${tellStateSql} AS state FROM tells
     WHERE ${tellStateSql} = 'pending' ORDER BY sequence`)
         .all();
     return rows.map((row) => decodeTellRow(database, row));
 }
+export function openTellDispositionIds(database, bodySequence) {
+    const rows = database
+        .prepare(`SELECT tell_id FROM tell_dispositions
+    WHERE body_sequence = ? AND resolved_at IS NULL ORDER BY tell_id`)
+        .all(bodySequence);
+    return rows.length === 0 ? null : rows.map((row) => row.tell_id);
+}
+export function latestOpenTellDisposition(database) {
+    const row = database
+        .prepare(`SELECT body_sequence FROM tell_dispositions
+    WHERE resolved_at IS NULL ORDER BY body_sequence DESC LIMIT 1`)
+        .get();
+    if (row === undefined)
+        return null;
+    const tellIds = openTellDispositionIds(database, row.body_sequence);
+    return tellIds === null ? null : { bodySequence: row.body_sequence, tellIds };
+}
+export function insertTellDispositionSnapshot(database, bodySequence, tellIds, at) {
+    const insert = database.prepare(`INSERT OR IGNORE INTO tell_dispositions(body_sequence, tell_id, decided_at)
+    VALUES (?, ?, ?)`);
+    for (const tellId of tellIds)
+        insert.run(bodySequence, tellId, at);
+}
+export function resolveTellDispositionSnapshot(database, bodySequence, at) {
+    database
+        .prepare(`UPDATE tell_dispositions SET resolved_at = ?
+    WHERE body_sequence = ? AND resolved_at IS NULL`)
+        .run(at, bodySequence);
+}
+function requireDispositionTell(database, tellId) {
+    const tell = tellFact(database, tellId);
+    if (tell === null) {
+        throw new AuthorityCorruptionError(`Akuma disposition references missing tell ${tellId}`);
+    }
+    return tell;
+}
+/** Heart proof that a disposition snapshot is held: every frozen Tell-id left pending. */
+export function dispositionSnapshotProven(database, disposition) {
+    for (const tellId of disposition.tellIds) {
+        if (requireDispositionTell(database, tellId).state === "pending")
+            return false;
+    }
+    return true;
+}
+/**
+ * Identify the successor Body that took a disposition snapshot by delivery.
+ * Returns that Body sequence when every frozen Tell-id has a delivery on a
+ * turn owned by one Body after `bodySequence`; otherwise null. An unqualified
+ * newer Body or held leash is not proof. A missing Tell row is Heart corruption.
+ */
+export function successorBodyHoldingDisposition(database, disposition) {
+    let successor = null;
+    for (const tellId of disposition.tellIds) {
+        const tell = requireDispositionTell(database, tellId);
+        if (tell.state === "pending")
+            return null;
+        const row = database
+            .prepare(`SELECT t.body_sequence AS body_sequence
+      FROM tell_deliveries d
+      JOIN turns t ON t.sequence = d.turn_sequence
+      WHERE d.tell_id = ? AND t.body_sequence > ?
+      ORDER BY t.body_sequence ASC LIMIT 1`)
+            .get(tellId, disposition.bodySequence);
+        if (row === undefined) {
+            // Terminal witness without successor delivery (e.g. undelivered) is not successor custody.
+            return null;
+        }
+        if (successor === null)
+            successor = row.body_sequence;
+        else if (successor !== row.body_sequence)
+            return null;
+    }
+    return successor;
+}
+export function insertUndeliveredTellReceipts(database, tellIds, at) {
+    for (const tellId of tellIds) {
+        const current = requireDispositionTell(database, tellId);
+        if (current.state !== "pending")
+            continue;
+        insertTellReceiptFact(database, {
+            evidence: "exact",
+            tellId,
+            kind: "undelivered",
+            receivedAt: at,
+        });
+    }
+}
+export function insertTellBindingFact(database, input) {
+    const result = database
+        .prepare("INSERT OR IGNORE INTO tell_bindings(tell_id, turn_sequence, bound_at) VALUES (?, ?, ?)")
+        .run(input.tellId, input.turnSequence, input.boundAt);
+    const row = database
+        .prepare("SELECT turn_sequence FROM tell_bindings WHERE tell_id = ?")
+        .get(input.tellId);
+    if (row === undefined || (result.changes === 0 && row.turn_sequence !== input.turnSequence)) {
+        throw new Error(`tell ${input.tellId} is already bound to a different Turn`);
+    }
+}
+export function drainPendingTells(pending) {
+    const unbound = pending.filter((tell) => tell.binding === undefined);
+    if (unbound.length === 0)
+        return [];
+    const first = unbound[0];
+    const drained = [first];
+    for (const tell of unbound.slice(1)) {
+        if (tell.schemaJson !== undefined)
+            break;
+        drained.push(tell);
+    }
+    return drained;
+}
+export function openBoundTurns(database, bodySequence) {
+    return database
+        .prepare(`SELECT DISTINCT turns.sequence AS sequence
+    FROM turns
+    JOIN tell_bindings ON tell_bindings.turn_sequence = turns.sequence
+    WHERE turns.body_sequence = ? AND turns.end_sequence IS NULL
+    ORDER BY turns.sequence`)
+        .all(bodySequence)
+        .map((row) => row.sequence);
+}

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

@@ -49,7 +49,7 @@ export function pruneActivityFacts(database, limit) {
 function turn(database, sequence) {
     const row = database
         .prepare(`SELECT sequence, body_sequence, started_at, end_sequence, outcome,
-    history_id, session_json, answer, diagnostic, completed_at FROM turns WHERE sequence = ?`)
+    history_id, session_json, answer, answer_json, schema_json, diagnostic, completed_at FROM turns WHERE sequence = ?`)
         .get(sequence);
     if (row === undefined)
         throw new Error(`Akuma timeline references missing Turn ${sequence}`);
@@ -57,11 +57,17 @@ function turn(database, sequence) {
 }
 function turnStart(database, sequence) {
     const row = database
-        .prepare("SELECT sequence, body_sequence, started_at FROM turns WHERE sequence = ?")
+        .prepare("SELECT sequence, body_sequence, started_at, schema_json FROM turns WHERE sequence = ?")
         .get(sequence);
     if (row === undefined)
         throw new Error(`Akuma timeline references missing Turn ${sequence}`);
-    return { kind: "turn-start", sequence: row.sequence, bodySequence: row.body_sequence, startedAt: row.started_at };
+    return {
+        kind: "turn-start",
+        sequence: row.sequence,
+        bodySequence: row.body_sequence,
+        startedAt: row.started_at,
+        ...(row.schema_json === null ? {} : { schemaJson: row.schema_json }),
+    };
 }
 function decodeTimelineRow(database, row) {
     if (row.kind === "turn-start")

package/build/src/akuma/projection-read.js

@@ -48,11 +48,44 @@ function flattenReportedChanges(rows) {
         }));
     });
 }
+function aggregateReportedChanges(changes) {
+    const groups = new Map();
+    changes.forEach((change, index) => {
+        const current = groups.get(change.path);
+        const diffstat = change.diffstat;
+        if (current === undefined) {
+            groups.set(change.path, {
+                latest: change,
+                lastIndex: index,
+                added: diffstat?.added ?? 0,
+                removed: diffstat?.removed ?? 0,
+                complete: diffstat !== undefined,
+            });
+            return;
+        }
+        current.latest = change;
+        current.lastIndex = index;
+        if (diffstat === undefined)
+            current.complete = false;
+        else {
+            current.added += diffstat.added;
+            current.removed += diffstat.removed;
+        }
+    });
+    return [...groups.values()]
+        .sort((left, right) => left.lastIndex - right.lastIndex)
+        .map((group) => {
+        if (group.complete)
+            return { ...group.latest, diffstat: { added: group.added, removed: group.removed } };
+        const { sequence, at, op, path } = group.latest;
+        return { sequence, at, op, path };
+    });
+}
 function summarizeReportedChanges(rows) {
-    const eligible = flattenReportedChanges(rows);
+    const files = aggregateReportedChanges(flattenReportedChanges(rows));
     return {
-        reportedChanges: eligible.slice(-REPORTED_CHANGE_LIMIT),
-        reportedChangesOmitted: Math.max(0, eligible.length - REPORTED_CHANGE_LIMIT),
+        reportedChanges: files.slice(-REPORTED_CHANGE_LIMIT),
+        reportedChangesOmitted: Math.max(0, files.length - REPORTED_CHANGE_LIMIT),
     };
 }
 function frontierReportedChanges(ledger) {

package/build/src/akuma/projection.js

@@ -1,4 +1,3 @@
-/* eslint-disable max-lines -- Akuma owns one coherent activity projection and strict boundary schema. */
 import { decodeAgentEvent } from "./provider.js";
 import { projectTell } from "./heart/facts.js";
 import { z } from "zod";
@@ -193,9 +192,9 @@ export const activitySnapshotSchema = z.union([
 ]);
 function publicOutcome(turnSequence, outcome) {
     const historyId = `turn/${turnSequence}`;
-    return outcome.kind === "answered"
-        ? { kind: "answered", historyId, answer: outcome.answer }
-        : { kind: "failed", historyId, diagnostic: outcome.diagnostic };
+    if (outcome.kind === "answered")
+        return { kind: "answered", historyId, answer: outcome.answer };
+    return { kind: "failed", historyId, diagnostic: outcome.diagnostic };
 }
 export function selectExactHistory(rows, id) {
     const outcome = rows.find((row) => row.kind === "outcome" && row.outcome.historyId === id);

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

@@ -4,6 +4,7 @@ export type { ResumeCoordinate } from "./coordinate.js";
 export declare const AKUMA_REQUESTS_ENV = "AKUMA_REQUESTS";
 export declare const AGENT_EVENT_TEXT_LIMIT = 16384;
 export declare const AGENT_THOUGHT_TEXT_LIMIT = 4000;
+export declare const AGENT_EVENT_QUEUE_LIMIT = 256;
 export type SearchScope = "content" | "files" | "web";
 export type ToolCall = Readonly<{
     kind: "run";
@@ -85,6 +86,8 @@ export declare function unknownEvent(kind: string): Extract<AgentEvent, {
 export declare class AgentEventChannel implements AsyncIterable<AgentEvent> {
     private readonly queued;
     private readonly waiters;
+    private overflowMarker;
+    private overflowCount;
     private ended;
     emit(event: AgentEvent): void;
     end(): void;
@@ -169,6 +172,7 @@ export type DriveInput = Readonly<{
     requests: Readonly<{
         dir: string;
     }>;
+    schemaJson?: string;
 }>;
 export type ProviderOptionAdmission = Readonly<{
     kind: "admitted";

package/build/src/akuma/provider.js

@@ -2,6 +2,7 @@ import { decodeResumeCoordinate, encodeResumeCoordinate } from "./coordinate.js"
 export const AKUMA_REQUESTS_ENV = "AKUMA_REQUESTS";
 export const AGENT_EVENT_TEXT_LIMIT = 16_384;
 export const AGENT_THOUGHT_TEXT_LIMIT = 4_000;
+export const AGENT_EVENT_QUEUE_LIMIT = 256;
 const AGENT_EVENT_TYPES = {
     session: true,
     assistant: true,
@@ -313,16 +314,64 @@ export function noteEvent(note) {
 export function unknownEvent(kind) {
     return { type: "unknown", kind };
 }
+// Slow consumers may lose reconstructible narration, but session coordinates,
+// notes, and error events stay observable. A full protected queue replaces one
+// protected item with a bounded aggregate note; `end` ignores later emission.
+function isErrorEvent(event) {
+    if (event.type === "note")
+        return true;
+    if (event.type === "tool" && event.phase === "completed")
+        return event.result.status === "error";
+    return event.type === "unknown" && /(?:error|fail|abort|cancel|stop|terminal)/iu.test(event.kind);
+}
+function isReconstructibleEvent(event) {
+    return event.type !== "session" && !isErrorEvent(event);
+}
+const AGENT_EVENT_OVERFLOW_PREFIX = "Agent event queue overflow";
+function overflowEvent(count) {
+    return { type: "note", text: `${AGENT_EVENT_OVERFLOW_PREFIX}: ${count} terminal/error events coalesced` };
+}
 export class AgentEventChannel {
     queued = [];
     waiters = [];
+    overflowMarker;
+    overflowCount = 0;
     ended = false;
     emit(event) {
+        if (this.ended)
+            return;
         const waiter = this.waiters.shift();
-        if (waiter === undefined)
-            this.queued.push(event);
-        else
+        if (waiter !== undefined) {
             waiter.resolve({ done: false, value: event });
+            return;
+        }
+        if (this.queued.length >= AGENT_EVENT_QUEUE_LIMIT) {
+            const reconstructible = this.queued.findIndex(isReconstructibleEvent);
+            if (reconstructible === -1) {
+                if (isReconstructibleEvent(event))
+                    return;
+                this.overflowCount += 1;
+                if (this.overflowMarker !== undefined) {
+                    const marker = overflowEvent(this.overflowCount);
+                    const markerIndex = this.queued.indexOf(this.overflowMarker);
+                    if (markerIndex !== -1) {
+                        this.queued[markerIndex] = marker;
+                        this.overflowMarker = marker;
+                        return;
+                    }
+                    this.overflowMarker = undefined;
+                }
+                const protectedIndex = this.queued.findIndex((queued) => queued.type !== "session");
+                const replacement = protectedIndex === -1 ? 0 : protectedIndex;
+                this.overflowCount += 1;
+                const marker = overflowEvent(this.overflowCount);
+                this.queued[replacement] = marker;
+                this.overflowMarker = marker;
+                return;
+            }
+            this.queued.splice(reconstructible, 1);
+        }
+        this.queued.push(event);
     }
     end() {
         if (this.ended)
@@ -335,6 +384,10 @@ export class AgentEventChannel {
         return {
             next: () => {
                 const event = this.queued.shift();
+                if (event === this.overflowMarker) {
+                    this.overflowMarker = undefined;
+                    this.overflowCount = 0;
+                }
                 if (event !== undefined)
                     return Promise.resolve({ done: false, value: event });
                 if (this.ended)

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

@@ -86,6 +86,9 @@ function claudeQueryOptions(input, execution, abortController) {
                     : { type: "preset", preset: "claude_code", append: input.options.systemPrompt },
             }),
         ...(input.session.kind === "fresh" ? {} : { resume: claudeSessionId(input.session.coordinate) }),
+        ...(input.schemaJson === undefined
+            ? {}
+            : { outputFormat: { type: "json_schema", schema: JSON.parse(input.schemaJson) } }),
     };
 }
 async function forkClaude(load, execution, input) {

package/build/src/akuma/providers/codex-app-server/index.js

@@ -95,6 +95,7 @@ async function admitTurn(server, input, state, events, config) {
         ...(input.options.effort === undefined ? {} : { effort: input.options.effort }),
         approvalPolicy: "never",
         sandboxPolicy: sandbox(input.cwd, input.options, input.requests),
+        ...(input.schemaJson === undefined ? {} : { outputSchema: JSON.parse(input.schemaJson) }),
     }));
 }
 async function forkCodex(execution, input, custody) {
@@ -152,11 +153,8 @@ async function startCodex(execution, input, custody) {
     const events = new AgentEventChannel();
     const server = codexServer(execution, input);
     const closed = new Promise((resolve) => server.onExit(() => resolve()));
-    custody.own({
-        closed,
-        abort: async () => await server.close(true),
-        forceDispose: async () => await server.close(true),
-    });
+    const close = async () => await server.close(true);
+    custody.own({ closed, abort: close, forceDispose: close });
     const state = { settled: false, tools: new Map() };
     let settle;
     const completion = new Promise((resolve) => {
@@ -168,13 +166,11 @@ async function startCodex(execution, input, custody) {
             return;
         terminal = result;
         state.settled = true;
-        void server.endInputAndDrain().then(() => {
-            events.end();
-            settle(result);
-        }, () => {
+        const done = () => {
             events.end();
             settle(result);
-        });
+        };
+        void server.endInputAndDrain().then(done, done);
     };
     server.onNotification((notification) => {
         const result = codexNotificationResult(notification, state, events);
@@ -202,13 +198,19 @@ async function startCodex(execution, input, custody) {
             await server.close(true);
             throw signal.reason;
         }
-        finish({ kind: "failed", diagnostic: diagnostic(error) });
+        const message = diagnostic(error);
+        finish({ kind: "failed", diagnostic: message });
+        await server.close(true);
+        throw error instanceof Error ? error : new Error(message);
     }
     finally {
         signal.removeEventListener("abort", abortSetup);
     }
-    if (state.turnId === undefined)
+    if (state.turnId === undefined) {
+        if (terminal?.kind === "failed" && terminal.diagnostic.length > 0)
+            throw new Error(terminal.diagnostic);
         throw new Error("codex app-server did not admit a turn");
+    }
     return {
         admission: { fence: state.turnId },
         events,

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

@@ -79,7 +79,13 @@ async function createPiSession(sdk, execution, input) {
 }
 async function runPiPrompt(native, input, events, state, settle) {
     try {
-        await native.prompt([input.body, ...input.launchTells.map((tell) => tell.text)].join("\n\n"));
+        const prompt = [input.body, ...input.launchTells.map((tell) => tell.text)].filter((part) => part.length > 0).join("\n\n");
+        const schemaPrompt = input.schemaJson === undefined
+            ? prompt
+            : [prompt, "Respond with JSON matching this JSON Schema and no other text:", input.schemaJson]
+                .filter((part) => part.length > 0)
+                .join("\n\n");
+        await native.prompt(schemaPrompt);
         let result;
         if (state.aborting)
             result = { kind: "failed", diagnostic: "Pi session aborted" };