@fungi.computer/shiitake 0.2.0 → 0.3.1

package/dist/delegation.js

@@ -0,0 +1,319 @@
+/**
+ * Shiitake's Agent delegation composition for hosts: fleet correspondence,
+ * 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 * 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 { decodeClientSessionCreationRequest } from "./internal/client-boundary.js";
+/** Host-owned identity and admission around BirdDog's ordinary envelope. */
+export class AgentDelegation {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    fleetOwner;
+    fleet() {
+        return (this.fleetOwner ??= createFleetCorrespondence({
+            storage: this.deps.storage,
+            open: (agentId) => this.deps.directory().open(agentId, new AbortController().signal),
+            deliver: this.deps.deliver,
+        }));
+    }
+    async scope(signal) {
+        const agents = await this.deps.directory().list(signal);
+        const identity = await this.deps.identity();
+        if (identity === null)
+            throw new Error("Agent scope is unavailable");
+        const source = agents.find(({ agentId }) => agentId === identity.agentId);
+        if (source === undefined)
+            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);
+        if (sender.scopeId !== scope.scopeId ||
+            !scope.agents.some(({ agentId }) => agentId === sender.agentId))
+            throw new AgentDisclosureRefused();
+        const facts = await host.readSettlement(sessionId, commandId);
+        if (facts !== undefined && facts.acceptedSender !== sender.agentId)
+            throw new AgentDisclosureRefused();
+        return facts;
+    }
+    /** Delegate work to an in-scope Agent: steer its Session, or start fleet correspondence. */
+    async send(input, sourceSessionId, signal, invocation) {
+        if (invocation === undefined)
+            throw new Error("Delegation requires a tool invocation");
+        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);
+        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,
+        });
+        const meta = delegationSendMeta({ id: scope.agentId, name: scope.source.name }, invocation.meta);
+        signal.throwIfAborted();
+        const accepted = await this.fleet().start({
+            agents: scope.agents.map(({ agentId }) => agentId),
+            actions: ["delegate"],
+            expiresAt: this.deps.expiresAt(),
+            provenance,
+            meta,
+        }, {
+            agentId: input.agentId,
+            sessionId: input.sessionId,
+            text: input.text,
+            requestId,
+        });
+        return accepted;
+    }
+    /** Resolve this sender's exact request, then let the recipient guard pending work. */
+    async recall(input, sourceSessionId, signal) {
+        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);
+        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));
+            return admitted.status === "accepted"
+                ? await session.cancel({
+                    commandId: admitted.commandId,
+                    onlyIfPending: true,
+                })
+                : admitted;
+        }
+        finally {
+            await opened.release();
+        }
+    }
+    /**
+     * 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.
+     */
+    async authenticatedReply(mail) {
+        const delegation = this.fleet().authenticateReply(mail);
+        if (delegation === undefined)
+            return undefined;
+        const scope = await this.scope(new AbortController().signal);
+        const replier = scope.agents.find(({ agentId }) => agentId === delegation.reply.agentId);
+        if (replier === undefined)
+            return undefined;
+        const meta = delegationReplyMeta(delegation, replier.name);
+        return { mail: { ...mail, meta }, reply: delegation.reply };
+    }
+    /** Admit one addressed Agent mail for this Agent, or refuse it. */
+    async receive(raw) {
+        const envelope = Schema.decodeUnknownOption(PostEnvelopeSchema)(raw);
+        if (envelope._tag === "None" || envelope.value.kind !== "agentMail")
+            return "refused";
+        const address = Schema.decodeUnknownOption(agentMailAddressSchema)(envelope.value.address);
+        const parsed = Schema.decodeUnknownOption(BirdDogMailSchema)(envelope.value.event);
+        if (address._tag === "None" || parsed._tag === "None")
+            return "refused";
+        const mail = parsed.value;
+        const valid = async () => {
+            const scope = await this.scope(new AbortController().signal);
+            return (address.value.scopeId === scope.scopeId &&
+                address.value.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)) &&
+                (mail.replyTo.length === 0 ||
+                    (mail.replyTo.length === 1 &&
+                        mail.replyTo[0]?.agentId === mail.from.agentId &&
+                        mail.replyTo[0].sessionId === mail.from.sessionId)));
+        };
+        if (!(await valid()))
+            return "refused";
+        const admitted = mail.replyTo.length > 0
+            ? { mail, reply: undefined }
+            : await this.authenticatedReply(mail);
+        if (admitted === undefined)
+            return "refused";
+        await this.deps.prepare(admitted.mail);
+        if (!(await valid()))
+            return "refused";
+        return {
+            status: "accepted",
+            receipt: await this.deps.accept(admitted.mail, admitted.reply),
+        };
+    }
+}
+/** A current correspondent no longer has disclosure authority. */
+export class AgentDisclosureRefused extends Error {
+    constructor() {
+        super("Agent is not an admitted original correspondent");
+    }
+}
+/** Current disclosure admission runs at every transport attempt, including frozen retries. */
+export function agentMailRoute(namespace, replySettlement) {
+    return definePostRoute({
+        addressKind: "agent",
+        address: agentMailAddressSchema,
+        event: BirdDogMailSchema,
+        name: ({ agentId }) => agentId,
+        namespace: {
+            getByName: (name) => ({
+                deliver: async (envelope) => {
+                    const mail = Schema.decodeUnknownSync(BirdDogMailSchema)(envelope.event);
+                    if (mail.reply !== undefined &&
+                        (await replySettlement(mail)) === undefined)
+                        return "refused";
+                    return namespace.getByName(name).deliver(envelope);
+                },
+            }),
+        },
+    });
+}
+/** Recipient-owned replies and receipt-bearing submissions over the host's one Post lane. */
+export class AgentMail {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async envelope(mail) {
+        const identity = await this.deps.identity();
+        if (identity === null)
+            throw new Error("Agent scope is unavailable");
+        return {
+            key: mail.key,
+            kind: "agentMail",
+            address: { scopeId: identity.scopeId, agentId: mail.to.agentId },
+            event: mail,
+        };
+    }
+    /** Submit one mail and return the recipient's Accepted receipt. */
+    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));
+        if (row?.state === "dead")
+            throw new Error(`Agent delivery ${row.reason}`);
+        throw new Error("Agent did not return a delegated work receipt");
+    }
+    /** BirdDog's mail room: disclosed settlement replies fan out over Post. */
+    mailRoom() {
+        return {
+            fanOut: (settlement) => Effect.tryPromise({
+                try: async () => {
+                    const author = messageAuthor(settlement.meta);
+                    const replies = settlementReplies(settlement.job.outcome === "cancelled"
+                        ? {
+                            ...settlement,
+                            content: author === undefined
+                                ? "Work cancelled."
+                                : `Work cancelled by ${author.name}.`,
+                        }
+                        : settlement, Date.now());
+                    const admitted = [];
+                    for (const mail of replies) {
+                        const facts = await this.deps.replySettlement(mail);
+                        if (facts === undefined)
+                            continue;
+                        admitted.push(await this.envelope({
+                            ...mail,
+                            content: facts.terminal.outcome === "cancelled"
+                                ? mail.content
+                                : facts.content || mail.content,
+                        }));
+                    }
+                    this.deps.storage.transactionSync(() => {
+                        for (const envelope of admitted) {
+                            if (this.deps.post().read(envelope.key) === undefined)
+                                this.deps.post().send(envelope);
+                        }
+                    });
+                    if (admitted.length > 0)
+                        await this.deps.wake();
+                },
+                catch: (cause) => new BirdDogError("Agent reply fan-out is unavailable", { cause }),
+            }),
+            drainOutbox: () => Effect.void,
+            nextWakeAt: () => Effect.try({
+                try: () => this.deps.post().nextWake() ?? undefined,
+                catch: (cause) => new BirdDogError("Agent reply wake is unavailable", { cause }),
+            }),
+        };
+    }
+}
+/**
+ * The Agent wire decoders a host lends Oyster's machine-link client, so the
+ * device link routes Agent work without owning Shiitake's grammar.
+ */
+export const machineAgentCodecs = {
+    /** The Session-creation intent, or null when the body is not one. */
+    sessionCreation(body) {
+        const decoded = decodeClientSessionCreationRequest(body);
+        return decoded._tag === "Failure" ? null : decoded.success;
+    },
+    /** One serialized settlement from a hosted or machine-homed Agent. */
+    settlement(encoded) {
+        return Schema.decodeUnknownSync(Schema.fromJsonString(commandSettlementSchema))(encoded);
+    },
+    /** Throws unless an acknowledgment carries a well-formed Accepted receipt. */
+    accepted(receipt) {
+        parseAccepted(JSON.stringify(receipt));
+    },
+};
+/**
+ * Machine-homed Agent identities in the ordinary directory over the
+ * enrollment's own store: one Team identity per enrollment receipt, reserved
+ * without opening a hosted Agent. The enrolling member is the grant actor.
+ */
+export function machineAgentReservations(sql) {
+    const directory = createAgentDirectory(sql);
+    return (reservation) => {
+        const grant = {
+            agents: "all",
+            actions: ["create", "read"],
+            expiresAt: Number.MAX_SAFE_INTEGER,
+            provenance: { actor: reservation.memberId },
+        };
+        const { agent } = directory.create(grant, {
+            requestId: reservation.requestId,
+            name: reservation.name,
+            configuration: "machine",
+        });
+        return { agentId: agent.agentId };
+    };
+}

package/dist/effect.d.ts

@@ -8,7 +8,7 @@ import type { Accepted } from "./client.js";
 import type { ShiitakeError } from "./errors.js";
 import type { ShiitakeEffectOptions, ShiitakeEffectOwner } from "./internal/effect-contracts.js";
 import type { SqliteOwner } from "./internal/contracts.js";
-export type { AbortCommand, BranchCommand, CompactCommand, CancelCommand, CancelResult, Accepted, ForkCommand, ForkedSession, PromptCommand, PromptDelivery, ReadOptions, SessionCommand, SessionCommandHandler, SessionFrame, SessionMessage, SessionProgress, SessionSnapshot, SessionActivity, AgentRunningWork, SubscribeOptions, TooLate, WatchOptions, } from "./client.js";
+export type { AbortCommand, BranchCommand, CompactCommand, CancelCommand, CancelResult, Accepted, ForkCommand, ForkedSession, PromptCommand, PromptDelivery, ReadOptions, SessionCommand, SessionCommandHandler, SessionFrame, SessionMessage, SessionProgress, SessionToolOutput, SessionSnapshot, SessionActivity, AgentRunningWork, SubscribeOptions, TooLate, WatchOptions, } from "./client.js";
 export type { InstructionSnapshot, InstructionSource, ModelAcquisition, ModelDescription, ModelSource, RuntimeHost, RuntimePendingWork, SqliteCursor, SqliteOwner, SqliteValue, SqliteRow, GrantsDelivery, GrantsDeliveryResult, ShiitakeOptions, ToolAccess, HostMetaOptions, StandardHostMetaResult, StandardHostMetaSchema, ToolSource, } from "./internal/contracts.js";
 export type { InstructionSourceEffect, ModelAcquisitionEffect, ModelSourceEffect, RuntimeHostEffect, ShiitakeEffectAgent, ShiitakeEffectAgentExtensions, ShiitakeEffectCommandHandler, ShiitakeEffectOptions, ShiitakeEffectOwner, ShiitakeEffectSession, ShiitakeEffectSessionExtension, ShiitakeEffectSendOptions, ShiitakeEffectWatch, ToolSourceEffect, } from "./internal/effect-contracts.js";
 export type { SessionSummary } from "./client.js";

package/dist/errors.d.ts

@@ -4,14 +4,14 @@ declare const ShiitakeErrorBoundarySchema: Schema.Literals<readonly ["contract",
 /** Stable boundary that rejected a Shiitake operation. */
 export type ShiitakeErrorBoundary = Schema.Schema.Type<typeof ShiitakeErrorBoundarySchema>;
 /** Safe failure category exposed by both Shiitake facades. */
-declare const ShiitakeErrorCauseSchema: Schema.Literals<readonly ["closed", "conflict", "incompatible", "invalid", "rejected", "unavailable", "storage_pressure", "context_too_large"]>;
+declare const ShiitakeErrorCauseSchema: Schema.Literals<readonly ["closed", "conflict", "incompatible", "invalid", "rejected", "unavailable", "state_reset_required", "storage_pressure"]>;
 /** Safe failure category exposed by both Shiitake facades. */
 export type ShiitakeErrorCause = Schema.Schema.Type<typeof ShiitakeErrorCauseSchema>;
 /** Canonical serialized Shiitake failure. */
 export declare const ShiitakeErrorWireSchema: Schema.Struct<{
     readonly _tag: Schema.Literal<"ShiitakeError">;
     readonly boundary: Schema.Literals<readonly ["contract", "extensions", "instructions", "model", "runtime", "store", "tools"]>;
-    readonly cause: Schema.Literals<readonly ["closed", "conflict", "incompatible", "invalid", "rejected", "unavailable", "storage_pressure", "context_too_large"]>;
+    readonly cause: Schema.Literals<readonly ["closed", "conflict", "incompatible", "invalid", "rejected", "unavailable", "state_reset_required", "storage_pressure"]>;
     readonly message: Schema.String;
     readonly requestId: Schema.optionalKey<Schema.String>;
 }>;

package/dist/errors.js

@@ -17,10 +17,10 @@ const ShiitakeErrorCauseSchema = Schema.Literals([
     "invalid",
     "rejected",
     "unavailable",
+    /** Stored extension state needs an explicitly authorized reset, not a migration. */
+    "state_reset_required",
     /** Owner storage is near its budget; new Sessions and prompts wait. */
     "storage_pressure",
-    /** One model context read is larger than the owner can safely decode. */
-    "context_too_large",
 ]);
 const requestIdSchema = Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.isMaxLength(256)));
 /** Canonical serialized Shiitake failure. */

package/dist/extension-contract.d.ts

@@ -69,5 +69,13 @@ export type ExtensionContractV0<C extends CommandsV0, P, PI> = Readonly<{
     commands: C;
     projection: ProjectionSpecV0<P, PI> | null;
 }>;
-/** Activity already observed by the client, never an execution authority. */
-export type ClientActivityV0 = "idle" | "working" | "blocked" | "unknown";
+/** What a client observed about the Session, never an execution authority. */
+export type ClientActivityStateV0 = "idle" | "working" | "blocked" | "unknown";
+/**
+ * Activity already observed by the client. `header` is only the short heading
+ * of what blocks the Session; it never carries question bodies or answers.
+ */
+export type ClientActivityV0 = Readonly<{
+    state: ClientActivityStateV0;
+    header?: string;
+}>;

package/dist/extensions.d.ts

@@ -14,7 +14,7 @@ import type { StateUpdate } from "./internal/extension-hook.js";
 import type { DocumentHandlesV0, DocumentsV0 } from "./session-documents.js";
 import { ExtensionId, extensionFingerprintSchema, extensionRevisionSchema, type CommandsV0, type ExtensionCapabilityV0, type ExtensionContractV0, type ExtensionManifestV0 } from "./extension-contract.js";
 export { ExtensionId, extensionIdentifier, extensionVersion, } from "./extension-contract.js";
-export type { AnyCommandSpecV0, ClientActivityV0, CommandsV0, CommandSpecV0, ExtensionCapabilityV0, ExtensionContractV0, ExtensionManifestV0, ProjectionSpecV0, ShiitakeExtensionProtocolV0, } from "./extension-contract.js";
+export type { AnyCommandSpecV0, ClientActivityStateV0, ClientActivityV0, CommandsV0, CommandSpecV0, ExtensionCapabilityV0, ExtensionContractV0, ExtensionManifestV0, ProjectionSpecV0, ShiitakeExtensionProtocolV0, } from "./extension-contract.js";
 import { type RegisteredExtensionCommandV0 } from "./internal/extension-command-registry.js";
 export type { RegisteredExtensionCommandV0 } from "./internal/extension-command-registry.js";
 import { type CommandToolsV0 } from "./internal/extension-command-tools.js";
@@ -68,7 +68,7 @@ declare const ExtensionStateError_base: new <A extends Record<string, any> = {}>
 } & Readonly<A>;
 /** Durable record failure: stored or supplied values broke their schema or bounds. */
 export declare class ExtensionStateError extends ExtensionStateError_base<{
-    reason: "decode" | "encode" | "bound" | "unavailable";
+    reason: "decode" | "encode" | "bound" | "unavailable" | "session_absent";
     message: string;
 }> {
 }
@@ -318,6 +318,8 @@ export type ExtensionContextV0<S extends CollectionsV0, Config extends Json, D e
     send: (input: SendInputV0) => Effect.Effect<SendResultV0, AdmissionError, ExtensionTx>;
     timers: TimersV0;
     attention: AttentionV0;
+    /** Committed selected Session position, or zero before its first entry. Requires state. */
+    sessionPosition: (sessionId: string) => Effect.Effect<number, ExtensionStateError, ExtensionRead>;
     /** Observe accepted steering without consuming Mule's next control delivery. Requires run_tools. */
     hasPendingSteer: (run: Pick<RunIdentityV0, "sessionId" | "workId">) => Effect.Effect<boolean, ExtensionStateError, ExtensionRead>;
     /** Whether this run durably recorded a successful tool outcome. Requires run_tools. */
@@ -549,6 +551,8 @@ export type ExtensionSlotV0 = Readonly<{
 }>;
 /** Borrowed view of the exact objects already built for compaction. */
 export type BorrowedCompactionViewV0 = Readonly<{
+    /** Session being compacted; a host binds the Agent itself. */
+    sessionId: string;
     /** Exact Pi preparation array summarized by the history call. */
     messagesToSummarize: readonly Message[];
     /** Exact Pi preparation array summarized for a split turn, when present. */

package/dist/fleet.d.ts

@@ -8,7 +8,7 @@ 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 FungiAuthor } from "@fungi.computer/agar/agents";
+import { type AuthorMeta } from "@fungi.computer/agar/agents";
 /** Operations explicitly admitted by the host. */
 export declare const agentActionSchema: z.ZodEnum<{
     send: "send";
@@ -78,6 +78,7 @@ export declare const agentCreationSchema: z.ZodLazy<z.ZodObject<{
     name: z.ZodString;
     requestId: z.ZodString;
     configuration: z.ZodString;
+    createdBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strict>>;
 /** One idempotent directory reservation. */
 export type AgentCreation = z.infer<typeof agentCreationSchema>;
@@ -90,6 +91,8 @@ export type AgentRename = z.infer<typeof agentRenameSchema>;
 /** One durable Agent directory record. */
 export type DirectoryAgent = Readonly<{
     agentId: AgentId;
+    /** The ordinary Agent that created this Agent; never the credential owner. */
+    createdBy: string | null;
     name: string;
     createdAt: number;
     updatedAt: number;
@@ -112,6 +115,8 @@ export declare function createAgentDirectory(sql: WatchdogSqliteOwner["sql"]): {
     create: (grant: AgentGrant, raw: AgentCreation) => {
         agent: Readonly<{
             agentId: AgentId;
+            /** The ordinary Agent that created this Agent; never the credential owner. */
+            createdBy: string | null;
             name: string;
             createdAt: number;
             updatedAt: number;
@@ -120,6 +125,8 @@ export declare function createAgentDirectory(sql: WatchdogSqliteOwner["sql"]): {
     } | {
         agent: Readonly<{
             agentId: AgentId;
+            /** The ordinary Agent that created this Agent; never the credential owner. */
+            createdBy: string | null;
             name: string;
             createdAt: number;
             updatedAt: number;
@@ -196,7 +203,7 @@ export type AuthenticatedDelegationReply = Readonly<{
 }>;
 /** The host metadata a delegated send carries, as JSON. */
 export type DelegationSendMeta = {
-    author: FungiAuthor;
+    author: AuthorMeta["author"];
     delegation?: {
         ancestors: string[];
         maxDepth: number;
@@ -204,7 +211,7 @@ export type DelegationSendMeta = {
 };
 /** The host metadata on one authenticated reply line, as JSON. */
 export type DelegationReplyMeta = Readonly<{
-    author: FungiAuthor;
+    author: AuthorMeta["author"];
     delegation: Readonly<{
         ancestors: readonly string[];
         maxDepth: number;
@@ -225,24 +232,50 @@ export declare function delegationProvenance(session: Readonly<{
  * and only the path inherited from the invoking line. A reply's verified facts
  * stay on that reply's own line and never travel onward.
  */
-export declare function delegationSendMeta(sender: FungiAuthor, invocationMeta?: Json): DelegationSendMeta;
+export declare function delegationSendMeta(sender: Readonly<{
+    id: string;
+    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.
  */
 export declare function delegationReplyMeta(delegation: AuthenticatedDelegationReply, replierName: string): DelegationReplyMeta;
 /**
- * Hosted BirdDog submission and Pending observation. The durable row freezes
+ * Delegated work an owner still waits on; `unreadable` says why its state
+ * could not be read, when it could not.
+ */
+export type OutstandingDelegation = Readonly<{
+    agentId: string;
+    sessionId: string;
+    commandId: string;
+    unreadable?: string;
+}>;
+/**
+ * BirdDog submission and reply authentication. The durable row freezes
  * correspondence before transport; an ambiguous delivery reuses that exact mail.
  * Shiitake owns work deduplication, execution and settlement; Post owns replies.
  */
-export declare function createFleetDelegation(options: FleetDelegationOptions): {
-    /** Authenticate a reply against its frozen mail and restore the caller's path. */
-    authenticateReply: (mail: BirdDogMail) => AuthenticatedDelegationReply | undefined;
-    /** Submit once and return the existing Shiitake admission receipt. */
+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>;
+    /** 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;
+};
+/** 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>;
+    /** 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;
+    /** The delegated work this owner still waits on, if any. */
+    outstanding: () => Promise<OutstandingDelegation | undefined>;
 };
 /** Acquire ordinary Session access; an in-process host applies meta with withMeta. */
 export type FleetAgentAccess = (agentId: string, meta?: Json) => Promise<Readonly<{
@@ -280,6 +313,7 @@ export declare function createFleetSessions(open: FleetAgentAccess): {
         pending: import("./client.js").SessionPendingPrompts;
         activity: import("./client.js").SessionActivity;
         progress: import("./client.js").SessionProgress | null;
+        toolOutput: readonly import("./client.js").SessionToolOutput[];
         extensions: import("./client.js").SessionExtensionSlots;
         attention: readonly import("./session-attention.js").SessionAttention[];
         context?: import("./client.js").SessionContext;