@fungi.computer/shiitake 0.6.0 → 0.7.0

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

@@ -101,6 +101,11 @@ export type ShiitakeEffectOptions = Readonly<{
     store: SqliteOwner;
     /** Host storage-pressure check; absent never refuses for storage pressure. */
     storagePressure?: StoragePressureCheck;
+    /** Host-owned synchronous new-work admission at the common door. */
+    admission?: Readonly<{
+        /** Check the host's current flag synchronously inside admission's transaction. */
+        assertOpen: () => void;
+    }>;
     /** Compaction budgets; absent uses Pi's defaults for every model. */
     compaction?: CompactionOptions;
     /** One host lane in Shiitake's existing Watchdog, opened before recovery. */

package/dist/internal/extension-runtime.js

@@ -340,9 +340,11 @@ export function openExtensionRuntime(input) {
                     reason: error instanceof ShiitakeError
                         ? error.cause === "conflict"
                             ? "conflict"
-                            : error.cause === "closed"
-                                ? "closed"
-                                : "invalid"
+                            : error.cause === "archived"
+                                ? "archived"
+                                : error.cause === "closed"
+                                    ? "closed"
+                                    : "invalid"
                         : "invalid",
                     message: error instanceof ShiitakeError
                         ? error.message

package/dist/internal/promise-facade.js

@@ -139,6 +139,8 @@ function liftOptions(options, runtime) {
         Object.assign(base, { meta: options.meta });
     if (options.storagePressure !== undefined)
         Object.assign(base, { storagePressure: options.storagePressure });
+    if (options.admission !== undefined)
+        Object.assign(base, { admission: options.admission });
     if (options.compaction !== undefined)
         Object.assign(base, { compaction: options.compaction });
     const toolSource = options.tools;

package/dist/internal/run-scope.js

@@ -1,15 +1,30 @@
 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";
+// 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",
     runtime: "Tool runtime failed",
@@ -119,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];
     });
 }
@@ -137,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,

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,6 +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 { readOutstandingDelegationSync } from "../fleet.js";
 import { publishAgentExecutionChange } from "./observation-kernel.js";
 import { ShiitakeError } from "../errors.js";
 import { agentTurnRecovery, executeAcceptedRun, } from "./accepted-run-executor.js";
@@ -11,7 +12,7 @@ import { openCompactionSettings } from "./compaction/settings.js";
 import { admitExtensionRosterV0, } from "./extension-roster.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),
@@ -248,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"
@@ -260,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

@@ -155,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,
+                }));
             },
         });
     });

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>;

package/dist/internal/session-context.js

@@ -14,103 +14,100 @@ function settledContextTokens(store, sessionId) {
     return messages.length === 0 ? null : estimateContextTokens(messages).tokens;
 }
 /**
- * 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 function readSessionContext(options, sessionId, cursor, cache = true) {
-    return Effect.gen(function* () {
-        const savedPreference = yield* Effect.result(Effect.try({
-            try: () => readSessionModelPreference(options.store, sessionId),
-            catch: (error) => error,
-        }));
-        if (savedPreference._tag === "Failure") {
-            reportCatchFailure("session-context.preference", savedPreference.failure);
-            return undefined;
-        }
-        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 (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);
+export function prepareSessionContext(options, sessionId, cursor, cache = true) {
+    let preference;
+    try {
+        preference = readSessionModelPreference(options.store, sessionId);
+    }
+    catch (error) {
+        reportCatchFailure("session-context.preference", error);
+        return Effect.succeed(undefined);
+    }
+    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 (previous?.cursor === cursor && previous.preference === preferenceKey) {
+        if (previous.value === undefined || describe === undefined)
+            return Effect.succeed(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 describe({ sessionId, preference }).pipe(Effect.map(({ contextWindow }) => {
+            if (previousValue.window === contextWindow)
                 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)
+            const value = Object.freeze({
+                tokens: previousValue.tokens,
+                window: contextWindow,
+            });
+            if (cache && ownerCache.get(sessionId)?.cursor === cursor)
                 ownerCache.set(sessionId, {
                     cursor,
                     preference: preferenceKey,
-                    value: undefined,
+                    value,
                 });
-            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.
+        }), 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.
+    let tokens;
+    try {
+        tokens = settledContextTokens(options.store, sessionId);
+    }
+    catch (error) {
+        reportCatchFailure("session-context.figure", error);
+        return Effect.succeed(undefined);
+    }
+    if (tokens === null) {
         if (cache)
             ownerCache.set(sessionId, {
                 cursor,
                 preference: preferenceKey,
-                value: Object.freeze({ tokens, window: null }),
+                value: undefined,
             });
-        // 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(() => {
-            reportCatchFailure("session-context.describe", error);
-            return null;
-        })));
+        return Effect.succeed(undefined);
+    }
+    if (describe === undefined) {
+        const value = Object.freeze({ tokens, window: null });
+        if (cache)
+            ownerCache.set(sessionId, { cursor, preference: preferenceKey, value });
+        return Effect.succeed(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.
+    return describe({
+        sessionId,
+        preference,
+    }).pipe(Effect.map(({ contextWindow }) => contextWindow), Effect.catch((error) => Effect.sync(() => {
+        reportCatchFailure("session-context.describe", error);
+        return null;
+    })), Effect.map((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/session-status.d.ts

@@ -1,10 +1,10 @@
 import type { WatchdogQueueHead } from "@fungi.computer/watchdog/effect";
 import type { AgentRunningWork, SessionActivity, SessionProgress, SessionToolOutput } from "../client.js";
 import type { SqliteOwner } from "./contracts.js";
-/** Public activity facts plus the process-local progress read with them. */
+/** Activity facts plus an explicit, on-demand bounded progress read. */
 export type ObservedActivity = Readonly<{
     facts: SessionActivity;
-    progress: SessionProgress | null;
+    readProgress: () => SessionProgress | null;
     toolOutput: readonly SessionToolOutput[];
 }>;
 /** Join Watchdog authority with Woodstock facts and process-local progress. */

package/dist/internal/session-status.js

@@ -12,7 +12,7 @@ export function readSessionActivity(owner, sessionId, head, runningWork) {
                 lastModelChoiceSequence,
                 compaction: null,
             },
-            progress: null,
+            readProgress: () => null,
             toolOutput: [],
         };
     if (head.state === "queued")
@@ -27,7 +27,7 @@ export function readSessionActivity(owner, sessionId, head, runningWork) {
                 lastModelChoiceSequence,
                 compaction: null,
             },
-            progress: null,
+            readProgress: () => null,
             toolOutput: [],
         };
     const latestRetry = readLatestLiveRetryForWork(owner, sessionId, head.jobId);
@@ -49,7 +49,9 @@ export function readSessionActivity(owner, sessionId, head, runningWork) {
             lastModelChoiceSequence,
             compaction: readProcessCompaction(owner, sessionId),
         },
-        progress: readProcessProgressForWork(owner, sessionId, head.jobId),
+        // Only baselines need a flattened bounded tail. Live subscribers read
+        // appends directly and must not materialize it on every token.
+        readProgress: () => readProcessProgressForWork(owner, sessionId, head.jobId),
         toolOutput: readProcessToolOutputForWork(owner, sessionId, head.jobId),
     };
 }

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

@@ -5,7 +5,7 @@ import { readSessionDelegator } from "./session-delegator.js";
 import { ShiitakeError } from "../../errors.js";
 import { decodeWoodstockCursor, encodeWoodstockCursor } from "./cursor.js";
 import { operatorClientMessage, promptCommand } from "./session-entry.js";
-import { lineageEntrySequence, lineageHasSequence, lineageRowLimit, readLineageWindow, readLineageWorkFacts, hasSessionWorkTerminal, readSessionEntriesForWork, readSessionLineage, readPendingSessionCommands, readSessionCommandAdmission, readNewestPendingSessionCommand, } from "./session-store.js";
+import { lineageEntrySequence, lineageHasSequence, lineageRowLimit, readLineageWindow, readLineageWorkFacts, hasSessionWorkTerminal, readSessionEntriesForWork, readSessionLineage, readPendingSessionCommands, readSessionCommandAdmission, readNewestPendingSessionCommand, withSessionReadTransaction, } from "./session-store.js";
 const maximumPagePayloadBytes = 2_097_152;
 const replayPageLimit = 200;
 const maximumRowsPerPage = lineageRowLimit;
@@ -344,7 +344,7 @@ function resolveHistoryAnchor(owner, lineage, before) {
  * history, including what compaction summarized away.
  */
 export function readClientSnapshot(owner, sessionId, options, activity, projectExtensions = () => ({})) {
-    return owner.transactionSync(() => {
+    return withSessionReadTransaction(owner, sessionId, () => {
         const pending = readPendingPrompts(owner, sessionId);
         const lineage = readSessionLineage(owner, { sessionId });
         if (lineage === undefined)
@@ -359,7 +359,7 @@ export function readClientSnapshot(owner, sessionId, options, activity, projectE
                 compactionNotices: Object.freeze([]),
                 pending,
                 activity: activity.facts,
-                progress: activity.progress,
+                progress: activity.readProgress(),
                 toolOutput: activity.toolOutput,
                 extensions: projectExtensions(),
                 attention: readSessionAttention(owner, sessionId),
@@ -394,7 +394,7 @@ export function readClientSnapshot(owner, sessionId, options, activity, projectE
             compactionNotices: compactionNoticesIn(consumedRows),
             pending,
             activity: activity.facts,
-            progress: options.before === undefined ? activity.progress : null,
+            progress: options.before === undefined ? activity.readProgress() : null,
             toolOutput: options.before === undefined ? activity.toolOutput : [],
             extensions: projectExtensions(),
             attention: readSessionAttention(owner, sessionId),
@@ -442,12 +442,6 @@ function replayFrames(owner, lineage, start, delivery, activity, extensions, att
             ? { ...frame, sandboxFailures: page.sandboxFailures }
             : frame),
     ];
-    if (delivery === "live" && !page.hasMore && activity.progress !== null)
-        frames.push(Object.freeze({
-            kind: "progress",
-            progress: activity.progress,
-            activity: activity.facts,
-        }));
     return Object.freeze({
         kind: "page",
         frames: Object.freeze(!page.hasMore
@@ -468,7 +462,7 @@ export function readClientReplayPage(owner, sessionId, after, delivery, activity
     const position = after === undefined ? undefined : decodeWoodstockCursor(after);
     if (after !== undefined && position === undefined)
         return resetReplayPage;
-    return owner.transactionSync(() => {
+    return withSessionReadTransaction(owner, sessionId, () => {
         const pending = readPendingPrompts(owner, sessionId);
         const lineage = readSessionLineage(owner, { sessionId });
         if (lineage === undefined) {

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

@@ -27,10 +27,11 @@ export declare function createFleetDelegationStore(storage: WatchdogSqliteOwner)
     read: (requestId: string) => {
         readonly [x: string]: string | number | ArrayBuffer | null;
     } | undefined;
-    /** Every recipient-accepted delegation, newest first. */
-    sent: () => readonly {
+    /** Accepted sends not yet observed settled, for owner-local archive admission. */
+    unsettled: () => readonly {
         readonly [x: string]: string | number | ArrayBuffer | null;
     }[];
+    recordSettled(requestId: string): void;
     reserve(requestId: string, input: string, mail: string): void;
     recordReceipt(requestId: string, receipt: string, expectedMail: string, acceptedMail: string): void;
     recordHeld(requestId: string): void;