@fungi.computer/shiitake 0.3.1 → 0.4.0

package/dist/delegation.d.ts

@@ -3,7 +3,7 @@ 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 PostRoute, type PostRuntime, type PostEnvelope, type PostDeliveryResult } from "@fungi.computer/carrier/post";
-import { type Accepted, type CancelResult } from "./client.js";
+import { type Accepted, type DelegationReceipt, type CancelResult } from "./client.js";
 import type { CommandSettlement, ShiitakeHost, VerifiedAgentReply } from "./index.js";
 import type { AgentControlDirectory, AgentDelegationInput, AgentDelegationInvocation, AgentRecallInput } from "./agent-control.js";
 /** Shiitake host-pack identity; core consumes OysterAgents, never this engine. */
@@ -19,19 +19,23 @@ export declare class AgentDelegation {
         expiresAt: () => number;
         identity: () => DelegationIdentity | null | Promise<DelegationIdentity | null>;
         directory: () => AgentControlDirectory;
-        deliver: (mail: BirdDogMail) => Promise<Accepted>;
+        deliver: (mail: BirdDogMail) => Promise<DelegationReceipt>;
         prepare: (mail: BirdDogMail) => Promise<void>;
+        /**
+         * Synchronously stage the accepted notice in this recipient's durable
+         * outbox, in the same transaction as acceptance.
+         */
+        stageAcceptedNotice: (mail: BirdDogMail, scopeId: string) => void;
         /** Admit mail; `reply` is present only for an authenticated reply. */
-        accept: (mail: BirdDogMail, reply?: VerifiedAgentReply) => Promise<Accepted>;
+        accept: (mail: BirdDogMail, reply: VerifiedAgentReply | undefined, stageAcceptedNotice: (mail: BirdDogMail) => void) => Promise<Accepted>;
     }>);
     private fleetOwner;
     private fleet;
     private scope;
-    private requestKey;
     /** 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. */
-    send(input: AgentDelegationInput, sourceSessionId: string, signal: AbortSignal, invocation?: AgentDelegationInvocation): Promise<Accepted>;
+    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>;
     /**
@@ -41,8 +45,11 @@ export declare class AgentDelegation {
      * settled or cancelled the work, and its meta carries the verified reply.
      */
     private authenticatedReply;
+    private parseAddressedMail;
     /** Admit one addressed Agent mail for this Agent, or refuse it. */
     receive(raw: PostEnvelope): Promise<PostDeliveryResult>;
+    private recordAcceptedNotice;
+    private acceptAdmitted;
 }
 /** A current correspondent no longer has disclosure authority. */
 export declare class AgentDisclosureRefused extends Error {
@@ -63,7 +70,7 @@ export declare function agentMailRoute(namespace: PostRoute<never, never>["names
     readonly to: {
         readonly kind: "agent";
         readonly agentId: string;
-        readonly sessionId: string;
+        readonly sessionId?: string;
     };
     readonly replyTo: readonly {
         readonly kind: "agent";
@@ -75,7 +82,37 @@ 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 key: string;
+    readonly reply: {
+        readonly outcome: "undeliverable";
+        readonly reason: "recipient_offline" | "recipient_left";
     };
+    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 sessionId?: string;
+    };
+    readonly replyTo: readonly {
+        readonly kind: "agent";
+        readonly agentId: string;
+        readonly sessionId: string;
+    }[];
+    readonly meta?: Schema.Json;
 }, {
     readonly key: string;
     readonly content: string;
@@ -88,7 +125,7 @@ export declare function agentMailRoute(namespace: PostRoute<never, never>["names
     readonly to: {
         readonly kind: "agent";
         readonly agentId: string;
-        readonly sessionId: string;
+        readonly sessionId?: string;
     };
     readonly replyTo: readonly {
         readonly kind: "agent";
@@ -100,7 +137,37 @@ 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 key: string;
+    readonly reply: {
+        readonly outcome: "undeliverable";
+        readonly reason: "recipient_offline" | "recipient_left";
+    };
+    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 sessionId?: string;
     };
+    readonly replyTo: readonly {
+        readonly kind: "agent";
+        readonly agentId: string;
+        readonly sessionId: string;
+    }[];
+    readonly meta?: Schema.Json;
 }, import("@fungi.computer/seam/machine-link-protocol").AgentMailAddress, {
     readonly key: string;
     readonly content: string;
@@ -113,7 +180,7 @@ export declare function agentMailRoute(namespace: PostRoute<never, never>["names
     readonly to: {
         readonly kind: "agent";
         readonly agentId: string;
-        readonly sessionId: string;
+        readonly sessionId?: string;
     };
     readonly replyTo: readonly {
         readonly kind: "agent";
@@ -125,7 +192,37 @@ 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 key: string;
+    readonly reply: {
+        readonly outcome: "undeliverable";
+        readonly reason: "recipient_offline" | "recipient_left";
+    };
+    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 sessionId?: string;
     };
+    readonly replyTo: readonly {
+        readonly kind: "agent";
+        readonly agentId: string;
+        readonly sessionId: string;
+    }[];
+    readonly meta?: Schema.Json;
 }, {
     readonly key: string;
     readonly content: string;
@@ -138,7 +235,7 @@ export declare function agentMailRoute(namespace: PostRoute<never, never>["names
     readonly to: {
         readonly kind: "agent";
         readonly agentId: string;
-        readonly sessionId: string;
+        readonly sessionId?: string;
     };
     readonly replyTo: readonly {
         readonly kind: "agent";
@@ -150,9 +247,40 @@ 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 key: string;
+    readonly reply: {
+        readonly outcome: "undeliverable";
+        readonly reason: "recipient_offline" | "recipient_left";
+    };
+    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 sessionId?: string;
     };
+    readonly replyTo: readonly {
+        readonly kind: "agent";
+        readonly agentId: string;
+        readonly sessionId: string;
+    }[];
+    readonly meta?: Schema.Json;
 }> & Omit<Readonly<{
     addressKind: string;
+    deadlineMs?: number | undefined;
     address: Schema.Codec<unknown, unknown>;
     event: Schema.Codec<unknown, unknown>;
     encodeEnvelope: (envelope: PostEnvelope) => PostEnvelope;
@@ -181,10 +309,14 @@ export declare class AgentMail {
         wake: () => Promise<void>;
     }>);
     private envelope;
-    /** Submit one mail and return the recipient's Accepted receipt. */
-    send(mail: BirdDogMail): Promise<Accepted>;
+    /** Submit one mail and return recipient acceptance or relay-held custody. */
+    send(mail: BirdDogMail): Promise<DelegationReceipt>;
+    /** 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;
+    mailRoom(): BirdDogEffect & {
+        stageAcceptedNotice: (mail: BirdDogMail, scopeId: string) => void;
+    };
 }
 /**
  * The Agent wire decoders a host lends Oyster's machine-link client, so the
@@ -197,7 +329,7 @@ export declare const machineAgentCodecs: {
     }> | null;
     /** One serialized settlement from a hosted or machine-homed Agent. */
     readonly settlement: (encoded: string) => CommandSettlement;
-    /** Throws unless an acknowledgment carries a well-formed Accepted receipt. */
+    /** Throws unless an acknowledgment carries a valid acceptance or Held result. */
     readonly accepted: (receipt: Schema.Json) => void;
 };
 /**

package/dist/delegation.js

@@ -3,15 +3,14 @@
  * 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, delegationProvenance, delegationReplyMeta, delegationSendMeta, } from "./fleet.js";
-import { deterministicReplayKey } from "@fungi.computer/cairn";
+import { commandSettlementSchema, createAgentDirectory, createFleetCorrespondence, agentDelegationRequestKey, delegationProvenance, delegationReplyMeta, delegationSendMeta, } 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 { PostEnvelopeSchema, definePostRoute, } from "@fungi.computer/carrier/post";
-import { parseAccepted } from "./client.js";
+import { parseDelegationReceipt, } from "./client.js";
 import { decodeClientSessionCreationRequest } from "./internal/client-boundary.js";
 /** Host-owned identity and admission around BirdDog's ordinary envelope. */
 export class AgentDelegation {
@@ -37,16 +36,6 @@ export class AgentDelegation {
             throw new Error("Agent is outside this scope");
         return { ...identity, agents, source };
     }
-    requestKey(scope, input, sourceSessionId) {
-        return deterministicReplayKey("oyster-agent-delegation", [
-            scope.scopeId,
-            scope.agentId,
-            sourceSessionId,
-            input.agentId,
-            input.sessionId,
-            input.requestId,
-        ]);
-    }
     /** Recipient-local disclosure through the public host, never another Agent's RPC. */
     async settlement(sender, sessionId, commandId, host) {
         const scope = await this.scope(new AbortController().signal);
@@ -65,7 +54,16 @@ export class AgentDelegation {
         const scope = await this.scope(signal);
         if (!scope.agents.some(({ agentId }) => agentId === input.agentId))
             throw new Error("Agent is outside this scope");
-        const requestId = await this.requestKey(scope, input, sourceSessionId);
+        const requestId = await agentDelegationRequestKey({
+            owner: {
+                kind: "hosted",
+                scopeId: scope.scopeId,
+                agentId: scope.agentId,
+            },
+            sourceSessionId,
+            targetAgentId: input.agentId,
+            requestId: input.requestId,
+        });
         signal.throwIfAborted();
         if (input.delivery === "steer") {
             const opened = await this.deps.directory().open(input.agentId, signal);
@@ -104,12 +102,25 @@ export class AgentDelegation {
         const scope = await this.scope(signal);
         if (!scope.agents.some(({ agentId }) => agentId === input.agentId))
             throw new Error("Agent is outside this scope");
-        const requestId = await this.requestKey(scope, input, sourceSessionId);
+        const requestId = await agentDelegationRequestKey({
+            owner: {
+                kind: "hosted",
+                scopeId: scope.scopeId,
+                agentId: scope.agentId,
+            },
+            sourceSessionId,
+            targetAgentId: input.agentId,
+            requestId: input.requestId,
+        });
         signal.throwIfAborted();
         const opened = await this.deps.directory().open(input.agentId, signal);
         try {
-            const session = opened.agent.session(input.sessionId);
-            const admitted = this.fleet().receipt(requestId) ?? (await session.withdraw(requestId));
+            const receipt = this.fleet().receipt(requestId);
+            if (receipt?.sessionId !== undefined &&
+                receipt.sessionId !== input.sessionId)
+                return { status: "unknown" };
+            const session = opened.agent.session(receipt?.sessionId ?? input.sessionId);
+            const admitted = receipt ?? (await session.withdraw(requestId));
             return admitted.status === "accepted"
                 ? await session.cancel({
                     commandId: admitted.commandId,
@@ -133,46 +144,81 @@ export class AgentDelegation {
             return undefined;
         const scope = await this.scope(new AbortController().signal);
         const replier = scope.agents.find(({ agentId }) => agentId === delegation.reply.agentId);
-        if (replier === undefined)
+        const undeliverable = delegation.reply.outcome === "undeliverable";
+        if (replier === undefined && !undeliverable)
             return undefined;
-        const meta = delegationReplyMeta(delegation, replier.name);
+        const meta = delegationReplyMeta(delegation, replier?.name ?? delegation.reply.agentId);
         return { mail: { ...mail, meta }, reply: delegation.reply };
     }
-    /** Admit one addressed Agent mail for this Agent, or refuse it. */
-    async receive(raw) {
+    parseAddressedMail(raw) {
         const envelope = Schema.decodeUnknownOption(PostEnvelopeSchema)(raw);
         if (envelope._tag === "None" || envelope.value.kind !== "agentMail")
-            return "refused";
+            return undefined;
         const address = Schema.decodeUnknownOption(agentMailAddressSchema)(envelope.value.address);
-        const parsed = Schema.decodeUnknownOption(BirdDogMailSchema)(envelope.value.event);
-        if (address._tag === "None" || parsed._tag === "None")
+        const mail = Schema.decodeUnknownOption(BirdDogMailSchema)(envelope.value.event);
+        if (address._tag === "None" || mail._tag === "None")
+            return undefined;
+        return {
+            envelope: envelope.value,
+            address: address.value,
+            mail: mail.value,
+        };
+    }
+    /** Admit one addressed Agent mail for this Agent, or refuse it. */
+    async receive(raw) {
+        const addressed = this.parseAddressedMail(raw);
+        if (addressed === undefined)
             return "refused";
-        const mail = parsed.value;
+        const { envelope, address, mail } = addressed;
+        let authenticated;
         const valid = async () => {
             const scope = await this.scope(new AbortController().signal);
-            return (address.value.scopeId === scope.scopeId &&
-                address.value.agentId === scope.agentId &&
+            const frozenUndeliverable = authenticated?.reply.outcome === "undeliverable" &&
+                authenticated.reply.agentId === mail.from.agentId;
+            return (address.scopeId === scope.scopeId &&
+                address.agentId === scope.agentId &&
                 mail.to.agentId === scope.agentId &&
-                envelope.value.key === mail.key &&
-                [mail.from, ...mail.replyTo].every((ref) => scope.agents.some(({ agentId }) => agentId === ref.agentId)) &&
+                envelope.key === mail.key &&
+                (frozenUndeliverable ||
+                    scope.agents.some(({ agentId }) => agentId === mail.from.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)));
         };
+        if (mail.replyTo.length === 0)
+            authenticated = await this.authenticatedReply(mail);
         if (!(await valid()))
             return "refused";
-        const admitted = mail.replyTo.length > 0
-            ? { mail, reply: undefined }
-            : await this.authenticatedReply(mail);
+        if (mail.reply?.outcome === "accepted")
+            return this.recordAcceptedNotice(mail, valid);
+        const admitted = mail.replyTo.length > 0 ? { mail, reply: undefined } : authenticated;
         if (admitted === undefined)
             return "refused";
+        return this.acceptAdmitted(admitted, address.scopeId, valid);
+    }
+    async recordAcceptedNotice(mail, valid) {
+        if (mail.to.sessionId === undefined)
+            return "refused";
+        await this.deps.prepare(mail);
+        if (!(await valid()))
+            return "refused";
+        const receipt = this.fleet().recordAcceptedNotice(mail);
+        return receipt === undefined ? "refused" : { status: "accepted", receipt };
+    }
+    async acceptAdmitted(admitted, scopeId, valid) {
         await this.deps.prepare(admitted.mail);
         if (!(await valid()))
             return "refused";
+        const stageAcceptedNotice = (notice) => {
+            this.deps.stageAcceptedNotice(notice, scopeId);
+        };
+        const receipt = await this.deps.accept(admitted.mail, admitted.reply, stageAcceptedNotice);
+        const sessionId = admitted.mail.to.sessionId ?? receipt.sessionId;
         return {
             status: "accepted",
-            receipt: await this.deps.accept(admitted.mail, admitted.reply),
+            receipt: sessionId === undefined ? receipt : { ...receipt, sessionId },
         };
     }
 }
@@ -194,6 +240,13 @@ export function agentMailRoute(namespace, replySettlement) {
                 deliver: async (envelope) => {
                     const mail = Schema.decodeUnknownSync(BirdDogMailSchema)(envelope.event);
                     if (mail.reply !== undefined &&
+                        mail.reply.outcome !== "accepted" &&
+                        mail.reply.outcome !== "undeliverable" &&
+                        mail.to.sessionId === undefined)
+                        return "refused";
+                    if (mail.reply !== undefined &&
+                        mail.reply.outcome !== "undeliverable" &&
+                        mail.reply.outcome !== "accepted" &&
                         (await replySettlement(mail)) === undefined)
                         return "refused";
                     return namespace.getByName(name).deliver(envelope);
@@ -219,18 +272,27 @@ export class AgentMail {
             event: mail,
         };
     }
-    /** Submit one mail and return the recipient's Accepted receipt. */
+    /** Submit one mail and return recipient acceptance or relay-held custody. */
     async send(mail) {
         this.deps.post().send(await this.envelope(mail));
         // Borrow the existing Post lane once, not a new waiter, loop or supervisor.
         await this.deps.drain();
         const row = this.deps.post().read(mail.key);
         if (row?.state === "delivered" && row.receipt !== undefined)
-            return parseAccepted(JSON.stringify(row.receipt));
+            return parseDelegationReceipt(JSON.stringify(row.receipt));
         if (row?.state === "dead")
             throw new Error(`Agent delivery ${row.reason}`);
         throw new Error("Agent did not return a delegated work receipt");
     }
+    /** Stage the acceptance reply through this Post owner without leaving the transaction. */
+    stageAcceptedNotice(mail, scopeId) {
+        this.deps.post().send({
+            key: mail.key,
+            kind: "agentMail",
+            address: { scopeId, agentId: mail.to.agentId },
+            event: mail,
+        });
+    }
     /** BirdDog's mail room: disclosed settlement replies fan out over Post. */
     mailRoom() {
         return {
@@ -268,6 +330,16 @@ export class AgentMail {
                 },
                 catch: (cause) => new BirdDogError("Agent reply fan-out is unavailable", { cause }),
             }),
+            postMail: (mail) => Effect.tryPromise({
+                try: async () => {
+                    this.deps.post().send(await this.envelope(mail));
+                    await this.deps.wake();
+                },
+                catch: (cause) => new BirdDogError("Agent mail staging is unavailable", { cause }),
+            }),
+            stageAcceptedNotice: (mail, scopeId) => {
+                this.stageAcceptedNotice(mail, scopeId);
+            },
             drainOutbox: () => Effect.void,
             nextWakeAt: () => Effect.try({
                 try: () => this.deps.post().nextWake() ?? undefined,
@@ -290,9 +362,9 @@ export const machineAgentCodecs = {
     settlement(encoded) {
         return Schema.decodeUnknownSync(Schema.fromJsonString(commandSettlementSchema))(encoded);
     },
-    /** Throws unless an acknowledgment carries a well-formed Accepted receipt. */
+    /** Throws unless an acknowledgment carries a valid acceptance or Held result. */
     accepted(receipt) {
-        parseAccepted(JSON.stringify(receipt));
+        parseDelegationReceipt(JSON.stringify(receipt));
     },
 };
 /**

package/dist/effect.d.ts

@@ -22,7 +22,7 @@ export type ShiitakeEffectHost = Readonly<{
     readSettlement: (sessionId: string, commandId: string) => Effect.Effect<CommandSettlement | undefined, ShiitakeError>;
     agent: ShiitakeEffectOwner;
     /** Durably admit one addressed mail item through the host owner. */
-    acceptMail: (mail: BirdDogMail, meta?: HostJson, reply?: VerifiedAgentReply) => Effect.Effect<Accepted, ShiitakeError>;
+    acceptMail: (mail: BirdDogMail, meta?: HostJson, reply?: VerifiedAgentReply, stageAcceptedNotice?: (mail: BirdDogMail) => void) => Effect.Effect<Accepted, ShiitakeError>;
 }>;
 /** Open the Effect-native host composition with addressed mail. */
 export declare function openHost(options: ShiitakeEffectOptions, mailRoom: BirdDogEffect): Effect.Effect<ShiitakeEffectHost, ShiitakeError>;

package/dist/fleet.d.ts

@@ -1,14 +1,34 @@
+export { commandSettlementSchema } from "./client-wire.js";
 import { type VerifiedAgentReply } from "./internal/woodstock/index.js";
 import type { CommandSettlement } from "./internal/contracts.js";
 import { type Pending } from "@fungi.computer/agar";
 import type { BirdDogMail } from "@fungi.computer/bird-dog";
-import * as Schema from "effect/Schema";
-import { type Accepted, type ShiitakeAgent } from "./client.js";
+import { type Accepted, type DelegationReceipt, type ShiitakeAgent } from "./client.js";
 import type { Json } from "./extensions.js";
 import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
 import { type CairnId } from "@fungi.computer/cairn/id";
 import { z } from "zod";
 import { type AuthorMeta } from "@fungi.computer/agar/agents";
+/** Inputs shared by Local and hosted delegation request identity. */
+export type AgentDelegationRequestKeyInput = Readonly<{
+    owner: Readonly<{
+        kind: "local";
+        agentId: string;
+    }> | Readonly<{
+        kind: "hosted";
+        scopeId: string;
+        agentId: string;
+    }>;
+    sourceSessionId: string;
+    targetAgentId: string;
+    requestId: string;
+}>;
+/**
+ * One idempotency identity for a caller-owned delegation request.
+ * The target Session is deliberately excluded: a sessionless send learns it
+ * only after acceptance, when recall must still resolve the original receipt.
+ */
+export declare function agentDelegationRequestKey(input: AgentDelegationRequestKeyInput): Promise<string>;
 /** Operations explicitly admitted by the host. */
 export declare const agentActionSchema: z.ZodEnum<{
     send: "send";
@@ -69,7 +89,7 @@ export declare class AgentGrantError extends Error {
 export declare function assertAgentGrant(grant: AgentGrant, action: AgentAction, agentId?: string): void;
 /** Stable Agent identities, retained across host compositions. */
 export declare const agentIds: Readonly<{
-    readonly agent: import("@fungi.computer/cairn/id").IdCodec<"agent", "agent", 1>;
+    readonly agent: import("@fungi.computer/cairn").IdCodec<"agent", "agent", 1>;
 }>;
 /** An ordinary Agent directory identity. */
 export type AgentId = CairnId<"agent", "agent">;
@@ -169,8 +189,6 @@ export declare const agentDelegationTaskSchema: z.ZodLazy<z.ZodObject<{
 }, z.core.$strict>>;
 /** A caller reuses this task unchanged while polling Pending. */
 export type AgentDelegationTask = z.infer<typeof agentDelegationTaskSchema>;
-/** Exact host facts encoded over internal transports, without transcript content. */
-export declare const commandSettlementSchema: Schema.Codec<CommandSettlement>;
 /** Exact settled Session facts, including Pi usage and tool-call records. */
 export type AgentDelegationOutcome = Readonly<{
     kind: "settled";
@@ -181,7 +199,7 @@ export type AgentDelegationOutcome = Readonly<{
 export type FleetDelegationOptions = Readonly<{
     storage: WatchdogSqliteOwner;
     /** Admit the frozen addressed mail through the destination owner. */
-    deliver: (mail: BirdDogMail) => Promise<Accepted>;
+    deliver: (mail: BirdDogMail) => Promise<DelegationReceipt>;
     /** Read exact work facts at the target owner, independent of transcript selection. */
     readSettlement: (agentId: string, sessionId: string, commandId: string) => Promise<CommandSettlement | undefined>;
     /** Acquire a Session client only when creating the delegated conversation. */
@@ -258,22 +276,26 @@ export type OutstandingDelegation = Readonly<{
  */
 export declare function createFleetCorrespondence(options: Omit<FleetDelegationOptions, "readSettlement">): {
     /** Submit frozen mail or reuse its recorded Session admission receipt. */
-    start: (grant: AgentGrant, raw: AgentDelegationTask) => Promise<Accepted>;
+    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;
     /** Read an existing acceptance receipt without reserving or delivering mail. */
     receipt: (requestId: string) => Accepted | undefined;
+    /** Consume a recipient's stable `<mailKey>:accepted` notice. */
+    recordAcceptedNotice: (mail: BirdDogMail) => Accepted | undefined;
 };
 /** Local hosts may observe exact work directly; remote correspondence never pulls it. */
 export declare function createFleetDelegation(options: FleetDelegationOptions): {
     /** Submit or poll the exact turn, yielding Agar Pending until settled. */
     delegate: (grant: AgentGrant, task: AgentDelegationTask) => Promise<Pending | AgentDelegationOutcome>;
     /** Submit frozen mail or reuse its recorded Session admission receipt. */
-    start: (grant: AgentGrant, raw: AgentDelegationTask) => Promise<Accepted>;
+    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;
     /** Read an existing acceptance receipt without reserving or delivering mail. */
     receipt: (requestId: string) => Accepted | undefined;
+    /** Consume a recipient's stable `<mailKey>:accepted` notice. */
+    recordAcceptedNotice: (mail: BirdDogMail) => Accepted | undefined;
     /** The delegated work this owner still waits on, if any. */
     outstanding: () => Promise<OutstandingDelegation | undefined>;
 };