@fungi.computer/shiitake 0.4.0 → 0.5.0

package/README.md

@@ -20,16 +20,7 @@ To add your own behaviour, start the extension guide at
 ## Community-funded
 
 We don't take VC money. Fungi is built in the open and proudly backed by its
-community, including the **$SHIIT** community token.
-
-$SHIT is not $SHIIT.
-
-Official contract address (Solana):
-`412ECWXN3jGbd1kn8ck7eeupWttkmrFkNm9JqfAzpump`
-
-This is the only official address. Fungi will never DM you about the token.
-Nothing here is financial advice, and the token isn't a share in Fungi. More at
-[fungi.computer/funding](https://fungi.computer/funding).
+community.
 
 ## Recover an uncertain send
 

package/dist/agent-control.d.ts

@@ -136,13 +136,14 @@ export declare function waitForAgentSettlement(session: ShiitakeSession, command
 }>>;
 /**
  * A host's refusal of an Agent creating an Agent: the creator asked to give the
- * created Agent more than it holds, or the host cannot tell which Agent is
- * creating. It reaches the caller as an `agents.create` failure.
+ * created Agent more than it holds, the host cannot tell which Agent is
+ * creating, or the request id belongs to another creating Agent or Session. It
+ * reaches the caller as an `agents.create` failure.
  */
 export declare class AgentCreateRefused extends Error {
-    readonly reason: "exceeds_creator" | "no_creator";
+    readonly reason: "exceeds_creator" | "no_creator" | "request_conflict";
     readonly name = "AgentCreateRefused";
-    constructor(reason: "exceeds_creator" | "no_creator", message: string);
+    constructor(reason: "exceeds_creator" | "no_creator" | "request_conflict", message: string);
 }
 /** Compose one authorized Agent-control projection for a single run lease. */
 export declare function createAgentControlSource(directory: AgentControlDirectory): CapabilitySource;

package/dist/agent-control.js

@@ -258,8 +258,9 @@ export async function waitForAgentSettlement(session, commandId, timeoutMs, sign
 }
 /**
  * A host's refusal of an Agent creating an Agent: the creator asked to give the
- * created Agent more than it holds, or the host cannot tell which Agent is
- * creating. It reaches the caller as an `agents.create` failure.
+ * created Agent more than it holds, the host cannot tell which Agent is
+ * creating, or the request id belongs to another creating Agent or Session. It
+ * reaches the caller as an `agents.create` failure.
  */
 export class AgentCreateRefused extends Error {
     reason;

package/dist/delegation.d.ts

@@ -1,7 +1,7 @@
 import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
 import * as Schema from "effect/Schema";
 import { type BirdDogEffect } from "@fungi.computer/bird-dog/effect";
-import type { BirdDogMail } from "@fungi.computer/bird-dog";
+import { type BirdDogMail } from "@fungi.computer/bird-dog";
 import { type PostRoute, type PostRuntime, type PostEnvelope, type PostDeliveryResult } from "@fungi.computer/carrier/post";
 import { type Accepted, type DelegationReceipt, type CancelResult } from "./client.js";
 import type { CommandSettlement, ShiitakeHost, VerifiedAgentReply } from "./index.js";
@@ -41,8 +41,8 @@ export declare class AgentDelegation {
     /**
      * A reply-less envelope is only ever BirdDog's reply to work this Agent
      * sent. Admit it only after the fleet authenticates it against that frozen
-     * mail; the line is then authored by the replying Agent, never by whoever
-     * settled or cancelled the work, and its meta carries the verified reply.
+     * mail. A recipient-left reply remains Agent-authored; a recipient-offline
+     * reply is Hub-authored. Its meta carries only the authenticated reply.
      */
     private authenticatedReply;
     private parseAddressedMail;
@@ -50,6 +50,8 @@ export declare class AgentDelegation {
     receive(raw: PostEnvelope): Promise<PostDeliveryResult>;
     private recordAcceptedNotice;
     private acceptAdmitted;
+    /** Admit local outbox exhaustion through the same Fleet/system reply gate. */
+    localUndeliverable(original: BirdDogMail): Promise<PostDeliveryResult>;
 }
 /** A current correspondent no longer has disclosure authority. */
 export declare class AgentDisclosureRefused extends Error {
@@ -82,25 +84,24 @@ export declare function agentMailRoute(namespace: PostRoute<never, never>["names
         readonly commandId: string;
         readonly outcome: "completed" | "failed" | "cancelled" | "interrupted" | "outcome_unknown";
         readonly diagnostic?: string;
-    } | {
-        readonly outcome: "undeliverable";
-        readonly reason: "recipient_offline" | "recipient_left";
     } | {
         readonly outcome: "accepted";
         readonly commandId: string;
+    } | {
+        readonly outcome: "undeliverable";
+        readonly reason: "recipient_left";
     };
 } | {
     readonly key: string;
     readonly reply: {
         readonly outcome: "undeliverable";
-        readonly reason: "recipient_offline" | "recipient_left";
+        readonly reason: "recipient_offline";
     };
     readonly content: string;
     readonly createdAt: number;
     readonly from: {
-        readonly kind: "agent";
-        readonly agentId: string;
-        readonly sessionId?: string;
+        readonly kind: "system";
+        readonly systemId: "hub";
     };
     readonly to: {
         readonly kind: "agent";
@@ -137,25 +138,24 @@ export declare function agentMailRoute(namespace: PostRoute<never, never>["names
         readonly commandId: string;
         readonly outcome: "completed" | "failed" | "cancelled" | "interrupted" | "outcome_unknown";
         readonly diagnostic?: string;
-    } | {
-        readonly outcome: "undeliverable";
-        readonly reason: "recipient_offline" | "recipient_left";
     } | {
         readonly outcome: "accepted";
         readonly commandId: string;
+    } | {
+        readonly outcome: "undeliverable";
+        readonly reason: "recipient_left";
     };
 } | {
     readonly key: string;
     readonly reply: {
         readonly outcome: "undeliverable";
-        readonly reason: "recipient_offline" | "recipient_left";
+        readonly reason: "recipient_offline";
     };
     readonly content: string;
     readonly createdAt: number;
     readonly from: {
-        readonly kind: "agent";
-        readonly agentId: string;
-        readonly sessionId?: string;
+        readonly kind: "system";
+        readonly systemId: "hub";
     };
     readonly to: {
         readonly kind: "agent";
@@ -192,25 +192,24 @@ export declare function agentMailRoute(namespace: PostRoute<never, never>["names
         readonly commandId: string;
         readonly outcome: "completed" | "failed" | "cancelled" | "interrupted" | "outcome_unknown";
         readonly diagnostic?: string;
-    } | {
-        readonly outcome: "undeliverable";
-        readonly reason: "recipient_offline" | "recipient_left";
     } | {
         readonly outcome: "accepted";
         readonly commandId: string;
+    } | {
+        readonly outcome: "undeliverable";
+        readonly reason: "recipient_left";
     };
 } | {
     readonly key: string;
     readonly reply: {
         readonly outcome: "undeliverable";
-        readonly reason: "recipient_offline" | "recipient_left";
+        readonly reason: "recipient_offline";
     };
     readonly content: string;
     readonly createdAt: number;
     readonly from: {
-        readonly kind: "agent";
-        readonly agentId: string;
-        readonly sessionId?: string;
+        readonly kind: "system";
+        readonly systemId: "hub";
     };
     readonly to: {
         readonly kind: "agent";
@@ -247,25 +246,24 @@ export declare function agentMailRoute(namespace: PostRoute<never, never>["names
         readonly commandId: string;
         readonly outcome: "completed" | "failed" | "cancelled" | "interrupted" | "outcome_unknown";
         readonly diagnostic?: string;
-    } | {
-        readonly outcome: "undeliverable";
-        readonly reason: "recipient_offline" | "recipient_left";
     } | {
         readonly outcome: "accepted";
         readonly commandId: string;
+    } | {
+        readonly outcome: "undeliverable";
+        readonly reason: "recipient_left";
     };
 } | {
     readonly key: string;
     readonly reply: {
         readonly outcome: "undeliverable";
-        readonly reason: "recipient_offline" | "recipient_left";
+        readonly reason: "recipient_offline";
     };
     readonly content: string;
     readonly createdAt: number;
     readonly from: {
-        readonly kind: "agent";
-        readonly agentId: string;
-        readonly sessionId?: string;
+        readonly kind: "system";
+        readonly systemId: "hub";
     };
     readonly to: {
         readonly kind: "agent";
@@ -295,7 +293,7 @@ export declare function agentMailRoute(namespace: PostRoute<never, never>["names
 /** The host's one Post lane, as Agent mail borrows it. */
 export type AgentMailPost = Pick<PostRuntime<{
     agentMail: ReturnType<typeof agentMailRoute>;
-}>, "send" | "read" | "nextWake">;
+}>, "send" | "read" | "nextWake" | "deadLetters">;
 /** Recipient-owned replies and receipt-bearing submissions over the host's one Post lane. */
 export declare class AgentMail {
     private readonly deps;
@@ -305,12 +303,16 @@ export declare class AgentMail {
         identity: () => DelegationIdentity | null | Promise<DelegationIdentity | null>;
         /** Only a typed disclosure refusal becomes undefined; missing settled facts must fail. */
         replySettlement: AgentReplySettlement;
+        /** Route a terminal reply for this sender through its Fleet admission. */
+        onUndeliverable: (original: BirdDogMail, reply: BirdDogMail) => Promise<PostDeliveryResult>;
         drain: () => Promise<void>;
         wake: () => Promise<void>;
     }>);
     private envelope;
     /** Submit one mail and return recipient acceptance or relay-held custody. */
     send(mail: BirdDogMail): Promise<DelegationReceipt>;
+    /** Reconcile exhausted original outbox mail into one local system reply. */
+    stageUndeliverableReplies(): Promise<void>;
     /** Stage the acceptance reply through this Post owner without leaving the transaction. */
     stageAcceptedNotice(mail: BirdDogMail, scopeId: string): void;
     /** BirdDog's mail room: disclosed settlement replies fan out over Post. */

package/dist/delegation.js

@@ -9,6 +9,7 @@ import { agentMailAddressSchema } from "@fungi.computer/seam/machine-link-protoc
 import { BirdDogMailSchema, BirdDogError, settlementReplies, } from "@fungi.computer/bird-dog/effect";
 import * as Effect from "effect/Effect";
 import { messageAuthor } from "@fungi.computer/agar/agents";
+import { undeliverableReply } from "@fungi.computer/bird-dog";
 import { PostEnvelopeSchema, definePostRoute, } from "@fungi.computer/carrier/post";
 import { parseDelegationReceipt, } from "./client.js";
 import { decodeClientSessionCreationRequest } from "./internal/client-boundary.js";
@@ -135,8 +136,8 @@ export class AgentDelegation {
     /**
      * A reply-less envelope is only ever BirdDog's reply to work this Agent
      * sent. Admit it only after the fleet authenticates it against that frozen
-     * mail; the line is then authored by the replying Agent, never by whoever
-     * settled or cancelled the work, and its meta carries the verified reply.
+     * mail. A recipient-left reply remains Agent-authored; a recipient-offline
+     * reply is Hub-authored. Its meta carries only the authenticated reply.
      */
     async authenticatedReply(mail) {
         const delegation = this.fleet().authenticateReply(mail);
@@ -173,19 +174,21 @@ export class AgentDelegation {
         let authenticated;
         const valid = async () => {
             const scope = await this.scope(new AbortController().signal);
-            const frozenUndeliverable = authenticated?.reply.outcome === "undeliverable" &&
-                authenticated.reply.agentId === mail.from.agentId;
+            const sender = mail.from;
+            const authenticatedUndeliverable = authenticated?.reply.outcome === "undeliverable";
             return (address.scopeId === scope.scopeId &&
                 address.agentId === scope.agentId &&
                 mail.to.agentId === scope.agentId &&
                 envelope.key === mail.key &&
-                (frozenUndeliverable ||
-                    scope.agents.some(({ agentId }) => agentId === mail.from.agentId)) &&
+                (authenticatedUndeliverable ||
+                    (sender.kind === "agent" &&
+                        scope.agents.some(({ agentId }) => agentId === sender.agentId))) &&
                 mail.replyTo.every(({ agentId }) => scope.agents.some((agent) => agent.agentId === agentId)) &&
                 (mail.replyTo.length === 0 ||
                     (mail.replyTo.length === 1 &&
-                        mail.replyTo[0]?.agentId === mail.from.agentId &&
-                        mail.replyTo[0].sessionId === mail.from.sessionId)));
+                        sender.kind === "agent" &&
+                        mail.replyTo[0]?.agentId === sender.agentId &&
+                        mail.replyTo[0].sessionId === sender.sessionId)));
         };
         if (mail.replyTo.length === 0)
             authenticated = await this.authenticatedReply(mail);
@@ -215,12 +218,37 @@ export class AgentDelegation {
             this.deps.stageAcceptedNotice(notice, scopeId);
         };
         const receipt = await this.deps.accept(admitted.mail, admitted.reply, stageAcceptedNotice);
+        if (admitted.reply?.outcome === "undeliverable" &&
+            admitted.mail.from.kind === "system") {
+            this.fleet().recordUndeliverableReply(admitted.mail.key.slice(0, -":reply:0".length));
+        }
         const sessionId = admitted.mail.to.sessionId ?? receipt.sessionId;
         return {
             status: "accepted",
             receipt: sessionId === undefined ? receipt : { ...receipt, sessionId },
         };
     }
+    /** Admit local outbox exhaustion through the same Fleet/system reply gate. */
+    async localUndeliverable(original) {
+        const identity = await this.deps.identity();
+        if (identity === null)
+            return "refused";
+        let reply;
+        try {
+            reply = undeliverableReply(original, Date.now());
+        }
+        catch {
+            return "refused";
+        }
+        if (!this.fleet().recordLocalUndeliverable(original, reply))
+            return "refused";
+        return await this.receive({
+            key: reply.key,
+            kind: "agentMail",
+            address: { scopeId: identity.scopeId, agentId: identity.agentId },
+            event: reply,
+        });
+    }
 }
 /** A current correspondent no longer has disclosure authority. */
 export class AgentDisclosureRefused extends Error {
@@ -284,6 +312,39 @@ export class AgentMail {
             throw new Error(`Agent delivery ${row.reason}`);
         throw new Error("Agent did not return a delegated work receipt");
     }
+    /** Reconcile exhausted original outbox mail into one local system reply. */
+    async stageUndeliverableReplies() {
+        const identity = await this.deps.identity();
+        if (identity === null)
+            return;
+        const post = this.deps.post();
+        let cursor;
+        do {
+            const page = post.deadLetters(64, cursor);
+            for (const letter of page.letters) {
+                if (letter.reason !== "exhausted" ||
+                    letter.envelope.kind !== "agentMail")
+                    continue;
+                const envelope = Schema.decodeUnknownOption(PostEnvelopeSchema)(letter.envelope);
+                if (envelope._tag === "None" || envelope.value.kind !== "agentMail")
+                    continue;
+                const original = Schema.decodeUnknownOption(BirdDogMailSchema)(envelope.value.event);
+                const address = Schema.decodeUnknownOption(agentMailAddressSchema)(envelope.value.address);
+                if (original._tag === "None" ||
+                    address._tag === "None" ||
+                    original.value.key !== envelope.value.key ||
+                    original.value.reply !== undefined ||
+                    original.value.from.kind !== "agent" ||
+                    original.value.from.agentId !== identity.agentId ||
+                    address.value.scopeId !== identity.scopeId ||
+                    address.value.agentId !== original.value.to.agentId)
+                    continue;
+                const reply = undeliverableReply(original.value, Date.now());
+                await this.deps.onUndeliverable(original.value, reply);
+            }
+            cursor = page.nextCursor;
+        } while (cursor !== undefined);
+    }
     /** Stage the acceptance reply through this Post owner without leaving the transaction. */
     stageAcceptedNotice(mail, scopeId) {
         this.deps.post().send({

package/dist/fleet.d.ts

@@ -255,8 +255,9 @@ export declare function delegationSendMeta(sender: Readonly<{
     name: string;
 }>, invocationMeta?: Json): DelegationSendMeta;
 /**
- * The host metadata for one authenticated reply line: the replying Agent is
- * its author, and the verified reply rides beside the caller's own path.
+ * The host metadata for one authenticated reply line. An ordinary reply is
+ * authored by its replying Agent; a delivery failure is a Hub/system fact,
+ * while the verified reply retains the failed recipient's identity.
  */
 export declare function delegationReplyMeta(delegation: AuthenticatedDelegationReply, replierName: string): DelegationReplyMeta;
 /**
@@ -279,6 +280,8 @@ export declare function createFleetCorrespondence(options: Omit<FleetDelegationO
     start: (grant: AgentGrant, raw: AgentDelegationTask) => Promise<DelegationReceipt>;
     /** Match a reply to frozen mail and restore the caller's delegation path. */
     authenticateReply: (mail: BirdDogMail) => AuthenticatedDelegationReply | undefined;
+    recordLocalUndeliverable: (original: BirdDogMail, reply: BirdDogMail) => boolean;
+    recordUndeliverableReply: (mailKey: string) => boolean;
     /** Read an existing acceptance receipt without reserving or delivering mail. */
     receipt: (requestId: string) => Accepted | undefined;
     /** Consume a recipient's stable `<mailKey>:accepted` notice. */
@@ -292,6 +295,8 @@ export declare function createFleetDelegation(options: FleetDelegationOptions):
     start: (grant: AgentGrant, raw: AgentDelegationTask) => Promise<DelegationReceipt>;
     /** Match a reply to frozen mail and restore the caller's delegation path. */
     authenticateReply: (mail: BirdDogMail) => AuthenticatedDelegationReply | undefined;
+    recordLocalUndeliverable: (original: BirdDogMail, reply: BirdDogMail) => boolean;
+    recordUndeliverableReply: (mailKey: string) => boolean;
     /** Read an existing acceptance receipt without reserving or delivering mail. */
     receipt: (requestId: string) => Accepted | undefined;
     /** Consume a recipient's stable `<mailKey>:accepted` notice. */

package/dist/fleet.js

@@ -318,16 +318,21 @@ export function delegationSendMeta(sender, invocationMeta) {
         };
 }
 /**
- * The host metadata for one authenticated reply line: the replying Agent is
- * its author, and the verified reply rides beside the caller's own path.
+ * The host metadata for one authenticated reply line. An ordinary reply is
+ * authored by its replying Agent; a delivery failure is a Hub/system fact,
+ * while the verified reply retains the failed recipient's identity.
  */
 export function delegationReplyMeta(delegation, replierName) {
-    return {
-        ...authorMeta({
+    const author = delegation.reply.outcome === "undeliverable" &&
+        delegation.reply.reason === "recipient_offline"
+        ? authorMeta({ id: "hub/system", name: "Hub/system" })
+        : authorMeta({
             id: delegation.reply.agentId,
             name: replierName,
             kind: "agent",
-        }),
+        });
+    return {
+        ...author,
         delegation: {
             ancestors: [...delegation.ancestors],
             maxDepth: delegation.maxDepth,
@@ -341,7 +346,7 @@ const delegationMetadata = z.object({
 const delegationRowSchema = z.lazy(() => z.strictObject({
     input: z.string(),
     mail: z.string(),
-    state: z.enum(["pending", "held", "accepted"]),
+    state: z.enum(["pending", "held", "accepted", "undeliverable"]),
     receipt: z.string().nullable(),
 }));
 const heldRecipientOffline = {
@@ -351,7 +356,7 @@ const heldRecipientOffline = {
 };
 const decodeMail = Schema.decodeUnknownSync(Schema.fromJsonString(BirdDogMailSchema));
 function bindRecipientSession(mail, sessionId) {
-    if (mail.from.sessionId === undefined)
+    if (mail.from.kind !== "agent")
         throw new DirectoryError(503, "partial_init");
     return {
         ...mail,
@@ -434,7 +439,7 @@ export function createFleetCorrespondence(options) {
             throw new DirectoryError(503, "partial_init");
         if (row.input !== input)
             throw new DirectoryError(409, "request_conflict");
-        if (row.state === "held")
+        if (row.state === "held" || row.state === "undeliverable")
             return heldRecipientOffline;
         if (row.state === "accepted") {
             if (row.receipt === null)
@@ -472,17 +477,36 @@ export function createFleetCorrespondence(options) {
             mail.reply.outcome === "accepted" ||
             !mail.key.endsWith(suffix))
             return undefined;
-        const row = read(mail.key.slice(0, -suffix.length));
-        if (row === undefined)
+        const mailKey = mail.key.slice(0, -suffix.length);
+        const row = read(mailKey);
+        if (row === undefined || row.state === "undeliverable")
             return undefined;
         const sent = decodeMail(row.mail);
-        if (mail.reply.outcome !== "undeliverable" &&
-            mail.from.sessionId === undefined)
+        if (sent.key !== mailKey)
             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)
+        const systemUndeliverable = mail.reply.outcome === "undeliverable" &&
+            mail.reply.reason === "recipient_offline" &&
+            mail.from.kind === "system";
+        if (systemUndeliverable) {
+            if (row.state !== "held" ||
+                sent.from.kind !== "agent" ||
+                mail.key !== `${sent.key}:reply:0` ||
+                mail.to.agentId !== sent.from.agentId ||
+                mail.to.sessionId !== sent.from.sessionId)
+                return undefined;
+        }
+        else {
+            if (sent.from.kind !== "agent" ||
+                mail.from.kind !== "agent" ||
+                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 (mail.reply.outcome === "undeliverable" &&
+            mail.reply.reason === "recipient_offline" &&
+            !systemUndeliverable)
             return undefined;
         if (mail.reply.outcome !== "undeliverable" &&
             row.state === "accepted" &&
@@ -496,16 +520,28 @@ export function createFleetCorrespondence(options) {
             return undefined;
         let reply;
         if (mail.reply.outcome === "undeliverable") {
-            const undeliverable = { agentId: mail.from.agentId, ...mail.reply };
+            const agentId = systemUndeliverable
+                ? sent.to.agentId
+                : mail.from.kind === "agent"
+                    ? mail.from.agentId
+                    : undefined;
+            if (agentId === undefined)
+                return undefined;
+            const undeliverable = { agentId, ...mail.reply };
+            const sessionId = systemUndeliverable
+                ? sent.to.sessionId
+                : mail.from.kind === "agent"
+                    ? mail.from.sessionId
+                    : undefined;
             reply =
-                mail.from.sessionId === undefined
+                sessionId === undefined
                     ? undeliverable
-                    : { ...undeliverable, sessionId: mail.from.sessionId };
+                    : { ...undeliverable, sessionId };
         }
         else {
-            const sessionId = mail.from.sessionId;
-            if (sessionId === undefined)
+            if (mail.from.kind !== "agent")
                 return undefined;
+            const sessionId = mail.from.sessionId;
             reply = { agentId: mail.from.agentId, sessionId, ...mail.reply };
         }
         return {
@@ -514,6 +550,29 @@ export function createFleetCorrespondence(options) {
             reply,
         };
     }
+    /** Bind an exhausted local Carrier row to its frozen sender correspondence. */
+    function recordLocalUndeliverable(original, reply) {
+        const row = read(original.key);
+        if (row === undefined ||
+            (row.state !== "pending" && row.state !== "held") ||
+            original.from.kind !== "agent" ||
+            original.reply !== undefined ||
+            JSON.stringify(decodeMail(row.mail)) !== JSON.stringify(original) ||
+            reply.key !== `${original.key}:reply:0` ||
+            reply.from.kind !== "system" ||
+            reply.reply?.outcome !== "undeliverable" ||
+            reply.reply.reason !== "recipient_offline" ||
+            reply.to.agentId !== original.from.agentId ||
+            reply.to.sessionId !== original.from.sessionId ||
+            reply.replyTo.length !== 0)
+            return false;
+        store.recordHeld(original.key);
+        return read(original.key)?.state === "held";
+    }
+    /** Make a successfully admitted system disposition replay-ineligible. */
+    function recordUndeliverableReply(mailKey) {
+        return store.recordUndeliverable(mailKey);
+    }
     /** Read only the existing acceptance receipt; do not reserve or deliver mail. */
     function receipt(requestId) {
         const row = read(requestId);
@@ -524,9 +583,11 @@ export function createFleetCorrespondence(options) {
     /** Atomically bind the recipient Session carried by a late acceptance notice. */
     function recordAcceptedNotice(mail) {
         const suffix = ":accepted";
+        if (mail.from.kind !== "agent")
+            return undefined;
+        const sender = mail.from;
         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);
@@ -534,29 +595,31 @@ export function createFleetCorrespondence(options) {
         if (row === undefined)
             return undefined;
         const sent = decodeMail(row.mail);
+        if (sent.from.kind !== "agent")
+            return undefined;
+        const sentSender = sent.from;
         const path = delegationMetadata.safeParse(sent.meta);
-        if (sent.from.sessionId === undefined ||
-            !path.success ||
+        if (!path.success ||
             path.data.delegation === undefined ||
             mail.key !== `${sent.key}:accepted` ||
-            mail.from.agentId !== sent.to.agentId ||
+            sender.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)
+                sent.to.sessionId !== sender.sessionId) ||
+            mail.to.agentId !== sentSender.agentId ||
+            mail.to.sessionId !== sentSender.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)
+                current.sessionId !== sender.sessionId)
                 return undefined;
         }
         const accepted = {
             status: "accepted",
             commandId: mail.reply.commandId,
-            sessionId: mail.from.sessionId,
+            sessionId: sender.sessionId,
         };
-        store.recordReceipt(requestId, JSON.stringify(accepted), row.mail, JSON.stringify(bindRecipientSession(sent, mail.from.sessionId)));
+        store.recordReceipt(requestId, JSON.stringify(accepted), row.mail, JSON.stringify(bindRecipientSession(sent, sender.sessionId)));
         return accepted;
     }
     return {
@@ -564,6 +627,8 @@ export function createFleetCorrespondence(options) {
         start,
         /** Match a reply to frozen mail and restore the caller's delegation path. */
         authenticateReply,
+        recordLocalUndeliverable,
+        recordUndeliverableReply,
         /** Read an existing acceptance receipt without reserving or delivering mail. */
         receipt,
         /** Consume a recipient's stable `<mailKey>:accepted` notice. */

package/dist/internal/admission-door.js

@@ -16,9 +16,14 @@ function decodeReply(request) {
         return undefined;
     const reply = requireDecoded(decodeVerifiedReply(request.reply), "Verified Agent reply is invalid");
     const mail = request.mail;
+    const agentAuthored = mail?.from.kind === "agent" &&
+        mail.from.agentId === reply.agentId &&
+        mail.from.sessionId === reply.sessionId;
+    const systemUndeliverable = mail?.from.kind === "system" &&
+        reply.outcome === "undeliverable" &&
+        reply.reason === "recipient_offline";
     if (mail?.replyTo.length !== 0 ||
-        mail.from.agentId !== reply.agentId ||
-        mail.from.sessionId !== reply.sessionId ||
+        (!agentAuthored && !systemUndeliverable) ||
         request.command.type !== "prompt" ||
         request.command.delivery !== "steer")
         throw new ShiitakeError("contract", "invalid", "Verified Agent reply does not match its mail");

package/dist/internal/woodstock/fleet-store.d.ts

@@ -34,4 +34,5 @@ export declare function createFleetDelegationStore(storage: WatchdogSqliteOwner)
     reserve(requestId: string, input: string, mail: string): void;
     recordReceipt(requestId: string, receipt: string, expectedMail: string, acceptedMail: string): void;
     recordHeld(requestId: string): void;
+    recordUndeliverable(requestId: string): boolean;
 };

package/dist/internal/woodstock/fleet-store.js

@@ -86,11 +86,16 @@ export function createFleetDelegationStore(storage) {
   ) STRICT`);
     storage.sql.exec(`CREATE TABLE IF NOT EXISTS shiitake_fleet_held_delegations (
     request_id TEXT PRIMARY KEY
+  ) STRICT`);
+    storage.sql
+        .exec(`CREATE TABLE IF NOT EXISTS shiitake_fleet_undeliverable_delegations (
+    request_id TEXT PRIMARY KEY
   ) STRICT`);
     return {
         read: (requestId) => storage.sql
             .exec(`SELECT delegation.input, delegation.mail,
             CASE
+              WHEN terminal.request_id IS NOT NULL THEN 'undeliverable'
               WHEN held.request_id IS NOT NULL THEN 'held'
               WHEN delegation.receipt IS NOT NULL THEN 'accepted'
               ELSE 'pending'
@@ -99,6 +104,8 @@ export function createFleetDelegationStore(storage) {
           FROM shiitake_fleet_delegations AS delegation
           LEFT JOIN shiitake_fleet_held_delegations AS held
             ON held.request_id = delegation.request_id
+          LEFT JOIN shiitake_fleet_undeliverable_delegations AS terminal
+            ON terminal.request_id = delegation.request_id
           WHERE delegation.request_id = ?`, requestId)
             .toArray()[0],
         /** Every recipient-accepted delegation, newest first. */
@@ -135,7 +142,27 @@ export function createFleetDelegationStore(storage) {
             storage.transactionSync(() => {
                 storage.sql.exec(`INSERT OR IGNORE INTO shiitake_fleet_held_delegations (request_id)
           SELECT request_id FROM shiitake_fleet_delegations
-          WHERE request_id = ? AND receipt IS NULL`, requestId);
+          WHERE request_id = ? AND receipt IS NULL
+            AND NOT EXISTS (
+              SELECT 1 FROM shiitake_fleet_undeliverable_delegations
+              WHERE request_id = ?
+            )`, requestId, requestId);
+            });
+        },
+        recordUndeliverable(requestId) {
+            return storage.transactionSync(() => {
+                const held = storage.sql
+                    .exec(`SELECT delegation.request_id
+            FROM shiitake_fleet_delegations AS delegation
+            JOIN shiitake_fleet_held_delegations AS held
+              ON held.request_id = delegation.request_id
+            WHERE delegation.request_id = ? AND delegation.receipt IS NULL`, requestId)
+                    .toArray()[0];
+                if (held === undefined)
+                    return false;
+                storage.sql.exec("INSERT OR IGNORE INTO shiitake_fleet_undeliverable_delegations(request_id) VALUES (?)", requestId);
+                storage.sql.exec("DELETE FROM shiitake_fleet_held_delegations WHERE request_id = ?", requestId);
+                return true;
             });
         },
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fungi.computer/shiitake",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "author": "Levi <levi@technomancy.dev>",
   "description": "Effect-native durable Session acceptance and bounded run orchestration",
   "type": "module",
@@ -82,10 +82,10 @@
     "node": ">=22.13"
   },
   "dependencies": {
-    "@fungi.computer/bird-dog": "0.2.0",
+    "@fungi.computer/bird-dog": "0.2.1",
     "@fungi.computer/cairn": "0.1.0",
     "@fungi.computer/carrier": "0.2.0",
-    "@fungi.computer/knapsack": "0.3.0",
+    "@fungi.computer/knapsack": "0.3.1",
     "@fungi.computer/mule": "0.2.0",
     "@fungi.computer/mycelium": "0.2.2",
     "@fungi.computer/seam": "0.2.0",
@@ -94,7 +94,7 @@
     "zod": "4.4.3",
     "@earendil-works/pi-ai": "1.3.0",
     "@fungi.computer/gills": "0.2.0",
-    "@fungi.computer/agar": "0.3.1"
+    "@fungi.computer/agar": "0.4.0"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "5.20260828.1",