@fungi.computer/shiitake 0.1.0 → 0.3.0

package/dist/internal/compaction/utils.d.ts

@@ -1,10 +1,17 @@
 /**
  * Adapted from the maintained Pi v0.84.4 coding-agent compaction utilities.
+ * Token estimates are pi-ai's own (`@earendil-works/pi-ai/utils/estimate`).
  * The only destination delta is carrying Pi's native Message values directly.
  */
-import type { AssistantMessage, Message } from "@earendil-works/pi-ai";
-/** Pi's native compaction boundary projection, retained without a custom role. */
-export declare function compactionSummaryMessage(summary: string, timestamp: number): Message;
+import type { AssistantMessage, Message, UserMessage } from "@earendil-works/pi-ai";
+/**
+ * Pi's compaction entry model message (Pi Durable `compaction.ts`): the
+ * summary as the user message the model reads, built once when the entry is
+ * appended and stored with it.
+ */
+export declare function compactionSummaryMessage(summary: string, timestamp: number): UserMessage;
+/** The summary text inside a stored compaction model message. */
+export declare function compactionSummaryText(message: UserMessage): string;
 export type FileOperations = {
     edited: Set<string>;
     read: Set<string>;
@@ -18,24 +25,20 @@ export declare function computeFileLists(fileOps: FileOperations): {
 };
 export declare function formatFileOperations(readFiles: readonly string[], modifiedFiles: readonly string[]): string;
 export declare function serializeConversation(messages: readonly Message[]): string;
-/** Pi's chars/4 estimator, including its image and tool-call constants. */
-export declare function estimateTokens(message: Message): number;
-export declare function estimateContextTokens(messages: readonly Message[]): {
-    tokens: number;
-    usageTokens: number;
-    trailingTokens: number;
-    lastUsageIndex: null;
-} | {
-    tokens: number;
-    usageTokens: number;
-    trailingTokens: number;
-    lastUsageIndex: number;
-};
 export declare function shouldCompact(contextTokens: number, contextWindow: number, settings: CompactionSettings): boolean;
+/**
+ * A background compaction starts above the blocking threshold minus
+ * `backgroundTokens` and at or below the blocking threshold; past that the
+ * blocking check owns it. Token-based only: byte limits are Zookeeper's.
+ * Unclamped like Pi Durable generation.ts:322-339 (Levi, 2026-10-17: match Pi); keepRecentTokens gates small windows.
+ */
+export declare function shouldCompactInBackground(contextTokens: number, contextWindow: number, settings: CompactionSettings): boolean;
 export type CompactionSettings = {
     enabled: boolean;
     reserveTokens: number;
     keepRecentTokens: number;
+    /** Tokens before the blocking threshold at which a background compaction starts; 0 turns it off. */
+    backgroundTokens: number;
 };
 export declare const DEFAULT_COMPACTION_SETTINGS: CompactionSettings;
 export declare const SUMMARIZATION_SYSTEM_PROMPT = "You are a context summarization assistant. Your task is to read a conversation between a user and an AI coding assistant, then produce a structured summary following the exact format specified.\n\nDo NOT continue the conversation. Do NOT respond to any questions in the conversation. ONLY output the structured summary.";

package/dist/internal/compaction/utils.js

@@ -6,7 +6,11 @@ const COMPACTION_SUMMARY_PREFIX = `The conversation history before this point wa
 `;
 const COMPACTION_SUMMARY_SUFFIX = `
 </summary>`;
-/** Pi's native compaction boundary projection, retained without a custom role. */
+/**
+ * Pi's compaction entry model message (Pi Durable `compaction.ts`): the
+ * summary as the user message the model reads, built once when the entry is
+ * appended and stored with it.
+ */
 export function compactionSummaryMessage(summary, timestamp) {
     return {
         role: "user",
@@ -19,6 +23,16 @@ export function compactionSummaryMessage(summary, timestamp) {
         timestamp,
     };
 }
+/** The summary text inside a stored compaction model message. */
+export function compactionSummaryText(message) {
+    const block = Array.isArray(message.content) ? message.content[0] : undefined;
+    const text = block?.type === "text" ? block.text : undefined;
+    if (text === undefined ||
+        !text.startsWith(COMPACTION_SUMMARY_PREFIX) ||
+        !text.endsWith(COMPACTION_SUMMARY_SUFFIX))
+        throw new Error("Compaction model message is not a summary");
+    return text.slice(COMPACTION_SUMMARY_PREFIX.length, text.length - COMPACTION_SUMMARY_SUFFIX.length);
+}
 export function createFileOps() {
     return { edited: new Set(), read: new Set(), written: new Set() };
 }
@@ -76,14 +90,11 @@ function serializeUserMessage(message) {
 }
 function serializeAssistantMessage(message) {
     const text = [];
-    const thinking = [];
     const calls = [];
     for (const block of message.content) {
         if (block.type === "text")
             text.push(block.text);
-        else if (block.type === "thinking")
-            thinking.push(block.thinking);
-        else {
+        else if (block.type === "toolCall") {
             const args = Object.entries(block.arguments)
                 .map(([key, value]) => `${key}=${JSON.stringify(value)}`)
                 .join(", ");
@@ -91,8 +102,6 @@ function serializeAssistantMessage(message) {
         }
     }
     const parts = [];
-    if (thinking.length > 0)
-        parts.push(`[Assistant thinking]: ${thinking.join("\n")}`);
     if (text.length > 0)
         parts.push(`[Assistant]: ${text.join("\n")}`);
     if (calls.length > 0)
@@ -129,92 +138,29 @@ export function serializeConversation(messages) {
     }
     return parts.join("\n\n");
 }
-const ESTIMATED_IMAGE_CHARS = 4800;
-function estimateTextAndImageContentChars(content) {
-    if (isString(content))
-        return content.length;
-    return content.reduce((chars, block) => chars +
-        (block.type === "text"
-            ? (block.text?.length ?? 0)
-            : block.type === "image"
-                ? ESTIMATED_IMAGE_CHARS
-                : 0), 0);
-}
-/** Pi's chars/4 estimator, including its image and tool-call constants. */
-export function estimateTokens(message) {
-    let chars = 0;
-    switch (message.role) {
-        case "system":
-            return Math.ceil(estimateTextAndImageContentChars(message.content) / 4);
-        case "user":
-            return Math.ceil(estimateTextAndImageContentChars(message.content) / 4);
-        case "assistant":
-            for (const block of message.content) {
-                if (block.type === "text")
-                    chars += block.text.length;
-                else if (block.type === "thinking")
-                    chars += block.thinking.length;
-                else
-                    chars += block.name.length + JSON.stringify(block.arguments).length;
-            }
-            return Math.ceil(chars / 4);
-        case "toolResult":
-            return Math.ceil(estimateTextAndImageContentChars(message.content) / 4);
-    }
-}
-function calculateContextTokens(usage) {
-    return (usage.totalTokens ||
-        usage.input + usage.output + usage.cacheRead + usage.cacheWrite);
-}
-function validAssistantUsage(message) {
-    if (message.role !== "assistant")
-        return undefined;
-    if (message.stopReason === "aborted" || message.stopReason === "error")
-        return undefined;
-    return calculateContextTokens(message.usage) > 0 ? message.usage : undefined;
-}
-export function estimateContextTokens(messages) {
-    let index = null;
-    let usageTokens = 0;
-    for (let cursor = messages.length - 1; cursor >= 0; cursor -= 1) {
-        const message = messages[cursor];
-        if (message === undefined)
-            continue;
-        const usage = validAssistantUsage(message);
-        if (usage !== undefined) {
-            index = cursor;
-            usageTokens = calculateContextTokens(usage);
-            break;
-        }
-    }
-    if (index === null) {
-        const tokens = messages.reduce((sum, message) => sum + estimateTokens(message), 0);
-        return {
-            tokens,
-            usageTokens: 0,
-            trailingTokens: tokens,
-            lastUsageIndex: null,
-        };
-    }
-    const trailingTokens = messages
-        .slice(index + 1)
-        .reduce((sum, message) => sum + estimateTokens(message), 0);
-    return {
-        tokens: usageTokens + trailingTokens,
-        usageTokens,
-        trailingTokens,
-        lastUsageIndex: index,
-    };
-}
 export function shouldCompact(contextTokens, contextWindow, settings) {
     if (!settings.enabled)
         return false;
     return contextTokens > contextWindow - settings.reserveTokens;
 }
+/**
+ * A background compaction starts above the blocking threshold minus
+ * `backgroundTokens` and at or below the blocking threshold; past that the
+ * blocking check owns it. Token-based only: byte limits are Zookeeper's.
+ * Unclamped like Pi Durable generation.ts:322-339 (Levi, 2026-10-17: match Pi); keepRecentTokens gates small windows.
+ */
+export function shouldCompactInBackground(contextTokens, contextWindow, settings) {
+    if (!settings.enabled || settings.backgroundTokens === 0)
+        return false;
+    const blocking = contextWindow - settings.reserveTokens;
+    return (contextTokens > blocking - settings.backgroundTokens &&
+        !shouldCompact(contextTokens, contextWindow, settings));
+}
 export const DEFAULT_COMPACTION_SETTINGS = {
     enabled: true,
     reserveTokens: 16384,
     keepRecentTokens: 20000,
+    backgroundTokens: 32768,
 };
 export const SUMMARIZATION_SYSTEM_PROMPT = `You are a context summarization assistant. Your task is to read a conversation between a user and an AI coding assistant, then produce a structured summary following the exact format specified.
 

package/dist/internal/contracts.d.ts

@@ -24,6 +24,12 @@ export type SqliteOwner = Omit<WatchdogSqliteOwner, "sql"> & Readonly<{
         /** Execute a statement with SQLite scalar bindings. */
         exec: (statement: string, ...bindings: SqliteValue[]) => SqliteCursor;
     }>;
+    /**
+     * How the host names this store when Woodstock refuses part of it, so its
+     * operator knows which store to act on: its Durable Object or its file.
+     * Absent is "Woodstock store".
+     */
+    storeName?: string;
 }>;
 /** Acquired Pi model and optional explicit Pi stream function. */
 export type ModelAcquisition = Readonly<{
@@ -31,8 +37,16 @@ export type ModelAcquisition = Readonly<{
     model: Model<Api>;
     /** Optional explicit Pi stream function for custom providers and tests. */
     stream?: MuleStreamFunction;
+    /** Typed retry decision for this door's exact message; unknown means false. */
+    retryable: (message: AssistantMessage) => boolean;
     /** Provider's bounded Retry-After for a clean HTTP refusal, if reported. */
     retryAfterMs?: (message: AssistantMessage) => number | undefined;
+    /**
+     * Describe only a failure message produced by this acquired model door.
+     * Return its owner-authored safe reason, never arbitrary SDK error prose.
+     * Unknown messages must return undefined.
+     */
+    failureReason?: (message: AssistantMessage) => string | undefined;
     /** Release the acquired model resources. */
     release: () => Promise<void>;
 }>;
@@ -124,18 +138,19 @@ export type RuntimeHost = Readonly<{
     }>>;
 }>;
 /**
- * A host's disk budget for owner storage, with the platform's own measure of
- * it. Near the budget, Shiitake refuses new Sessions and new prompts with a
- * typed `storage_pressure` error while admitted work finishes.
+ * A host's storage-pressure check. Shiitake owns the refusal door and the
+ * typed `storage_pressure` error; the host owns the numbers behind it, such
+ * as Zookeeper's budget and thresholds. While the check reports pressure,
+ * new Sessions and new prompts are refused and admitted work finishes.
  */
-export type StorageBudget = Readonly<{
+export type StoragePressureCheck = Readonly<{
     /**
-     * Bytes the owner database occupies now, read from the platform, such as
-     * Cloudflare's `ctx.storage.sql.databaseSize`.
+     * Whether the owner is under storage pressure now. Called only for a new
+     * Session or a new prompt, never for a replay or for writes that finish
+     * admitted work. A throw, such as an unreadable measurement, refuses the
+     * new work with that error.
      */
-    usedBytes: () => number;
-    /** The host's budget for those bytes. */
-    budgetBytes: number;
+    underPressure: () => boolean;
 }>;
 /** One model's compaction token budgets; omitted fields fall back. */
 export type CompactionBudget = Readonly<{
@@ -143,11 +158,13 @@ export type CompactionBudget = Readonly<{
     reserveTokens?: number;
     /** Recent tokens kept verbatim instead of summarized. */
     keepRecentTokens?: number;
+    /** Tokens before the blocking threshold at which compaction starts in the background; 0 turns it off (default 32768). */
+    backgroundTokens?: number;
 }>;
 /**
  * Pi's compaction settings. Each budget resolves through the exact
  * `provider/modelId` override, then the ordinary value, then Pi's default
- * (16384 reserve, 20000 kept). `enabled` is global and governs automatic
+ * (16384 reserve, 20000 kept, 32768 background). `enabled` is global and governs automatic
  * compaction only; a manual compaction always runs.
  */
 export type CompactionOptions = CompactionBudget & Readonly<{
@@ -159,13 +176,14 @@ export type CompactionOptions = CompactionBudget & Readonly<{
 export type ShiitakeOptions = Readonly<{
     /**
      * The schema of the opaque metadata this host attaches to prompts and
-     * operator lines. Shiitake checks, stores and returns it; it never reads it.
+     * operator lines. Shiitake checks, stores and returns it; the host owns its
+     * grammar and may select a principal identity path for recall authorization.
      */
     meta?: HostMetaOptions;
     /** Native owner storage and synchronous transaction capability. */
     store: SqliteOwner;
-    /** Disk budget for `store`; absent never refuses for storage pressure. */
-    storageBudget?: StorageBudget;
+    /** Host storage-pressure check; absent never refuses for storage pressure. */
+    storagePressure?: StoragePressureCheck;
     /** Compaction budgets; absent uses Pi's defaults for every model. */
     compaction?: CompactionOptions;
     /** Runtime host that schedules the opaque durable reconciler. */
@@ -202,6 +220,13 @@ export type ToolAccess = Pick<AccessOptions,
  * remote client can.
  */
 export type ShiitakeOwnerAgent = ShiitakeAgent & Readonly<{
+    /** Stage a configuration without disturbing an in-flight turn. */
+    prepareConfiguration: (configuration: Pick<ShiitakeOptions, "extensions" | "tools">) => Promise<Readonly<{
+        /** Publish synchronously; the next turn applies the prepared roster. */
+        commit: () => void;
+        /** Drop the staged configuration without applying it. */
+        discard: () => Promise<void>;
+    }>>;
     /** Each Session's delivered tool grants, read at every call. */
     grants: Readonly<{
         /**
@@ -224,6 +249,8 @@ export type { GrantsDelivery, GrantsDeliveryResult, } from "./woodstock/index.js
 export type { HostMetaOptions, StandardHostMetaResult, StandardHostMetaSchema, } from "./host-meta.js";
 /** Exact accepted-work facts, independent of the current Session branch or page. */
 export type CommandSettlement = Readonly<{
+    /** Original Agent sender recorded at acceptance, never the terminal's canceller. */
+    acceptedSender: string | null;
     /** Durable terminal and the command that ended the work's opaque metadata. */
     terminal: SessionTerminal;
     /** Last completed assistant text; cancelled work returns no answer. */

package/dist/internal/coordinator.js

@@ -9,7 +9,7 @@ import { mergeObservationSignals, openObservationKernel, publishOwnerObservation
 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, readSessionModelPreference, readSessionReplayPage, readSessionInbox, createSession, deleteSession, deliverSessionGrants, readSessionGrants, setSessionModelPreference, setSessionTitle, } from "./woodstock/index.js";
+import { abortSession, cancelSession, branchSession, recordOperatorLine, forkSession, readSession, 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({
@@ -33,7 +33,7 @@ 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, runtime, sessionId).pipe(Effect.map((context) => withContext(snapshot, context)))));
+    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).pipe(Effect.map((context) => withContext(snapshot, context)))));
 }
 function sessionOwnerOperation(runtime, sessionId, operation) {
     return runtime.assertOpen.pipe(Effect.andThen(Effect.try({
@@ -106,14 +106,21 @@ function subscriptionFrames(options, runtime, registration, sessionId, after, de
         if (signal === "reset")
             return resetFrame(options, runtime, sessionId, includeSandboxFailures).pipe(Effect.map(continueFromReset));
         return runtime.assertOpen.pipe(Effect.andThen(currentSessionActivity(options, runtime, sessionId)), Effect.flatMap((activity) => {
-            if (signal === "progress" &&
-                state.delivery === "live" &&
-                activity.progress !== null) {
+            if (signal === "progress" && state.delivery === "live") {
                 return Effect.succeed([
                     [
+                        ...(activity.progress === null
+                            ? []
+                            : [
+                                {
+                                    kind: "progress",
+                                    progress: activity.progress,
+                                    activity: activity.facts,
+                                },
+                            ]),
                         {
-                            kind: "progress",
-                            progress: activity.progress,
+                            kind: "tool_output",
+                            toolOutput: activity.toolOutput,
                             activity: activity.facts,
                         },
                     ],
@@ -124,7 +131,10 @@ function subscriptionFrames(options, runtime, registration, sessionId, after, de
                 if (page.kind === "reset")
                     return resetFrame(options, runtime, sessionId, includeSandboxFailures).pipe(Effect.map(continueFromReset));
                 const latestCursor = page.frames
-                    .flatMap((frame) => frame.kind === "progress" ? [] : [frame.cursor])
+                    .flatMap((frame) => frame.kind === "progress" ||
+                    frame.kind === "tool_output"
+                    ? []
+                    : [frame.cursor])
                     .at(-1);
                 const next = {
                     after: latestCursor ?? state.after,
@@ -133,7 +143,7 @@ function subscriptionFrames(options, runtime, registration, sessionId, after, de
                 };
                 // Every update carries the context use it settles on.
                 return (page.frames.some((frame) => frame.kind === "update")
-                    ? readSessionContext(options, runtime, sessionId)
+                    ? readSessionContext(options, sessionId)
                     : Effect.succeed(undefined)).pipe(Effect.map((context) => [
                     context === undefined
                         ? page.frames
@@ -195,7 +205,10 @@ function admitUserWork(runtime, sessionId, input, meta, mail, reply) {
         : Effect.fail(new ShiitakeError("runtime", "unavailable", "Session command was not admitted"))));
 }
 function cancelRequestedSession(options, runtime, sessionId, input, meta) {
-    return runtime.assertOpen.pipe(Effect.andThen(cancelSession(options.store, sessionId, input.commandId, input.onlyIfPending, () => runtime.readQueueHeadTransactional(sessionId), runtime.recordAcceptedCancellation, meta)), Effect.flatMap((cancellation) => cancellation === undefined
+    return runtime.assertOpen.pipe(Effect.andThen(sessionOwnerOperation(runtime, sessionId, (decoded) => {
+        if (options.meta?.identityPath !== undefined && meta !== undefined)
+            assertAdmissionIdentity(options.store, decoded, input.commandId, readAdmissionIdentity(options.store, options.meta.identityPath, meta));
+    })), Effect.andThen(cancelSession(options.store, sessionId, input.commandId, input.onlyIfPending, () => runtime.readQueueHeadTransactional(sessionId), runtime.recordAcceptedCancellation, meta)), Effect.flatMap((cancellation) => cancellation === undefined
         ? Effect.succeed({
             status: "too_late",
             commandId: input.commandId,
@@ -282,6 +295,7 @@ export function openCoordinator(options, runtime) {
         }
         return Object.freeze({
             command,
+            withdraw: (requestId) => runtime.assertOpen.pipe(Effect.andThen(runtime.door.withdraw(sessionId, requestId))),
             abort: command({ type: "abort" }),
             send: (text, input) => Effect.sync(() => input?.requestId ?? nanoid()).pipe(Effect.flatMap((requestId) => {
                 const prompt = {
@@ -297,6 +311,9 @@ export function openCoordinator(options, runtime) {
                     : new ShiitakeError(error.boundary, error.cause, error.message, requestId)));
             })),
             cancel: (input) => command({ type: "cancel", ...input }),
+            latestPending: sessionOwnerOperation(runtime, sessionId, (decoded) => readLatestPendingPrompt(options.store, decoded, options.meta?.identityPath === undefined || meta === undefined
+                ? undefined
+                : readAdmissionIdentity(options.store, options.meta.identityPath, meta))),
             modelPreference: Object.freeze({
                 read: sessionOwnerOperation(runtime, sessionId, (decoded) => readSessionModelPreference(options.store, decoded)),
                 set: (preference) => Effect.try({
@@ -335,6 +352,7 @@ export function openCoordinator(options, runtime) {
     });
     return Object.freeze({
         ...agent,
+        prepareConfiguration: runtime.prepareConfiguration,
         grants: Object.freeze({
             // A synchronous owner write: a delivery lands before any other work
             // can interleave, so the very next tool call reads it.

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

@@ -1,7 +1,9 @@
 import * as Effect from "effect/Effect";
 import type { ShiitakeAgent } from "../client.js";
-import type { ShiitakeEffectAgent, ShiitakeEffectOwner } from "./effect-contracts.js";
-import type { ShiitakeOwnerAgent } from "./contracts.js";
+import type { ShiitakeEffectAgent, ShiitakeEffectOwner, ShiitakeEffectOptions } from "./effect-contracts.js";
+import type { ShiitakeOwnerAgent, ShiitakeOptions } from "./contracts.js";
+/** Adapt a Promise tool configuration for both initial open and reload. */
+export declare function liftTools(toolSource: NonNullable<ShiitakeOptions["tools"]>): NonNullable<ShiitakeEffectOptions["tools"]>;
 /** Run one Shiitake Effect through its sole Promise error adaptation. */
 export declare function runShiitakePromise<A, E>(effect: Effect.Effect<A, E>): Promise<A>;
 /** Adapt one canonical Effect agent to Shiitake's ordinary web interface. */

package/dist/internal/effect-client.js

@@ -1,10 +1,23 @@
 import { nanoid } from "@fungi.computer/cairn";
+import { fromTypedSandbox } from "@fungi.computer/mycelium/effect";
 import * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import * as Option from "effect/Option";
 import * as Stream from "effect/Stream";
 import { ShiitakeError } from "../errors.js";
+/** Adapt a Promise tool configuration for both initial open and reload. */
+export function liftTools(toolSource) {
+    const tools = {
+        modules: toolSource.modules ?? [],
+        sources: toolSource.sources ?? [],
+        sandbox: fromTypedSandbox(toolSource.sandbox),
+        access: toolSource.access ?? {},
+    };
+    return toolSource.execution === undefined
+        ? tools
+        : { ...tools, execution: toolSource.execution };
+}
 /** Run one Shiitake Effect through its sole Promise error adaptation. */
 export function runShiitakePromise(effect) {
     return Effect.runPromiseExit(effect).then((exit) => {
@@ -47,9 +60,11 @@ function sessionFacade(address, session) {
     return Object.freeze({
         address,
         command,
+        withdraw: (requestId) => runShiitakePromise(session.withdraw(requestId)),
         abort: () => runShiitakePromise(session.abort),
         send: (text, options) => runShiitakePromise(session.send(text, options)),
         cancel: (input) => runShiitakePromise(session.cancel(input)),
+        latestPending: () => runShiitakePromise(session.latestPending),
         modelPreference: Object.freeze({
             read: () => runShiitakePromise(session.modelPreference.read),
             set: (preference) => runShiitakePromise(session.modelPreference.set(preference)),
@@ -93,6 +108,20 @@ export function toPromiseOwner(owner) {
     const address = `local:${nanoid()}`;
     return Object.freeze({
         ...toPromiseAgent(owner, address),
+        prepareConfiguration: async (configuration) => {
+            const next = {
+                extensions: configuration.extensions,
+            };
+            if (configuration.tools !== undefined)
+                Object.assign(next, { tools: liftTools(configuration.tools) });
+            const prepared = await runShiitakePromise(owner.prepareConfiguration(next));
+            return {
+                commit: () => {
+                    runShiitakeSync(prepared.commit);
+                },
+                discard: () => runShiitakePromise(prepared.discard),
+            };
+        },
         grants: Object.freeze({
             deliver: (sessionId, delivery) => runShiitakeSync(owner.grants.deliver(sessionId, delivery)),
             read: (sessionId) => runShiitakeSync(owner.grants.read(sessionId)),

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

@@ -9,10 +9,10 @@ import * as Stream from "effect/Stream";
 import type * as Scope from "effect/Scope";
 import type { WatchdogError } from "@fungi.computer/watchdog";
 import type { WatchdogExecutionDecision, WatchdogRunningJob, ConcurrentWatchdogRuntimeEffect } from "@fungi.computer/watchdog/effect";
-import type { AbortCommand, Accepted, BranchCommand, OperatorCommand, TitleCommand, CancelCommand, CancelResult, ForkCommand, ForkedSession, CompactCommand, PromptCommand, PromptDelivery, ReadOptions, SessionCommand, SessionFrame, SessionSnapshot, SessionSummaryPage, SubscribeOptions, WatchOptions } from "../client.js";
+import type { AbortCommand, Accepted, BranchCommand, OperatorCommand, TitleCommand, CancelCommand, CancelResult, ForkCommand, ForkedSession, CompactCommand, PromptCommand, PromptDelivery, ReadOptions, SessionCommand, SessionFrame, SessionSnapshot, SessionPendingPrompt, SessionSummaryPage, SubscribeOptions, WatchOptions } from "../client.js";
 import type { ShiitakeError } from "../errors.js";
 import type { ExtensionStatusV0, Json } from "../extensions.js";
-import type { InstructionSnapshot, ModelDescription, RuntimePendingWork, SqliteOwner, StorageBudget, CompactionOptions } from "./contracts.js";
+import type { InstructionSnapshot, ModelDescription, RuntimePendingWork, SqliteOwner, StoragePressureCheck, CompactionOptions } from "./contracts.js";
 import type { ModelPreference } from "./model-preference.js";
 /** Effect-native acquired Pi model and finalizer. */
 export type ModelAcquisitionEffect = Readonly<{
@@ -22,6 +22,10 @@ export type ModelAcquisitionEffect = Readonly<{
     stream?: MuleStreamFunction;
     /** Provider’s bounded Retry-After for a clean HTTP refusal, if reported. */
     retryAfterMs?: (message: AssistantMessage) => number | undefined;
+    /** Typed retry decision for this door's exact message; unknown means false. */
+    retryable: (message: AssistantMessage) => boolean;
+    /** Owner-authored reason for this door's failure message, never SDK prose. */
+    failureReason?: (message: AssistantMessage) => string | undefined;
     /** Effect finalizer for acquired model resources. */
     release: Effect.Effect<void, ShiitakeError>;
 }>;
@@ -91,8 +95,8 @@ export type ShiitakeEffectOptions = Readonly<{
     meta?: HostMetaOptions;
     /** Native owner storage and synchronous transaction capability. */
     store: SqliteOwner;
-    /** Disk budget for `store`; absent never refuses for storage pressure. */
-    storageBudget?: StorageBudget;
+    /** Host storage-pressure check; absent never refuses for storage pressure. */
+    storagePressure?: StoragePressureCheck;
     /** Compaction budgets; absent uses Pi's defaults for every model. */
     compaction?: CompactionOptions;
     /** One host lane in Shiitake's existing Watchdog, opened before recovery. */
@@ -161,6 +165,8 @@ export type ShiitakeEffectSendOptions = Readonly<{
 export type ShiitakeEffectSession = Readonly<{
     /** Execute one retained type-discriminated Session command. */
     command: ShiitakeEffectCommandHandler;
+    /** Resolve admission or durably fence a request that has not been admitted. */
+    withdraw: (requestId: string) => Effect.Effect<import("../client.js").WithdrawResult, ShiitakeError>;
     /** Cancel the running turn and all queued prompts, retaining their text. */
     abort: Effect.Effect<void, ShiitakeError>;
     /** Send text with one generated or explicitly supplied request identity. */
@@ -170,6 +176,8 @@ export type ShiitakeEffectSession = Readonly<{
         commandId: string;
         onlyIfPending?: boolean;
     }) => Effect.Effect<CancelResult, ShiitakeError>;
+    /** Newest pending prompt scoped by the host's bound identity. */
+    latestPending: Effect.Effect<SessionPendingPrompt | null, ShiitakeError>;
     /** Address one rostered extension's Session-scope commands. */
     extension: (extensionId: string) => ShiitakeEffectSessionExtension;
     /** Lineage-local selection used when the next run acquires its model. */
@@ -221,6 +229,11 @@ export type ShiitakeEffectAgent = Readonly<{
  * remote client can.
  */
 export type ShiitakeEffectOwner = ShiitakeEffectAgent & Readonly<{
+    /** Stage a configuration without disturbing an in-flight turn. */
+    prepareConfiguration: (configuration: Pick<ShiitakeEffectOptions, "extensions" | "tools">) => Effect.Effect<Readonly<{
+        commit: Effect.Effect<void, ShiitakeError>;
+        discard: Effect.Effect<void>;
+    }>, ShiitakeError>;
     /** Each Session's delivered tool grants, read at every call. */
     grants: Readonly<{
         /** Store one versioned delivery; versions only move forward. */

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

@@ -11,6 +11,11 @@ import type { AdmittedExtensionV0 } from "./extension-roster.js";
 export declare const coreConsumer = "core";
 /** Core's generic view of rostered v1 extensions. */
 export type ExtensionRuntime = Readonly<{
+    /** Prepare additions without replacing any live member; apply only between turns. */
+    stage: (admitted: readonly AdmittedExtensionV0[]) => Effect.Effect<Readonly<{
+        apply: Effect.Effect<void, ShiitakeError>;
+        discard: Effect.Effect<void>;
+    }>, ShiitakeError>;
     /** Running extensions that participate in runs, with their fingerprints. */
     runParticipants: () => readonly (readonly [
         ExtensionId,