@fungi.computer/shiitake 0.4.0 → 0.6.0

package/dist/client-wire.js

@@ -282,10 +282,16 @@ export function parseForkedSession(value) {
 /** Exact command facts shared by Session clients and host fleet transports. */
 export const commandSettlementSchema = Schema.Struct({
     acceptedSender: Schema.NullOr(Schema.String),
+    delegator: 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)),
+    waitingOnYou: Schema.Array(Schema.Struct({
+        itemId: Schema.String,
+        kind: Schema.String,
+        summary: Schema.String,
+    })).check(Schema.isMaxLength(8)),
 });
 /** A timeout is null on the JSON wire and undefined at the client boundary. */
 export function parseCommandSettlement(value) {

package/dist/client.d.ts

@@ -5,12 +5,13 @@ export { type SessionAttention } from "./session-attention.js";
 import type { SandboxFailureEvent } from "@fungi.computer/mycelium";
 import type { ModelPreference } from "./internal/model-preference.js";
 import type { Message } from "@fungi.computer/mule/effect";
-import type { ExtensionSlotV0, ExtensionStatusV0, Json } from "./extensions.js";
+import type { ExtensionCommandCallerV0, ExtensionSlotV0, ExtensionStatusV0, Json } from "./extensions.js";
 import type { AbortCommand, BranchCommand, CompactCommand, OperatorCommand, TitleCommand, CancelCommand, ForkCommand, PromptCommand, PromptDelivery, SessionCommand } from "./internal/client-boundary.js";
 export { createShiitakeClient, type ShiitakeClientOptions, } from "./remote-client.js";
 export { bindAgentExtension, bindSessionExtension, type BoundAgentExtensionV0, type BoundCallV0, type BoundSessionExtensionV0, type ExtensionViewV0, type ScopedCommandsV0, } from "./extension-client.js";
 export { AcceptedSchema, DelegationReceiptSchema, HeldSchema, parseAccepted, parseDelegationReceipt, parseCancelResult, parseLatestPendingPrompt, parseWithdrawResult, parseForkedSession, parseSessionFrame, parseSessionSnapshot, parseSessionSummaryPage, parseShiitakeError, } from "./client-wire.js";
 export type { AbortCommand, BranchCommand, CompactCommand, CancelCommand, ForkCommand, OperatorCommand, PromptCommand, PromptDelivery, SessionCommand, TitleCommand, } from "./internal/client-boundary.js";
+export { participantSnapshot, visitorPendingPrompt, visitorSnapshot, visitorView, type ParticipantPolicy, type VisitorPendingPrompt, type VisitorView, } from "./client-visitor.js";
 /** Semantic acknowledgement returned after one durable acceptance commit. */
 export type Accepted = Readonly<{
     /** Indicates that the owner transaction committed. */
@@ -185,8 +186,8 @@ export type SessionActivity = Readonly<{
 export type SessionExtensionSlots = Readonly<Record<string, ExtensionSlotV0>>;
 /** Generic Session-scope extension commands. */
 export type SessionExtensionControls = Readonly<{
-    /** Call one Session-scope command with its encoded input; resolves the encoded output. */
-    call: (command: string, input: Json) => Promise<Json>;
+    /** Call one Session-scope command with its encoded input and optional host caller. */
+    call: (command: string, input: Json, caller?: ExtensionCommandCallerV0) => Promise<Json>;
 }>;
 /** Generic Agent-scope extension controls. */
 export type AgentExtensionControls = Readonly<{

package/dist/client.js

@@ -2,3 +2,4 @@ export {} from "./session-attention.js";
 export { createShiitakeClient, } from "./remote-client.js";
 export { bindAgentExtension, bindSessionExtension, } from "./extension-client.js";
 export { AcceptedSchema, DelegationReceiptSchema, HeldSchema, parseAccepted, parseDelegationReceipt, parseCancelResult, parseLatestPendingPrompt, parseWithdrawResult, parseForkedSession, parseSessionFrame, parseSessionSnapshot, parseSessionSummaryPage, parseShiitakeError, } from "./client-wire.js";
+export { participantSnapshot, visitorPendingPrompt, visitorSnapshot, visitorView, } from "./client-visitor.js";

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";
@@ -34,15 +34,15 @@ export declare class AgentDelegation {
     private scope;
     /** Recipient-local disclosure through the public host, never another Agent's RPC. */
     settlement(sender: DelegationIdentity, sessionId: string, commandId: string, host: Pick<ShiitakeHost, "readSettlement">): Promise<CommandSettlement | undefined>;
-    /** Delegate work to an in-scope Agent: steer its Session, or start fleet correspondence. */
+    /** Delegate work to an in-scope Agent through fleet correspondence; a steer rides the mail. */
     send(input: AgentDelegationInput, sourceSessionId: string, signal: AbortSignal, invocation?: AgentDelegationInvocation): Promise<DelegationReceipt>;
     /** Resolve this sender's exact request, then let the recipient guard pending work. */
     recall(input: AgentRecallInput, sourceSessionId: string, signal: AbortSignal): Promise<CancelResult>;
     /**
      * 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 {
@@ -61,15 +63,9 @@ export type AgentReplySettlement = (mail: BirdDogMail) => Promise<CommandSettlem
 export declare function agentMailRoute(namespace: PostRoute<never, never>["namespace"], replySettlement: AgentReplySettlement): PostRoute<import("@fungi.computer/seam/machine-link-protocol").AgentMailAddress, {
     readonly key: string;
     readonly content: string;
-    readonly createdAt: number;
-    readonly from: {
-        readonly kind: "agent";
-        readonly agentId: string;
-        readonly sessionId: string;
-    };
     readonly to: {
-        readonly kind: "agent";
         readonly agentId: string;
+        readonly kind: "agent";
         readonly sessionId?: string;
     };
     readonly replyTo: readonly {
@@ -77,34 +73,39 @@ export declare function agentMailRoute(namespace: PostRoute<never, never>["names
         readonly agentId: string;
         readonly sessionId: string;
     }[];
+    readonly createdAt: number;
+    readonly from: {
+        readonly kind: "agent";
+        readonly agentId: string;
+        readonly sessionId: string;
+    };
     readonly meta?: Schema.Json;
     readonly reply?: {
         readonly commandId: string;
         readonly outcome: "completed" | "failed" | "cancelled" | "interrupted" | "outcome_unknown";
         readonly diagnostic?: string;
-    } | {
-        readonly outcome: "undeliverable";
-        readonly reason: "recipient_offline" | "recipient_left";
+        readonly waitingOnYou?: readonly {
+            readonly itemId: string;
+            readonly kind: string;
+            readonly summary: string;
+        }[];
     } | {
         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 to: {
-        readonly kind: "agent";
         readonly agentId: string;
+        readonly kind: "agent";
         readonly sessionId?: string;
     };
     readonly replyTo: readonly {
@@ -112,19 +113,18 @@ export declare function agentMailRoute(namespace: PostRoute<never, never>["names
         readonly agentId: string;
         readonly sessionId: string;
     }[];
+    readonly createdAt: number;
+    readonly from: {
+        readonly kind: "system";
+        readonly systemId: "hub";
+    };
     readonly meta?: Schema.Json;
 }, {
     readonly key: string;
     readonly content: string;
-    readonly createdAt: number;
-    readonly from: {
-        readonly kind: "agent";
-        readonly agentId: string;
-        readonly sessionId: string;
-    };
     readonly to: {
-        readonly kind: "agent";
         readonly agentId: string;
+        readonly kind: "agent";
         readonly sessionId?: string;
     };
     readonly replyTo: readonly {
@@ -132,34 +132,39 @@ export declare function agentMailRoute(namespace: PostRoute<never, never>["names
         readonly agentId: string;
         readonly sessionId: string;
     }[];
+    readonly createdAt: number;
+    readonly from: {
+        readonly kind: "agent";
+        readonly agentId: string;
+        readonly sessionId: string;
+    };
     readonly meta?: Schema.Json;
     readonly reply?: {
         readonly commandId: string;
         readonly outcome: "completed" | "failed" | "cancelled" | "interrupted" | "outcome_unknown";
         readonly diagnostic?: string;
-    } | {
-        readonly outcome: "undeliverable";
-        readonly reason: "recipient_offline" | "recipient_left";
+        readonly waitingOnYou?: readonly {
+            readonly itemId: string;
+            readonly kind: string;
+            readonly summary: string;
+        }[];
     } | {
         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 to: {
-        readonly kind: "agent";
         readonly agentId: string;
+        readonly kind: "agent";
         readonly sessionId?: string;
     };
     readonly replyTo: readonly {
@@ -167,19 +172,18 @@ export declare function agentMailRoute(namespace: PostRoute<never, never>["names
         readonly agentId: string;
         readonly sessionId: string;
     }[];
+    readonly createdAt: number;
+    readonly from: {
+        readonly kind: "system";
+        readonly systemId: "hub";
+    };
     readonly meta?: Schema.Json;
 }, import("@fungi.computer/seam/machine-link-protocol").AgentMailAddress, {
     readonly key: string;
     readonly content: string;
-    readonly createdAt: number;
-    readonly from: {
-        readonly kind: "agent";
-        readonly agentId: string;
-        readonly sessionId: string;
-    };
     readonly to: {
-        readonly kind: "agent";
         readonly agentId: string;
+        readonly kind: "agent";
         readonly sessionId?: string;
     };
     readonly replyTo: readonly {
@@ -187,34 +191,39 @@ export declare function agentMailRoute(namespace: PostRoute<never, never>["names
         readonly agentId: string;
         readonly sessionId: string;
     }[];
+    readonly createdAt: number;
+    readonly from: {
+        readonly kind: "agent";
+        readonly agentId: string;
+        readonly sessionId: string;
+    };
     readonly meta?: Schema.Json;
     readonly reply?: {
         readonly commandId: string;
         readonly outcome: "completed" | "failed" | "cancelled" | "interrupted" | "outcome_unknown";
         readonly diagnostic?: string;
-    } | {
-        readonly outcome: "undeliverable";
-        readonly reason: "recipient_offline" | "recipient_left";
+        readonly waitingOnYou?: readonly {
+            readonly itemId: string;
+            readonly kind: string;
+            readonly summary: string;
+        }[];
     } | {
         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 to: {
-        readonly kind: "agent";
         readonly agentId: string;
+        readonly kind: "agent";
         readonly sessionId?: string;
     };
     readonly replyTo: readonly {
@@ -222,19 +231,18 @@ export declare function agentMailRoute(namespace: PostRoute<never, never>["names
         readonly agentId: string;
         readonly sessionId: string;
     }[];
+    readonly createdAt: number;
+    readonly from: {
+        readonly kind: "system";
+        readonly systemId: "hub";
+    };
     readonly meta?: Schema.Json;
 }, {
     readonly key: string;
     readonly content: string;
-    readonly createdAt: number;
-    readonly from: {
-        readonly kind: "agent";
-        readonly agentId: string;
-        readonly sessionId: string;
-    };
     readonly to: {
-        readonly kind: "agent";
         readonly agentId: string;
+        readonly kind: "agent";
         readonly sessionId?: string;
     };
     readonly replyTo: readonly {
@@ -242,34 +250,39 @@ export declare function agentMailRoute(namespace: PostRoute<never, never>["names
         readonly agentId: string;
         readonly sessionId: string;
     }[];
+    readonly createdAt: number;
+    readonly from: {
+        readonly kind: "agent";
+        readonly agentId: string;
+        readonly sessionId: string;
+    };
     readonly meta?: Schema.Json;
     readonly reply?: {
         readonly commandId: string;
         readonly outcome: "completed" | "failed" | "cancelled" | "interrupted" | "outcome_unknown";
         readonly diagnostic?: string;
-    } | {
-        readonly outcome: "undeliverable";
-        readonly reason: "recipient_offline" | "recipient_left";
+        readonly waitingOnYou?: readonly {
+            readonly itemId: string;
+            readonly kind: string;
+            readonly summary: string;
+        }[];
     } | {
         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 to: {
-        readonly kind: "agent";
         readonly agentId: string;
+        readonly kind: "agent";
         readonly sessionId?: string;
     };
     readonly replyTo: readonly {
@@ -277,6 +290,11 @@ export declare function agentMailRoute(namespace: PostRoute<never, never>["names
         readonly agentId: string;
         readonly sessionId: string;
     }[];
+    readonly createdAt: number;
+    readonly from: {
+        readonly kind: "system";
+        readonly systemId: "hub";
+    };
     readonly meta?: Schema.Json;
 }> & Omit<Readonly<{
     addressKind: string;
@@ -295,7 +313,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,16 +323,21 @@ 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. */
     mailRoom(): BirdDogEffect & {
+        /** Stage acceptance through this Post owner within the caller's transaction. */
         stageAcceptedNotice: (mail: BirdDogMail, scopeId: string) => void;
     };
 }

package/dist/delegation.js

@@ -3,12 +3,13 @@
  * addressed Agent mail over Carrier Post, and the Agent grammar a host hands
  * to Oyster's machine link as ports. Oyster core never imports this engine.
  */
-import { commandSettlementSchema, createAgentDirectory, createFleetCorrespondence, agentDelegationRequestKey, delegationProvenance, delegationReplyMeta, delegationSendMeta, } from "./fleet.js";
+import { commandSettlementSchema, createAgentDirectory, createFleetCorrespondence, agentDelegationRequestKey, delegationProvenance, delegationReplyMeta, delegationSendMeta, settlementReadableBy, } from "./fleet.js";
 import * as Schema from "effect/Schema";
 import { agentMailAddressSchema } from "@fungi.computer/seam/machine-link-protocol";
 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";
@@ -43,11 +44,11 @@ export class AgentDelegation {
             !scope.agents.some(({ agentId }) => agentId === sender.agentId))
             throw new AgentDisclosureRefused();
         const facts = await host.readSettlement(sessionId, commandId);
-        if (facts !== undefined && facts.acceptedSender !== sender.agentId)
+        if (facts !== undefined && !settlementReadableBy(facts, sender.agentId))
             throw new AgentDisclosureRefused();
         return facts;
     }
-    /** Delegate work to an in-scope Agent: steer its Session, or start fleet correspondence. */
+    /** Delegate work to an in-scope Agent through fleet correspondence; a steer rides the mail. */
     async send(input, sourceSessionId, signal, invocation) {
         if (invocation === undefined)
             throw new Error("Delegation requires a tool invocation");
@@ -65,18 +66,6 @@ export class AgentDelegation {
             requestId: input.requestId,
         });
         signal.throwIfAborted();
-        if (input.delivery === "steer") {
-            const opened = await this.deps.directory().open(input.agentId, signal);
-            try {
-                return await opened.agent.session(input.sessionId).send(input.text, {
-                    requestId,
-                    delivery: "steer",
-                });
-            }
-            finally {
-                await opened.release();
-            }
-        }
         const provenance = await delegationProvenance({
             agentId: scope.agentId,
             sessionId: sourceSessionId,
@@ -92,6 +81,7 @@ export class AgentDelegation {
         }, {
             agentId: input.agentId,
             sessionId: input.sessionId,
+            delivery: input.delivery,
             text: input.text,
             requestId,
         });
@@ -135,8 +125,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 +163,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 +207,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 +301,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/effect.d.ts

@@ -38,5 +38,30 @@ export declare function readSessionSummaries(owner: SqliteOwner, after?: string)
     sessions: readonly import("./internal/woodstock/session-store.js").StoredSessionSummaryRow[];
     next: string | undefined;
 }>, ShiitakeError, never>;
+/**
+ * One page of saved conversations with their stored run state (needs_you,
+ * running, errored, done), in tier then newest-activity order, read from the
+ * store alone: no Agent runtime starts. The state is as the runtime last wrote
+ * it, so it can lag work a stopped runtime left behind.
+ */
+export declare function readStoredSessionStates(owner: SqliteOwner, after?: string): Effect.Effect<Readonly<{
+    sessions: readonly import("./client.js").SessionSummaryRow[];
+    next: string | undefined;
+}>, ShiitakeError, never>;
+/** One saved conversation's open attention items, read from the store alone. */
+export declare function readStoredAttention(owner: SqliteOwner, sessionId: string): Effect.Effect<readonly {
+    readonly id: string;
+    readonly kind: string;
+    readonly summary: string;
+    readonly since: number;
+    readonly extensionId: string;
+    readonly expiresAt?: number | undefined;
+    readonly inbox?: false | undefined;
+    readonly waitingOn?: {
+        readonly agentId: string;
+        readonly sessionId: string;
+        readonly name: string;
+    } | undefined;
+}[], ShiitakeError, never>;
 export { sqliteRowSchema } from "./internal/contracts.js";
 export type { CommandSettlement } from "./internal/contracts.js";

package/dist/effect.js

@@ -1,5 +1,5 @@
 import * as Effect from "effect/Effect";
-import { readSessionFactPage } from "./internal/woodstock/index.js";
+import { readSessionFactPage, readSessionInbox, readStoredSessionAttention, } from "./internal/woodstock/index.js";
 export { ShiitakeError } from "./errors.js";
 /** Construct the canonical Effect-native Shiitake scaffold. */
 export function make(options) {
@@ -17,4 +17,17 @@ export function openHost(options, mailRoom) {
 export function readSessionSummaries(owner, after) {
     return readSessionFactPage(owner, after);
 }
+/**
+ * One page of saved conversations with their stored run state (needs_you,
+ * running, errored, done), in tier then newest-activity order, read from the
+ * store alone: no Agent runtime starts. The state is as the runtime last wrote
+ * it, so it can lag work a stopped runtime left behind.
+ */
+export function readStoredSessionStates(owner, after) {
+    return readSessionInbox(owner, after);
+}
+/** One saved conversation's open attention items, read from the store alone. */
+export function readStoredAttention(owner, sessionId) {
+    return readStoredSessionAttention(owner, sessionId);
+}
 export { sqliteRowSchema } from "./internal/contracts.js";