@fungi.computer/shiitake 0.3.0 → 0.4.0

package/dist/fleet.js

@@ -1,13 +1,31 @@
-import { SessionTerminalSchema } from "./client-wire.js";
-import { usage, createFleetDirectoryStore, createFleetDelegationStore, } from "./internal/woodstock/index.js";
+export { commandSettlementSchema } from "./client-wire.js";
+import { createFleetDirectoryStore, createFleetDelegationStore, } from "./internal/woodstock/index.js";
 import { pending } from "@fungi.computer/agar";
 import { BirdDogMailSchema } from "@fungi.computer/bird-dog/effect";
 import * as Schema from "effect/Schema";
-import { parseAccepted } from "./client.js";
+import { parseAccepted, parseDelegationReceipt, } from "./client.js";
 import { checkHostMeta } from "./internal/host-meta.js";
 import { defineIdFamily } from "@fungi.computer/cairn/id";
+import { deterministicReplayKey } from "@fungi.computer/cairn";
 import { z } from "zod";
 import { authorMeta, FungiMessageMetaSchema, } from "@fungi.computer/agar/agents";
+/**
+ * One idempotency identity for a caller-owned delegation request.
+ * The target Session is deliberately excluded: a sessionless send learns it
+ * only after acceptance, when recall must still resolve the original receipt.
+ */
+export async function agentDelegationRequestKey(input) {
+    const ownerIdentity = input.owner.kind === "hosted"
+        ? [input.owner.scopeId, input.owner.agentId]
+        : [input.owner.agentId];
+    return deterministicReplayKey("agent-delegation-request", [
+        input.owner.kind,
+        ...ownerIdentity,
+        input.sourceSessionId,
+        input.targetAgentId,
+        input.requestId,
+    ]);
+}
 const identity = z.string().min(1).max(256);
 /** Operations explicitly admitted by the host. */
 export const agentActionSchema = z.enum([
@@ -261,14 +279,6 @@ export const agentDelegationTaskSchema = z.lazy(() => z.strictObject({
         .min(1)
         .max(256 * 1024),
 }));
-/** Exact host facts encoded over internal transports, without transcript content. */
-export const commandSettlementSchema = Schema.Struct({
-    acceptedSender: Schema.NullOr(Schema.String),
-    terminal: SessionTerminalSchema,
-    content: Schema.String,
-    usage: Schema.Array(Schema.Struct({ provider: Schema.String, model: Schema.String, usage })),
-    toolCalls: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-});
 /**
  * Provenance for one delegated send from the invoking Agent's Session. The
  * model program's digest is frozen with the replay input, so a retried tool
@@ -331,9 +341,23 @@ const delegationMetadata = z.object({
 const delegationRowSchema = z.lazy(() => z.strictObject({
     input: z.string(),
     mail: z.string(),
+    state: z.enum(["pending", "held", "accepted"]),
     receipt: z.string().nullable(),
 }));
+const heldRecipientOffline = {
+    status: "held",
+    reason: "recipient_offline",
+    message: "waiting: recipient offline",
+};
 const decodeMail = Schema.decodeUnknownSync(Schema.fromJsonString(BirdDogMailSchema));
+function bindRecipientSession(mail, sessionId) {
+    if (mail.from.sessionId === undefined)
+        throw new DirectoryError(503, "partial_init");
+    return {
+        ...mail,
+        to: { ...mail.to, sessionId },
+    };
+}
 /**
  * BirdDog submission and reply authentication. The durable row freezes
  * correspondence before transport; an ambiguous delivery reuses that exact mail.
@@ -384,21 +408,20 @@ export function createFleetCorrespondence(options) {
         });
         let row = read(task.requestId);
         if (row === undefined) {
-            let sessionId = task.sessionId;
-            if (sessionId === undefined) {
-                const opened = await options.open(task.agentId);
-                try {
-                    sessionId = await opened.agent.createSession(task.requestId);
-                }
-                finally {
-                    await opened.release();
-                }
-            }
             const from = { kind: "agent", ...parent };
             let mail = {
                 key: task.requestId,
                 from,
-                to: { kind: "agent", agentId: task.agentId, sessionId },
+                to: task.sessionId === undefined
+                    ? {
+                        kind: "agent",
+                        agentId: task.agentId,
+                    }
+                    : {
+                        kind: "agent",
+                        agentId: task.agentId,
+                        sessionId: task.sessionId,
+                    },
                 replyTo: [from],
                 content: task.text,
                 createdAt: Date.now(),
@@ -411,11 +434,26 @@ export function createFleetCorrespondence(options) {
             throw new DirectoryError(503, "partial_init");
         if (row.input !== input)
             throw new DirectoryError(409, "request_conflict");
-        if (row.receipt !== null)
+        if (row.state === "held")
+            return heldRecipientOffline;
+        if (row.state === "accepted") {
+            if (row.receipt === null)
+                throw new DirectoryError(503, "partial_init");
             return parseAccepted(row.receipt);
+        }
         assertAgentGrant(grant, "delegate", task.agentId);
-        const receipt = parseAccepted(JSON.stringify(await options.deliver(decodeMail(row.mail))));
-        store.recordReceipt(task.requestId, JSON.stringify(receipt));
+        const receipt = parseDelegationReceipt(JSON.stringify(await options.deliver(decodeMail(row.mail))));
+        if (receipt.status === "held")
+            store.recordHeld(task.requestId);
+        else {
+            const sent = decodeMail(row.mail);
+            const sessionId = receipt.sessionId ?? sent.to.sessionId;
+            if (sessionId === undefined)
+                throw new DirectoryError(503, "partial_init");
+            const accepted = { ...receipt, sessionId };
+            store.recordReceipt(task.requestId, JSON.stringify(accepted), row.mail, JSON.stringify(bindRecipientSession(sent, sessionId)));
+            return accepted;
+        }
         return receipt;
     }
     /**
@@ -431,28 +469,45 @@ export function createFleetCorrespondence(options) {
         const suffix = ":reply:0";
         if (mail.replyTo.length !== 0 ||
             mail.reply === undefined ||
+            mail.reply.outcome === "accepted" ||
             !mail.key.endsWith(suffix))
             return undefined;
         const row = read(mail.key.slice(0, -suffix.length));
         if (row === undefined)
             return undefined;
         const sent = decodeMail(row.mail);
+        if (mail.reply.outcome !== "undeliverable" &&
+            mail.from.sessionId === undefined)
+            return undefined;
         if (mail.from.agentId !== sent.to.agentId ||
             mail.from.sessionId !== sent.to.sessionId ||
             mail.to.agentId !== sent.from.agentId ||
             mail.to.sessionId !== sent.from.sessionId)
             return undefined;
-        if (row.receipt !== null &&
-            parseAccepted(row.receipt).commandId !== mail.reply.commandId)
-            return undefined;
+        if (mail.reply.outcome !== "undeliverable" &&
+            row.state === "accepted" &&
+            row.receipt !== null) {
+            const sentResult = parseAccepted(row.receipt);
+            if (sentResult.commandId !== mail.reply.commandId)
+                return undefined;
+        }
         const path = delegationMetadata.parse(sent.meta).delegation;
         if (path === undefined)
             return undefined;
-        const reply = {
-            agentId: mail.from.agentId,
-            sessionId: mail.from.sessionId,
-            ...mail.reply,
-        };
+        let reply;
+        if (mail.reply.outcome === "undeliverable") {
+            const undeliverable = { agentId: mail.from.agentId, ...mail.reply };
+            reply =
+                mail.from.sessionId === undefined
+                    ? undeliverable
+                    : { ...undeliverable, sessionId: mail.from.sessionId };
+        }
+        else {
+            const sessionId = mail.from.sessionId;
+            if (sessionId === undefined)
+                return undefined;
+            reply = { agentId: mail.from.agentId, sessionId, ...mail.reply };
+        }
         return {
             ancestors: path.ancestors.slice(0, -1),
             maxDepth: path.maxDepth,
@@ -461,10 +516,48 @@ export function createFleetCorrespondence(options) {
     }
     /** Read only the existing acceptance receipt; do not reserve or deliver mail. */
     function receipt(requestId) {
-        const encoded = read(requestId)?.receipt;
-        return encoded === undefined || encoded === null
+        const row = read(requestId);
+        return row?.state !== "accepted" || row.receipt === null
             ? undefined
-            : parseAccepted(encoded);
+            : parseAccepted(row.receipt);
+    }
+    /** Atomically bind the recipient Session carried by a late acceptance notice. */
+    function recordAcceptedNotice(mail) {
+        const suffix = ":accepted";
+        if (mail.replyTo.length !== 0 ||
+            mail.reply?.outcome !== "accepted" ||
+            mail.from.sessionId === undefined ||
+            !mail.key.endsWith(suffix))
+            return undefined;
+        const requestId = mail.key.slice(0, -suffix.length);
+        const row = read(requestId);
+        if (row === undefined)
+            return undefined;
+        const sent = decodeMail(row.mail);
+        const path = delegationMetadata.safeParse(sent.meta);
+        if (sent.from.sessionId === undefined ||
+            !path.success ||
+            path.data.delegation === undefined ||
+            mail.key !== `${sent.key}:accepted` ||
+            mail.from.agentId !== sent.to.agentId ||
+            (sent.to.sessionId !== undefined &&
+                sent.to.sessionId !== mail.from.sessionId) ||
+            mail.to.agentId !== sent.from.agentId ||
+            mail.to.sessionId !== sent.from.sessionId)
+            return undefined;
+        if (row.state === "accepted" && row.receipt !== null) {
+            const current = parseAccepted(row.receipt);
+            if (current.commandId !== mail.reply.commandId ||
+                current.sessionId !== mail.from.sessionId)
+                return undefined;
+        }
+        const accepted = {
+            status: "accepted",
+            commandId: mail.reply.commandId,
+            sessionId: mail.from.sessionId,
+        };
+        store.recordReceipt(requestId, JSON.stringify(accepted), row.mail, JSON.stringify(bindRecipientSession(sent, mail.from.sessionId)));
+        return accepted;
     }
     return {
         /** Submit frozen mail or reuse its recorded Session admission receipt. */
@@ -473,6 +566,8 @@ export function createFleetCorrespondence(options) {
         authenticateReply,
         /** Read an existing acceptance receipt without reserving or delivering mail. */
         receipt,
+        /** Consume a recipient's stable `<mailKey>:accepted` notice. */
+        recordAcceptedNotice,
     };
 }
 /** Local hosts may observe exact work directly; remote correspondence never pulls it. */
@@ -485,13 +580,18 @@ export function createFleetDelegation(options) {
         if (raw === undefined)
             throw new DirectoryError(503, "partial_init");
         const mail = decodeMail(delegationRowSchema.parse(raw).mail);
-        const settlement = await options.readSettlement(mail.to.agentId, mail.to.sessionId, accepted.commandId);
+        if (accepted.status === "held")
+            return pending(1000);
+        const sessionId = mail.to.sessionId ?? accepted.sessionId;
+        if (sessionId === undefined)
+            throw new DirectoryError(503, "partial_init");
+        const settlement = await options.readSettlement(mail.to.agentId, sessionId, accepted.commandId);
         return settlement === undefined
             ? pending(1000)
             : {
                 kind: "settled",
                 agentId: mail.to.agentId,
-                sessionId: mail.to.sessionId,
+                sessionId,
                 ...settlement,
             };
     }
@@ -504,8 +604,12 @@ export function createFleetDelegation(options) {
             const row = delegationRowSchema.parse(raw);
             if (row.receipt === null)
                 continue;
+            if (row.state !== "accepted")
+                continue;
             const { to } = decodeMail(row.mail);
             const { commandId } = parseAccepted(row.receipt);
+            if (to.sessionId === undefined)
+                throw new DirectoryError(503, "partial_init");
             const target = {
                 agentId: to.agentId,
                 sessionId: to.sessionId,

package/dist/http-routes.d.ts

@@ -217,7 +217,7 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
             output: {
                 readonly providerId: string;
                 readonly modelId: string;
-                readonly reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+                readonly reasoning?: "high" | "low" | "max" | "medium" | "minimal" | "xhigh" | undefined;
             } | null;
             outputFormat: "json";
             status: 200;
@@ -230,7 +230,7 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                 json: {
                     readonly providerId: string;
                     readonly modelId: string;
-                    readonly reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+                    readonly reasoning?: "high" | "low" | "max" | "medium" | "minimal" | "xhigh" | undefined;
                 } | null;
             } & {
                 param: {
@@ -251,7 +251,7 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                 json: {
                     readonly providerId: string;
                     readonly modelId: string;
-                    readonly reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+                    readonly reasoning?: "high" | "low" | "max" | "medium" | "minimal" | "xhigh" | undefined;
                 } | null;
             } & {
                 param: {
@@ -297,6 +297,7 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
             output: {
                 readonly status: "accepted";
                 readonly commandId: string;
+                readonly sessionId?: string | undefined;
             } | {
                 readonly status: "unknown";
             };
@@ -453,6 +454,7 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
             output: {
                 readonly status: "accepted";
                 readonly commandId: string;
+                readonly sessionId?: string | undefined;
             } | {
                 readonly status: "unknown";
             } | {
@@ -465,6 +467,75 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
             status: 200;
         };
     };
+} & {
+    "/sessions/:sessionId/settlement": {
+        $get: {
+            input: {
+                query: {
+                    readonly commandId: string | string[];
+                    readonly timeoutMs: string | string[];
+                };
+            } & {
+                param: {
+                    sessionId: string;
+                };
+            };
+            output: {
+                readonly cause: "closed" | "conflict" | "incompatible" | "invalid" | "rejected" | "unavailable" | "state_reset_required" | "storage_pressure";
+                readonly _tag: "ShiitakeError";
+                readonly boundary: "contract" | "extensions" | "instructions" | "model" | "runtime" | "store" | "tools";
+                readonly message: string;
+                readonly requestId?: string | undefined;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {
+                query: {
+                    readonly commandId: string | string[];
+                    readonly timeoutMs: string | string[];
+                };
+            } & {
+                param: {
+                    sessionId: string;
+                };
+            };
+            output: {
+                readonly acceptedSender: string | null;
+                readonly terminal: {
+                    readonly commandId: string;
+                    readonly outcome: "completed" | "cancelled" | "failed" | "interrupted";
+                    readonly sequence: number;
+                    readonly diagnostic: string | null;
+                    readonly meta?: any;
+                };
+                readonly content: string;
+                readonly usage: readonly {
+                    model: string;
+                    provider: import("@fungi.computer/mule/effect").ProviderId;
+                    usage: {
+                        input: number;
+                        output: number;
+                        cacheRead: number;
+                        cacheWrite: number;
+                        cacheWrite1h?: number | undefined;
+                        reasoning?: number | undefined;
+                        totalTokens: number;
+                        cost: {
+                            input: number;
+                            output: number;
+                            cacheRead: number;
+                            cacheWrite: number;
+                            total: number;
+                        };
+                    };
+                }[];
+                readonly toolCalls: number;
+            } | null;
+            outputFormat: "json";
+            status: 200;
+        };
+    };
 } & {
     "/sessions/:sessionId": {
         $get: {
@@ -579,13 +650,13 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                             thinkingSignature?: string | undefined;
                             redacted?: boolean | undefined;
                         })[];
-                        api: import("@earendil-works/pi-ai").Api;
-                        provider: import("@earendil-works/pi-ai").ProviderId;
+                        api: import("@fungi.computer/mule/effect").Api;
+                        provider: import("@fungi.computer/mule/effect").ProviderId;
                         model: string;
                         responseModel?: string | undefined;
                         responseId?: string | undefined;
                         providerThinkingLevel?: string | undefined;
-                        thinkingLevel?: import("@earendil-works/pi-ai").ModelThinkingLevel | undefined;
+                        thinkingLevel?: import("@fungi.computer/mule/effect").ModelThinkingLevel | undefined;
                         diagnostics?: {
                             type: string;
                             timestamp: number;
@@ -615,7 +686,7 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                                 total: number;
                             };
                         };
-                        stopReason: import("@earendil-works/pi-ai").StopReason;
+                        stopReason: import("@fungi.computer/mule/effect").StopReason;
                         deferred?: {
                             provider: string;
                             modelId: string;
@@ -626,6 +697,7 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                             data?: any;
                         } | undefined;
                         errorMessage?: string | undefined;
+                        providerError?: string | undefined;
                         rawStopReason?: string | undefined;
                         endTurn?: boolean | undefined;
                         timestamp: number;
@@ -633,6 +705,17 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                     } | {
                         toolCallId: string;
                         role: "toolResult";
+                        timestamp: number;
+                        content: ({
+                            type: "text";
+                            text: string;
+                            textSignature?: string | undefined;
+                        } | {
+                            type: "image";
+                            data: string;
+                            mimeType: string;
+                        })[];
+                        toolName: string;
                         usage?: {
                             input: number;
                             output: number;
@@ -649,18 +732,6 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                                 total: number;
                             };
                         } | undefined;
-                        content: ({
-                            type: "text";
-                            text: string;
-                            textSignature?: string | undefined;
-                        } | {
-                            type: "image";
-                            data: string;
-                            mimeType: string;
-                        })[];
-                        timestamp: number;
-                        durationMs?: number | undefined;
-                        toolName: string;
                         nestedCalls?: {
                             calls: {
                                 id: string;
@@ -676,6 +747,7 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                             complete: boolean;
                         } | undefined;
                         isError: boolean;
+                        durationMs?: number | undefined;
                     };
                 }[];
                 readonly terminals: readonly {

package/dist/http-routes.js

@@ -6,7 +6,7 @@ import { validator } from "hono/validator";
 import * as Schema from "effect/Schema";
 import { ShiitakeError, toShiitakeErrorWire } from "./errors.js";
 import { JsonValueSchema } from "./internal/json-value.js";
-import { decodeClientIdentity, decodeClientEventsQuery, decodeClientReadQuery, decodeClientSessionCommandRequest, decodeClientSessionCreationRequest, decodeClientPageCursor, decodeClientSessionId, } from "./internal/client-boundary.js";
+import { decodeClientIdentity, decodeClientEventsQuery, decodeClientReadQuery, decodeClientSettlementQuery, decodeClientSessionCommandRequest, decodeClientSessionCreationRequest, decodeClientPageCursor, decodeClientSessionId, } from "./internal/client-boundary.js";
 const decodeJsonValue = Schema.decodeUnknownResult(Schema.fromJsonString(JsonValueSchema));
 /** One encoded extension output; its contract, not Hono, types the value. */
 function jsonResponse(value) {
@@ -218,6 +218,20 @@ export function createShiitakeHttpRoutes(resolveSession, listSessions, createSes
             return context.body(null, 204);
         }
         return context.json(await session.command(command), 200);
+    })
+        .get("/sessions/:sessionId/settlement", validator("query", (value, context) => {
+        const decoded = decodeClientSettlementQuery(value);
+        if (decoded._tag === "Failure")
+            return context.json(toShiitakeErrorWire(invalidRequest("Settlement request is invalid")), 400);
+        return decoded.success;
+    }), async (context) => {
+        const session = await resolveSession(decodeClientSessionId(context.req.param("sessionId")), context.get("shiitakeMeta"));
+        const { commandId, timeoutMs } = context.req.valid("query");
+        const settled = await session.readSettlement(commandId, {
+            timeoutMs,
+            signal: context.req.raw.signal,
+        });
+        return context.json(settled ?? null, 200);
     })
         .get("/sessions/:sessionId", validator("query", (value, context) => {
         const decoded = decodeClientReadQuery(value);

package/dist/index.d.ts

@@ -5,7 +5,7 @@ import type { VerifiedAgentReply } from "./internal/woodstock/index.js";
 import type { BirdDogEffect } from "@fungi.computer/bird-dog/effect";
 import type { Accepted } from "./client.js";
 import type { ShiitakeOptions, ShiitakeOwnerAgent } from "./internal/contracts.js";
-export type { AbortCommand, AgentExtensionControls, BranchCommand, CompactCommand, CancelCommand, CancelResult, Accepted, ForkCommand, ForkedSession, OperatorCommand, TitleCommand, PromptCommand, PromptDelivery, SendOptions, ReadOptions, SessionCommand, SessionCommandHandler, SessionExtensionControls, SessionExtensionSlots, SessionFrame, SessionMessage, SessionProgress, SessionToolOutput, SessionContext, SessionSnapshot, SessionInboxState, SessionSummary, SessionSummaryPage, SessionSummaryRow, SessionActivity, AgentRunningWork, SessionTerminal, SessionCompactionMarker, SessionCompactionNotice, SessionCompactionTrigger, ShiitakeEventSourceConstructor, SessionWatch, ShiitakeAgent, ShiitakeSession, SubscribeOptions, TooLate, UnknownRequest, WatchOptions, } from "./client.js";
+export type { AbortCommand, AgentExtensionControls, BranchCommand, CompactCommand, CancelCommand, CancelResult, Accepted, DelegationReceipt, Held, ForkCommand, ForkedSession, OperatorCommand, TitleCommand, PromptCommand, PromptDelivery, SendOptions, ReadOptions, SessionCommand, SessionCommandHandler, SessionExtensionControls, SessionExtensionSlots, SessionFrame, SessionMessage, SessionProgress, SessionToolOutput, SessionContext, SessionSnapshot, SessionInboxState, SessionSummary, SessionSummaryPage, SessionSummaryRow, SessionActivity, AgentRunningWork, SessionTerminal, SessionCompactionMarker, SessionCompactionNotice, SessionCompactionTrigger, ShiitakeEventSourceConstructor, SessionWatch, ShiitakeAgent, ShiitakeSession, SubscribeOptions, TooLate, UnknownRequest, WatchOptions, } from "./client.js";
 export type { ColdSessionPage, ColdSessionPageRequest, ColdSessionRow, } from "./cold-sessions.js";
 export { parseForkedSession, parseSessionFrame, parseSessionSnapshot, } from "./client.js";
 export type { InstructionSnapshot, InstructionSource, ModelAcquisition, ModelDescription, ModelSource, RuntimeHost, RuntimePendingWork, SqliteCursor, SqliteOwner, SqliteValue, SqliteRow, StoragePressureCheck, CompactionBudget, CompactionOptions, GrantsDelivery, GrantsDeliveryResult, ShiitakeOptions, ShiitakeOwnerAgent, ToolAccess, HostMetaOptions, StandardHostMetaResult, StandardHostMetaSchema, ToolSource, } from "./internal/contracts.js";
@@ -22,7 +22,7 @@ export type ShiitakeHost = Readonly<{
     readSettlement: (sessionId: string, commandId: string) => Promise<CommandSettlement | undefined>;
     agent: ShiitakeOwnerAgent;
     /** Durably admit one addressed mail item through the host owner. */
-    acceptMail: (mail: BirdDogMail, meta?: HostJson, reply?: VerifiedAgentReply) => Promise<Accepted>;
+    acceptMail: (mail: BirdDogMail, meta?: HostJson, reply?: VerifiedAgentReply, stageAcceptedNotice?: (mail: BirdDogMail) => void) => Promise<Accepted>;
 }>;
 /** Construct the host-only Promise facade over the canonical Effect program. */
 export declare function makeHost(options: ShiitakeOptions, mailRoom: BirdDogEffect): Promise<ShiitakeHost>;

package/dist/internal/admission-door.d.ts

@@ -32,6 +32,8 @@ export type AdmitRequest = Readonly<{
      * host passes it, after checking the reply against the mail it sent.
      */
     reply?: VerifiedAgentReply;
+    /** Synchronous owner-local side effect committed with a mail admission. */
+    onAccepted?: (sessionId: string, commandId: string) => void;
 }>;
 /** Outcome of one door admission. */
 export type AdmitResult = Readonly<{

package/dist/internal/admission-door.js

@@ -35,6 +35,7 @@ export function openAdmissionDoor(input) {
         when: request.when,
         mail: request.mail,
         reply: decodeReply(request),
+        onAccepted: request.onAccepted,
         meta: request.meta === undefined
             ? undefined
             : checkHostMeta(input.hostMeta, request.meta),
@@ -69,6 +70,7 @@ export function openAdmissionDoor(input) {
                 input.enqueue(work, request.mail);
             }
             : undefined, targetWorkId, request.reply);
+        request.onAccepted?.(sessionId, accepted.accepted.commandId);
         touched.set(sessionId, (touched.get(sessionId) ?? false) || accepted.delivery === "new");
         return Object.freeze({
             status: "accepted",

package/dist/internal/client-boundary.d.ts

@@ -8,6 +8,16 @@ export declare const PromptImageSchema: Schema.Struct<{
 }>;
 /** Delivery policy for input accepted while a Session run is active. */
 export type PromptDelivery = "steer" | "followUp";
+/** One bounded exact-command read, shared by the in-process and HTTP doors. */
+export declare const decodeClientSettlementRequest: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Result.Result<{
+    readonly commandId: string;
+    readonly timeoutMs: number;
+}, Schema.SchemaError>;
+/** Query encoding of the same bounded exact-command read. */
+export declare const decodeClientSettlementQuery: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Result.Result<{
+    readonly commandId: string;
+    readonly timeoutMs: number;
+}, Schema.SchemaError>;
 declare const SessionCreationRequestSchema: Schema.Struct<{
     readonly requestId: Schema.String;
 }>;

package/dist/internal/client-boundary.js

@@ -27,6 +27,16 @@ export const PromptImageSchema = Schema.Struct({
 const PromptImagesSchema = Schema.Array(PromptImageSchema).check(Schema.isMinLength(1), Schema.isMaxLength(8));
 const PromptDeliverySchema = Schema.Literals(["steer", "followUp"]);
 const SessionIdSchema = boundedId;
+/** One bounded exact-command read, shared by the in-process and HTTP doors. */
+export const decodeClientSettlementRequest = Schema.decodeUnknownResult(Schema.Struct({
+    commandId: boundedId,
+    timeoutMs: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(30_000)),
+}), { onExcessProperty: "error" });
+/** Query encoding of the same bounded exact-command read. */
+export const decodeClientSettlementQuery = Schema.decodeUnknownResult(Schema.Struct({
+    commandId: boundedId,
+    timeoutMs: Schema.NumberFromString.check(Schema.isInt(), Schema.isBetween({ minimum: 0, maximum: 30_000 })),
+}), { onExcessProperty: "error" });
 const decodeSessionPageCursorValue = Schema.decodeUnknownResult(boundedText(512));
 const SessionCreationRequestSchema = Schema.Struct({ requestId: boundedId });
 const PromptCommandSchema = Schema.Struct({

package/dist/internal/compaction/compaction.d.ts

@@ -5,7 +5,7 @@
  * Range selection follows Pi Durable spec §8.7 (`earendil-works/pi` at
  * 8efd314f) and token estimates are pi-ai's own.
  */
-import type { Api, Model, Usage } from "@earendil-works/pi-ai";
+import type { Api, Model, Usage } from "@fungi.computer/mule/effect";
 import type { MuleStreamFunction } from "@fungi.computer/mule/effect";
 import * as Effect from "effect/Effect";
 import type { BorrowedCompactionViewV0 } from "../../extensions.js";
@@ -14,14 +14,14 @@ import { createFileOps, type CompactionSettings } from "./utils.js";
 export type CompactionSourceEntry = Readonly<{
     id: string;
     kind: "message";
-    message: import("@earendil-works/pi-ai").Message;
+    message: import("@fungi.computer/mule/effect").Message;
 }> | Readonly<{
     id: string;
     kind: "compaction";
     /** Pi's entry head: the first entry the summary keeps. */
     head: string;
     /** Pi's entry model message: the summary the model reads. */
-    model: import("@earendil-works/pi-ai").UserMessage;
+    model: import("@fungi.computer/mule/effect").UserMessage;
     usage: Usage;
     details?: Readonly<{
         readFiles: readonly string[];
@@ -30,8 +30,8 @@ export type CompactionSourceEntry = Readonly<{
 }>;
 export type CompactionPreparation = Readonly<{
     firstKeptEntryId: string;
-    messagesToSummarize: readonly import("@earendil-works/pi-ai").Message[];
-    turnPrefixMessages: readonly import("@earendil-works/pi-ai").Message[];
+    messagesToSummarize: readonly import("@fungi.computer/mule/effect").Message[];
+    turnPrefixMessages: readonly import("@fungi.computer/mule/effect").Message[];
     isSplitTurn: boolean;
     tokensBefore: number;
     previousSummary?: string;

package/dist/internal/compaction/compaction.js

@@ -1,13 +1,14 @@
+import { normalizeContext } from "@earendil-works/pi-ai/utils/transcript";
+import { streamModel } from "@fungi.computer/mule/effect";
 // Leaf helpers, not Pi's root entry, which also evaluates its validators.
 import { estimateContextTokens, estimateMessageTokens, } from "@earendil-works/pi-ai/utils/estimate";
 import { retryAssistantCall } from "@earendil-works/pi-ai/utils/retry";
 import { contentText } from "@earendil-works/pi-ai/utils/text";
-import { normalizeContext } from "@earendil-works/pi-ai/utils/transcript";
 import { uuidv7 } from "@earendil-works/pi-ai/utils/uuid";
 import * as Effect from "effect/Effect";
 import { ShiitakeError } from "../../errors.js";
 import { computeFileLists, createFileOps, extractFileOpsFromMessage, formatFileOperations, serializeConversation, SUMMARIZATION_PROMPT, SUMMARIZATION_SYSTEM_PROMPT, TURN_PREFIX_SUMMARIZATION_PROMPT, UPDATE_SUMMARIZATION_PROMPT, compactionSummaryText, summaryFailure, } from "./utils.js";
-/** A summary is a model call: its bounded provider message is shown. */
+/** A summary uses the stream failure diagnostic, never failed-turn provider prose. */
 function failure(message) {
     return new ShiitakeError("model", "rejected", message);
 }
@@ -210,9 +211,7 @@ function completeSummarization(model, context, options, streamFn) {
         cacheRetention: "none",
         sessionId: options.sessionId ?? uuidv7(),
     };
-    return retryAssistantCall(() => streamFn
-        ? Promise.resolve(streamFn(model, normalizeContext(context), requestOptions)).then((stream) => stream.result())
-        : import("@earendil-works/pi-ai/compat").then(({ completeSimple }) => completeSimple(model, context, requestOptions)), RETRY_POLICY, requestOptions.signal);
+    return retryAssistantCall(() => Promise.resolve((streamFn ?? streamModel)(model, normalizeContext(context), requestOptions)).then((stream) => stream.result()), RETRY_POLICY, requestOptions.signal);
 }
 function buildContext(promptText) {
     return {