@fungi.computer/shiitake 0.3.1 → 0.5.0

package/dist/internal/run-scope.js

@@ -1,4 +1,4 @@
-import { muleEffect, piCodingAgentRetryDefaults, piHttpIdleTimeoutMs, } from "@fungi.computer/mule/effect";
+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 Cause from "effect/Cause";
@@ -33,13 +33,21 @@ export class ToolSetupError extends ShiitakeError {
  * Map Mule's retry transitions onto Woodstock's retained `live_retry` facts.
  * A started attempt ends the backoff countdown before streaming resumes.
  */
-function toLiveRetryEvent(event) {
+function toLiveRetryEvent(event, model) {
     if (event.type === "retry_attempt_started")
         return {
             type: "auto_retry_attempt",
             run: event.run,
             attempt: event.attempt,
         };
+    // Mule's retry text is Pi's private error body. Woodstock's retry journal
+    // feeds status and recovery, not the owner's failed-turn conversation.
+    const safeReason = ("Model request failed. Retry the request. " +
+        unavailableRunReason({
+            runId: event.run.value,
+            provider: model.provider,
+            model: model.id,
+        })).slice(0, 200);
     return event.type === "retry_scheduled"
         ? {
             type: "auto_retry_start",
@@ -47,7 +55,7 @@ function toLiveRetryEvent(event) {
             attempt: event.attempt,
             maxAttempts: event.maxAttempts,
             delayMs: event.delayMs,
-            errorMessage: event.errorMessage,
+            errorMessage: safeReason,
         }
         : event.finalError === undefined
             ? {
@@ -61,7 +69,7 @@ function toLiveRetryEvent(event) {
                 run: event.run,
                 attempt: event.attempt,
                 success: event.success,
-                finalError: event.finalError,
+                finalError: safeReason,
             };
 }
 /** Acquire the run's tools for exactly one Session, so hosts can project per Session. */
@@ -139,6 +147,7 @@ export function runAcceptedCommand(options, prepared, executionContract, extensi
         let resume = prepared.resume;
         const settings = openCompactionSettings(options.compaction)(acquired.model);
         let failureReason;
+        let failedModelAttempts = 0;
         const run = yield* runWithCompaction({
             store: options.store,
             sessionId: prepared.command.sessionId,
@@ -151,6 +160,7 @@ export function runAcceptedCommand(options, prepared, executionContract, extensi
             messages: prepared.messages,
             resuming: resume !== undefined,
             run: (workingMessages, betweenTurns) => {
+                failedModelAttempts = 0;
                 const continuation = resume;
                 resume = undefined;
                 // A failed lifecycle notification precedes Mule's returned outcome
@@ -162,11 +172,21 @@ export function runAcceptedCommand(options, prepared, executionContract, extensi
                         failedEnd = event;
                         return Effect.void;
                     }
+                    if (event.type === "message_end" &&
+                        event.value.role === "assistant" &&
+                        event.value.stopReason === "error") {
+                        const providerError = acquired.providerError?.(event.value);
+                        if (providerError !== undefined)
+                            return recorder({
+                                ...event,
+                                value: { ...event.value, providerError },
+                            });
+                    }
                     return recorder(event);
                 };
                 const input = {
                     model: acquired.model,
-                    modelStreamIdleTimeoutMs: options.modelStreamIdleTimeoutMs ?? piHttpIdleTimeoutMs,
+                    modelStreamIdleTimeoutMs: options.modelStreamIdleTimeoutMs,
                     retry: options.retry ?? piCodingAgentRetryDefaults,
                     retryAfterMs: acquired.retryAfterMs,
                     retryable: acquired.retryable,
@@ -191,7 +211,11 @@ export function runAcceptedCommand(options, prepared, executionContract, extensi
                         phase: "control",
                         message: error.message,
                     }))),
-                    onRetry: (event) => recordLiveRetryEvent(options.store, accepted, toLiveRetryEvent(event), event.turn),
+                    onRetry: (event) => {
+                        if (event.type === "retry_finished" && !event.success)
+                            failedModelAttempts = event.attempt + 1;
+                        return recordLiveRetryEvent(options.store, accepted, toLiveRetryEvent(event, acquired.model), event.turn);
+                    },
                 };
                 return muleEffect
                     .run(acquired.stream === undefined
@@ -201,8 +225,13 @@ export function runAcceptedCommand(options, prepared, executionContract, extensi
                     if (failedEnd === undefined)
                         return Effect.void;
                     if (Exit.isSuccess(exit)) {
-                        failureReason = (acquired.failureReason?.(exit.value.message) ??
-                            returnedFailureReason(exit.value)).slice(0, 200);
+                        const cause = exit.value.modelLimitReason ??
+                            acquired.failureReason?.(exit.value.message) ??
+                            returnedFailureReason(exit.value);
+                        failureReason = (failedModelAttempts > 1 &&
+                            exit.value.modelLimitReason === undefined
+                            ? `The model failed ${String(failedModelAttempts)} times on this conversation: ${cause}`
+                            : cause).slice(0, 200);
                         return recorder(failedEnd, failureReason);
                     }
                     const error = Cause.findErrorOption(exit.cause);

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

@@ -2,6 +2,7 @@ import { type BirdDogEffect } from "@fungi.computer/bird-dog/effect";
 import { type WatchdogQueueHead } from "@fungi.computer/watchdog/effect";
 import * as Effect from "effect/Effect";
 import type { AgentRunningWork } from "../client.js";
+import type { GrantsDelivery } from "./contracts.js";
 import { ShiitakeError } from "../errors.js";
 import { type AdmissionDoor } from "./admission-door.js";
 import type { ShiitakeEffectOptions } from "./effect-contracts.js";
@@ -19,6 +20,10 @@ export type RuntimeCoordinator = Readonly<{
     beginClose: Effect.Effect<void>;
     /** The one accepted-command door every prompt producer admits through. */
     door: AdmissionDoor;
+    /** Reserve a Session within the admission door's enclosing transaction. */
+    createSessionWithinTransaction: (requestId: string) => string;
+    /** Write new-Session grants through the enclosing admission transaction. */
+    stageSessionGrantsWithinTransaction: (sessionId: string, delivery: GrantsDelivery) => void;
     /** Storage-pressure check for new Sessions and new prompts. */
     storage: StorageAdmission;
     recordAcceptedCancellation: RecordAcceptedCancellation;

package/dist/internal/runtime-coordinator.js

@@ -3,7 +3,7 @@ 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 { publishOwnerObservation } from "./observation-kernel.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";
@@ -11,7 +11,7 @@ import { openCompactionSettings } from "./compaction/settings.js";
 import { admitExtensionRosterV0, } from "./extension-roster.js";
 import { coreConsumer, openExtensionRuntime, } from "./extension-runtime.js";
 import { reconcileRuntime } from "./runtime-reconciliation.js";
-import { advanceCursor, prepareExtensionStore, projectSessionRun, openStorageAdmission, readCursor, } from "./woodstock/index.js";
+import { advanceCursor, createSessionWithinTransaction, deliverSessionGrants, prepareExtensionStore, projectSessionRun, openStorageAdmission, readCursor, } from "./woodstock/index.js";
 function runtimeFailure(message) {
     return new ShiitakeError("runtime", "rejected", message);
 }
@@ -64,7 +64,7 @@ export function openRuntimeCoordinator(options, coreDigest, admitted, mailRoom)
                     if (runningWork.kind === "session")
                         activeSessions.add(job.queue);
                     // A different Session's wait changes when this executor changes.
-                    publishOwnerObservation(options.store, null);
+                    publishAgentExecutionChange(options.store);
                 }), () => job.lane === options.hostJobs?.lane
                     ? (hostExecutor.current?.execute(job) ??
                         Effect.fail(new WatchdogError("execution_failed")))
@@ -82,7 +82,7 @@ export function openRuntimeCoordinator(options, coreDigest, admitted, mailRoom)
                     if (job.lane !== options.hostJobs?.lane)
                         activeSessions.delete(job.queue);
                     runningSlots.delete(job.lane === options.hostJobs?.lane ? "host" : "serial");
-                    publishOwnerObservation(options.store, null);
+                    publishAgentExecutionChange(options.store);
                 })),
             },
             wake: {
@@ -253,6 +253,10 @@ 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),
+            stageSessionGrantsWithinTransaction: (sessionId, delivery) => {
+                deliverSessionGrants(options.store, sessionId, delivery);
+            },
             storage,
             recordAcceptedCancellation: ({ jobId, cancellationId, onlyIfPending }) => watchdog.transactional.recordCancellationIntent({
                 jobId,

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

@@ -5,6 +5,7 @@ import type { VerifiedAgentReply } from "./woodstock/index.js";
 import type { BirdDogEffect } from "@fungi.computer/bird-dog/effect";
 import * as Effect from "effect/Effect";
 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";
 /** Private host composition with the addressed-mail ingress kept off Session. */
@@ -13,7 +14,7 @@ export type RuntimeCore = Readonly<{
     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[]>;
-    acceptMail: (mail: BirdDogMail, meta?: Json, reply?: VerifiedAgentReply) => Effect.Effect<Accepted, ShiitakeError>;
+    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. */
 export declare function openRuntimeCore(options: ShiitakeEffectOptions, mailRoom?: BirdDogEffect): Effect.Effect<RuntimeCore, ShiitakeError>;

package/dist/internal/runtime-core.js

@@ -34,7 +34,12 @@ export function openRuntimeCore(options, mailRoom) {
             agent: owner,
             readSettlement: (sessionId, commandId) => runtime.assertOpen.pipe(Effect.andThen(readCommandSettlement(options.store, sessionId, commandId))),
             activeSessions: runtime.activeSessions,
-            acceptMail: (mail, meta, reply) => acceptAddressedMail(runtime, mail, meta, reply),
+            acceptMail: (mail, meta, reply, stageAcceptedNotice, sessionGrantDelivery) => acceptAddressedMail(runtime, mail, meta, reply, stageAcceptedNotice ??
+                ((notice) => {
+                    if (mailRoom?.postMail === undefined)
+                        throw new Error("Recipient Agent mail outbox is unavailable");
+                    Effect.runSync(mailRoom.postMail(notice));
+                }), sessionGrantDelivery),
         });
     });
 }

package/dist/internal/session-context.d.ts

@@ -7,4 +7,4 @@ import type { ShiitakeEffectOptions } from "./effect-contracts.js";
  * context or its context cannot be read; a window the host cannot describe is
  * null, never guessed.
  */
-export declare function readSessionContext(options: ShiitakeEffectOptions, sessionId: string): Effect.Effect<SessionContext | undefined>;
+export declare function readSessionContext(options: ShiitakeEffectOptions, sessionId: string, cursor: string | null, cache?: boolean): Effect.Effect<SessionContext | undefined>;

package/dist/internal/session-context.js

@@ -2,6 +2,7 @@ import * as Effect from "effect/Effect";
 import { estimateContextTokens } from "@earendil-works/pi-ai/utils/estimate";
 import { reportCatchFailure } from "./failure.js";
 import { buildSessionContext, readSessionContextPath, readSessionModelPreference, } from "./woodstock/index.js";
+const contextByOwner = new WeakMap();
 /**
  * The context size compaction measures against the model's window, for the
  * Session's settled context: the next run starts from it. Null before the
@@ -18,28 +19,98 @@ function settledContextTokens(store, sessionId) {
  * context or its context cannot be read; a window the host cannot describe is
  * null, never guessed.
  */
-export function readSessionContext(options, sessionId) {
+export function readSessionContext(options, sessionId, cursor, cache = true) {
     return Effect.gen(function* () {
-        // A context too large to read safely has no footer figure.
-        const read = yield* Effect.result(Effect.try({
-            try: () => ({
-                tokens: settledContextTokens(options.store, sessionId),
-                preference: readSessionModelPreference(options.store, sessionId),
-            }),
+        const savedPreference = yield* Effect.result(Effect.try({
+            try: () => readSessionModelPreference(options.store, sessionId),
             catch: (error) => error,
         }));
-        if (read._tag === "Failure" || read.success.tokens === null)
+        if (savedPreference._tag === "Failure") {
+            reportCatchFailure("session-context.preference", savedPreference.failure);
             return undefined;
-        const { tokens, preference } = read.success;
+        }
+        const preference = savedPreference.success;
+        const preferenceKey = JSON.stringify(preference);
+        const ownerCache = contextByOwner.get(options) ?? new Map();
+        contextByOwner.set(options, ownerCache);
+        const previous = cache ? ownerCache.get(sessionId) : undefined;
         const describe = options.model.describe;
-        if (describe === undefined)
-            return Object.freeze({ tokens, window: null });
+        if (previous?.cursor === cursor && previous.preference === preferenceKey) {
+            if (previous.value === undefined || describe === undefined)
+                return previous.value;
+            const previousValue = previous.value;
+            // A null Session override follows a mutable Agent default. Check the
+            // selected window without decoding history again; a changed window is
+            // a distinct effective preference for this cursor.
+            return yield* describe({ sessionId, preference }).pipe(Effect.map(({ contextWindow }) => {
+                if (previousValue.window === contextWindow)
+                    return previousValue;
+                const value = Object.freeze({
+                    tokens: previousValue.tokens,
+                    window: contextWindow,
+                });
+                if (cache && ownerCache.get(sessionId)?.cursor === cursor)
+                    ownerCache.set(sessionId, {
+                        cursor,
+                        preference: preferenceKey,
+                        value,
+                    });
+                return value;
+            }), Effect.catch((error) => Effect.sync(() => {
+                reportCatchFailure("session-context.describe", error);
+                return previousValue;
+            })));
+        }
+        // At most one cached whole-window read per Session, cursor, and
+        // preference: a late describe may publish only while this cursor still
+        // owns the cache entry. Reads before the tip bypass the cache and each read
+        // the whole window. A cold-cache connection also reads the whole kept
+        // window.
+        const contextRead = yield* Effect.result(Effect.try({
+            try: () => settledContextTokens(options.store, sessionId),
+            catch: (error) => error,
+        }));
+        if (contextRead._tag === "Failure") {
+            reportCatchFailure("session-context.figure", contextRead.failure);
+            return undefined;
+        }
+        const tokens = contextRead.success;
+        if (tokens === null) {
+            if (cache)
+                ownerCache.set(sessionId, {
+                    cursor,
+                    preference: preferenceKey,
+                    value: undefined,
+                });
+            return undefined;
+        }
+        if (describe === undefined) {
+            const value = Object.freeze({ tokens, window: null });
+            if (cache)
+                ownerCache.set(sessionId, { cursor, preference: preferenceKey, value });
+            return value;
+        }
+        // Publish the decoded figure before yielding to the host's model
+        // description. Concurrent watchers then reuse these tokens rather than
+        // decoding the same Session window while `describe` is in flight.
+        if (cache)
+            ownerCache.set(sessionId, {
+                cursor,
+                preference: preferenceKey,
+                value: Object.freeze({ tokens, window: null }),
+            });
         // A null Session override follows a mutable Agent default. Resolve through
         // the host's turn-model selector on every read, without acquiring a turn.
-        const window = yield* describe({ sessionId, preference }).pipe(Effect.map(({ contextWindow }) => contextWindow), Effect.catch((error) => Effect.sync(() => {
+        const window = yield* describe({
+            sessionId,
+            preference,
+        }).pipe(Effect.map(({ contextWindow }) => contextWindow), Effect.catch((error) => Effect.sync(() => {
             reportCatchFailure("session-context.describe", error);
             return null;
         })));
-        return Object.freeze({ tokens, window });
+        const value = Object.freeze({ tokens, window });
+        if (cache && ownerCache.get(sessionId)?.cursor === cursor)
+            ownerCache.set(sessionId, { cursor, preference: preferenceKey, value });
+        return value;
     });
 }

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

@@ -5,13 +5,18 @@ import * as Schema from "effect/Schema";
  * the mail it sent: the replying Agent and Session plus BirdDog's settlement
  * facts. Only `acceptMail` stores it, and only the host passes it.
  */
-export declare const VerifiedAgentReplySchema: Schema.Struct<{
+export declare const VerifiedAgentReplySchema: Schema.Union<readonly [Schema.Struct<{
     readonly commandId: Schema.String;
     readonly outcome: Schema.Literals<readonly ["completed", "failed", "interrupted", "cancelled", "outcome_unknown"]>;
     readonly diagnostic: Schema.optionalKey<Schema.String>;
     readonly agentId: Schema.String;
     readonly sessionId: Schema.String;
-}>;
+}>, Schema.Struct<{
+    readonly outcome: Schema.Literal<"undeliverable">;
+    readonly reason: Schema.Literals<readonly ["recipient_offline", "recipient_left"]>;
+    readonly agentId: Schema.String;
+    readonly sessionId: Schema.optionalKey<Schema.String>;
+}>]>;
 /** A delegated Agent's reply after the admitting host authenticated it. */
 export type VerifiedAgentReply = typeof VerifiedAgentReplySchema.Type;
 /** The tag that marks a host-verified Agent reply in model context. */

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

@@ -1,4 +1,4 @@
-import { BirdDogReplySchema } from "@fungi.computer/bird-dog/effect";
+import { SettledBirdDogReplySchema, UndeliverableBirdDogReplySchema, } from "@fungi.computer/bird-dog/effect";
 import * as Schema from "effect/Schema";
 const Identifier = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256));
 /**
@@ -6,11 +6,18 @@ const Identifier = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength
  * the mail it sent: the replying Agent and Session plus BirdDog's settlement
  * facts. Only `acceptMail` stores it, and only the host passes it.
  */
-export const VerifiedAgentReplySchema = Schema.Struct({
-    agentId: Identifier,
-    sessionId: Identifier,
-    ...BirdDogReplySchema.fields,
-});
+export const VerifiedAgentReplySchema = Schema.Union([
+    Schema.Struct({
+        agentId: Identifier,
+        sessionId: Identifier,
+        ...SettledBirdDogReplySchema.fields,
+    }),
+    Schema.Struct({
+        agentId: Identifier,
+        sessionId: Schema.optionalKey(Identifier),
+        ...UndeliverableBirdDogReplySchema.fields,
+    }),
+]);
 /** The tag that marks a host-verified Agent reply in model context. */
 export const AGENT_REPLY_TAG = "fungi_agent_reply";
 // `<` before the tag name, allowing the spacing and case a model would still read as the tag.
@@ -27,14 +34,16 @@ function attribute(value) {
         .replaceAll(">", "&gt;");
 }
 function opening(reply) {
-    const attributes = [
-        ["agent_id", reply.agentId],
-        ["session_id", reply.sessionId],
-        ["command_id", reply.commandId],
-        ["outcome", reply.outcome],
-    ];
-    if (reply.diagnostic !== undefined)
+    const attributes = [["agent_id", reply.agentId]];
+    if (reply.sessionId !== undefined)
+        attributes.push(["session_id", reply.sessionId]);
+    if (reply.outcome !== "undeliverable")
+        attributes.push(["command_id", reply.commandId]);
+    attributes.push(["outcome", reply.outcome]);
+    if (reply.outcome !== "undeliverable" && reply.diagnostic !== undefined)
         attributes.push(["diagnostic", reply.diagnostic]);
+    if (reply.outcome === "undeliverable")
+        attributes.push(["reason", reply.reason]);
     const rendered = attributes
         .map(([name, value]) => `${name}="${attribute(value)}"`)
         .join(" ");

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

@@ -27,10 +27,12 @@ export declare function createFleetDelegationStore(storage: WatchdogSqliteOwner)
     read: (requestId: string) => {
         readonly [x: string]: string | number | ArrayBuffer | null;
     } | undefined;
-    /** Every delegation this owner has sent and had accepted, newest first. */
+    /** Every recipient-accepted delegation, newest first. */
     sent: () => readonly {
         readonly [x: string]: string | number | ArrayBuffer | null;
     }[];
     reserve(requestId: string, input: string, mail: string): void;
-    recordReceipt(requestId: string, receipt: string): void;
+    recordReceipt(requestId: string, receipt: string, expectedMail: string, acceptedMail: string): void;
+    recordHeld(requestId: string): void;
+    recordUndeliverable(requestId: string): boolean;
 };

package/dist/internal/woodstock/fleet-store.js

@@ -81,24 +81,88 @@ export function createFleetDirectoryStore(sql) {
 /** Durable correspondence is frozen before delivery; retries reuse the same row. */
 export function createFleetDelegationStore(storage) {
     storage.sql.exec(`CREATE TABLE IF NOT EXISTS shiitake_fleet_delegations (
-    request_id TEXT PRIMARY KEY, input TEXT NOT NULL, mail TEXT NOT NULL, receipt TEXT
+    request_id TEXT PRIMARY KEY, input TEXT NOT NULL, mail TEXT NOT NULL,
+    receipt TEXT
+  ) STRICT`);
+    storage.sql.exec(`CREATE TABLE IF NOT EXISTS shiitake_fleet_held_delegations (
+    request_id TEXT PRIMARY KEY
+  ) STRICT`);
+    storage.sql
+        .exec(`CREATE TABLE IF NOT EXISTS shiitake_fleet_undeliverable_delegations (
+    request_id TEXT PRIMARY KEY
   ) STRICT`);
     return {
         read: (requestId) => storage.sql
-            .exec("SELECT input, mail, receipt FROM shiitake_fleet_delegations WHERE request_id = ?", requestId)
+            .exec(`SELECT delegation.input, delegation.mail,
+            CASE
+              WHEN terminal.request_id IS NOT NULL THEN 'undeliverable'
+              WHEN held.request_id IS NOT NULL THEN 'held'
+              WHEN delegation.receipt IS NOT NULL THEN 'accepted'
+              ELSE 'pending'
+            END AS state,
+            delegation.receipt
+          FROM shiitake_fleet_delegations AS delegation
+          LEFT JOIN shiitake_fleet_held_delegations AS held
+            ON held.request_id = delegation.request_id
+          LEFT JOIN shiitake_fleet_undeliverable_delegations AS terminal
+            ON terminal.request_id = delegation.request_id
+          WHERE delegation.request_id = ?`, requestId)
             .toArray()[0],
-        /** Every delegation this owner has sent and had accepted, newest first. */
+        /** Every recipient-accepted delegation, newest first. */
         sent: () => storage.sql
-            .exec("SELECT input, mail, receipt FROM shiitake_fleet_delegations WHERE receipt IS NOT NULL ORDER BY rowid DESC")
+            .exec(`SELECT input, mail, 'accepted' AS state, receipt
+          FROM shiitake_fleet_delegations
+          WHERE receipt IS NOT NULL
+          ORDER BY rowid DESC`)
             .toArray(),
         reserve(requestId, input, mail) {
             storage.transactionSync(() => {
                 storage.sql.exec("INSERT OR IGNORE INTO shiitake_fleet_delegations(request_id, input, mail) VALUES (?, ?, ?)", requestId, input, mail);
             });
         },
-        recordReceipt(requestId, receipt) {
+        recordReceipt(requestId, receipt, expectedMail, acceptedMail) {
             storage.transactionSync(() => {
-                storage.sql.exec("UPDATE shiitake_fleet_delegations SET receipt = ? WHERE request_id = ?", receipt, requestId);
+                const row = storage.sql
+                    .exec("SELECT mail, receipt FROM shiitake_fleet_delegations WHERE request_id = ?", requestId)
+                    .toArray()[0];
+                if (row === undefined)
+                    throw new Error("Cannot record acceptance without frozen delegation mail");
+                if (row.receipt !== null) {
+                    if (row.receipt === receipt && row.mail === acceptedMail)
+                        return;
+                    throw new Error("Delegation acceptance conflicts with its recorded receipt");
+                }
+                if (row.mail !== expectedMail)
+                    throw new Error("Delegation mail changed before acceptance was recorded");
+                storage.sql.exec("UPDATE shiitake_fleet_delegations SET mail = ?, receipt = ? WHERE request_id = ? AND receipt IS NULL", acceptedMail, receipt, requestId);
+                storage.sql.exec("DELETE FROM shiitake_fleet_held_delegations WHERE request_id = ?", requestId);
+            });
+        },
+        recordHeld(requestId) {
+            storage.transactionSync(() => {
+                storage.sql.exec(`INSERT OR IGNORE INTO shiitake_fleet_held_delegations (request_id)
+          SELECT request_id FROM shiitake_fleet_delegations
+          WHERE request_id = ? AND receipt IS NULL
+            AND NOT EXISTS (
+              SELECT 1 FROM shiitake_fleet_undeliverable_delegations
+              WHERE request_id = ?
+            )`, requestId, requestId);
+            });
+        },
+        recordUndeliverable(requestId) {
+            return storage.transactionSync(() => {
+                const held = storage.sql
+                    .exec(`SELECT delegation.request_id
+            FROM shiitake_fleet_delegations AS delegation
+            JOIN shiitake_fleet_held_delegations AS held
+              ON held.request_id = delegation.request_id
+            WHERE delegation.request_id = ? AND delegation.receipt IS NULL`, requestId)
+                    .toArray()[0];
+                if (held === undefined)
+                    return false;
+                storage.sql.exec("INSERT OR IGNORE INTO shiitake_fleet_undeliverable_delegations(request_id) VALUES (?)", requestId);
+                storage.sql.exec("DELETE FROM shiitake_fleet_held_delegations WHERE request_id = ?", requestId);
+                return true;
             });
         },
     };

package/dist/internal/woodstock/index.d.ts

@@ -125,6 +125,8 @@ export declare function readSessionSummary(owner: SqliteOwner, sessionId: string
  * `admitNew` may refuse a new Session; a replayed request is never refused.
  */
 export declare function createSession(owner: SqliteOwner, requestId: string, admitNew: () => void): Effect.Effect<string, ShiitakeError>;
+/** Reserve or replay a Session inside an enclosing owner transaction. */
+export declare function createSessionWithinTransaction(owner: SqliteOwner, requestId: string, admitNew: () => void): string;
 /** Permanently delete one idle Session; false when it does not exist. */
 export declare function deleteSession(owner: SqliteOwner, input: Readonly<{
     sessionId: string;

package/dist/internal/woodstock/index.js

@@ -7,7 +7,7 @@ import { diagnosticsByWorkId, projectCommandSettlement, readClientReplayPage, re
 import { sessionIds } from "./identities.js";
 import { openProgress, openToolProgress } from "./progress.js";
 import { encodeStoredSessionEntry, } from "./session-entry.js";
-import { appendSessionEntry, appendCompactionTransitionOwned, appendCompactionNoticeOwned, placeCompactionTransitionOwned, acceptSessionAbort, acceptSessionCancellation, completeSessionLeaf, prepareSessionRun, prepareSessionStore, readSessionEntriesForWork, readSessionCommandAdmission, settleSessionControls, takePendingSessionControls, readSessionEntryById, selectSessionBranch, forkSessionAt, readStoredSessionSummary as readSessionSummaryOwned, readStoredSessionFactPage, createStoredSession, deleteStoredSession, appendOperatorEntry, } from "./session-store.js";
+import { appendSessionEntry, appendCompactionTransitionOwned, appendCompactionNoticeOwned, placeCompactionTransitionOwned, acceptSessionAbort, acceptSessionCancellation, completeSessionLeaf, prepareSessionRun, prepareSessionStore, readSessionEntriesForWork, readSessionCommandAdmission, settleSessionControls, takePendingSessionControls, readSessionEntryById, selectSessionBranch, forkSessionAt, readStoredSessionSummary as readSessionSummaryOwned, readStoredSessionFactPage, createStoredSession, createStoredSessionWithinTransaction, deleteStoredSession, appendOperatorEntry, } from "./session-store.js";
 import { readSessionInboxPage, recordSessionInboxDeletion, } from "./session-inbox.js";
 export * from "./extension-store.js";
 export { readLatestPendingPrompt } from "./client-projection.js";
@@ -66,7 +66,7 @@ export function cancelSession(owner, sessionId, commandId, onlyIfPending, readQu
     return storeEffect(() => {
         const cancellation = acceptSessionCancellation(owner, sessionId, commandId, readQueueHead, record, onlyIfPending, meta);
         if (cancellation?.delivery === "new")
-            publishOwnerObservation(owner, sessionId);
+            publishOwnerObservation(owner, sessionId, "settlement");
         return cancellation;
     });
 }
@@ -83,14 +83,14 @@ export function takeSessionControls(owner, input) {
 export function settleControls(owner, input) {
     return storeEffect(() => {
         settleSessionControls(owner, input);
-        publishOwnerObservation(owner, input.sessionId);
+        publishOwnerObservation(owner, input.sessionId, "settlement");
     });
 }
 /** Resolve Session-scoped abort to private work and record it atomically. */
 export function abortSession(owner, sessionId, readQueueHead, record, meta) {
     return storeEffect(() => {
         const cancellation = acceptSessionAbort(owner, sessionId, readQueueHead, record, meta);
-        publishOwnerObservation(owner, sessionId);
+        publishOwnerObservation(owner, sessionId, "settlement");
         return cancellation?.accepted;
     });
 }
@@ -202,6 +202,10 @@ export function readSessionSummary(owner, sessionId) {
 export function createSession(owner, requestId, admitNew) {
     return storeEffect(() => createStoredSession(owner, decodeClientSessionCreationRequestId({ requestId }), admitNew));
 }
+/** Reserve or replay a Session inside an enclosing owner transaction. */
+export function createSessionWithinTransaction(owner, requestId, admitNew) {
+    return createStoredSessionWithinTransaction(owner, decodeClientSessionCreationRequestId({ requestId }), admitNew);
+}
 /** Permanently delete one idle Session; false when it does not exist. */
 export function deleteSession(owner, input) {
     return storeEffect(() => deleteStoredSession(owner, {
@@ -273,7 +277,9 @@ function appendRecordedEntry(owner, accepted, entry, findExisting, beforeAppend)
         throw rejected("Session fact identity allocation failed");
     });
     if (delivery === "new")
-        publishOwnerObservation(owner, accepted.sessionId);
+        publishOwnerObservation(owner, accepted.sessionId, entry.kind === "run_terminal" || entry.kind === "work_terminal"
+            ? "settlement"
+            : "durable");
 }
 /** Persist an operator-only sandbox diagnostic beside its accepted Session work. */
 export function recordSandboxFailure(owner, accepted, event) {

package/dist/internal/woodstock/run-recovery.js

@@ -56,7 +56,10 @@ export function contextMessageIds(path, activeWorkId) {
             if (entry.value.role === "assistant") {
                 lastWorkAssistant.set(entry.workId, row.id);
             }
-            if (terminalWork.has(entry.workId) || entry.workId === activeWorkId)
+            if ((terminalWork.has(entry.workId) || entry.workId === activeWorkId) &&
+                (entry.value.role !== "assistant" ||
+                    (entry.value.stopReason !== "error" &&
+                        entry.value.stopReason !== "aborted")))
                 messages.add(row.id);
         }
         if ((entry.kind === "compaction" && entry.data.resumesRun) ||