@fungi.computer/shiitake 0.6.0 → 0.8.0

package/dist/internal/coordinator.js

@@ -7,11 +7,11 @@ import * as Option from "effect/Option";
 import * as Stream from "effect/Stream";
 import { ShiitakeError } from "../errors.js";
 import { decodeClientReadOptions, decodeClientSettlementRequest, requireDecoded, decodeClientSessionCommand, decodeClientSessionId, decodeClientSubscribeOptions, } from "./client-boundary.js";
-import { mergeObservationSignals, openObservationKernel, publishOwnerObservation, } from "./observation-kernel.js";
+import { mergeObservationSignals, openObservationKernel, publishAgentExecutionChange, publishOwnerObservation, } from "./observation-kernel.js";
 import { checkHostMeta } from "./host-meta.js";
-import { readSessionActivity } from "./session-status.js";
-import { readSessionContext } from "./session-context.js";
-import { abortSession, cancelSession, branchSession, recordOperatorLine, forkSession, readSession, readCommandSettlement, readSessionModelPreference, readSessionReplayPage, readSessionInbox, readLatestPendingPrompt, createSession, deleteSession, deliverSessionGrants, readSessionGrants, setSessionModelPreference, setSessionTitle, readAdmissionIdentity, assertAdmissionIdentity, } from "./woodstock/index.js";
+import { readSessionActivity, } from "./session-status.js";
+import { prepareSessionContext } from "./session-context.js";
+import { progressPosition, readProcessProgressDelta, abortSession, cancelSession, branchSession, recordOperatorLine, forkSession, readSession, readCommandSettlement, readSessionModelPreference, readSessionReplayPage, readSessionInbox, readLatestPendingPrompt, createSession, deleteSession, deliverSessionGrants, readSessionGrants, setSessionModelPreference, setSessionTitle, readAdmissionIdentity, assertAdmissionIdentity, } from "./woodstock/index.js";
 /** Generic Agent-scope extension controls over the runtime's one call door. */
 function agentExtensions(runtime) {
     return Object.freeze({
@@ -20,12 +20,15 @@ function agentExtensions(runtime) {
         call: (extensionId, command, input) => runtime.assertOpen.pipe(Effect.andThen(runtime.extensions.call({ scope: "agent" }, extensionId, command, input))),
     });
 }
-function currentSessionActivity(options, runtime, sessionId) {
+function currentSessionWork(runtime, sessionId) {
     return runtime
         .readQueueHead(sessionId)
         .pipe(Effect.flatMap((head) => (head.state === "queued"
         ? runtime.runningWork(head.jobId)
-        : Effect.succeed(null)).pipe(Effect.map((runningWork) => readSessionActivity(options.store, sessionId, head, runningWork)))));
+        : Effect.succeed(null)).pipe(Effect.map((runningWork) => ({ head, runningWork })))));
+}
+function currentSessionActivity(options, runtime, sessionId) {
+    return currentSessionWork(runtime, sessionId).pipe(Effect.map(({ head, runningWork }) => readSessionActivity(options.store, sessionId, head, runningWork)));
 }
 /** Carry the Session's context use on a baseline, when it has one. */
 function withContext(snapshot, context) {
@@ -35,7 +38,10 @@ function withContext(snapshot, context) {
 }
 /** Read the baseline and its context use for one Session. */
 function readSessionWithContext(options, runtime, sessionId, input) {
-    return currentSessionActivity(options, runtime, sessionId).pipe(Effect.flatMap((activity) => readSession(options.store, sessionId, activity, input, () => runtime.extensions.project(sessionId))), Effect.flatMap((snapshot) => readSessionContext(options, sessionId, snapshot.cursor, input?.before === undefined).pipe(Effect.map((context) => withContext(snapshot, context)))));
+    return currentSessionWork(runtime, sessionId).pipe(Effect.flatMap(({ head, runningWork }) => readSession(options.store, sessionId, () => readSessionActivity(options.store, sessionId, head, runningWork), input, () => runtime.extensions.project(sessionId), (snapshot) => ({
+        snapshot,
+        context: prepareSessionContext(options, sessionId, snapshot.cursor, input?.before === undefined),
+    }))), Effect.flatMap(({ snapshot, context }) => context.pipe(Effect.map((value) => withContext(snapshot, value)))));
 }
 function sessionOwnerOperation(runtime, sessionId, operation) {
     return runtime.assertOpen.pipe(Effect.andThen(Effect.try({
@@ -92,7 +98,46 @@ function continueFromReset(frame) {
         }),
     ];
 }
-function subscriptionFrames(options, runtime, registration, sessionId, after, delivery, includeSandboxFailures = false) {
+function subscriptionFrames(options, runtime, registration, sessionId, after, delivery, includeSandboxFailures = false, baselineProgress = null) {
+    let position = progressPosition(baselineProgress);
+    let toolOutput = [];
+    const reset = () => resetFrame(options, runtime, sessionId, includeSandboxFailures).pipe(Effect.map((frame) => {
+        position = progressPosition(frame.baseline.progress);
+        toolOutput = frame.baseline.toolOutput;
+        return continueFromReset(frame);
+    }));
+    const liveFrames = (activity) => {
+        const queue = activity.facts.queue;
+        const delta = queue.state !== "running"
+            ? null
+            : readProcessProgressDelta(options.store, sessionId, queue.commandId, position);
+        if (delta === undefined)
+            return undefined;
+        const frames = [];
+        if (delta !== null) {
+            frames.push({
+                kind: "progress",
+                progress: delta,
+                activity: activity.facts,
+            });
+            position = {
+                messageId: delta.messageId,
+                revision: delta.revision,
+                text: delta.text.offset + delta.text.append.length,
+                thinking: delta.thinking.offset + delta.thinking.append.length,
+            };
+        }
+        if (toolOutput.length !== activity.toolOutput.length ||
+            toolOutput.some((slot, index) => slot !== activity.toolOutput[index])) {
+            toolOutput = activity.toolOutput;
+            frames.push({
+                kind: "tool_output",
+                toolOutput,
+                activity: activity.facts,
+            });
+        }
+        return frames;
+    };
     const initial = {
         after,
         delivery,
@@ -106,64 +151,73 @@ function subscriptionFrames(options, runtime, registration, sessionId, after, de
         if (signal === "closed")
             return Effect.succeed([[], Option.none()]);
         if (signal === "reset")
-            return resetFrame(options, runtime, sessionId, includeSandboxFailures).pipe(Effect.map(continueFromReset));
+            return reset();
         return runtime.assertOpen.pipe(Effect.andThen(currentSessionActivity(options, runtime, sessionId)), Effect.flatMap((activity) => {
             registration.setQueued(activity.facts.queue.state === "queued");
-            if (signal === "activity" && state.delivery === "live")
-                return Effect.succeed([
-                    [{ kind: "activity", activity: activity.facts }],
-                    Option.some({ ...state, awaitSignal: true }),
-                ]);
-            if (signal === "progress" && state.delivery === "live") {
+            if ((signal === "progress" || signal === "activity") &&
+                state.delivery === "live") {
+                const frames = liveFrames(activity);
+                if (frames === undefined)
+                    return reset();
                 return Effect.succeed([
                     [
-                        ...(activity.progress === null
-                            ? []
-                            : [
+                        ...(signal === "activity"
+                            ? [
                                 {
-                                    kind: "progress",
-                                    progress: activity.progress,
+                                    kind: "activity",
                                     activity: activity.facts,
                                 },
-                            ]),
-                        {
-                            kind: "tool_output",
-                            toolOutput: activity.toolOutput,
-                            activity: activity.facts,
-                        },
+                            ]
+                            : []),
+                        ...frames,
                     ],
                     Option.some({ ...state, awaitSignal: true }),
                 ]);
             }
-            return readSessionReplayPage(options.store, sessionId, state.after, state.delivery, activity, () => runtime.extensions.project(sessionId), includeSandboxFailures).pipe(Effect.flatMap((page) => {
+            return readSessionReplayPage(options.store, sessionId, state.after, state.delivery, activity, () => runtime.extensions.project(sessionId), includeSandboxFailures, (page) => {
+                const latestCursor = page.kind === "page"
+                    ? page.frames
+                        .flatMap((frame) => frame.kind === "progress" ||
+                        frame.kind === "activity" ||
+                        frame.kind === "tool_output"
+                        ? []
+                        : [frame.cursor])
+                        .at(-1)
+                    : undefined;
+                // Prepare a figure only for the final moving update,
+                // while its cursor and stored context share the read.
+                const context = page.kind === "page" &&
+                    !page.hasMore &&
+                    page.frames.some((frame) => frame.kind === "update" &&
+                        frame.cursor !== state.after)
+                    ? prepareSessionContext(options, sessionId, latestCursor ?? null)
+                    : Effect.succeed(undefined);
+                return { page, latestCursor, context };
+            }).pipe(Effect.flatMap(({ page, latestCursor, context, }) => {
                 if (page.kind === "reset")
-                    return resetFrame(options, runtime, sessionId, includeSandboxFailures).pipe(Effect.map(continueFromReset));
-                const latestCursor = page.frames
-                    .flatMap((frame) => frame.kind === "progress" ||
-                    frame.kind === "activity" ||
-                    frame.kind === "tool_output"
+                    return reset();
+                if (!page.hasMore)
+                    toolOutput = activity.toolOutput;
+                const progressFrames = page.hasMore
                     ? []
-                    : [frame.cursor])
-                    .at(-1);
+                    : liveFrames(activity);
+                if (progressFrames === undefined)
+                    return reset();
                 const next = {
                     after: latestCursor ?? state.after,
                     delivery: page.hasMore ? state.delivery : "live",
                     awaitSignal: !page.hasMore,
                 };
-                // Only a final update that moves the cursor gets a
-                // figure. A wake that moved nothing never re-reads the
-                // whole kept window.
-                const movedHistory = page.frames.some((frame) => frame.kind === "update" &&
-                    frame.cursor !== state.after);
-                return (movedHistory && !page.hasMore
-                    ? readSessionContext(options, sessionId, latestCursor ?? null)
-                    : Effect.succeed(undefined)).pipe(Effect.map((context) => [
-                    context === undefined
-                        ? page.frames
-                        : page.frames.map((frame) => frame.kind === "update" &&
-                            frame.cursor === latestCursor
-                            ? Object.freeze({ ...frame, context })
-                            : frame),
+                return context.pipe(Effect.map((context) => [
+                    [
+                        ...(context === undefined
+                            ? page.frames
+                            : page.frames.map((frame) => frame.kind === "update" &&
+                                frame.cursor === latestCursor
+                                ? Object.freeze({ ...frame, context })
+                                : frame)),
+                        ...progressFrames,
+                    ],
                     Option.some(next),
                 ]));
             }));
@@ -191,7 +245,7 @@ function watchSession(options, runtime, observation, sessionId, input) {
             registration.setQueued(snapshot.activity.queue.state === "queued");
             return Object.freeze({
                 snapshot,
-                changes: subscriptionFrames(options, runtime, registration, decoded.sessionId, snapshot.cursor ?? undefined, "live", decoded.options.includeSandboxFailures === true).pipe(Stream.ensuring(Effect.sync(registration.close))),
+                changes: subscriptionFrames(options, runtime, registration, decoded.sessionId, snapshot.cursor ?? undefined, "live", decoded.options.includeSandboxFailures === true, snapshot.progress).pipe(Stream.ensuring(Effect.sync(registration.close))),
                 close: Effect.sync(registration.close),
             });
         }))).pipe(Effect.onError(() => Effect.sync(registration.close)));
@@ -289,7 +343,9 @@ function executeSessionCommand(options, runtime, sessionId, meta, input) {
                     .commit(sessionOwnerOperation(runtime, decodedSessionId, (decoded) => {
                     setSessionTitle(options.store, decoded, command.title);
                 }))
-                    .pipe(Effect.as(undefined));
+                    .pipe(Effect.tap(() => Effect.sync(() => {
+                    publishAgentExecutionChange(options.store);
+                })), Effect.as(undefined));
         }
     }));
 }
@@ -455,6 +511,7 @@ export function acceptAddressedMail(runtime, mail, meta, reply, stageMail, sessi
             const result = admit(meta === undefined ? request : { ...request, meta });
             if (result.status !== "accepted")
                 throw new Error("Sessionless addressed mail was not admitted");
+            runtime.recordCreatedSessionDelegatorWithinTransaction(sessionId, addressed);
             return {
                 status: "accepted",
                 commandId: result.commandId,

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/observation-kernel.js

@@ -57,6 +57,14 @@ function deliverObservation(listener, reason) {
         listener.reset = true;
     }
 }
+/** Queued views reconcile occupancy without replaying another Session's facts. */
+function notifyQueuedViews(listeners, sourceSessionId) {
+    for (const listener of listeners)
+        if (listener.queued &&
+            !listener.settlementOnly &&
+            listener.sessionId !== sourceSessionId)
+            deliverObservation(listener, "activity");
+}
 /** Notify observers of one Session's durable or process-local change. */
 export function publishOwnerObservation(store, sessionId, reason = "durable") {
     const publishers = ownerPublishers.get(store);
@@ -131,11 +139,12 @@ export function openObservationKernel(store) {
     };
     const publish = (publication) => {
         if (publication.kind === "agent-execution") {
-            for (const listener of active)
-                if (listener.queued && !listener.settlementOnly)
-                    deliverObservation(listener, "activity");
+            notifyQueuedViews(active, null);
             return;
         }
+        // Reuse bounded activity hints for the occupant's changing phase.
+        if (publication.sessionId !== null && publication.reason !== "settlement")
+            notifyQueuedViews(active, publication.sessionId);
         const listeners = publication.sessionId === null
             ? active
             : sessions.get(publication.sessionId);

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.d.ts

@@ -7,6 +7,7 @@ import type { ShiitakeEffectOptions } from "./effect-contracts.js";
 import type { CompactionHandoffV0, PromptSectionV0 } from "../extensions.js";
 import { type ManualCompactionOutcome } from "./compaction/session-compaction.js";
 import { type PreparedSessionRun, type RunContract } from "./woodstock/index.js";
+export declare const runFinalizerGraceMs = 1000;
 declare const toolSetupMessages: {
     readonly missing: "Instruction capabilities have no tool runtime";
     readonly runtime: "Tool runtime failed";

package/dist/internal/run-scope.js

@@ -1,15 +1,32 @@
 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. Allow one second per foreign
+// release before detaching it: the held-model regression exercises the full
+// grace and proves Watchdog can settle and claim the next priority-1 steer.
+// Keep the test's eventual queue-idle budget tied to this product bound.
+export 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 +136,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 +154,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,8 @@ 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 { readSessionPhase } from "./session-status.js";
+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 +13,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, } from "./woodstock/index.js";
 function runtimeFailure(message) {
     return new ShiitakeError("runtime", "rejected", message);
 }
@@ -119,13 +121,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 +279,24 @@ 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)
+                    return Effect.succeed(null);
+                if (work.kind === "host")
+                    return Effect.succeed({ phase: "thinking" });
+                return Effect.try({
+                    try: () => ({
+                        phase: readSessionPhase(options.store, work.sessionId, watchdog.transactional.readQueueHead(work.sessionId)),
+                    }),
+                    catch: (cause) => new ShiitakeError("runtime", "rejected", "Running phase is unavailable", undefined, cause),
+                });
+            }), Effect.mapError((cause) => new ShiitakeError("runtime", "rejected", "Running work is unavailable", undefined, cause))),
             extensions,
             commit: bound.commit,
             assertOpen: Effect.suspend(() => lifecycleState === "open"
@@ -260,11 +304,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>;