@fungi.computer/shiitake 0.2.0 → 0.3.0

package/dist/fleet.js

@@ -71,6 +71,7 @@ const agentRowSchema = z.lazy(() => z.strictObject({
     agent_id: z.string(),
     name: z.string(),
     actor_user_id: z.string(),
+    created_by: z.string().min(1).max(256).nullable(),
     created_at: z.number().int().nonnegative(),
     updated_at: z.number().int().nonnegative(),
 }));
@@ -86,6 +87,7 @@ export const agentCreationSchema = z.lazy(() => z.strictObject({
     name: z.string().min(1).max(256),
     requestId: z.string().min(1).max(256),
     configuration: z.string().min(1).max(4096),
+    createdBy: z.string().min(1).max(256).nullable().optional(),
 }));
 /** Owner-only rename input: an Agent's new display name. */
 export const agentRenameSchema = z.lazy(() => z.strictObject({
@@ -110,6 +112,7 @@ function asDirectoryAgent(row) {
         throw new DirectoryError(503, "partial_init");
     return Object.freeze({
         agentId: agent.value,
+        createdBy: parsed.data.created_by,
         name: parsed.data.name,
         createdAt: parsed.data.created_at,
         updatedAt: parsed.data.updated_at,
@@ -142,6 +145,8 @@ export function createAgentDirectory(sql) {
             const existing = readStored(agentId.value);
             if (existing === null)
                 throw new DirectoryError(503, "partial_init");
+            if (existing.createdBy !== (command.createdBy ?? null))
+                throw new DirectoryError(409, "request_conflict");
             return existing;
         }
         return null;
@@ -165,7 +170,7 @@ export function createAgentDirectory(sql) {
             throw new DirectoryError(409, "name_taken");
         const agentId = agentIds.agent.generate();
         const now = Date.now();
-        store.reserve(agentId, command.name, actorUserId, now, command.requestId, command.configuration);
+        store.reserve(agentId, command.name, actorUserId, now, command.requestId, command.configuration, command.createdBy ?? null);
         const created = readStored(agentId);
         if (created === null)
             throw new DirectoryError(503, "partial_init");
@@ -258,6 +263,7 @@ export const agentDelegationTaskSchema = z.lazy(() => z.strictObject({
 }));
 /** 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 })),
@@ -287,7 +293,7 @@ export async function delegationProvenance(session, toolCallCode) {
  * stay on that reply's own line and never travel onward.
  */
 export function delegationSendMeta(sender, invocationMeta) {
-    const author = authorMeta(sender);
+    const author = authorMeta({ ...sender, kind: "agent" });
     const inherited = invocationMeta === undefined
         ? undefined
         : FungiMessageMetaSchema.parse(invocationMeta).delegation;
@@ -307,7 +313,11 @@ export function delegationSendMeta(sender, invocationMeta) {
  */
 export function delegationReplyMeta(delegation, replierName) {
     return {
-        ...authorMeta({ id: delegation.reply.agentId, name: replierName }),
+        ...authorMeta({
+            id: delegation.reply.agentId,
+            name: replierName,
+            kind: "agent",
+        }),
         delegation: {
             ancestors: [...delegation.ancestors],
             maxDepth: delegation.maxDepth,
@@ -325,11 +335,11 @@ const delegationRowSchema = z.lazy(() => z.strictObject({
 }));
 const decodeMail = Schema.decodeUnknownSync(Schema.fromJsonString(BirdDogMailSchema));
 /**
- * Hosted BirdDog submission and Pending observation. The durable row freezes
+ * BirdDog submission and reply authentication. The durable row freezes
  * correspondence before transport; an ambiguous delivery reuses that exact mail.
  * Shiitake owns work deduplication, execution and settlement; Post owns replies.
  */
-export function createFleetDelegation(options) {
+export function createFleetCorrespondence(options) {
     const store = createFleetDelegationStore(options.storage);
     function read(requestId) {
         const row = store.read(requestId);
@@ -351,7 +361,8 @@ export function createFleetDelegation(options) {
             : undefined;
         const ancestors = inherited?.ancestors ?? [];
         const maxDepth = Math.min(grant.maxDepth ?? 8, inherited?.maxDepth ?? 8);
-        if (ancestors.includes(task.agentId) || parent.agentId === task.agentId)
+        // Ancestry bounds work depth; it does not remove authorized peer targets.
+        if (parent.agentId === task.agentId)
             throw new AgentGrantError("delegation_loop");
         if (ancestors.length >= maxDepth)
             throw new AgentGrantError("delegation_depth");
@@ -407,22 +418,6 @@ export function createFleetDelegation(options) {
         store.recordReceipt(task.requestId, JSON.stringify(receipt));
         return receipt;
     }
-    async function delegate(grant, task) {
-        const accepted = await start(grant, task);
-        const row = read(task.requestId);
-        if (row === undefined)
-            throw new DirectoryError(503, "partial_init");
-        const mail = decodeMail(row.mail);
-        const settlement = await options.readSettlement(mail.to.agentId, mail.to.sessionId, accepted.commandId);
-        return settlement === undefined
-            ? pending(1000)
-            : {
-                kind: "settled",
-                agentId: mail.to.agentId,
-                sessionId: mail.to.sessionId,
-                ...settlement,
-            };
-    }
     /**
      * Authenticate one arriving reply against the frozen mail this owner sent.
      * It must be BirdDog's single reply key for that mail, mirror its sender and
@@ -464,11 +459,79 @@ export function createFleetDelegation(options) {
             reply,
         };
     }
+    /** 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
+            ? undefined
+            : parseAccepted(encoded);
+    }
     return {
-        /** Authenticate a reply against its frozen mail and restore the caller's path. */
-        authenticateReply,
-        /** Submit once and return the existing Shiitake admission receipt. */
+        /** Submit frozen mail or reuse its recorded Session admission receipt. */
         start,
+        /** Match a reply to frozen mail and restore the caller's delegation path. */
+        authenticateReply,
+        /** Read an existing acceptance receipt without reserving or delivering mail. */
+        receipt,
+    };
+}
+/** Local hosts may observe exact work directly; remote correspondence never pulls it. */
+export function createFleetDelegation(options) {
+    const correspondence = createFleetCorrespondence(options);
+    const store = createFleetDelegationStore(options.storage);
+    async function delegate(grant, task) {
+        const accepted = await correspondence.start(grant, task);
+        const raw = store.read(task.requestId);
+        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);
+        return settlement === undefined
+            ? pending(1000)
+            : {
+                kind: "settled",
+                agentId: mail.to.agentId,
+                sessionId: mail.to.sessionId,
+                ...settlement,
+            };
+    }
+    /**
+     * The newest delegation this owner sent whose work has not settled at its
+     * target, so the owner is still waiting for a reply; undefined when none.
+     */
+    async function outstanding() {
+        for (const raw of store.sent()) {
+            const row = delegationRowSchema.parse(raw);
+            if (row.receipt === null)
+                continue;
+            const { to } = decodeMail(row.mail);
+            const { commandId } = parseAccepted(row.receipt);
+            const target = {
+                agentId: to.agentId,
+                sessionId: to.sessionId,
+                commandId,
+            };
+            let settlement;
+            try {
+                settlement = await options.readSettlement(to.agentId, to.sessionId, commandId);
+            }
+            catch (cause) {
+                // Work whose state cannot be read is still owed; say why.
+                return {
+                    ...target,
+                    unreadable: cause instanceof Error ? cause.message : "unreadable",
+                };
+            }
+            if (settlement === undefined)
+                return target;
+        }
+        return undefined;
+    }
+    return {
+        /** The delegated work this owner still waits on, if any. */
+        outstanding,
+        /** Authenticate a reply against its frozen mail and restore the caller's path. */
+        ...correspondence,
         /** Submit or poll the exact turn, yielding Agar Pending until settled. */
         delegate,
     };

package/dist/hosted.js

@@ -169,6 +169,7 @@ function hostedPort(manifest, revision, grants) {
                 clear: () => Effect.fail(unavailable("Attention")),
             }),
             hasPendingSteer: () => Effect.fail(unavailable("Steering")),
+            sessionPosition: () => Effect.fail(unavailable("Session timeline")),
             hasSuccessfulToolResult: () => Effect.fail(unavailable("A tool result")),
             observe: () => Effect.die(unavailable("Observation")),
             transact: () => Effect.fail(new ShiitakeError("extensions", "rejected", "A hosted extension has no Agent transaction")),

package/dist/http-routes.d.ts

@@ -42,7 +42,7 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                 };
             };
             output: {
-                readonly cause: "closed" | "conflict" | "incompatible" | "invalid" | "rejected" | "unavailable" | "storage_pressure" | "context_too_large";
+                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;
@@ -109,7 +109,7 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                 };
             };
             output: {
-                readonly cause: "closed" | "conflict" | "incompatible" | "invalid" | "rejected" | "unavailable" | "storage_pressure" | "context_too_large";
+                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;
@@ -150,7 +150,7 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
         $get: {
             input: {};
             output: {
-                readonly cause: "closed" | "conflict" | "incompatible" | "invalid" | "rejected" | "unavailable" | "storage_pressure" | "context_too_large";
+                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;
@@ -178,6 +178,34 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
             status: 200;
         };
     };
+} & {
+    "/sessions/:sessionId/pending/latest": {
+        $get: {
+            input: {
+                param: {
+                    sessionId: string;
+                };
+            };
+            output: {
+                readonly requestId: string;
+                readonly meta?: any;
+                readonly origin?: {
+                    readonly extensionId: string;
+                    readonly correlation: string | null;
+                } | undefined;
+                readonly commandId: string;
+                readonly text: string;
+                readonly images?: readonly {
+                    readonly type: "image";
+                    readonly data: string;
+                    readonly mimeType: string;
+                }[] | undefined;
+                readonly delivery: import("./client.js").PromptDelivery;
+            } | null;
+            outputFormat: "json";
+            status: 200;
+        };
+    };
 } & {
     "/sessions/:sessionId/model-preference": {
         $get: {
@@ -210,7 +238,7 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                 };
             };
             output: {
-                readonly cause: "closed" | "conflict" | "incompatible" | "invalid" | "rejected" | "unavailable" | "storage_pressure" | "context_too_large";
+                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;
@@ -235,6 +263,47 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
             status: 204;
         };
     };
+} & {
+    "/sessions/:sessionId/withdraw": {
+        $post: {
+            input: {
+                json: {
+                    readonly requestId: 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: {
+                json: {
+                    readonly requestId: string;
+                };
+            } & {
+                param: {
+                    sessionId: string;
+                };
+            };
+            output: {
+                readonly status: "accepted";
+                readonly commandId: string;
+            } | {
+                readonly status: "unknown";
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
 } & {
     "/sessions/:sessionId/command": {
         $post: {
@@ -282,7 +351,7 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                 };
             };
             output: {
-                readonly cause: "closed" | "conflict" | "incompatible" | "invalid" | "rejected" | "unavailable" | "storage_pressure" | "context_too_large";
+                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;
@@ -384,6 +453,8 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
             output: {
                 readonly status: "accepted";
                 readonly commandId: string;
+            } | {
+                readonly status: "unknown";
             } | {
                 readonly status: "too_late";
                 readonly commandId: string;
@@ -409,7 +480,7 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                 };
             };
             output: {
-                readonly cause: "closed" | "conflict" | "incompatible" | "invalid" | "rejected" | "unavailable" | "storage_pressure" | "context_too_large";
+                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;
@@ -435,7 +506,9 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                 readonly hasMore: boolean;
                 readonly oldestCursor?: string | null | undefined;
                 readonly messages: readonly {
+                    readonly requestId?: string | undefined;
                     readonly meta?: any;
+                    readonly data?: any;
                     readonly origin?: {
                         readonly extensionId: string;
                         readonly correlation: string | null;
@@ -499,6 +572,7 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                             };
                             thoughtSignature?: string | undefined;
                             namespace?: string | undefined;
+                            argumentsError?: string | undefined;
                         } | {
                             type: "thinking";
                             thinking: string;
@@ -555,20 +629,10 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                         rawStopReason?: string | undefined;
                         endTurn?: boolean | undefined;
                         timestamp: number;
+                        durationMs?: number | undefined;
                     } | {
-                        role: "toolResult";
                         toolCallId: string;
-                        toolName: string;
-                        content: ({
-                            type: "text";
-                            text: string;
-                            textSignature?: string | undefined;
-                        } | {
-                            type: "image";
-                            data: string;
-                            mimeType: string;
-                        })[];
-                        details?: any;
+                        role: "toolResult";
                         usage?: {
                             input: number;
                             output: number;
@@ -585,6 +649,18 @@ 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;
@@ -600,7 +676,6 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                             complete: boolean;
                         } | undefined;
                         isError: boolean;
-                        timestamp: number;
                     };
                 }[];
                 readonly terminals: readonly {
@@ -623,7 +698,7 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                     readonly sequence: number;
                     readonly at: number;
                     readonly trigger: import("./client.js").SessionCompactionTrigger;
-                    readonly result: "nothing_to_compact" | "failed";
+                    readonly result: "nothing_to_compact" | "failed" | "stale" | "insufficient";
                     readonly diagnostic: string | null;
                 }[] | undefined;
                 readonly sandboxFailures?: readonly {
@@ -632,7 +707,7 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                     readonly executionId: string;
                     readonly adapter: string;
                     readonly buildSha: string | null;
-                    readonly tag: "Unknown" | "SourceInvalid" | "GuestThrew" | "DeadlineExceeded" | "Cancelled" | "DispatchLost" | "SandboxCrashed" | "BadResponse" | "ResultTooLarge" | "ResultNotJson" | "CapabilityFailed";
+                    readonly tag: "Unknown" | "SourceInvalid" | "GuestThrew" | "DeadlineExceeded" | "SandboxBusy" | "Cancelled" | "DispatchLost" | "SandboxCrashed" | "BadResponse" | "ResultTooLarge" | "ResultNotJson" | "CapabilityFailed";
                     readonly fields: {
                         readonly [x: string]: any;
                     };
@@ -641,6 +716,7 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                 readonly pending: {
                     readonly total: number;
                     readonly prompts: readonly {
+                        readonly requestId: string;
                         readonly meta?: any;
                         readonly origin?: {
                             readonly extensionId: string;
@@ -698,6 +774,13 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                     readonly textTruncated: boolean;
                     readonly thinkingTruncated: boolean;
                 } | null;
+                readonly toolOutput: readonly {
+                    readonly toolCallId: string;
+                    readonly revision: number;
+                    readonly tail: string;
+                    readonly droppedBytes: number;
+                    readonly totalBytes: number;
+                }[];
                 readonly extensions: {
                     readonly [x: string]: {
                         readonly status: "running";
@@ -717,6 +800,7 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                     readonly since: number;
                     readonly extensionId: string;
                     readonly expiresAt?: number | undefined;
+                    readonly inbox?: false | undefined;
                 }[];
                 readonly context?: {
                     readonly tokens: number;
@@ -759,7 +843,7 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                 };
             };
             output: {
-                readonly cause: "closed" | "conflict" | "incompatible" | "invalid" | "rejected" | "unavailable" | "storage_pressure" | "context_too_large";
+                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;

package/dist/http-routes.js

@@ -171,6 +171,10 @@ export function createShiitakeHttpRoutes(resolveSession, listSessions, createSes
         }
         const page = await listSessions(cursor);
         return context.json(page, 200);
+    })
+        .get("/sessions/:sessionId/pending/latest", async (context) => {
+        const session = await resolveSession(decodeClientSessionId(context.req.param("sessionId")), context.get("shiitakeMeta"));
+        return context.json(await session.latestPending(), 200);
     })
         .get("/sessions/:sessionId/model-preference", async (context) => {
         const session = await resolveSession(decodeClientSessionId(context.req.param("sessionId")), context.get("shiitakeMeta"));
@@ -187,6 +191,15 @@ export function createShiitakeHttpRoutes(resolveSession, listSessions, createSes
         const session = await resolveSession(decodeClientSessionId(context.req.param("sessionId")), context.get("shiitakeMeta"));
         await session.modelPreference.set(context.req.valid("json"));
         return context.body(null, 204);
+    })
+        .post("/sessions/:sessionId/withdraw", validator("json", (value, context) => {
+        const decoded = decodeClientSessionCreationRequest(value);
+        if (decoded._tag === "Failure")
+            return context.json(toShiitakeErrorWire(invalidRequest("Withdrawal request is invalid")), 400);
+        return decoded.success;
+    }), async (context) => {
+        const session = await resolveSession(decodeClientSessionId(context.req.param("sessionId")), context.get("shiitakeMeta"));
+        return context.json(await session.withdraw(context.req.valid("json").requestId), 200);
     })
         .post("/sessions/:sessionId/command", validator("json", (value, context) => {
         const decoded = decodeClientSessionCommandRequest(value);
@@ -238,5 +251,9 @@ export function createShiitakeHttpRoutes(resolveSession, listSessions, createSes
             includeSandboxFailures: query.includeSandboxFailures === "true",
         }));
     })
-        .onError((error, context) => context.json(toShiitakeErrorWire(error), 503));
+        .onError((error, context) => context.json(toShiitakeErrorWire(error), error instanceof ShiitakeError &&
+        error.boundary === "runtime" &&
+        error.cause === "rejected"
+        ? 403
+        : 503));
 }

package/dist/index.d.ts

@@ -5,9 +5,10 @@ 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, PromptCommand, PromptDelivery, SendOptions, ReadOptions, SessionCommand, SessionCommandHandler, SessionExtensionControls, SessionExtensionSlots, SessionFrame, SessionMessage, SessionProgress, SessionContext, SessionSnapshot, SessionInboxState, SessionSummary, SessionSummaryPage, SessionSummaryRow, SessionActivity, AgentRunningWork, SessionTerminal, SessionCompactionMarker, SessionCompactionNotice, SessionCompactionTrigger, ShiitakeEventSourceConstructor, SessionWatch, ShiitakeAgent, ShiitakeSession, SubscribeOptions, TooLate, WatchOptions, } from "./client.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 { 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, StorageBudget, CompactionBudget, CompactionOptions, GrantsDelivery, GrantsDeliveryResult, ShiitakeOptions, ShiitakeOwnerAgent, ToolAccess, HostMetaOptions, StandardHostMetaResult, StandardHostMetaSchema, ToolSource, } from "./internal/contracts.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";
 export type { BorrowedCompactionViewV0, CompactionHandoffErrorV0, CompactionHandoffResultV0, CompactionHandoffV0, ExtensionCapabilityV0, ExtensionGrantV0, ExtensionRosterV0, ExtensionSlotV0, ExtensionStatusV0, RosteredExtensionV0, } from "./extensions.js";
 export { ShiitakeError, type ShiitakeErrorBoundary, type ShiitakeErrorCause, } from "./errors.js";
 /** Public construction namespace for the Promise-facing durable harness. */

package/dist/internal/accepted-run-executor.d.ts

@@ -18,6 +18,11 @@ export declare function executeAcceptedRun(options: ShiitakeEffectOptions, coreD
     readonly kind: "outcome_unknown";
 } | {
     kind: "failed" | "cancelled";
+    reason?: never;
 } | {
     kind: "completed";
+    reason?: never;
+} | {
+    kind: "failed";
+    reason: string;
 }, never, never>;

package/dist/internal/accepted-run-executor.js

@@ -7,10 +7,11 @@ import * as Schema from "effect/Schema";
 import { ShiitakeError } from "../errors.js";
 import { ExtensionId } from "../extension-contract.js";
 import { publishOwnerObservation } from "./observation-kernel.js";
+import { returnedFailureReason } from "./run-failure-reason.js";
 import { coreProtocolDigest } from "./extension-roster.js";
 import { runAcceptedCommand, runAcceptedCompaction, ToolSetupError, } from "./run-scope.js";
 import { CompactionCommitError } from "./compaction/session-compaction.js";
-import { isCompactCommand, loadAcceptedRun, readExtensionAdmissionOrigin, recordWorkSettlement, } from "./woodstock/index.js";
+import { BrokenSessionError, isCompactCommand, loadAcceptedRun, readExtensionAdmissionOrigin, recordWorkSettlement, } from "./woodstock/index.js";
 /** Bounded process-loss recovery for every accepted Agent turn. */
 export const agentTurnRecovery = Object.freeze({ maxRecoveries: 2 });
 function runtimeFailure(message) {
@@ -23,7 +24,9 @@ function runtimeFailure(message) {
  */
 function failedDecision(error) {
     const category = `${error.boundary}:${error.cause}`;
-    const diagnostic = error instanceof ToolSetupError || error instanceof CompactionCommitError
+    const diagnostic = error instanceof ToolSetupError ||
+        error instanceof CompactionCommitError ||
+        error instanceof BrokenSessionError
         ? error.diagnostic
         : error.boundary === "model"
             ? error.message
@@ -114,7 +117,7 @@ export function executeAcceptedRun(options, coreDigest, job, extensions) {
                 : yield* coreProtocolDigest(fileTools.map((tool) => tool.descriptor.name)),
             extensions: extensions?.runParticipants() ?? [],
         };
-        const run = yield* runAcceptedCommand(options, prepared, executionContract, extensionModules, fileTools, extensionHandoff, extensions === undefined
+        const { run, failureReason } = yield* runAcceptedCommand(options, prepared, executionContract, extensionModules, fileTools, extensionHandoff, extensions === undefined
             ? undefined
             : () => extensions.promptSections(runIdentity, participants));
         switch (run.status) {
@@ -123,7 +126,10 @@ export function executeAcceptedRun(options, coreDigest, job, extensions) {
             case "cancelled":
                 return { kind: "cancelled" };
             case "failed":
-                return { kind: "failed" };
+                return {
+                    kind: "failed",
+                    reason: failureReason ?? returnedFailureReason(run),
+                };
         }
     }).pipe(Effect.catch((error) => logRunFailed(job.jobId, error).pipe(Effect.as(failedDecision(error)))));
 }

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

@@ -1,6 +1,7 @@
 import type { BirdDogMail } from "@fungi.computer/bird-dog";
 import * as Effect from "effect/Effect";
 import type { AcceptedWork } from "./client-boundary.js";
+import type { WithdrawResult } from "../client.js";
 import type { Json } from "../extensions.js";
 import { type HostMetaOptions } from "./host-meta.js";
 import { ShiitakeError } from "../errors.js";
@@ -50,6 +51,8 @@ export type AdmitWithin = (request: AdmitRequest) => AdmitResult;
 export type AdmissionBoundary = "request" | "reconcile";
 /** The one accepted-command door. Nothing else writes accepted commands. */
 export type AdmissionDoor = Readonly<{
+    /** In the same owner transaction as admission, keep the receipt or fence the key. */
+    withdraw: (sessionId: string, requestId: string) => Effect.Effect<WithdrawResult, ShiitakeError>;
     /** Admit one prompt in its own transaction. */
     admit: (request: AdmitRequest, boundary?: AdmissionBoundary) => Effect.Effect<AdmitResult, ShiitakeError>;
     /**

package/dist/internal/admission-door.js

@@ -2,9 +2,9 @@ import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
 import { checkHostMeta } from "./host-meta.js";
 import { ShiitakeError } from "../errors.js";
-import { decodeClientAcceptedCommand, decodeClientSessionId, requireDecoded, } from "./client-boundary.js";
+import { decodeClientAcceptedCommand, decodeClientSessionId, decodeClientSessionCreationRequestId, requireDecoded, } from "./client-boundary.js";
 import { publishOwnerObservation } from "./observation-kernel.js";
-import { AdmissionOriginSchema, acceptSessionCommandOwned, readSessionCommandAdmissionByRequest, hasStoredSession, VerifiedAgentReplySchema, } from "./woodstock/index.js";
+import { AdmissionOriginSchema, acceptSessionCommandOwned, readSessionCommandAdmissionByRequest, withdrawSessionRequestOwned, assertSessionRequestNotWithdrawn, hasStoredSession, VerifiedAgentReplySchema, } from "./woodstock/index.js";
 const decodeOrigin = Schema.decodeUnknownResult(AdmissionOriginSchema, {
     onExcessProperty: "error",
 });
@@ -42,6 +42,7 @@ export function openAdmissionDoor(input) {
     const admitDecoded = (request, touched) => {
         const { sessionId, origin } = request;
         const command = request.command;
+        assertSessionRequestNotWithdrawn(input.owner, sessionId, command.requestId);
         if (request.requireExistingSession &&
             !hasStoredSession(input.owner, sessionId))
             throw new ShiitakeError("contract", "closed", "Session target is unavailable");
@@ -95,6 +96,15 @@ export function openAdmissionDoor(input) {
     const transact = (body, boundary = "request") => run((admit) => body((request) => admit(decode(request))), boundary);
     return Object.freeze({
         transact,
+        withdraw: (sessionId, requestId) => Effect.try({
+            try: () => ({
+                sessionId: decodeClientSessionId(sessionId),
+                requestId: decodeClientSessionCreationRequestId({ requestId }),
+            }),
+            catch: (error) => error instanceof ShiitakeError
+                ? error
+                : new ShiitakeError("contract", "invalid", "Withdrawal request is invalid"),
+        }).pipe(Effect.flatMap((decoded) => run(() => withdrawSessionRequestOwned(input.owner, decoded.sessionId, decoded.requestId), "request"))),
         admit: (request, boundary) => Effect.try({
             try: () => decode(request),
             catch: (error) => error instanceof ShiitakeError

package/dist/internal/client-boundary.js

@@ -5,7 +5,13 @@ const encoder = new TextEncoder();
 function boundedText(maximumBytes) {
     return Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(maximumBytes), Schema.makeFilter((value) => encoder.encode(value).byteLength <= maximumBytes));
 }
-const boundedId = boundedText(256);
+/** A lone UTF-16 surrogate; SQLite's UTF-8 text columns cannot store one. */
+const loneSurrogate = /\p{Cs}/u;
+/**
+ * Session and request ids are indexed SQLite text, so they must be well-formed
+ * Unicode: a lone surrogate would be stored as U+FFFD and never match again.
+ */
+const boundedId = boundedText(256).check(Schema.makeFilter((value) => !loneSurrogate.test(value)));
 /**
  * The one prompt-text grammar. Human, mail, host and extension prompts are all
  * admitted through the accepted-command door under this bound. Text is