@fungi.computer/shiitake 0.5.0 → 0.6.0

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

@@ -34,7 +34,7 @@ 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>;
@@ -63,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 {
@@ -79,11 +73,22 @@ 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 waitingOnYou?: readonly {
+            readonly itemId: string;
+            readonly kind: string;
+            readonly summary: string;
+        }[];
     } | {
         readonly outcome: "accepted";
         readonly commandId: string;
@@ -98,14 +103,9 @@ export declare function agentMailRoute(namespace: PostRoute<never, never>["names
         readonly reason: "recipient_offline";
     };
     readonly content: string;
-    readonly createdAt: number;
-    readonly from: {
-        readonly kind: "system";
-        readonly systemId: "hub";
-    };
     readonly to: {
-        readonly kind: "agent";
         readonly agentId: string;
+        readonly kind: "agent";
         readonly sessionId?: string;
     };
     readonly replyTo: readonly {
@@ -113,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 {
@@ -133,11 +132,22 @@ 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 waitingOnYou?: readonly {
+            readonly itemId: string;
+            readonly kind: string;
+            readonly summary: string;
+        }[];
     } | {
         readonly outcome: "accepted";
         readonly commandId: string;
@@ -152,14 +162,9 @@ export declare function agentMailRoute(namespace: PostRoute<never, never>["names
         readonly reason: "recipient_offline";
     };
     readonly content: string;
-    readonly createdAt: number;
-    readonly from: {
-        readonly kind: "system";
-        readonly systemId: "hub";
-    };
     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,11 +191,22 @@ 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 waitingOnYou?: readonly {
+            readonly itemId: string;
+            readonly kind: string;
+            readonly summary: string;
+        }[];
     } | {
         readonly outcome: "accepted";
         readonly commandId: string;
@@ -206,14 +221,9 @@ export declare function agentMailRoute(namespace: PostRoute<never, never>["names
         readonly reason: "recipient_offline";
     };
     readonly content: string;
-    readonly createdAt: number;
-    readonly from: {
-        readonly kind: "system";
-        readonly systemId: "hub";
-    };
     readonly to: {
-        readonly kind: "agent";
         readonly agentId: string;
+        readonly kind: "agent";
         readonly sessionId?: string;
     };
     readonly replyTo: readonly {
@@ -221,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 {
@@ -241,11 +250,22 @@ 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 waitingOnYou?: readonly {
+            readonly itemId: string;
+            readonly kind: string;
+            readonly summary: string;
+        }[];
     } | {
         readonly outcome: "accepted";
         readonly commandId: string;
@@ -260,14 +280,9 @@ export declare function agentMailRoute(namespace: PostRoute<never, never>["names
         readonly reason: "recipient_offline";
     };
     readonly content: string;
-    readonly createdAt: number;
-    readonly from: {
-        readonly kind: "system";
-        readonly systemId: "hub";
-    };
     readonly to: {
-        readonly kind: "agent";
         readonly agentId: string;
+        readonly kind: "agent";
         readonly sessionId?: string;
     };
     readonly replyTo: readonly {
@@ -275,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;
@@ -317,6 +337,7 @@ export declare class AgentMail {
     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,7 +3,7 @@
  * 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";
@@ -44,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");
@@ -66,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,
@@ -93,6 +81,7 @@ export class AgentDelegation {
         }, {
             agentId: input.agentId,
             sessionId: input.sessionId,
+            delivery: input.delivery,
             text: input.text,
             requestId,
         });

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";

package/dist/extensions.d.ts

@@ -1,6 +1,6 @@
 import type { FileTool } from "@fungi.computer/knapsack";
-import type { AttentionItem } from "./session-attention.js";
-export { AttentionItemSchema, type AttentionItem, type SessionAttention, } from "./session-attention.js";
+import type { AttentionItem, AttentionRecipient } from "./session-attention.js";
+export { AttentionItemSchema, AttentionRecipientSchema, type AttentionItem, type AttentionRecipient, type SessionAttention, } from "./session-attention.js";
 import type { Message, Usage } from "@fungi.computer/mule/effect";
 import type { ModuleRegistration } from "@fungi.computer/mycelium";
 import * as Brand from "effect/Brand";
@@ -261,6 +261,8 @@ export type SendInputV0 = Readonly<{
     when: "now" | "idle";
     /** Stored with the admission and returned on `SettledRunV0.origin`. */
     correlation?: string;
+    /** This work continues earlier work of the Session and keeps its sender. */
+    continuesWorkId?: string;
 }>;
 /** Door outcome for one extension admission. */
 export type SendResultV0 = Readonly<{
@@ -290,17 +292,26 @@ export type CommandSessionIdsV0 = {
     agent: null;
     session: string;
 };
+/** Host-authenticated caller context; never decoded from command JSON or HTTP. */
+export type ExtensionCommandCallerV0 = Readonly<{
+    agentId: string;
+    sessionId: string;
+}>;
 /** Handlers for every declared command, run in one core transaction. */
 export type CommandHandlersV0<C extends CommandsV0> = {
     readonly [K in keyof C]: (call: Readonly<{
         sessionId: CommandSessionIdsV0[C[K]["scope"]];
         input: C[K]["input"]["Type"];
+        /** Present only when the owning in-process host authenticates a caller. */
+        caller?: ExtensionCommandCallerV0;
     }>) => C[K]["output"]["Type"] | Effect.Effect<C[K]["output"]["Type"], ExtensionCommandError | ExtensionStateError | AdmissionError, ExtensionTx | ExtensionRead>;
 };
 /** Transaction-scoped, extension-owned attention on an existing Session. */
 export type AttentionV0 = Readonly<{
     /** Upsert this extension’s item and publish the committed Session change. */
     set: (sessionId: string, item: AttentionItem) => Effect.Effect<void, ExtensionStateError, ExtensionTx>;
+    /** Whether any extension holds an inbox item asking a person to act (a question or approval). */
+    awaitsPerson: (sessionId: string) => Effect.Effect<boolean, ExtensionStateError, ExtensionRead>;
     /** Clear this extension’s item; other owners cannot be changed. */
     clear: (sessionId: string, id: string) => Effect.Effect<void, ExtensionStateError, ExtensionTx>;
 }>;
@@ -322,10 +333,18 @@ export type ExtensionContextV0<S extends CollectionsV0, Config extends Json, D e
     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>;
+    /**
+     * The Agent Session that sent this run, or null when a person (or the host)
+     * did. Attention an extension raises for the run waits on it first.
+     * Requires run_tools.
+     */
+    workSender: (run: Pick<RunIdentityV0, "sessionId" | "workId">) => Effect.Effect<AttentionRecipient | null, ExtensionStateError, ExtensionRead>;
     /** Whether this run durably recorded a successful tool outcome. Requires run_tools. */
     hasSuccessfulToolResult: (run: Pick<RunIdentityV0, "sessionId" | "workId">, toolCallId: string) => Effect.Effect<boolean, ExtensionStateError, ExtensionRead>;
     /** Publish a Session observation after this transaction commits. */
     observe: (sessionId: string) => Effect.Effect<void, never, ExtensionTx>;
+    /** Process-local live-view demand, excluding exact-command settlement waiters. */
+    isObserved: (sessionId: string) => boolean;
     /**
      * Run one write transaction from outside a hook (for example a Mycelium
      * tool execute). Core commits, publishes, and requests a wake when it

package/dist/extensions.js

@@ -1,4 +1,4 @@
-export { AttentionItemSchema, } from "./session-attention.js";
+export { AttentionItemSchema, AttentionRecipientSchema, } from "./session-attention.js";
 import * as Brand from "effect/Brand";
 import * as Context from "effect/Context";
 import * as Data from "effect/Data";

package/dist/fleet.d.ts

@@ -180,11 +180,22 @@ export declare function createAgentDirectory(sql: WatchdogSqliteOwner["sql"]): {
     /** Whether the retained erasure roster covers this store. */
     erasureRosterComplete: () => boolean;
 };
+/**
+ * Whether an Agent may read one command's settlement: the Agent whose mail the
+ * command answered, or the Session's delegator of record for work no Agent's
+ * mail admitted (goal, loop and person turns, the work its reports carry).
+ * Another Agent's correspondence stays with that Agent.
+ */
+export declare function settlementReadableBy(facts: Pick<CommandSettlement, "acceptedSender" | "delegator">, agentId: string): boolean;
 /** Replay identity and work, with the parent supplied exclusively by the grant. */
 export declare const agentDelegationTaskSchema: z.ZodLazy<z.ZodObject<{
     requestId: z.ZodString;
     agentId: z.ZodString;
     sessionId: z.ZodOptional<z.ZodString>;
+    delivery: z.ZodOptional<z.ZodEnum<{
+        followUp: "followUp";
+        steer: "steer";
+    }>>;
     text: z.ZodString;
 }, z.core.$strict>>;
 /** A caller reuses this task unchanged while polling Pending. */
@@ -280,7 +291,9 @@ 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;
+    /** Bind exhausted local delivery to its frozen sender correspondence. */
     recordLocalUndeliverable: (original: BirdDogMail, reply: BirdDogMail) => boolean;
+    /** Prevent replay after a system undeliverable reply is admitted. */
     recordUndeliverableReply: (mailKey: string) => boolean;
     /** Read an existing acceptance receipt without reserving or delivering mail. */
     receipt: (requestId: string) => Accepted | undefined;
@@ -295,7 +308,9 @@ 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;
+    /** Bind exhausted local delivery to its frozen sender correspondence. */
     recordLocalUndeliverable: (original: BirdDogMail, reply: BirdDogMail) => boolean;
+    /** Prevent replay after a system undeliverable reply is admitted. */
     recordUndeliverableReply: (mailKey: string) => boolean;
     /** Read an existing acceptance receipt without reserving or delivering mail. */
     receipt: (requestId: string) => Accepted | undefined;

package/dist/fleet.js

@@ -269,11 +269,23 @@ export function createAgentDirectory(sql) {
         erasureRosterComplete: store.erasureRosterComplete,
     };
 }
+/**
+ * Whether an Agent may read one command's settlement: the Agent whose mail the
+ * command answered, or the Session's delegator of record for work no Agent's
+ * mail admitted (goal, loop and person turns, the work its reports carry).
+ * Another Agent's correspondence stays with that Agent.
+ */
+export function settlementReadableBy(facts, agentId) {
+    return (facts.acceptedSender === agentId ||
+        (facts.acceptedSender === null && facts.delegator === agentId));
+}
 /** Replay identity and work, with the parent supplied exclusively by the grant. */
 export const agentDelegationTaskSchema = z.lazy(() => z.strictObject({
     requestId: identity,
     agentId: identity,
     sessionId: identity.optional(),
+    /** A live steer into the recipient's running turn; queued follow-up when omitted. */
+    delivery: z.enum(["followUp", "steer"]).optional(),
     text: z
         .string()
         .min(1)
@@ -395,7 +407,8 @@ export function createFleetCorrespondence(options) {
             throw new AgentGrantError("delegation_loop");
         if (ancestors.length >= maxDepth)
             throw new AgentGrantError("delegation_depth");
-        const delegation = { ancestors: [...ancestors, parent.agentId], maxDepth };
+        const path = { ancestors: [...ancestors, parent.agentId], maxDepth };
+        const delegation = task.delivery === "steer" ? { ...path, steer: true } : path;
         const outgoingMeta = {
             ...(objectMeta.success
                 ? objectMeta.data
@@ -471,13 +484,23 @@ export function createFleetCorrespondence(options) {
      */
     function authenticateReply(mail) {
         // This owner sends to one correspondent, so BirdDog's reply index is zero.
-        const suffix = ":reply:0";
+        // A report names the idle Session's delegator mail and the settled command.
         if (mail.replyTo.length !== 0 ||
             mail.reply === undefined ||
-            mail.reply.outcome === "accepted" ||
-            !mail.key.endsWith(suffix))
+            mail.reply.outcome === "accepted")
+            return undefined;
+        const reportAt = mail.key.lastIndexOf(":report:");
+        // A report's key names the command it settles.
+        const isReport = reportAt >= 0 &&
+            "commandId" in mail.reply &&
+            mail.key.slice(reportAt) === `:report:${mail.reply.commandId}:0`;
+        const mailKey = isReport
+            ? mail.key.slice(0, reportAt)
+            : mail.key.endsWith(":reply:0")
+                ? mail.key.slice(0, -":reply:0".length)
+                : undefined;
+        if (mailKey === undefined)
             return undefined;
-        const mailKey = mail.key.slice(0, -suffix.length);
         const row = read(mailKey);
         if (row === undefined || row.state === "undeliverable")
             return undefined;
@@ -508,7 +531,8 @@ export function createFleetCorrespondence(options) {
             mail.reply.reason === "recipient_offline" &&
             !systemUndeliverable)
             return undefined;
-        if (mail.reply.outcome !== "undeliverable" &&
+        if (!isReport &&
+            mail.reply.outcome !== "undeliverable" &&
             row.state === "accepted" &&
             row.receipt !== null) {
             const sentResult = parseAccepted(row.receipt);
@@ -627,7 +651,9 @@ export function createFleetCorrespondence(options) {
         start,
         /** Match a reply to frozen mail and restore the caller's delegation path. */
         authenticateReply,
+        /** Bind exhausted local delivery to its frozen sender correspondence. */
         recordLocalUndeliverable,
+        /** Prevent replay after a system undeliverable reply is admitted. */
         recordUndeliverableReply,
         /** Read an existing acceptance receipt without reserving or delivering mail. */
         receipt,

package/dist/hosted.js

@@ -166,12 +166,15 @@ function hostedPort(manifest, revision, grants) {
             }),
             attention: Object.freeze({
                 set: () => Effect.fail(unavailable("Attention")),
+                awaitsPerson: () => Effect.fail(unavailable("Attention")),
                 clear: () => Effect.fail(unavailable("Attention")),
             }),
             hasPendingSteer: () => Effect.fail(unavailable("Steering")),
+            workSender: () => Effect.fail(unavailable("Run sender")),
             sessionPosition: () => Effect.fail(unavailable("Session timeline")),
             hasSuccessfulToolResult: () => Effect.fail(unavailable("A tool result")),
             observe: () => Effect.die(unavailable("Observation")),
+            isObserved: () => false,
             transact: () => Effect.fail(new ShiitakeError("extensions", "rejected", "A hosted extension has no Agent transaction")),
         }),
     });

package/dist/http-routes.d.ts

@@ -502,6 +502,7 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
             };
             output: {
                 readonly acceptedSender: string | null;
+                readonly delegator: string | null;
                 readonly terminal: {
                     readonly commandId: string;
                     readonly outcome: "completed" | "cancelled" | "failed" | "interrupted";
@@ -531,6 +532,11 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                     };
                 }[];
                 readonly toolCalls: number;
+                readonly waitingOnYou: readonly {
+                    readonly itemId: string;
+                    readonly kind: string;
+                    readonly summary: string;
+                }[];
             } | null;
             outputFormat: "json";
             status: 200;
@@ -873,6 +879,11 @@ export declare function createShiitakeHttpRoutes(resolveSession: ShiitakeSession
                     readonly extensionId: string;
                     readonly expiresAt?: number | undefined;
                     readonly inbox?: false | undefined;
+                    readonly waitingOn?: {
+                        readonly agentId: string;
+                        readonly sessionId: string;
+                        readonly name: string;
+                    } | undefined;
                 }[];
                 readonly context?: {
                     readonly tokens: number;