@fungi.computer/shiitake 0.5.0 → 0.6.0

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",
 });
@@ -29,6 +30,24 @@ function decodeReply(request) {
         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. */
@@ -41,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),
@@ -75,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)),

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"),