@fungi.computer/shiitake 0.5.0 → 0.7.0

package/dist/internal/run-scope.js

@@ -1,17 +1,29 @@
 import { muleEffect, piCodingAgentRetryDefaults, } from "@fungi.computer/mule/effect";
 import { make as makeMycelium } from "@fungi.computer/mycelium/effect";
 import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
 import * as Cause from "effect/Cause";
 import * as Exit from "effect/Exit";
 import * as Option from "effect/Option";
+import * as Scope from "effect/Scope";
 import { ShiitakeError } from "../errors.js";
 import { compactSession, runWithCompaction, } from "./compaction/session-compaction.js";
 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);
+// A run writes its terminal before scope release. Give each foreign release
+// one second to clean up without blocking the next Watchdog job indefinitely.
+const runFinalizerGraceMs = 1_000;
+function boundedRunFinalizer(name, workId, release) {
+    return Effect.gen(function* () {
+        // A detached release may finish later; interrupting a finalizer itself
+        // cannot bound an uninterruptible scope.
+        const fiber = yield* Effect.forkDetach(release);
+        const finished = yield* Effect.raceFirst(Fiber.join(fiber).pipe(Effect.as(true)), Effect.sleep(runFinalizerGraceMs).pipe(Effect.as(false)));
+        if (!finished)
+            yield* Effect.logError("shiitake_run_finalizer_hung").pipe(Effect.annotateLogs({ workId, finalizer: name }));
+    });
 }
 const toolSetupMessages = {
     missing: "Instruction capabilities have no tool runtime",
@@ -29,6 +41,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.
@@ -100,12 +134,12 @@ function acquiredTools(options, sessionId, workId, meta, instructions, extension
                 sessionGrants: () => readSessionGrants(options.store, sessionId)?.grants ?? {},
             },
         };
+        const toolScope = yield* Scope.make();
+        yield* Effect.addFinalizer(() => boundedRunFinalizer("tools", workId, Scope.close(toolScope, Exit.succeed(undefined))));
         const runtime = yield* makeMycelium(toolSource.execution === undefined
             ? runtimeOptions
-            : { ...runtimeOptions, execution: toolSource.execution }).pipe(Effect.mapError(() => new ToolSetupError("runtime")));
-        const lease = yield* runtime
-            .acquire()
-            .pipe(Effect.mapError(() => new ToolSetupError("lease")));
+            : { ...runtimeOptions, execution: toolSource.execution }).pipe(Effect.provideService(Scope.Scope, toolScope), Effect.mapError(() => new ToolSetupError("runtime")));
+        const lease = yield* runtime.acquire().pipe(Effect.provideService(Scope.Scope, toolScope), Effect.mapError(() => new ToolSetupError("lease")));
         return [lease.executeTool, ...lease.tools];
     });
 }
@@ -118,11 +152,16 @@ export function runAcceptedCommand(options, prepared, executionContract, extensi
         });
         const releaseInstructions = instructions.release;
         if (releaseInstructions !== undefined)
-            yield* Effect.addFinalizer(() => Effect.sync(releaseInstructions));
-        const acquired = yield* acquireOwnedModel(options.model.acquire({
+            yield* Effect.addFinalizer(() => boundedRunFinalizer("instructions", prepared.command.entry.workId, Effect.sync(releaseInstructions)));
+        const acquired = yield* acquireOwnedModel(options.model
+            .acquire({
             sessionId: prepared.command.sessionId,
             preference: prepared.modelPreference,
-        }));
+        })
+            .pipe(Effect.map((model) => ({
+            ...model,
+            release: boundedRunFinalizer("model", prepared.command.entry.workId, model.release),
+        }))));
         const tools = yield* acquiredTools(options, prepared.command.sessionId, prepared.command.entry.workId, prepared.command.entry.meta, instructions, extensionModules, extensionFileTools);
         const accepted = Object.freeze({
             sessionId: prepared.command.sessionId,
@@ -229,22 +268,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.d.ts

@@ -9,10 +9,23 @@ import type { ShiitakeEffectOptions } from "./effect-contracts.js";
 import { type AdmittedExtensionV0 } from "./extension-roster.js";
 import { type ExtensionRuntime } from "./extension-runtime.js";
 import { type RecordAcceptedCancellation, type StorageAdmission } from "./woodstock/index.js";
+/** Owner-local archive blocker read within the caller's SQLite transaction. */
+export type OwnerBusy = Readonly<{
+    kind: "session";
+    sessionId: string;
+    commandId: string;
+}> | Readonly<{
+    kind: "delegation";
+    agentId: string;
+    sessionId: string;
+    commandId: string;
+}>;
 /** Bound lifecycle and owner-transaction doors used by the public coordinator. */
 export type RuntimeCoordinator = Readonly<{
     prepareConfiguration: import("./effect-contracts.js").ShiitakeEffectOwner["prepareConfiguration"];
     activeSessions: Effect.Effect<readonly string[]>;
+    /** No awaits: use inside the same transaction as the host's archive flag. */
+    busySync: () => OwnerBusy | undefined;
     runningWork: (jobId: string) => Effect.Effect<AgentRunningWork | null, ShiitakeError>;
     assertOpen: Effect.Effect<void, ShiitakeError>;
     /** Rostered v1 extensions bound to core's doors and tables. */
@@ -22,6 +35,7 @@ export type RuntimeCoordinator = Readonly<{
     door: AdmissionDoor;
     /** Reserve a Session within the admission door's enclosing transaction. */
     createSessionWithinTransaction: (requestId: string) => string;
+    recordCreatedSessionDelegatorWithinTransaction: (sessionId: string, mail: import("@fungi.computer/bird-dog").BirdDogMail) => void;
     /** Write new-Session grants through the enclosing admission transaction. */
     stageSessionGrantsWithinTransaction: (sessionId: string, delivery: GrantsDelivery) => void;
     /** Storage-pressure check for new Sessions and new prompts. */

package/dist/internal/runtime-coordinator.js

@@ -3,15 +3,16 @@ import { WatchdogError } from "@fungi.computer/watchdog";
 import { makeRuntime as makeWatchdogRuntime, } from "@fungi.computer/watchdog/effect";
 import * as Effect from "effect/Effect";
 import * as Latch from "effect/Latch";
+import { readOutstandingDelegationSync } from "../fleet.js";
 import { publishAgentExecutionChange } from "./observation-kernel.js";
 import { ShiitakeError } from "../errors.js";
 import { agentTurnRecovery, executeAcceptedRun, } from "./accepted-run-executor.js";
 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";
+import { advanceCursor, createSessionWithinTransaction, deliverSessionGrants, prepareExtensionStore, recordSessionDelegator, projectSessionRun, openStorageAdmission, readCursor, readSessionInboxPage, readSessionSummary, } from "./woodstock/index.js";
 function runtimeFailure(message) {
     return new ShiitakeError("runtime", "rejected", message);
 }
@@ -119,13 +120,42 @@ export function openRuntimeCoordinator(options, coreDigest, admitted, mailRoom)
                 ? error
                 : runtimeFailure("Storage budget is unavailable"),
         });
+        const admitNew = () => {
+            options.admission?.assertOpen();
+            storage.admitNew();
+        };
+        const busySync = () => {
+            let after;
+            do {
+                const page = readSessionInboxPage(options.store, after);
+                for (const session of page.sessions) {
+                    if (session.state === "unavailable")
+                        throw new ShiitakeError("store", "unavailable", `Session ${session.sessionId} is unreadable`);
+                    const head = watchdog.transactional.readQueueHead(session.sessionId);
+                    if (head.state !== "idle")
+                        return {
+                            kind: "session",
+                            sessionId: session.sessionId,
+                            commandId: head.jobId,
+                        };
+                }
+                after = page.next;
+            } while (after !== undefined);
+            const outstanding = readOutstandingDelegationSync(options.store);
+            return outstanding === undefined
+                ? undefined
+                : { kind: "delegation", ...outstanding };
+        };
         const door = openAdmissionDoor({
             owner: options.store,
-            admitNew: storage.admitNew,
+            admitNew,
             hostMeta: options.meta,
             contract,
             enqueue: (work, mail) => {
-                const input = { work: { ...work, recovery: agentTurnRecovery } };
+                const input = {
+                    work: { ...work, recovery: agentTurnRecovery },
+                    delivery: work.delivery,
+                };
                 watchdog.transactional.enqueueAcceptedJob(agentJobFromInput(mail === undefined ? input : { ...input, mail }));
             },
             readQueueHead: (queue) => watchdog.transactional.readQueueHead(queue),
@@ -141,6 +171,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 +201,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"),
@@ -241,11 +278,20 @@ export function openRuntimeCoordinator(options, coreDigest, admitted, mailRoom)
                 };
             }),
             activeSessions: Effect.sync(() => [...activeSessions]),
-            runningWork: (jobId) => watchdog.read(jobId).pipe(Effect.map((result) => result.status === "found"
-                ? (runningSlots.get(result.job.lane === options.hostJobs?.lane
-                    ? "host"
-                    : "serial") ?? null)
-                : null), Effect.mapError((cause) => new ShiitakeError("runtime", "rejected", "Running work is unavailable", undefined, cause))),
+            busySync,
+            runningWork: (jobId) => watchdog.read(jobId).pipe(Effect.flatMap((result) => {
+                const work = result.status === "found"
+                    ? runningSlots.get(result.job.lane === options.hostJobs?.lane
+                        ? "host"
+                        : "serial")
+                    : undefined;
+                if (work === undefined || work.kind === "host")
+                    return Effect.succeed(work ?? null);
+                return readSessionSummary(options.store, work.sessionId).pipe(Effect.map((summary) => ({
+                    ...work,
+                    title: summary?.title ?? "",
+                })));
+            }), Effect.mapError((cause) => new ShiitakeError("runtime", "rejected", "Running work is unavailable", undefined, cause))),
             extensions,
             commit: bound.commit,
             assertOpen: Effect.suspend(() => lifecycleState === "open"
@@ -253,11 +299,14 @@ export function openRuntimeCoordinator(options, coreDigest, admitted, mailRoom)
                 : Effect.fail(new ShiitakeError("runtime", "closed", "Shiitake is closed"))),
             beginClose,
             door,
-            createSessionWithinTransaction: (requestId) => createSessionWithinTransaction(options.store, requestId, storage.admitNew),
+            createSessionWithinTransaction: (requestId) => createSessionWithinTransaction(options.store, requestId, admitNew),
+            recordCreatedSessionDelegatorWithinTransaction: (sessionId, mail) => {
+                recordSessionDelegator(options.store, sessionId, mail);
+            },
             stageSessionGrantsWithinTransaction: (sessionId, delivery) => {
                 deliverSessionGrants(options.store, sessionId, delivery);
             },
-            storage,
+            storage: { admitNew },
             recordAcceptedCancellation: ({ jobId, cancellationId, onlyIfPending }) => watchdog.transactional.recordCancellationIntent({
                 jobId,
                 cancellationId,

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

@@ -8,12 +8,15 @@ import type { Accepted } from "../client.js";
 import type { GrantsDelivery } from "./contracts.js";
 import { ShiitakeError } from "../errors.js";
 import type { ShiitakeEffectOptions, ShiitakeEffectOwner } from "./effect-contracts.js";
+import type { OwnerBusy } from "./runtime-coordinator.js";
 /** Private host composition with the addressed-mail ingress kept off Session. */
 export type RuntimeCore = Readonly<{
     agent: ShiitakeEffectOwner;
     readSettlement: (sessionId: string, commandId: string) => Effect.Effect<CommandSettlement | undefined, ShiitakeError>;
     /** Owner-local execution projection; never served by the remote client. */
     activeSessions: Effect.Effect<readonly string[]>;
+    /** Synchronous archive blocker; the host supplies the enclosing transaction. */
+    busySync: () => OwnerBusy | undefined;
     acceptMail: (mail: BirdDogMail, meta?: Json, reply?: VerifiedAgentReply, stageAcceptedNotice?: (mail: BirdDogMail) => void, sessionGrantDelivery?: (sessionId: string) => GrantsDelivery) => Effect.Effect<Accepted, ShiitakeError>;
 }>;
 /** Open Runtime Core, optionally joining its owner-local BirdDog mail room. */

package/dist/internal/runtime-core.js

@@ -34,6 +34,7 @@ export function openRuntimeCore(options, mailRoom) {
             agent: owner,
             readSettlement: (sessionId, commandId) => runtime.assertOpen.pipe(Effect.andThen(readCommandSettlement(options.store, sessionId, commandId))),
             activeSessions: runtime.activeSessions,
+            busySync: runtime.busySync,
             acceptMail: (mail, meta, reply, stageAcceptedNotice, sessionGrantDelivery) => acceptAddressedMail(runtime, mail, meta, reply, stageAcceptedNotice ??
                 ((notice) => {
                     if (mailRoom?.postMail === undefined)

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" &&
@@ -68,7 +155,10 @@ function settleTargetedControls(store, watchdog, job) {
             outcome,
             diagnostic: job.failureReason,
             enqueue: (work) => {
-                watchdog.transactional.enqueueAcceptedJob(agentJobFromInput({ work: { ...work, recovery: agentTurnRecovery } }));
+                watchdog.transactional.enqueueAcceptedJob(agentJobFromInput({
+                    work: { ...work, recovery: agentTurnRecovery },
+                    delivery: work.delivery,
+                }));
             },
         });
     });
@@ -148,7 +238,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 +262,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/session-context.d.ts

@@ -2,9 +2,9 @@ import * as Effect from "effect/Effect";
 import type { SessionContext } from "../client.js";
 import type { ShiitakeEffectOptions } from "./effect-contracts.js";
 /**
- * The Session's context use as compaction measures it, against the window of
- * the model a run would select now. Undefined while the Session has no
- * context or its context cannot be read; a window the host cannot describe is
- * null, never guessed.
+ * Read the stored figure synchronously with the Session baseline. Only model
+ * description remains in the returned Effect, outside the SQLite transaction
+ * and the request's ancestry scope. Undefined without readable context; a model
+ * window the host cannot describe is null, never guessed.
  */
-export declare function readSessionContext(options: ShiitakeEffectOptions, sessionId: string, cursor: string | null, cache?: boolean): Effect.Effect<SessionContext | undefined>;
+export declare function prepareSessionContext(options: ShiitakeEffectOptions, sessionId: string, cursor: string | null, cache?: boolean): Effect.Effect<SessionContext | undefined>;