@fungi.computer/shiitake 0.4.0 → 0.6.0

package/dist/internal/effect-contracts.d.ts

@@ -1,6 +1,6 @@
 import type { HostMetaOptions } from "./host-meta.js";
 import type { ExtensionRosterV0 } from "../extensions.js";
-import type { Api, AssistantMessage, Model, MuleStreamFunction, RetryPolicy } from "@fungi.computer/mule/effect";
+import type { Api, AssistantMessage, Model, MuleStreamFunction, ProviderRejection, RetryPolicy } from "@fungi.computer/mule/effect";
 import type { CapabilitySource, ExecutionOptions, ModuleRegistration } from "@fungi.computer/mycelium";
 import type { CommandSettlement, GrantsDelivery, GrantsDeliveryResult, ToolAccess } from "./contracts.js";
 import type { Sandbox } from "@fungi.computer/mycelium/effect";
@@ -26,6 +26,8 @@ export type ModelAcquisitionEffect = Readonly<{
     retryable: (message: AssistantMessage) => boolean;
     /** Owner-authored reason for this door's failure message, never SDK prose. */
     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;
     /** Effect finalizer for acquired model resources. */
@@ -201,7 +203,7 @@ export type ShiitakeEffectSession = Readonly<{
 /** Effect-native Session-scope extension commands. */
 export type ShiitakeEffectSessionExtension = Readonly<{
     /** Run one command with its encoded input; succeeds with the encoded output. */
-    call: (command: string, input: Json) => Effect.Effect<Json, ShiitakeError>;
+    call: (command: string, input: Json, caller?: import("../extensions.js").ExtensionCommandCallerV0) => Effect.Effect<Json, ShiitakeError>;
 }>;
 /** Effect-native Agent-scope extension controls. */
 export type ShiitakeEffectAgentExtensions = Readonly<{

package/dist/internal/extension-command-registry.d.ts

@@ -1,11 +1,12 @@
 import * as Effect from "effect/Effect";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
-import type { AdmissionError, CommandHandlersV0, CommandsV0, ExtensionCommandError, ExtensionRead, ExtensionStateError, ExtensionTx, Json } from "../extensions.js";
+import type { AdmissionError, CommandHandlersV0, CommandsV0, ExtensionCommandError, ExtensionCommandCallerV0, ExtensionRead, ExtensionStateError, ExtensionTx, Json } from "../extensions.js";
 /** A parsed invocation retains its typed handler until the transaction runs. */
 export type RegisteredExtensionCommandV0 = (frame: Readonly<{
     sessionId: string | null;
     input: Json;
+    caller?: ExtensionCommandCallerV0;
 }>) => Result.Result<() => Effect.Effect<Json, ExtensionCommandError | ExtensionStateError | AdmissionError, ExtensionTx | ExtensionRead>, Schema.SchemaError>;
 /** Capture each declared command's schemas and matching handler at activation. */
 export declare function registerExtensionCommands<C extends CommandsV0>(specs: C, handlers: CommandHandlersV0<C>): ReadonlyMap<string, RegisteredExtensionCommandV0>;

package/dist/internal/extension-command-registry.js

@@ -13,7 +13,9 @@ function bindCommand(spec, handler) {
     const decodeInput = Schema.decodeUnknownResult(spec.input, {
         onExcessProperty: "error",
     });
-    return (frame) => Result.flatMap(decodeSession(frame.sessionId), (sessionId) => Result.map(decodeInput(frame.input), (input) => () => invokeTransactionHook(() => handler({ sessionId, input })).pipe(Effect.flatMap((output) => Schema.encodeEffect(spec.output)(output).pipe(Effect.flatMap(Schema.decodeUnknownEffect(JsonValueSchema)), Effect.orDie)))));
+    return (frame) => Result.flatMap(decodeSession(frame.sessionId), (sessionId) => Result.map(decodeInput(frame.input), (input) => () => invokeTransactionHook(() => handler(frame.caller === undefined
+        ? { sessionId, input }
+        : { sessionId, input, caller: frame.caller })).pipe(Effect.flatMap((output) => Schema.encodeEffect(spec.output)(output).pipe(Effect.flatMap(Schema.decodeUnknownEffect(JsonValueSchema)), Effect.orDie)))));
 }
 /** Capture each declared command's schemas and matching handler at activation. */
 export function registerExtensionCommands(specs, handlers) {

package/dist/internal/extension-runtime.d.ts

@@ -9,6 +9,8 @@ import type { SqliteOwner } from "./contracts.js";
 import type { AdmittedExtensionV0 } from "./extension-roster.js";
 /** The settled consumer name core itself uses for mail and control repair. */
 export declare const coreConsumer = "core";
+/** Core reports to delegators after the extensions have seen a settlement. */
+export declare const reportConsumer = "core-report";
 /** Core's generic view of rostered v1 extensions. */
 export type ExtensionRuntime = Readonly<{
     /** Prepare additions without replacing any live member; apply only between turns. */
@@ -53,7 +55,7 @@ export type ExtensionRuntime = Readonly<{
         sessionId: string;
     } | {
         scope: "agent";
-    }>, extensionId: string, command: string, input: Json) => Effect.Effect<Json, ShiitakeError>;
+    }>, extensionId: string, command: string, input: Json, caller?: import("../extensions.js").ExtensionCommandCallerV0) => Effect.Effect<Json, ShiitakeError>;
     list: () => readonly ExtensionStatusV0[];
     resume: (id: string) => Effect.Effect<ExtensionStatusV0, ShiitakeError>;
     close: Effect.Effect<void, ShiitakeError>;

package/dist/internal/extension-runtime.js

@@ -12,11 +12,13 @@ import { ShiitakeError } from "../errors.js";
 import { AdmissionError, ExtensionCommandError, ExtensionRead, ExtensionStateError, ExtensionStop, ExtensionTx, } from "../extensions.js";
 import { decodeClientSessionId } from "./client-boundary.js";
 import { AsyncExtensionTransactionError, invokeExtensionHook, invokeSyncHandler, } from "./extension-hook.js";
-import { setSessionAttention, clearSessionAttention, projectSessionAttention, readAttentionSessionPage, replaceAttentionGrants, hasStoredSession, readSessionLineage, hasPendingSessionSteer, hasSuccessfulToolResult, advanceCursor, declareSessionDocument, readSessionDocument, writeSessionDocument, deleteAllRecords, deleteRecord, deleteTimer, deleteExtensionTimers, readAllRecords, readCursor, readDueTimers, readRecord, readRecordPage, readStateLedger, readStatus, readTimer, readTimerWake, writeRecord, writeStateLedger, writeStatus, writeTimer, } from "./woodstock/index.js";
+import { hasSessionAttention, setSessionAttention, clearSessionAttention, projectSessionAttention, readAttentionSessionPage, replaceAttentionGrants, hasStoredSession, readSessionLineage, hasPendingSessionSteer, readWorkSender, hasSuccessfulToolResult, advanceCursor, declareSessionDocument, readSessionDocument, writeSessionDocument, deleteAllRecords, deleteRecord, deleteTimer, deleteExtensionTimers, readAllRecords, readCursor, readDueTimers, readRecord, readRecordPage, readStateLedger, readStatus, readTimer, readTimerWake, writeRecord, writeStateLedger, writeStatus, writeTimer, } from "./woodstock/index.js";
 import { JsonValueSchema } from "./json-value.js";
-import { publishOwnerObservation } from "./observation-kernel.js";
+import { hasOwnerObservers, publishOwnerObservation, } from "./observation-kernel.js";
 /** The settled consumer name core itself uses for mail and control repair. */
 export const coreConsumer = "core";
+/** Core reports to delegators after the extensions have seen a settlement. */
+export const reportConsumer = "core-report";
 const maximumKeyLength = 256;
 const maximumRecordBytes = 1024 * 1024;
 const maximumReasonLength = 512;
@@ -288,7 +290,7 @@ export function openExtensionRuntime(input) {
             set: (sessionId, item) => {
                 const decoded = Schema.decodeUnknownResult(AttentionItemSchema, {
                     onExcessProperty: "error",
-                })(item);
+                })(item.waitingOn === undefined ? item : { ...item, inbox: false });
                 return decoded._tag === "Failure"
                     ? Effect.fail(stateError("bound", "Attention item is invalid"))
                     : mutate(sessionId, () => {
@@ -297,6 +299,7 @@ export function openExtensionRuntime(input) {
                         setSessionAttention(owner, sessionId, id, decoded.success);
                     });
             },
+            awaitsPerson: (sessionId) => requireRead(id).pipe(Effect.tap(() => grantGuard(member, "attention")), Effect.andThen(storeStep(() => hasSessionAttention(owner, sessionId)))),
             clear: (sessionId, itemId) => boundedKey(itemId, "An attention id").pipe(Effect.andThen(mutate(sessionId, () => {
                 clearSessionAttention(owner, sessionId, id, itemId);
             }))),
@@ -323,6 +326,7 @@ export function openExtensionRuntime(input) {
                             extensionId: id,
                             correlation: request.correlation ?? null,
                         },
+                        continuesWorkId: request.continuesWorkId,
                     });
                     return result.status === "accepted"
                         ? {
@@ -567,6 +571,7 @@ export function openExtensionRuntime(input) {
                 send: sendFor(member),
                 timers: timersFor(member),
                 attention: attentionFor(member),
+                isObserved: (sessionId) => member.status === "running" && hasOwnerObservers(owner, sessionId),
                 sessionPosition: (sessionId) => requireRead(member.admitted.id).pipe(Effect.andThen(grantGuard(member, "state")), Effect.andThen(storeStep(() => {
                     const id = decodeClientSessionId(sessionId);
                     if (!hasStoredSession(owner, id))
@@ -575,6 +580,7 @@ export function openExtensionRuntime(input) {
                         ?.newestSequence ?? 0);
                 }))),
                 hasPendingSteer: (run) => requireRead(member.admitted.id).pipe(Effect.andThen(grantGuard(member, "run_tools")), Effect.andThen(storeStep(() => hasPendingSessionSteer(owner, decodeClientSessionId(run.sessionId), run.workId)))),
+                workSender: (run) => requireRead(member.admitted.id).pipe(Effect.andThen(grantGuard(member, "run_tools")), Effect.andThen(storeStep(() => readWorkSender(owner, decodeClientSessionId(run.sessionId), run.workId) ?? null))),
                 hasSuccessfulToolResult: (run, toolCallId) => requireRead(member.admitted.id).pipe(Effect.andThen(grantGuard(member, "run_tools")), Effect.andThen(storeStep(() => hasSuccessfulToolResult(owner, decodeClientSessionId(run.sessionId), run.workId, toolCallId)))),
                 observe: (sessionId) => requireFrame(member.admitted.id).pipe(Effect.map((frame) => {
                     frame.observed.add(sessionId);
@@ -1020,7 +1026,7 @@ export function openExtensionRuntime(input) {
                 }
                 return Object.freeze(slots);
             },
-            call: (target, extensionId, command, raw) => Effect.gen(function* () {
+            call: (target, extensionId, command, raw, caller) => Effect.gen(function* () {
                 const member = members.get(extensionId);
                 if (member?.admitted.grants.has("commands") !== true)
                     return yield* Effect.fail(new ShiitakeError("extensions", "unavailable", "Extension is unavailable"));
@@ -1049,7 +1055,9 @@ export function openExtensionRuntime(input) {
                     yield* recordStop(member, `command ${command} has no handler`, undefined, "own-transaction");
                     return yield* Effect.fail(new ShiitakeError("extensions", "unavailable", "Extension is stopped"));
                 }
-                const prepared = handler({ sessionId, input: raw });
+                const prepared = caller === undefined
+                    ? handler({ sessionId, input: raw })
+                    : handler({ sessionId, input: raw, caller });
                 if (prepared._tag === "Failure")
                     return yield* Effect.fail(new ShiitakeError("contract", "invalid", "Extension command input is invalid"));
                 const body = prepared.success();

package/dist/internal/model-acquisition.js

@@ -23,6 +23,8 @@ function asEffectAcquisition(acquisition) {
         shared = { ...shared, failureReason: acquisition.failureReason };
     if (acquisition.providerError !== undefined)
         shared = { ...shared, providerError: acquisition.providerError };
+    if (acquisition.rejection !== undefined)
+        shared = { ...shared, rejection: acquisition.rejection };
     if (acquisition.stream === undefined)
         return acquisition.retryAfterMs === undefined
             ? Object.freeze(shared)

package/dist/internal/observation-kernel.d.ts

@@ -4,6 +4,8 @@ import type { SqliteOwner } from "./contracts.js";
 /** Finite process-local signal; durable owner state remains authoritative. */
 export type ObservationSignal = "closed" | "reset" | "durable" | "activity" | "progress";
 export type ObservationReason = "durable" | "activity" | "progress" | "settlement";
+/** Actual live-view demand, excluding exact-command settlement waiters. */
+export declare function hasOwnerObservers(store: SqliteOwner, sessionId: string): boolean;
 /** One scoped process-local observation registration. */
 export type ObservationRegistration = Readonly<{
     /** Inspect and consume one pending finite signal without waiting. */

package/dist/internal/observation-kernel.js

@@ -4,6 +4,13 @@ import { reportCatchFailure } from "./failure.js";
 const MAX_OBSERVATIONS = 64;
 const MAX_PENDING_HINTS = 256;
 const ownerPublishers = new WeakMap();
+/** Actual live-view demand, excluding exact-command settlement waiters. */
+export function hasOwnerObservers(store, sessionId) {
+    for (const publisher of ownerPublishers.get(store) ?? [])
+        if (publisher.observes(sessionId))
+            return true;
+    return false;
+}
 /** Combine coalesced reasons without allowing a progress hint to hide a commit. */
 export function mergeObservationSignals(first, second) {
     if (first === "closed" || second === "closed")
@@ -55,9 +62,9 @@ export function publishOwnerObservation(store, sessionId, reason = "durable") {
     const publishers = ownerPublishers.get(store);
     if (publishers === undefined)
         return;
-    for (const publish of publishers) {
+    for (const publisher of publishers) {
         try {
-            publish({ kind: "session", sessionId, reason });
+            publisher.publish({ kind: "session", sessionId, reason });
         }
         catch (cause) {
             reportCatchFailure("owner-observation-publish", cause);
@@ -70,9 +77,9 @@ export function publishAgentExecutionChange(store) {
     const publishers = ownerPublishers.get(store);
     if (publishers === undefined)
         return;
-    for (const publish of publishers) {
+    for (const publisher of publishers) {
         try {
-            publish({ kind: "agent-execution" });
+            publisher.publish({ kind: "agent-execution" });
         }
         catch (cause) {
             reportCatchFailure("owner-execution-change-publish", cause);
@@ -140,7 +147,11 @@ export function openObservationKernel(store) {
             deliverObservation(listener, publication.reason === "settlement" ? "durable" : publication.reason);
         }
     };
-    publishers.add(publish);
+    const publisher = {
+        publish,
+        observes: (sessionId) => [...(sessions.get(sessionId) ?? [])].some((listener) => !listener.closed && !listener.settlementOnly),
+    };
+    publishers.add(publisher);
     ownerPublishers.set(store, publishers);
     return Object.freeze({
         register: (sessionId, interest) => Effect.suspend(() => {
@@ -194,7 +205,7 @@ export function openObservationKernel(store) {
             if (released)
                 return;
             released = true;
-            publishers.delete(publish);
+            publishers.delete(publisher);
             if (publishers.size === 0)
                 ownerPublishers.delete(store);
             for (const listener of active)

package/dist/internal/run-scope.d.ts

@@ -1,4 +1,5 @@
 import type { FileTool } from "@fungi.computer/knapsack";
+import { type MuleError } from "@fungi.computer/mule/effect";
 import type { ModuleRegistration } from "@fungi.computer/mycelium";
 import * as Effect from "effect/Effect";
 import { ShiitakeError } from "../errors.js";
@@ -17,6 +18,19 @@ export declare class ToolSetupError extends ShiitakeError {
     constructor(phase: keyof typeof toolSetupMessages);
     get diagnostic(): string;
 }
+/** Closed reasons a rejected run names, never a foreign error's own text. */
+declare const runRejectedDiagnostics: {
+    readonly model: "model-failed";
+    readonly tool: "tool-failed";
+    readonly control: "control-failed";
+    readonly listener: "listener-failed";
+};
+/** A run Mule ended with a non-model error; it names a closed reason. */
+export declare class RunRejectedError extends ShiitakeError {
+    private readonly reason;
+    constructor(reason: keyof typeof runRejectedDiagnostics, underlying: MuleError);
+    get diagnostic(): string;
+}
 /** Run one accepted command with Pi compaction explicitly composed around Mule. */
 export declare function runAcceptedCommand(options: ShiitakeEffectOptions, prepared: PreparedSessionRun, executionContract: RunContract, extensionModules: readonly ModuleRegistration[], extensionFileTools: readonly FileTool[], compactionHandoff: CompactionHandoffV0 | undefined, promptSections?: () => Effect.Effect<readonly PromptSectionV0[], ShiitakeError>): Effect.Effect<{
     run: import("@fungi.computer/mule/effect").MuleRunOutcome;

package/dist/internal/run-scope.js

@@ -10,9 +10,6 @@ import { openCompactionSettings } from "./compaction/settings.js";
 import { acquireOwnedModel } from "./model-acquisition.js";
 import { returnedFailureReason, unavailableRunReason, } from "./run-failure-reason.js";
 import { isCompactCommand, openMuleRecorder, readSessionGrants, recordLiveRetryEvent, recordSandboxFailure, takeSessionControls, } from "./woodstock/index.js";
-function runtimeFailure(message) {
-    return new ShiitakeError("runtime", "rejected", message);
-}
 const toolSetupMessages = {
     missing: "Instruction capabilities have no tool runtime",
     runtime: "Tool runtime failed",
@@ -29,6 +26,28 @@ export class ToolSetupError extends ShiitakeError {
         return toolSetupMessages[this.phase];
     }
 }
+/** Closed reasons a rejected run names, never a foreign error's own text. */
+const runRejectedDiagnostics = {
+    model: "model-failed",
+    tool: "tool-failed",
+    control: "control-failed",
+    listener: "listener-failed",
+};
+/** A run Mule ended with a non-model error; it names a closed reason. */
+export class RunRejectedError extends ShiitakeError {
+    reason;
+    constructor(reason, underlying) {
+        super("runtime", "rejected", "Mule rejected the durable command run", undefined, underlying);
+        this.reason = reason;
+    }
+    get diagnostic() {
+        return runRejectedDiagnostics[this.reason];
+    }
+}
+/** Name a non-model Mule error by its closed reason. */
+function rejectedRun(error) {
+    return new RunRejectedError(error.phase, error);
+}
 /**
  * Map Mule's retry transitions onto Woodstock's retained `live_retry` facts.
  * A started attempt ends the backoff countdown before streaming resumes.
@@ -229,22 +248,26 @@ export function runAcceptedCommand(options, prepared, executionContract, extensi
                             acquired.failureReason?.(exit.value.message) ??
                             returnedFailureReason(exit.value);
                         failureReason = (failedModelAttempts > 1 &&
-                            exit.value.modelLimitReason === undefined
+                            exit.value.modelLimitReason === undefined &&
+                            acquired.rejection?.(exit.value.message)?.code !==
+                                "usage-limit-reached"
                             ? `The model failed ${String(failedModelAttempts)} times on this conversation: ${cause}`
                             : cause).slice(0, 200);
                         return recorder(failedEnd, failureReason);
                     }
                     const error = Cause.findErrorOption(exit.cause);
-                    return recorder(failedEnd, Option.isSome(error) && error.value.phase === "model"
-                        ? `model:rejected: ${error.value.message}`.slice(0, 200)
-                        : unavailableRunReason({
+                    return recorder(failedEnd, Option.isNone(error)
+                        ? unavailableRunReason({
                             runId: failedEnd.run.value,
                             provider: acquired.model.provider,
                             model: acquired.model.id,
-                        }));
+                        })
+                        : error.value.phase === "model"
+                            ? `model:rejected: ${error.value.message}`.slice(0, 200)
+                            : `runtime:rejected: ${rejectedRun(error.value).diagnostic}`);
                 }), Effect.mapError((error) => error.phase === "model"
                     ? new ShiitakeError("model", "rejected", error.message, undefined, error)
-                    : runtimeFailure("Mule rejected the durable command run")));
+                    : rejectedRun(error)));
             },
         });
         return { run, failureReason };

package/dist/internal/runtime-coordinator.js

@@ -9,7 +9,7 @@ import { agentTurnRecovery, executeAcceptedRun, } from "./accepted-run-executor.
 import { openAdmissionDoor } from "./admission-door.js";
 import { openCompactionSettings } from "./compaction/settings.js";
 import { admitExtensionRosterV0, } from "./extension-roster.js";
-import { coreConsumer, openExtensionRuntime, } from "./extension-runtime.js";
+import { coreConsumer, reportConsumer, openExtensionRuntime, } from "./extension-runtime.js";
 import { reconcileRuntime } from "./runtime-reconciliation.js";
 import { advanceCursor, createSessionWithinTransaction, deliverSessionGrants, prepareExtensionStore, projectSessionRun, openStorageAdmission, readCursor, } from "./woodstock/index.js";
 function runtimeFailure(message) {
@@ -141,6 +141,12 @@ export function openRuntimeCoordinator(options, coreDigest, admitted, mailRoom)
                     options.store.transactionSync(() => {
                         advanceCursor(options.store, coreConsumer, 0);
                     });
+                // A store that predates reports starts them at the core cursor
+                // instead of reporting its history.
+                if (readCursor(options.store, reportConsumer) === undefined)
+                    options.store.transactionSync(() => {
+                        advanceCursor(options.store, reportConsumer, readCursor(options.store, coreConsumer) ?? 0);
+                    });
             },
             catch: () => new ShiitakeError("store", "unavailable", "Extension store is unavailable"),
         });
@@ -165,6 +171,7 @@ export function openRuntimeCoordinator(options, coreDigest, admitted, mailRoom)
             const cursors = yield* Effect.try({
                 try: () => [
                     readCursor(options.store, coreConsumer) ?? 0,
+                    readCursor(options.store, reportConsumer) ?? 0,
                     ...extensions.settledConsumers().map(({ cursor }) => cursor),
                 ],
                 catch: () => runtimeFailure("Settled cursor is unavailable"),

package/dist/internal/runtime-reconciliation.js

@@ -5,21 +5,19 @@ import * as Schema from "effect/Schema";
 import { agentTurnRecovery } from "./accepted-run-executor.js";
 import { ShiitakeError } from "../errors.js";
 import { ExtensionId } from "../extension-contract.js";
-import { coreConsumer } from "./extension-runtime.js";
+import { coreConsumer, reportConsumer, } from "./extension-runtime.js";
 import { publishOwnerObservation } from "./observation-kernel.js";
-import { advanceCursor, readCursor, readExtensionAdmissionOrigin, readSettledRunFacts, readSettlementContent, readSettlementDiagnostic, readSettlementMeta, recordWorkSettlement, sessionLineageRefused, settleControls, } from "./woodstock/index.js";
+import { advanceCursor, readCursor, readExtensionAdmissionOrigin, readSettledRunFacts, readSettlementContent, readSettlementDiagnostic, readSessionDelegator, readSettlementMeta, readWaitingOn, readWaitingOnSender, recordWorkSettlement, sessionLineageRefused, settleControls, } from "./woodstock/index.js";
 const pageSize = 64;
 function runtimeFailure(message) {
     return new ShiitakeError("runtime", "rejected", message);
 }
-function fanOutSettlement(store, mailRoom, job) {
-    if (mailRoom === undefined)
-        return Effect.void;
+/** BirdDog's settlement facts for one settled job, without its correspondents. */
+function settlementFacts(store, job, 
+/** The open items this settlement names as waiting on its recipient. */
+waitingOnYou) {
     return Effect.gen(function* () {
-        const payload = yield* Effect.try({
-            try: () => decodeAgentJob(job),
-            catch: () => runtimeFailure("Agent work payload is invalid"),
-        });
+        const payload = yield* decodeJob(job);
         const content = job.outcome === "cancelled"
             ? ""
             : yield* readSettlementContent(store, payload.work);
@@ -27,14 +25,103 @@ function fanOutSettlement(store, mailRoom, job) {
         const diagnostic = job.outcome === "completed" || job.outcome === "cancelled"
             ? undefined
             : yield* readSettlementDiagnostic(store, payload.work);
-        const settled = diagnostic === undefined
-            ? { job, content }
-            : { job, content, diagnostic };
-        yield* mailRoom
-            .fanOut(meta === undefined ? settled : { ...settled, meta })
-            .pipe(Effect.mapError(() => runtimeFailure("Agent reply fan-out is unavailable")));
+        let settled = { job, content };
+        if (diagnostic !== undefined)
+            settled = { ...settled, diagnostic };
+        // A cancelled run names nothing; what it left open is the canceller's to see.
+        const waiting = job.outcome === "cancelled" ? [] : yield* waitingOnYou;
+        if (waiting.length > 0)
+            settled = { ...settled, waitingOnYou: waiting };
+        return meta === undefined ? settled : { ...settled, meta };
     });
 }
+function decodeJob(job) {
+    return Effect.try({
+        try: () => decodeAgentJob(job),
+        catch: () => runtimeFailure("Agent work payload is invalid"),
+    });
+}
+function fanOut(mailRoom, settled) {
+    return mailRoom
+        .fanOut(settled)
+        .pipe(Effect.mapError(() => runtimeFailure("Agent reply fan-out is unavailable")));
+}
+/** Reply to the delegating mail that admitted this work, if it asked for one. */
+function replyToMail(store, mailRoom, job) {
+    if (mailRoom === undefined)
+        return Effect.void;
+    return Effect.gen(function* () {
+        const payload = yield* decodeJob(job);
+        if ((payload.mail?.replyTo.length ?? 0) === 0)
+            return;
+        // The reply goes to the mail's sender: name what waits on that sender.
+        const waiting = Effect.try({
+            try: () => readWaitingOnSender(store, payload.work.sessionId, payload.work.commandFactId),
+            catch: () => runtimeFailure("Session attention is unavailable"),
+        });
+        yield* fanOut(mailRoom, yield* settlementFacts(store, job, waiting));
+    });
+}
+/**
+ * Report work no delegating mail answered to the Session's delegator of
+ * record. It runs after the extensions have seen the settlement, so a goal
+ * or loop that admitted the next turn keeps the Session busy and the stretch
+ * of turns reports once, when the Session finally rests. Another Agent's
+ * original mail is that Agent's correspondence and never reported here.
+ */
+function reportToDelegator(store, watchdog, mailRoom, job) {
+    if (mailRoom === undefined)
+        return Effect.void;
+    return Effect.gen(function* () {
+        const payload = yield* decodeJob(job);
+        const mail = payload.mail;
+        if (mail !== undefined && mail.replyTo.length > 0)
+            return;
+        const head = yield* watchdog
+            .readQueueHead(job.queue)
+            .pipe(Effect.mapError(() => runtimeFailure("Session queue head is unavailable")));
+        if (head.state !== "idle")
+            return;
+        const delegator = yield* Effect.try({
+            try: () => readSessionDelegator(store, payload.work.sessionId),
+            catch: () => runtimeFailure("Session delegator is unavailable"),
+        });
+        if (delegator === undefined)
+            return;
+        const from = mail?.reply === undefined ? mail?.from : undefined;
+        const anotherAgentsMail = from !== undefined &&
+            !(from.kind === "agent" &&
+                delegator.replyTo.some(({ agentId }) => agentId === from.agentId));
+        if (anotherAgentsMail)
+            return;
+        // The report goes to the delegator: name what waits on it.
+        const waiting = Effect.try({
+            try: () => readWaitingOn(store, payload.work.sessionId, delegator.replyTo),
+            catch: () => runtimeFailure("Session attention is unavailable"),
+        });
+        const settled = yield* settlementFacts(store, job, waiting);
+        yield* fanOut(mailRoom, { ...settled, delegator });
+    });
+}
+/**
+ * The `core-report` settled consumer: after the extensions' turn, report each
+ * Session's last settled job in the page, one record at a time.
+ */
+function reportSettled(store, watchdog, mailRoom, records) {
+    return Effect.forEach(records, (record, index) => Effect.gen(function* () {
+        const later = records
+            .slice(index + 1)
+            .some(({ job }) => job.queue === record.job.queue);
+        if (!later && !(yield* settledInRefusedSession(store, record.job)))
+            yield* reportToDelegator(store, watchdog, mailRoom, record.job);
+        yield* Effect.try({
+            try: () => {
+                advanceCursor(store, reportConsumer, record.sequence);
+            },
+            catch: () => runtimeFailure("Settled cursor is unavailable"),
+        });
+    }), { discard: true });
+}
 function repairWorkSettlement(store, job) {
     const outcome = job.outcome;
     if (outcome !== "interrupted" &&
@@ -148,7 +235,7 @@ function settleCore(store, watchdog, mailRoom, records) {
         if (!(yield* settledInRefusedSession(store, record.job))) {
             yield* repairWorkSettlement(store, record.job);
             yield* settleTargetedControls(store, watchdog, record.job);
-            yield* fanOutSettlement(store, mailRoom, record.job);
+            yield* replyToMail(store, mailRoom, record.job);
         }
         yield* Effect.try({
             try: () => {
@@ -172,26 +259,34 @@ export function reconcileRuntime(input) {
             try: () => readCursor(input.store, coreConsumer) ?? 0,
             catch: () => runtimeFailure("Settled cursor is unavailable"),
         });
+        const reportCursor = yield* Effect.try({
+            try: () => readCursor(input.store, reportConsumer) ?? coreCursor,
+            catch: () => runtimeFailure("Settled cursor is unavailable"),
+        });
         const consumers = input.extensions.settledConsumers();
-        const after = Math.min(coreCursor, ...consumers.map(({ cursor }) => cursor));
+        const after = Math.min(coreCursor, reportCursor, ...consumers.map(({ cursor }) => cursor));
         const page = yield* input.watchdog.readSettled(pageSize, after);
         const core = yield* Effect.exit(settleCore(input.store, input.watchdog, input.mailRoom, page.filter(({ sequence }) => sequence > coreCursor)));
+        const processed = yield* Effect.try({
+            try: () => readCursor(input.store, coreConsumer) ?? 0,
+            catch: () => runtimeFailure("Settled cursor is unavailable"),
+        });
         const runs = yield* Effect.try({
-            try: () => {
-                const processed = readCursor(input.store, coreConsumer) ?? 0;
-                return page
-                    .filter(({ sequence }) => sequence <= processed)
-                    .map((record) => settledRun(input.store, record));
-            },
+            try: () => page
+                .filter(({ sequence }) => sequence <= processed)
+                .map((record) => settledRun(input.store, record)),
             catch: () => runtimeFailure("Settled run facts are unavailable"),
         });
-        yield* input.extensions.deliverSettled(runs, readCursor(input.store, coreConsumer) ?? 0);
+        yield* input.extensions.deliverSettled(runs, processed);
+        const reports = yield* Effect.exit(reportSettled(input.store, input.watchdog, input.mailRoom, page.filter(({ sequence }) => sequence > reportCursor && sequence <= processed)));
         const moreTimers = yield* input.extensions.fireDueTimers(Date.now());
         if (page.length === pageSize || moreTimers)
             yield* input.requestWake;
         yield* drainMail(input.mailRoom);
         if (Exit.isFailure(core))
             return yield* Effect.failCause(core.cause);
+        if (Exit.isFailure(reports))
+            return yield* Effect.failCause(reports.cause);
     }).pipe(Effect.mapError((failure) => failure instanceof ShiitakeError
         ? failure
         : runtimeFailure("Runtime reconciliation failed")));

package/dist/internal/woodstock/agent-reply.d.ts

@@ -9,6 +9,11 @@ export declare const VerifiedAgentReplySchema: Schema.Union<readonly [Schema.Str
     readonly commandId: Schema.String;
     readonly outcome: Schema.Literals<readonly ["completed", "failed", "interrupted", "cancelled", "outcome_unknown"]>;
     readonly diagnostic: Schema.optionalKey<Schema.String>;
+    readonly waitingOnYou: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly itemId: Schema.String;
+        readonly kind: Schema.String;
+        readonly summary: Schema.String;
+    }>>>;
     readonly agentId: Schema.String;
     readonly sessionId: Schema.String;
 }>, Schema.Struct<{

package/dist/internal/woodstock/agent-reply.js

@@ -42,6 +42,9 @@ function opening(reply) {
     attributes.push(["outcome", reply.outcome]);
     if (reply.outcome !== "undeliverable" && reply.diagnostic !== undefined)
         attributes.push(["diagnostic", reply.diagnostic]);
+    if (reply.outcome !== "undeliverable" && reply.waitingOnYou !== undefined)
+        // A host fact, outside the child's text: the items the child left waiting on the recipient.
+        attributes.push(["waiting_on_you", JSON.stringify(reply.waitingOnYou)]);
     if (reply.outcome === "undeliverable")
         attributes.push(["reason", reply.reason]);
     const rendered = attributes

package/dist/internal/woodstock/client-projection.js

@@ -1,9 +1,11 @@
 import { messageAuthor } from "@fungi.computer/agar/agents";
 import { readSessionAttention } from "./session-attention.js";
+import { readWaitingOnSender } from "./work-senders.js";
+import { readSessionDelegator } from "./session-delegator.js";
 import { ShiitakeError } from "../../errors.js";
 import { decodeWoodstockCursor, encodeWoodstockCursor } from "./cursor.js";
 import { operatorClientMessage, promptCommand } from "./session-entry.js";
-import { lineageEntrySequence, lineageHasSequence, lineageRowLimit, readLineageWindow, readLineageWorkFacts, readSessionEntriesForWork, readSessionLineage, readPendingSessionCommands, readSessionCommandAdmission, readNewestPendingSessionCommand, } from "./session-store.js";
+import { lineageEntrySequence, lineageHasSequence, lineageRowLimit, readLineageWindow, readLineageWorkFacts, hasSessionWorkTerminal, readSessionEntriesForWork, readSessionLineage, readPendingSessionCommands, readSessionCommandAdmission, readNewestPendingSessionCommand, } from "./session-store.js";
 const maximumPagePayloadBytes = 2_097_152;
 const replayPageLimit = 200;
 const maximumRowsPerPage = lineageRowLimit;
@@ -503,6 +505,10 @@ export function projectCommandSettlement(owner, sessionId, commandId) {
     const admission = readSessionCommandAdmission(owner, sessionId, commandId);
     if (admission === undefined)
         throw unavailable("Accepted Session command is unavailable");
+    // A live work has no settlement to project. The owner's terminal index
+    // answers this without decoding the work again on every polling tick.
+    if (!hasSessionWorkTerminal(owner, sessionId, admission.entry.workId))
+        return undefined;
     const rows = readSessionEntriesForWork(owner, sessionId, admission.entry.workId);
     const work = workFacts(owner, sessionId, rows);
     const terminal = rows
@@ -521,6 +527,7 @@ export function projectCommandSettlement(owner, sessionId, commandId) {
     const sender = messageAuthor(admission.entry.meta);
     return {
         acceptedSender: sender?.kind === "agent" ? sender.id : null,
+        delegator: readSessionDelegator(owner, sessionId)?.replyTo[0]?.agentId ?? null,
         terminal: meta === undefined ? terminal : { ...terminal, meta },
         content: terminal.outcome === "cancelled"
             ? ""
@@ -534,5 +541,6 @@ export function projectCommandSettlement(owner, sessionId, commandId) {
             usage,
         })),
         toolCalls: new Set(rows.flatMap(({ entry }) => entry.kind === "tool_intent" ? [entry.call.id] : [])).size,
+        waitingOnYou: readWaitingOnSender(owner, sessionId, admission.entry.workId),
     };
 }

package/dist/internal/woodstock/fleet-store.d.ts

@@ -34,4 +34,5 @@ export declare function createFleetDelegationStore(storage: WatchdogSqliteOwner)
     reserve(requestId: string, input: string, mail: string): void;
     recordReceipt(requestId: string, receipt: string, expectedMail: string, acceptedMail: string): void;
     recordHeld(requestId: string): void;
+    recordUndeliverable(requestId: string): boolean;
 };