@fungi.computer/shiitake 0.5.0 → 0.7.0

package/dist/delegation.d.ts

@@ -31,10 +31,15 @@ export declare class AgentDelegation {
     }>);
     private fleetOwner;
     private fleet;
+    /** Best-effort remote refresh before an owner-local archive transaction.
+     * Confirmed settlements are recorded by Shiitake; unreadable targets leave
+     * their local accepted receipt outstanding for busySync to refuse.
+     */
+    refreshOutstanding(readSettlement: (agentId: string, sessionId: string, commandId: string) => Promise<CommandSettlement | undefined>): Promise<void>;
     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 +68,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 +78,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 +108,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 +118,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 +137,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 +167,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 +177,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 +196,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 +226,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 +236,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 +255,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 +285,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 +295,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 +342,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, createFleetDelegation, 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";
@@ -27,6 +27,19 @@ export class AgentDelegation {
             deliver: this.deps.deliver,
         }));
     }
+    /** Best-effort remote refresh before an owner-local archive transaction.
+     * Confirmed settlements are recorded by Shiitake; unreadable targets leave
+     * their local accepted receipt outstanding for busySync to refuse.
+     */
+    async refreshOutstanding(readSettlement) {
+        const fleet = createFleetDelegation({
+            storage: this.deps.storage,
+            deliver: this.deps.deliver,
+            open: (agentId) => this.deps.directory().open(agentId, new AbortController().signal),
+            readSettlement,
+        });
+        await fleet.outstanding();
+    }
     async scope(signal) {
         const agents = await this.deps.directory().list(signal);
         const identity = await this.deps.identity();
@@ -44,11 +57,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,36 +79,28 @@ 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,
         });
         const meta = delegationSendMeta({ id: scope.agentId, name: scope.source.name }, invocation.meta);
         signal.throwIfAborted();
+        let task = {
+            agentId: input.agentId,
+            sessionId: input.sessionId,
+            delivery: input.delivery,
+            text: input.text,
+            requestId,
+        };
+        if (input.delivery === "followUp" && input.goal !== undefined)
+            task = { ...task, goal: input.goal };
         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,
-        });
+        }, task);
         return accepted;
     }
     /** Resolve this sender's exact request, then let the recipient guard pending work. */

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, SessionToolOutput, 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, SessionProgressDelta, 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";
@@ -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/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", "state_reset_required", "storage_pressure"]>;
+declare const ShiitakeErrorCauseSchema: Schema.Literals<readonly ["closed", "conflict", "incompatible", "invalid", "rejected", "unavailable", "state_reset_required", "storage_pressure", "archived"]>;
 /** 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", "state_reset_required", "storage_pressure"]>;
+    readonly cause: Schema.Literals<readonly ["closed", "conflict", "incompatible", "invalid", "rejected", "unavailable", "state_reset_required", "storage_pressure", "archived"]>;
     readonly message: Schema.String;
     readonly requestId: Schema.optionalKey<Schema.String>;
 }>;

package/dist/errors.js

@@ -21,6 +21,8 @@ const ShiitakeErrorCauseSchema = Schema.Literals([
     "state_reset_required",
     /** Owner storage is near its budget; new Sessions and prompts wait. */
     "storage_pressure",
+    /** This Agent is archived; new Sessions and prompts require restoration. */
+    "archived",
 ]);
 const requestIdSchema = Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.isMaxLength(256)));
 /** Canonical serialized Shiitake failure. */

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";
@@ -77,7 +77,7 @@ declare const AdmissionError_base: new <A extends Record<string, any> = {}>(args
 } & Readonly<A>;
 /** The door refused an extension admission. */
 export declare class AdmissionError extends AdmissionError_base<{
-    reason: "invalid" | "conflict" | "closed";
+    reason: "invalid" | "conflict" | "closed" | "archived";
     message: string;
 }> {
 }
@@ -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

@@ -82,8 +82,8 @@ export type AgentLifecycleFact = Readonly<{
 }>;
 /** Refusal of supplied authority; no host policy lookup is performed. */
 export declare class AgentGrantError extends Error {
-    readonly reason: "agent" | "action" | "expired" | "delegation_loop" | "delegation_depth";
-    constructor(reason: "agent" | "action" | "expired" | "delegation_loop" | "delegation_depth");
+    readonly reason: "agent" | "action" | "expired" | "delegation_loop" | "delegation_depth" | "delegator_missing";
+    constructor(reason: "agent" | "action" | "expired" | "delegation_loop" | "delegation_depth" | "delegator_missing");
 }
 /** Check every operation against its explicit authority. */
 export declare function assertAgentGrant(grant: AgentGrant, action: AgentAction, agentId?: string): void;
@@ -180,11 +180,23 @@ 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";
+    }>>;
+    goal: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<false>]>>;
     text: z.ZodString;
 }, z.core.$strict>>;
 /** A caller reuses this task unchanged while polling Pending. */
@@ -260,6 +272,8 @@ export declare function delegationSendMeta(sender: Readonly<{
  * while the verified reply retains the failed recipient's identity.
  */
 export declare function delegationReplyMeta(delegation: AuthenticatedDelegationReply, replierName: string): DelegationReplyMeta;
+/** An original one-way report can only name an ancestor of its Agent sender. */
+export declare function isOneWayAncestorNotice(mail: BirdDogMail): boolean;
 /**
  * Delegated work an owner still waits on; `unreadable` says why its state
  * could not be read, when it could not.
@@ -270,6 +284,11 @@ export type OutstandingDelegation = Readonly<{
     commandId: string;
     unreadable?: string;
 }>;
+/** Read confirmed sender receipts that have no locally observed settlement.
+ * Call inside the Agent owner's transaction that also changes archived state.
+ * Remote reads happen separately; an unobserved settlement remains busy.
+ */
+export declare function readOutstandingDelegationSync(storage: WatchdogSqliteOwner): OutstandingDelegation | undefined;
 /**
  * BirdDog submission and reply authentication. The durable row freezes
  * correspondence before transport; an ambiguous delivery reuses that exact mail.
@@ -280,7 +299,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 +316,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;