@fungi.computer/shiitake 0.4.0 → 0.6.0

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. */
@@ -255,8 +266,9 @@ export declare function delegationSendMeta(sender: Readonly<{
     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.
+ * The host metadata for one authenticated reply line. An ordinary reply is
+ * authored by its replying Agent; a delivery failure is a Hub/system fact,
+ * while the verified reply retains the failed recipient's identity.
  */
 export declare function delegationReplyMeta(delegation: AuthenticatedDelegationReply, replierName: string): DelegationReplyMeta;
 /**
@@ -279,6 +291,10 @@ 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;
     /** Consume a recipient's stable `<mailKey>:accepted` notice. */
@@ -292,6 +308,10 @@ 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;
     /** Consume a recipient's stable `<mailKey>:accepted` notice. */

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)
@@ -318,16 +330,21 @@ export function delegationSendMeta(sender, invocationMeta) {
         };
 }
 /**
- * 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.
+ * The host metadata for one authenticated reply line. An ordinary reply is
+ * authored by its replying Agent; a delivery failure is a Hub/system fact,
+ * while the verified reply retains the failed recipient's identity.
  */
 export function delegationReplyMeta(delegation, replierName) {
-    return {
-        ...authorMeta({
+    const author = delegation.reply.outcome === "undeliverable" &&
+        delegation.reply.reason === "recipient_offline"
+        ? authorMeta({ id: "hub/system", name: "Hub/system" })
+        : authorMeta({
             id: delegation.reply.agentId,
             name: replierName,
             kind: "agent",
-        }),
+        });
+    return {
+        ...author,
         delegation: {
             ancestors: [...delegation.ancestors],
             maxDepth: delegation.maxDepth,
@@ -341,7 +358,7 @@ const delegationMetadata = z.object({
 const delegationRowSchema = z.lazy(() => z.strictObject({
     input: z.string(),
     mail: z.string(),
-    state: z.enum(["pending", "held", "accepted"]),
+    state: z.enum(["pending", "held", "accepted", "undeliverable"]),
     receipt: z.string().nullable(),
 }));
 const heldRecipientOffline = {
@@ -351,7 +368,7 @@ const heldRecipientOffline = {
 };
 const decodeMail = Schema.decodeUnknownSync(Schema.fromJsonString(BirdDogMailSchema));
 function bindRecipientSession(mail, sessionId) {
-    if (mail.from.sessionId === undefined)
+    if (mail.from.kind !== "agent")
         throw new DirectoryError(503, "partial_init");
     return {
         ...mail,
@@ -390,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
@@ -434,7 +452,7 @@ export function createFleetCorrespondence(options) {
             throw new DirectoryError(503, "partial_init");
         if (row.input !== input)
             throw new DirectoryError(409, "request_conflict");
-        if (row.state === "held")
+        if (row.state === "held" || row.state === "undeliverable")
             return heldRecipientOffline;
         if (row.state === "accepted") {
             if (row.receipt === null)
@@ -466,25 +484,55 @@ 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 row = read(mail.key.slice(0, -suffix.length));
-        if (row === 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 row = read(mailKey);
+        if (row === undefined || row.state === "undeliverable")
             return undefined;
         const sent = decodeMail(row.mail);
-        if (mail.reply.outcome !== "undeliverable" &&
-            mail.from.sessionId === undefined)
+        if (sent.key !== mailKey)
             return undefined;
-        if (mail.from.agentId !== sent.to.agentId ||
-            mail.from.sessionId !== sent.to.sessionId ||
-            mail.to.agentId !== sent.from.agentId ||
-            mail.to.sessionId !== sent.from.sessionId)
+        const systemUndeliverable = mail.reply.outcome === "undeliverable" &&
+            mail.reply.reason === "recipient_offline" &&
+            mail.from.kind === "system";
+        if (systemUndeliverable) {
+            if (row.state !== "held" ||
+                sent.from.kind !== "agent" ||
+                mail.key !== `${sent.key}:reply:0` ||
+                mail.to.agentId !== sent.from.agentId ||
+                mail.to.sessionId !== sent.from.sessionId)
+                return undefined;
+        }
+        else {
+            if (sent.from.kind !== "agent" ||
+                mail.from.kind !== "agent" ||
+                mail.from.agentId !== sent.to.agentId ||
+                mail.from.sessionId !== sent.to.sessionId ||
+                mail.to.agentId !== sent.from.agentId ||
+                mail.to.sessionId !== sent.from.sessionId)
+                return undefined;
+        }
+        if (mail.reply.outcome === "undeliverable" &&
+            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);
@@ -496,16 +544,28 @@ export function createFleetCorrespondence(options) {
             return undefined;
         let reply;
         if (mail.reply.outcome === "undeliverable") {
-            const undeliverable = { agentId: mail.from.agentId, ...mail.reply };
+            const agentId = systemUndeliverable
+                ? sent.to.agentId
+                : mail.from.kind === "agent"
+                    ? mail.from.agentId
+                    : undefined;
+            if (agentId === undefined)
+                return undefined;
+            const undeliverable = { agentId, ...mail.reply };
+            const sessionId = systemUndeliverable
+                ? sent.to.sessionId
+                : mail.from.kind === "agent"
+                    ? mail.from.sessionId
+                    : undefined;
             reply =
-                mail.from.sessionId === undefined
+                sessionId === undefined
                     ? undeliverable
-                    : { ...undeliverable, sessionId: mail.from.sessionId };
+                    : { ...undeliverable, sessionId };
         }
         else {
-            const sessionId = mail.from.sessionId;
-            if (sessionId === undefined)
+            if (mail.from.kind !== "agent")
                 return undefined;
+            const sessionId = mail.from.sessionId;
             reply = { agentId: mail.from.agentId, sessionId, ...mail.reply };
         }
         return {
@@ -514,6 +574,29 @@ export function createFleetCorrespondence(options) {
             reply,
         };
     }
+    /** Bind an exhausted local Carrier row to its frozen sender correspondence. */
+    function recordLocalUndeliverable(original, reply) {
+        const row = read(original.key);
+        if (row === undefined ||
+            (row.state !== "pending" && row.state !== "held") ||
+            original.from.kind !== "agent" ||
+            original.reply !== undefined ||
+            JSON.stringify(decodeMail(row.mail)) !== JSON.stringify(original) ||
+            reply.key !== `${original.key}:reply:0` ||
+            reply.from.kind !== "system" ||
+            reply.reply?.outcome !== "undeliverable" ||
+            reply.reply.reason !== "recipient_offline" ||
+            reply.to.agentId !== original.from.agentId ||
+            reply.to.sessionId !== original.from.sessionId ||
+            reply.replyTo.length !== 0)
+            return false;
+        store.recordHeld(original.key);
+        return read(original.key)?.state === "held";
+    }
+    /** Make a successfully admitted system disposition replay-ineligible. */
+    function recordUndeliverableReply(mailKey) {
+        return store.recordUndeliverable(mailKey);
+    }
     /** Read only the existing acceptance receipt; do not reserve or deliver mail. */
     function receipt(requestId) {
         const row = read(requestId);
@@ -524,9 +607,11 @@ export function createFleetCorrespondence(options) {
     /** Atomically bind the recipient Session carried by a late acceptance notice. */
     function recordAcceptedNotice(mail) {
         const suffix = ":accepted";
+        if (mail.from.kind !== "agent")
+            return undefined;
+        const sender = mail.from;
         if (mail.replyTo.length !== 0 ||
             mail.reply?.outcome !== "accepted" ||
-            mail.from.sessionId === undefined ||
             !mail.key.endsWith(suffix))
             return undefined;
         const requestId = mail.key.slice(0, -suffix.length);
@@ -534,29 +619,31 @@ export function createFleetCorrespondence(options) {
         if (row === undefined)
             return undefined;
         const sent = decodeMail(row.mail);
+        if (sent.from.kind !== "agent")
+            return undefined;
+        const sentSender = sent.from;
         const path = delegationMetadata.safeParse(sent.meta);
-        if (sent.from.sessionId === undefined ||
-            !path.success ||
+        if (!path.success ||
             path.data.delegation === undefined ||
             mail.key !== `${sent.key}:accepted` ||
-            mail.from.agentId !== sent.to.agentId ||
+            sender.agentId !== sent.to.agentId ||
             (sent.to.sessionId !== undefined &&
-                sent.to.sessionId !== mail.from.sessionId) ||
-            mail.to.agentId !== sent.from.agentId ||
-            mail.to.sessionId !== sent.from.sessionId)
+                sent.to.sessionId !== sender.sessionId) ||
+            mail.to.agentId !== sentSender.agentId ||
+            mail.to.sessionId !== sentSender.sessionId)
             return undefined;
         if (row.state === "accepted" && row.receipt !== null) {
             const current = parseAccepted(row.receipt);
             if (current.commandId !== mail.reply.commandId ||
-                current.sessionId !== mail.from.sessionId)
+                current.sessionId !== sender.sessionId)
                 return undefined;
         }
         const accepted = {
             status: "accepted",
             commandId: mail.reply.commandId,
-            sessionId: mail.from.sessionId,
+            sessionId: sender.sessionId,
         };
-        store.recordReceipt(requestId, JSON.stringify(accepted), row.mail, JSON.stringify(bindRecipientSession(sent, mail.from.sessionId)));
+        store.recordReceipt(requestId, JSON.stringify(accepted), row.mail, JSON.stringify(bindRecipientSession(sent, sender.sessionId)));
         return accepted;
     }
     return {
@@ -564,6 +651,10 @@ 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,
         /** Consume a recipient's stable `<mailKey>:accepted` notice. */

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;

package/dist/internal/accepted-run-executor.js

@@ -9,7 +9,7 @@ import { ExtensionId } from "../extension-contract.js";
 import { publishOwnerObservation } from "./observation-kernel.js";
 import { returnedFailureReason } from "./run-failure-reason.js";
 import { coreProtocolDigest } from "./extension-roster.js";
-import { runAcceptedCommand, runAcceptedCompaction, ToolSetupError, } from "./run-scope.js";
+import { runAcceptedCommand, runAcceptedCompaction, RunRejectedError, ToolSetupError, } from "./run-scope.js";
 import { CompactionCommitError } from "./compaction/session-compaction.js";
 import { BrokenSessionError, isCompactCommand, loadAcceptedRun, readExtensionAdmissionOrigin, recordWorkSettlement, } from "./woodstock/index.js";
 /** Bounded process-loss recovery for every accepted Agent turn. */
@@ -25,6 +25,7 @@ function runtimeFailure(message) {
 function failedDecision(error) {
     const category = `${error.boundary}:${error.cause}`;
     const diagnostic = error instanceof ToolSetupError ||
+        error instanceof RunRejectedError ||
         error instanceof CompactionCommitError ||
         error instanceof BrokenSessionError
         ? error.diagnostic

package/dist/internal/admission-door.d.ts

@@ -34,6 +34,11 @@ export type AdmitRequest = Readonly<{
     reply?: VerifiedAgentReply;
     /** Synchronous owner-local side effect committed with a mail admission. */
     onAccepted?: (sessionId: string, commandId: string) => void;
+    /**
+     * New work that continues earlier work in this Session (for example, the
+     * follow-up that delivers an answer) keeps that work's sender.
+     */
+    continuesWorkId?: string | undefined;
 }>;
 /** Outcome of one door admission. */
 export type AdmitResult = Readonly<{

package/dist/internal/admission-door.js

@@ -1,10 +1,11 @@
+import { messageAuthor } from "@fungi.computer/agar/agents";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
 import { checkHostMeta } from "./host-meta.js";
 import { ShiitakeError } from "../errors.js";
 import { decodeClientAcceptedCommand, decodeClientSessionId, decodeClientSessionCreationRequestId, requireDecoded, } from "./client-boundary.js";
 import { publishOwnerObservation } from "./observation-kernel.js";
-import { AdmissionOriginSchema, acceptSessionCommandOwned, readSessionCommandAdmissionByRequest, withdrawSessionRequestOwned, assertSessionRequestNotWithdrawn, hasStoredSession, VerifiedAgentReplySchema, } from "./woodstock/index.js";
+import { AdmissionOriginSchema, acceptSessionCommandOwned, readSessionCommandAdmissionByRequest, withdrawSessionRequestOwned, assertSessionRequestNotWithdrawn, hasStoredSession, readWorkSender, recordWorkSender, recordSessionDelegator, VerifiedAgentReplySchema, } from "./woodstock/index.js";
 const decodeOrigin = Schema.decodeUnknownResult(AdmissionOriginSchema, {
     onExcessProperty: "error",
 });
@@ -16,14 +17,37 @@ function decodeReply(request) {
         return undefined;
     const reply = requireDecoded(decodeVerifiedReply(request.reply), "Verified Agent reply is invalid");
     const mail = request.mail;
+    const agentAuthored = mail?.from.kind === "agent" &&
+        mail.from.agentId === reply.agentId &&
+        mail.from.sessionId === reply.sessionId;
+    const systemUndeliverable = mail?.from.kind === "system" &&
+        reply.outcome === "undeliverable" &&
+        reply.reason === "recipient_offline";
     if (mail?.replyTo.length !== 0 ||
-        mail.from.agentId !== reply.agentId ||
-        mail.from.sessionId !== reply.sessionId ||
+        (!agentAuthored && !systemUndeliverable) ||
         request.command.type !== "prompt" ||
         request.command.delivery !== "steer")
         throw new ShiitakeError("contract", "invalid", "Verified Agent reply does not match its mail");
     return reply;
 }
+/**
+ * The Agent Session whose work this admission is: the sender of delegated
+ * mail that expects a reply, or the sender of the earlier work this one
+ * continues. Replies and every other admission have none.
+ */
+function workSender(owner, request) {
+    const mail = request.mail;
+    if (mail?.from.kind === "agent" && mail.replyTo.length > 0)
+        return {
+            agentId: mail.from.agentId,
+            sessionId: mail.from.sessionId,
+            // The host-authenticated author names the sender; mail.meta is the sender's own claim.
+            name: messageAuthor(request.meta)?.name ?? mail.from.agentId,
+        };
+    return request.continuesWorkId === undefined
+        ? undefined
+        : readWorkSender(owner, request.sessionId, request.continuesWorkId);
+}
 /** Bind the door to one owner, run contract, Watchdog queue and host wake. */
 export function openAdmissionDoor(input) {
     /** The door's one decode, done before any owner operation when possible. */
@@ -36,6 +60,7 @@ export function openAdmissionDoor(input) {
         mail: request.mail,
         reply: decodeReply(request),
         onAccepted: request.onAccepted,
+        continuesWorkId: request.continuesWorkId,
         meta: request.meta === undefined
             ? undefined
             : checkHostMeta(input.hostMeta, request.meta),
@@ -70,6 +95,12 @@ export function openAdmissionDoor(input) {
                 input.enqueue(work, request.mail);
             }
             : undefined, targetWorkId, request.reply);
+        if (accepted.delivery === "new" && targetWorkId === undefined) {
+            const sender = workSender(input.owner, request);
+            if (sender !== undefined)
+                recordWorkSender(input.owner, sessionId, accepted.accepted.commandId, sender);
+        }
+        recordSessionDelegator(input.owner, sessionId, request.mail);
         request.onAccepted?.(sessionId, accepted.accepted.commandId);
         touched.set(sessionId, (touched.get(sessionId) ?? false) || accepted.delivery === "new");
         return Object.freeze({

package/dist/internal/contracts.d.ts

@@ -3,7 +3,7 @@ import type { SessionTerminal, ShiitakeAgent } from "../client.js";
 import type { GrantsDelivery, GrantsDeliveryResult } from "./woodstock/index.js";
 import type { Json } from "../extensions.js";
 import type { ExtensionRosterV0 } from "../extensions.js";
-import type { Api, AssistantMessage, Model, MuleStreamFunction } from "@fungi.computer/mule/effect";
+import type { Api, AssistantMessage, Model, MuleStreamFunction, ProviderRejection } from "@fungi.computer/mule/effect";
 import type { AccessOptions, CapabilitySource, ExecutionOptions, ModuleRegistration, Sandbox } from "@fungi.computer/mycelium";
 import type { ModelPreference } from "./model-preference.js";
 import type { WatchdogSqliteValue, WatchdogSqliteRow, WatchdogSqliteOwner, WatchdogSqliteCursor } from "@fungi.computer/watchdog";
@@ -47,6 +47,8 @@ export type ModelAcquisition = Readonly<{
      * Unknown messages must return undefined.
      */
     failureReason?: (message: AssistantMessage) => string | undefined;
+    /** Bounded provider facts for this door's exact failure, never SDK prose. */
+    rejection?: (message: AssistantMessage) => ProviderRejection | undefined;
     /** Provider prose for this door's exact failed turn; never a diagnostic. */
     providerError?: (message: AssistantMessage) => string | undefined;
     /** Release the acquired model resources. */
@@ -253,6 +255,8 @@ export type { HostMetaOptions, StandardHostMetaResult, StandardHostMetaSchema, }
 export type CommandSettlement = Readonly<{
     /** Original Agent sender recorded at acceptance, never the terminal's canceller. */
     acceptedSender: string | null;
+    /** Agent that first sent this Session work and receives its reports, if any. */
+    delegator: string | null;
     /** Durable terminal and the command that ended the work's opaque metadata. */
     terminal: SessionTerminal;
     /** Last completed assistant text; cancelled work returns no answer. */
@@ -261,4 +265,13 @@ export type CommandSettlement = Readonly<{
     usage: readonly Pick<AssistantMessage, "provider" | "model" | "usage">[];
     /** Distinct tool-call intentions belonging to this exact work. */
     toolCalls: number;
+    /**
+     * Open items of the Session that now wait on the Agent that sent this work.
+     * Child-authored data: summaries inform, only the sender's host checks decide.
+     */
+    waitingOnYou: readonly Readonly<{
+        itemId: string;
+        kind: string;
+        summary: string;
+    }>[];
 }>;

package/dist/internal/coordinator.js

@@ -1,6 +1,7 @@
 import { nanoid } from "@fungi.computer/cairn";
 import { parseModelPreference } from "./model-preference.js";
 import { acceptedNotice } from "@fungi.computer/bird-dog/effect";
+import { FungiMessageMetaSchema } from "@fungi.computer/agar/agents";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Stream from "effect/Stream";
@@ -348,7 +349,7 @@ export function openCoordinator(options, runtime) {
                 })), Effect.asVoid))),
             }),
             extension: (extensionId) => Object.freeze({
-                call: (command, input) => runtime.assertOpen.pipe(Effect.andThen(runtime.extensions.call({ scope: "session", sessionId }, extensionId, command, input))),
+                call: (command, input, caller) => runtime.assertOpen.pipe(Effect.andThen(runtime.extensions.call({ scope: "session", sessionId }, extensionId, command, input, caller))),
             }),
             read: (input) => runtime.assertOpen.pipe(Effect.andThen(readSessionWithContext(options, runtime, sessionId, input))),
             readSettlement: (commandId, timeoutMs = 0) => Effect.scoped(Effect.gen(function* () {
@@ -410,6 +411,11 @@ export function openCoordinator(options, runtime) {
         }),
     });
 }
+/** Whether the sender asked this mail to steer the recipient's running turn. */
+function steersRunningTurn(mail) {
+    const meta = FungiMessageMetaSchema.safeParse(mail.meta);
+    return meta.success && meta.data.delegation?.steer === true;
+}
 /**
  * Accept one addressed mail envelope; the door decodes it as a prompt. `reply`
  * is the host's authentication of a delegated Agent's reply; only then does
@@ -458,7 +464,7 @@ export function acceptAddressedMail(runtime, mail, meta, reply, stageMail, sessi
     }
     return admitUserWork(runtime, mail.to.sessionId, {
         requestId: mail.key,
-        delivery: reply === undefined ? "followUp" : "steer",
+        delivery: reply !== undefined || steersRunningTurn(mail) ? "steer" : "followUp",
         type: "prompt",
         text: mail.content,
     }, meta, mail, reply);

package/dist/internal/effect-client.js

@@ -72,7 +72,7 @@ function sessionFacade(address, session) {
         extension: (extensionId) => {
             const extension = session.extension(extensionId);
             return Object.freeze({
-                call: (command, input) => runShiitakePromise(extension.call(command, input)),
+                call: (command, input, caller) => runShiitakePromise(extension.call(command, input, caller)),
             });
         },
         read: (input) => runShiitakePromise(session.read(input)),