@fungi.computer/shiitake 0.2.0 → 0.3.0

package/dist/client-wire.d.ts

@@ -1,5 +1,5 @@
 import * as Schema from "effect/Schema";
-import type { Accepted, CancelResult, ForkedSession, SessionFrame, SessionSnapshot, SessionSummaryPage, SessionTerminal } from "./client.js";
+import type { Accepted, CancelResult, WithdrawResult, ForkedSession, SessionFrame, SessionPendingPrompt, SessionSnapshot, SessionSummaryPage, SessionTerminal } from "./client.js";
 import { ShiitakeError } from "./errors.js";
 import type { ExtensionSlotV0, ExtensionStatusV0, Json } from "./extensions.js";
 /** Existing terminal wire grammar, shared by exact host settlement facts. */
@@ -10,7 +10,9 @@ export declare const SessionSnapshotSchema: Schema.Struct<{
     readonly hasMore: Schema.Boolean;
     readonly oldestCursor: Schema.optionalKey<Schema.NullOr<Schema.String>>;
     readonly messages: Schema.$Array<Schema.Codec<Readonly<{
+        requestId?: string;
         meta?: Json;
+        data?: Json;
         origin?: Readonly<{
             extensionId: string;
             correlation: string | null;
@@ -18,9 +20,11 @@ export declare const SessionSnapshotSchema: Schema.Struct<{
         id: string;
         sequence: number;
         commandId: string | null;
-        value: import("@earendil-works/pi-ai").Message;
+        value: import("./client.js").ModelMessage;
     }>, Readonly<{
+        requestId?: string;
         meta?: Json;
+        data?: Json;
         origin?: Readonly<{
             extensionId: string;
             correlation: string | null;
@@ -28,7 +32,7 @@ export declare const SessionSnapshotSchema: Schema.Struct<{
         id: string;
         sequence: number;
         commandId: string | null;
-        value: import("@earendil-works/pi-ai").Message;
+        value: import("./client.js").ModelMessage;
     }>, never, never>>;
     readonly terminals: Schema.$Array<Schema.Codec<Readonly<{
         commandId: string;
@@ -49,7 +53,7 @@ export declare const SessionSnapshotSchema: Schema.Struct<{
         readonly executionId: Schema.String;
         readonly adapter: Schema.String;
         readonly buildSha: Schema.NullOr<Schema.String>;
-        readonly tag: Schema.Literals<readonly ["SourceInvalid", "GuestThrew", "DeadlineExceeded", "Cancelled", "DispatchLost", "SandboxCrashed", "BadResponse", "ResultTooLarge", "ResultNotJson", "CapabilityFailed", "Unknown"]>;
+        readonly tag: Schema.Literals<readonly ["SourceInvalid", "GuestThrew", "DeadlineExceeded", "SandboxBusy", "Cancelled", "DispatchLost", "SandboxCrashed", "BadResponse", "ResultTooLarge", "ResultNotJson", "CapabilityFailed", "Unknown"]>;
         readonly fields: Schema.$Record<Schema.String, Schema.Codec<import("zod").JSONType, import("zod").JSONType, never, never>>;
         readonly healthAlert: Schema.Boolean;
     }>>>;
@@ -73,23 +77,23 @@ export declare const SessionSnapshotSchema: Schema.Struct<{
         sequence: number;
         at: number;
         trigger: import("./client.js").SessionCompactionTrigger;
-        result: "nothing_to_compact" | "failed";
+        result: "nothing_to_compact" | "failed" | "stale" | "insufficient";
         diagnostic: string | null;
     }>, Readonly<{
         id: string;
         sequence: number;
         at: number;
         trigger: import("./client.js").SessionCompactionTrigger;
-        result: "nothing_to_compact" | "failed";
+        result: "nothing_to_compact" | "failed" | "stale" | "insufficient";
         diagnostic: string | null;
     }>, never, never>>>;
     readonly pending: Schema.Codec<Readonly<{
         total: number;
-        prompts: readonly import("./client.js").SessionPendingPrompt[];
+        prompts: readonly SessionPendingPrompt[];
         hasMore: boolean;
     }>, Readonly<{
         total: number;
-        prompts: readonly import("./client.js").SessionPendingPrompt[];
+        prompts: readonly SessionPendingPrompt[];
         hasMore: boolean;
     }>, never, never>;
     readonly activity: Schema.Codec<Readonly<{
@@ -156,6 +160,13 @@ export declare const SessionSnapshotSchema: Schema.Struct<{
         textTruncated: boolean;
         thinkingTruncated: boolean;
     }>, never, never>>;
+    readonly toolOutput: Schema.$Array<Schema.Struct<{
+        readonly toolCallId: Schema.String;
+        readonly revision: Schema.Int;
+        readonly tail: Schema.String;
+        readonly droppedBytes: Schema.Int;
+        readonly totalBytes: Schema.Int;
+    }>>;
     readonly extensions: Schema.$Record<Schema.String, Schema.Codec<ExtensionSlotV0, ExtensionSlotV0, never, never>>;
     readonly attention: Schema.$Array<Schema.Struct<{
         readonly extensionId: Schema.NonEmptyString;
@@ -164,6 +175,7 @@ export declare const SessionSnapshotSchema: Schema.Struct<{
         readonly summary: Schema.NonEmptyString;
         readonly since: Schema.Int;
         readonly expiresAt: Schema.optional<Schema.Int>;
+        readonly inbox: Schema.optional<Schema.Literal<false>>;
     }>>;
     readonly context: Schema.optionalKey<Schema.Struct<{
         readonly tokens: Schema.Int;
@@ -173,6 +185,8 @@ export declare const SessionSnapshotSchema: Schema.Struct<{
 export declare const SessionFrameSchema: Schema.Codec<SessionFrame>;
 /** Decode a durable command acceptance value at an RPC boundary. */
 export declare const AcceptedSchema: Schema.Codec<Accepted>;
+/** Decode the owner's atomic request resolution. */
+export declare function parseWithdrawResult(value: string): WithdrawResult;
 /** Parse one serialized extension status. */
 export declare function parseExtensionStatus(value: string): ExtensionStatusV0;
 /** Parse the serialized list of rostered extension statuses. */
@@ -183,6 +197,8 @@ export declare function parseExtensionOutput(value: string): Json;
 export declare function parseAccepted(value: string): Accepted;
 /** Parse one serialized cancel outcome: accepted, or too late. */
 export declare function parseCancelResult(value: string): CancelResult;
+/** Decode the host-authorized newest pending lookup, including an empty result. */
+export declare function parseLatestPendingPrompt(value: string): SessionPendingPrompt | null;
 /** Parse one serialized fork result using Shiitake's public client grammar. */
 export declare function parseForkedSession(value: string): ForkedSession;
 /** Parse one serialized snapshot using Shiitake's public client grammar. */

package/dist/client-wire.js

@@ -4,10 +4,13 @@ import { SandboxFailureEventSchema } from "@fungi.computer/mycelium";
 import * as Schema from "effect/Schema";
 import { ShiitakeError, ShiitakeErrorWireSchema } from "./errors.js";
 import { JsonValueSchema } from "./internal/json-value.js";
+import { HostMetaSchema } from "./internal/host-meta.js";
 import { StoredPiMessageSchema, ExtensionAdmissionOriginSchema, } from "./internal/woodstock/index.js";
 const ExtensionOriginSchema = ExtensionAdmissionOriginSchema.mapFields(({ extensionId, correlation }) => ({ extensionId, correlation }));
 const SessionMessageSchema = Schema.Struct({
-    meta: Schema.optionalKey(JsonValueSchema),
+    requestId: Schema.optionalKey(Schema.String),
+    meta: Schema.optionalKey(HostMetaSchema),
+    data: Schema.optionalKey(JsonValueSchema),
     origin: Schema.optionalKey(ExtensionOriginSchema),
     id: Schema.String,
     sequence: Schema.Int.check(Schema.isGreaterThan(0)),
@@ -89,7 +92,7 @@ export const SessionTerminalSchema = Schema.Struct({
     ]),
     sequence: Schema.Int.check(Schema.isGreaterThan(0)),
     diagnostic: Schema.NullOr(Schema.String),
-    meta: Schema.optionalKey(JsonValueSchema),
+    meta: Schema.optionalKey(HostMetaSchema),
 });
 const SessionCompactionMarkerSchema = Schema.Struct({
     id: Schema.String,
@@ -104,7 +107,12 @@ const SessionCompactionNoticeSchema = Schema.Struct({
     sequence: Schema.Int.check(Schema.isGreaterThan(0)),
     at: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
     trigger: SessionCompactionTriggerSchema,
-    result: Schema.Literals(["nothing_to_compact", "failed"]),
+    result: Schema.Literals([
+        "nothing_to_compact",
+        "failed",
+        "stale",
+        "insufficient",
+    ]),
     diagnostic: Schema.NullOr(Schema.String),
 });
 const SessionProgressSchema = Schema.Struct({
@@ -115,16 +123,27 @@ const SessionProgressSchema = Schema.Struct({
     textTruncated: Schema.Boolean,
     thinkingTruncated: Schema.Boolean,
 });
+const SessionPendingPromptSchema = Schema.Struct({
+    commandId: Schema.String,
+    requestId: Schema.String,
+    meta: Schema.optionalKey(HostMetaSchema),
+    origin: Schema.optionalKey(ExtensionOriginSchema),
+    text: Schema.String,
+    images: Schema.optionalKey(Schema.Array(PromptImageSchema)),
+    delivery: Schema.Literals(["steer", "followUp"]),
+});
+const SessionToolOutputSchema = Schema.Struct({
+    toolCallId: Schema.String,
+    revision: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    tail: Schema.String.check(Schema.makeFilter((tail) => new TextEncoder().encode(tail).byteLength <= 8192 &&
+        tail.split("\n").length <= 200)),
+    droppedBytes: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    totalBytes: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+});
+const ToolOutputSchema = Schema.Array(SessionToolOutputSchema).check(Schema.isMaxLength(4));
 const SessionPendingPromptsSchema = Schema.Struct({
     total: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-    prompts: Schema.Array(Schema.Struct({
-        commandId: Schema.String,
-        meta: Schema.optionalKey(JsonValueSchema),
-        origin: Schema.optionalKey(ExtensionOriginSchema),
-        text: Schema.String,
-        images: Schema.optionalKey(Schema.Array(PromptImageSchema)),
-        delivery: Schema.Literals(["steer", "followUp"]),
-    })),
+    prompts: Schema.Array(SessionPendingPromptSchema),
     hasMore: Schema.Boolean,
 });
 const SessionContextSchema = Schema.Struct({
@@ -144,11 +163,17 @@ export const SessionSnapshotSchema = Schema.Struct({
     pending: SessionPendingPromptsSchema,
     activity: SessionActivitySchema,
     progress: Schema.NullOr(SessionProgressSchema),
+    toolOutput: ToolOutputSchema,
     extensions: ExtensionSlotsSchema,
     attention: SessionAttentionListSchema,
     context: Schema.optionalKey(SessionContextSchema),
 });
 export const SessionFrameSchema = Schema.Union([
+    Schema.Struct({
+        kind: Schema.Literal("tool_output"),
+        toolOutput: ToolOutputSchema,
+        activity: SessionActivitySchema,
+    }),
     Schema.Struct({
         kind: Schema.Literal("update"),
         delivery: Schema.Literals(["replay", "live"]),
@@ -181,8 +206,21 @@ export const AcceptedSchema = Schema.Struct({
     status: Schema.Literal("accepted"),
     commandId: Schema.String,
 });
+const UnknownRequestSchema = Schema.Struct({
+    status: Schema.Literal("unknown"),
+});
+const WithdrawResultSchema = Schema.Union([
+    AcceptedSchema,
+    UnknownRequestSchema,
+]);
+const decodeWithdrawResult = Schema.decodeUnknownSync(Schema.fromJsonString(WithdrawResultSchema));
+/** Decode the owner's atomic request resolution. */
+export function parseWithdrawResult(value) {
+    return decodeWithdrawResult(value);
+}
 const CancelResultSchema = Schema.Union([
     AcceptedSchema,
+    UnknownRequestSchema,
     Schema.Struct({
         status: Schema.Literal("too_late"),
         commandId: Schema.String,
@@ -220,6 +258,10 @@ export function parseAccepted(value) {
 export function parseCancelResult(value) {
     return decodeCancelResult(value);
 }
+/** Decode the host-authorized newest pending lookup, including an empty result. */
+export function parseLatestPendingPrompt(value) {
+    return Schema.decodeUnknownSync(Schema.fromJsonString(Schema.NullOr(SessionPendingPromptSchema)))(value);
+}
 /** Parse one serialized fork result using Shiitake's public client grammar. */
 export function parseForkedSession(value) {
     return decodeForkedSession(value);

package/dist/client.d.ts

@@ -7,7 +7,7 @@ import type { ExtensionSlotV0, ExtensionStatusV0, Json } from "./extensions.js";
 import type { AbortCommand, BranchCommand, CompactCommand, OperatorCommand, TitleCommand, CancelCommand, ForkCommand, PromptCommand, PromptDelivery, SessionCommand } from "./internal/client-boundary.js";
 export { createShiitakeClient, type ShiitakeClientOptions, } from "./remote-client.js";
 export { bindAgentExtension, bindSessionExtension, type BoundAgentExtensionV0, type BoundCallV0, type BoundSessionExtensionV0, type ExtensionViewV0, type ScopedCommandsV0, } from "./extension-client.js";
-export { AcceptedSchema, parseAccepted, parseCancelResult, parseForkedSession, parseSessionFrame, parseSessionSnapshot, parseSessionSummaryPage, parseShiitakeError, } from "./client-wire.js";
+export { AcceptedSchema, parseAccepted, parseCancelResult, parseLatestPendingPrompt, parseWithdrawResult, parseForkedSession, parseSessionFrame, parseSessionSnapshot, parseSessionSummaryPage, parseShiitakeError, } from "./client-wire.js";
 export type { AbortCommand, BranchCommand, CompactCommand, CancelCommand, ForkCommand, OperatorCommand, PromptCommand, PromptDelivery, SessionCommand, TitleCommand, } from "./internal/client-boundary.js";
 /** Semantic acknowledgement returned after one durable acceptance commit. */
 export type Accepted = Readonly<{
@@ -26,8 +26,14 @@ export type TooLate = Readonly<{
     /** The command the caller tried to cancel. */
     commandId: string;
 }>;
-/** Outcome of one cancel command. */
-export type CancelResult = Accepted | TooLate;
+/** No command has been admitted under this request key in the addressed Session. */
+export type UnknownRequest = Readonly<{
+    status: "unknown";
+}>;
+/** Outcome of one cancel command or request-based recall. */
+export type CancelResult = Accepted | TooLate | UnknownRequest;
+/** Atomic admission resolution: accepted work is kept; an unknown key is fenced forever. */
+export type WithdrawResult = Accepted | UnknownRequest;
 /** Result returned after a fork commits a new cold-readable Session. */
 export type ForkedSession = Readonly<{
     /** Identity of the newly created Session. */
@@ -55,13 +61,26 @@ export type SendOptions = Readonly<{
     /** Private retry key, generated once when omitted; not the admitted command ID. */
     requestId?: string;
 }>;
-/** One exact completed Pi message on the selected Session lineage. */
+/**
+ * Model-facing Pi content. Application tool display payloads belong to the
+ * surrounding entry's `data`, never to a message sent back to a provider.
+ */
+export type ModelMessage = Exclude<Message, {
+    role: "toolResult";
+}> | Omit<Extract<Message, {
+    role: "toolResult";
+}>, "details">;
+/** One completed model message and its separate application payload. */
 export type SessionMessage = Readonly<{
+    /** Caller identity of a prompt or operator line; absent on generated messages. */
+    requestId?: string;
     /**
      * Opaque metadata the in-process host attached; Shiitake never reads it.
      * Decode it with the host's own schema.
      */
     meta?: Json;
+    /** Opaque application display payload, independent of host metadata. */
+    data?: Json;
     /** Durable extension producer of this user message; absent for human prompts. */
     origin?: Readonly<{
         extensionId: string;
@@ -73,8 +92,8 @@ export type SessionMessage = Readonly<{
     sequence: number;
     /** Owner-issued accepted work correlation for this message, otherwise null. */
     commandId: string | null;
-    /** Exact Pi message; Shiitake does not normalize provider replay metadata. */
-    value: Message;
+    /** Model content; provider replay metadata remains unchanged. */
+    value: ModelMessage;
 }>;
 /** Minimal constructor seam for runtimes without a global EventSource. */
 export type ShiitakeEventSourceConstructor = new (url: string) => Pick<EventTarget, "addEventListener"> & Pick<EventSource, "close"> & {
@@ -166,6 +185,14 @@ export type AgentExtensionControls = Readonly<{
     /** Call one Agent-scope command with its encoded input; resolves the encoded output. */
     call: (extensionId: string, command: string, input: Json) => Promise<Json>;
 }>;
+/** Process-local running tool tail; never a durable Session fact. */
+export type SessionToolOutput = Readonly<{
+    toolCallId: string;
+    revision: number;
+    tail: string;
+    droppedBytes: number;
+    totalBytes: number;
+}>;
 /** Process-local assistant progress; never a durable Session fact. */
 export type SessionProgress = Readonly<{
     /** Stable message identity shared with the eventual completed Pi message. */
@@ -178,6 +205,8 @@ export type SessionProgress = Readonly<{
 }>;
 /** Accepted prompt waiting to enter the conversation, not a scheduling command. */
 export type SessionPendingPrompt = Readonly<{
+    /** Caller identity, available even before the command response reaches its client. */
+    requestId: string;
     /** Host-admitted metadata, retained opaquely before execution. */
     meta?: SessionMessage["meta"];
     /** Durable extension producer, absent for human prompts. */
@@ -220,8 +249,11 @@ export type SessionCompactionMarker = Readonly<{
 export type SessionCompactionTrigger = "manual" | "threshold" | "overflow";
 /**
  * A compaction that changed nothing: a manual request with nothing to
- * summarize yet, or a compaction that failed. Automatic failures are never
- * silent; each one is a notice at its own place in the timeline.
+ * summarize yet, a compaction that failed, or a finished background summary
+ * dropped unplaced: stale because the context had moved past its head, or
+ * insufficient because placing it would have left the context over the
+ * limit. Automatic failures are never silent; each one is a notice at its own
+ * place in the timeline.
  */
 export type SessionCompactionNotice = Readonly<{
     /** Stable identity of the durable notice entry. */
@@ -231,8 +263,8 @@ export type SessionCompactionNotice = Readonly<{
     /** When it was recorded, in milliseconds since the epoch. */
     at: number;
     trigger: SessionCompactionTrigger;
-    result: "nothing_to_compact" | "failed";
-    /** A failure's bounded reason; null for "nothing to compact". */
+    result: "nothing_to_compact" | "failed" | "stale" | "insufficient";
+    /** A failure's bounded reason; null for the other results. */
     diagnostic: string | null;
 }>;
 /**
@@ -273,6 +305,8 @@ export type SessionSnapshot = Readonly<{
     activity: SessionActivity;
     /** Latest replaceable progress snapshot, if an assistant message is live. */
     progress: SessionProgress | null;
+    /** Current bounded tool tails. Empty outside this process's running work. */
+    toolOutput: readonly SessionToolOutput[];
     /** Encoded projection slot of each extension granted one. */
     extensions: SessionExtensionSlots;
     /** Open requests for human attention from extensions. */
@@ -282,6 +316,10 @@ export type SessionSnapshot = Readonly<{
 }>;
 /** One bounded replay or live frame. */
 export type SessionFrame = Readonly<{
+    kind: "tool_output";
+    toolOutput: readonly SessionToolOutput[];
+    activity: SessionActivity;
+}> | Readonly<{
     /** Bounded Session-projection update discriminator. */
     kind: "update";
     /** Whether replay or a post-commit hint discovered the update. */
@@ -356,10 +394,15 @@ export type SessionWatch = Readonly<{
 }>;
 /** Addressable Session interface. Addressing itself performs no I/O. */
 export type ShiitakeSession = Readonly<{
-    /** Stable logical address used to share observation across client mounts. */
+    /**
+     * Address used to share observation across current client mounts.
+     * Remote addresses include the transport endpoint, not durable owner identity.
+     */
     address: string;
     /** Execute one retained type-discriminated Session command. */
     command: SessionCommandHandler;
+    /** Resolve a stalled request atomically; withdrawn keys can never be admitted later. */
+    withdraw: (requestId: string) => Promise<WithdrawResult>;
     /** Cancel the running turn and all queued prompts, retaining their text. */
     abort: () => Promise<void>;
     /** Send text with an optional private caller idempotency identity. */
@@ -369,6 +412,8 @@ export type ShiitakeSession = Readonly<{
         commandId: string;
         onlyIfPending?: boolean;
     }>) => Promise<CancelResult>;
+    /** Newest pending prompt in this host-authorized identity, never an oldest-page guess. */
+    latestPending: () => Promise<SessionPendingPrompt | null>;
     /** Address one rostered extension's Session-scope commands. */
     extension: (extensionId: string) => SessionExtensionControls;
     /** Lineage-local request for later runs; null inherits the Agent default. */

package/dist/client.js

@@ -1,4 +1,4 @@
 export {} from "./session-attention.js";
 export { createShiitakeClient, } from "./remote-client.js";
 export { bindAgentExtension, bindSessionExtension, } from "./extension-client.js";
-export { AcceptedSchema, parseAccepted, parseCancelResult, parseForkedSession, parseSessionFrame, parseSessionSnapshot, parseSessionSummaryPage, parseShiitakeError, } from "./client-wire.js";
+export { AcceptedSchema, parseAccepted, parseCancelResult, parseLatestPendingPrompt, parseWithdrawResult, parseForkedSession, parseSessionFrame, parseSessionSnapshot, parseSessionSummaryPage, parseShiitakeError, } from "./client-wire.js";

package/dist/cloudflare.d.ts

@@ -3,6 +3,7 @@ import type { BirdDogMail } from "@fungi.computer/bird-dog";
 import type { VerifiedAgentReply } from "./internal/woodstock/index.js";
 import type { BirdDogEffect } from "@fungi.computer/bird-dog/effect";
 import type { Accepted } from "./client.js";
+import type { ColdSessionPage, ColdSessionPageRequest } from "./cold-sessions.js";
 import type { HostMetaOptions } from "./internal/host-meta.js";
 import { DurableObject } from "cloudflare:workers";
 import type { CapabilitySource, ModuleRegistration, Sandbox } from "@fungi.computer/mycelium";
@@ -10,11 +11,10 @@ import { type WatchdogExecutionDecision, type WatchdogReadResult, type WatchdogR
 import type { ExtensionRosterV0, Json } from "./extensions.js";
 import { type ShiitakeHttpEnv } from "./http-routes.js";
 import { Hono } from "hono";
-import type { InstructionSource, ModelSource, GrantsDelivery, GrantsDeliveryResult, ShiitakeOwnerAgent, SqliteOwner, StorageBudget, CompactionOptions, ToolAccess } from "./internal/contracts.js";
+import type { InstructionSource, ModelSource, GrantsDelivery, GrantsDeliveryResult, ShiitakeOwnerAgent, SqliteOwner, StoragePressureCheck, CompactionOptions, ToolAccess } from "./internal/contracts.js";
 import { type SessionInboxChanges } from "./internal/woodstock/index.js";
-import { type BrowserHost } from "./internal/browser-sessions.js";
 export type { SessionInboxChanges } from "./internal/woodstock/index.js";
-export type { BrowserHost } from "./internal/browser-sessions.js";
+export type { ColdSessionPage, ColdSessionPageRequest, ColdSessionRow, } from "./cold-sessions.js";
 export type { GrantsDelivery, GrantsDeliveryResult, ShiitakeOwnerAgent, ToolAccess, } from "./internal/contracts.js";
 /**
  * Deliver one Session's grants into a Cloudflare owner's own storage,
@@ -33,6 +33,11 @@ export type CloudflareShiitakeState = Readonly<{
     };
     /** Extend the Durable Object event lifetime through runtime reconciliation. */
     waitUntil: (task: Promise<unknown>) => void;
+    /** The Durable Object's identity, named when its store refuses a Session. */
+    id?: Readonly<{
+        /** The identity as text, used to name the store in refusals. */
+        toString: () => string;
+    }>;
 }>;
 /** Non-empty Mycelium capabilities supplied by a Cloudflare host. */
 export type CloudflareShiitakeTools = Readonly<{
@@ -93,10 +98,10 @@ export type CloudflareShiitakeOptions = Readonly<{
     instructions: InstructionSource;
     tools?: readonly [] | CloudflareShiitakeTools;
     /**
-     * Disk budget for this Durable Object's SQLite, measured with
-     * `ctx.storage.sql.databaseSize`; absent never refuses for storage pressure.
+     * The host's storage-pressure check for this Durable Object; absent never
+     * refuses for storage pressure. The budget and thresholds are the host's.
      */
-    storageBudget?: StorageBudget;
+    storagePressure?: StoragePressureCheck;
     /** Compaction budgets; absent uses Pi's defaults for every model. */
     compaction?: CompactionOptions;
     /** The host's explicit extension roster and grants; there is no default. */
@@ -112,8 +117,6 @@ export type CloudflareShiitakeOptions = Readonly<{
     hostJobs?: CloudflareHostJobs;
     /** Host-owned addressed mail and settlement replies; absent disables mail. */
     mailRoom?: BirdDogEffect;
-    /** Session-scoped browser tools and maintained HTTP transport; absent disables it. */
-    browser?: (sessionId: string) => BrowserHost;
     /**
      * Lazily open ACP over the owned in-process handle. The host authorizes
      * ingress and supplies its context policy. ACP borrows this handle: closing
@@ -133,33 +136,33 @@ export type CloudflareShiitake = ShiitakeOwnerAgent & Readonly<{
     acceptMail: (mail: BirdDogMail, meta?: Json, reply?: VerifiedAgentReply) => Promise<Accepted>;
     /** Deliver the native owner alarm to the bound runtime. */
     alarm: () => Promise<void>;
-    /** Snapshot actual live executors, independent of instruction or browser leases. */
+    /** Snapshot actual live executors, independent of instruction leases. */
     activeSessions: () => Promise<readonly string[]>;
     /** Abort each currently executing Session through its ordinary cancellation door. */
     abortActive: () => Promise<void>;
-    /** Session-scoped browser transport and teardown, owned by this host. */
-    browser: Readonly<{
-        /** Serve a Session browser request after host ingress authorization. */
-        fetch: (request: Request) => Promise<Response>;
-        /** Cancel browser connections and release the current ephemeral hosts. */
-        clear: () => Promise<void>;
-    }>;
 }>;
-/** Construct Shiitake over one Durable Object's SQLite and lifetime. */
-export declare function makeCloudflareShiitake(state: CloudflareShiitakeState, options: CloudflareShiitakeOptions): Promise<CloudflareShiitake>;
+/**
+ * Open Shiitake over one Durable Object's storage. It resolves once the runtime
+ * is started and `initialize` has run; if `initialize` throws, the runtime is
+ * closed and the error is rethrown.
+ */
+export declare function makeCloudflareShiitake(unnamed: CloudflareShiitakeState, options: CloudflareShiitakeOptions): Promise<CloudflareShiitake>;
 /** Owns runtime opening, HTTP/ACP transport, inbox observation and alarm recovery. */
 export declare abstract class ShiitakeOwner<Env, State extends CloudflareShiitakeState = CloudflareShiitakeState> {
+    #private;
     protected readonly ctx: State;
     protected readonly env: Env;
     constructor(ctx: State, env: Env);
     private agentPromise;
     private openAcp;
+    /** This owner's state, its storage named once for Woodstock's refusals. */
+    private get named();
     private acpServer;
     /** Consecutive native alarm failures; reset on the next successful alarm. */
     private alarmFailures;
     private readonly routes;
     /** Supply this agent's model, instructions, and optional capabilities. */
-    protected abstract shiitakeOptions(): CloudflareShiitakeOptions;
+    protected abstract shiitakeOptions(): CloudflareShiitakeOptions | Promise<CloudflareShiitakeOptions>;
     /** Borrow this owner's runtime directly; only the host owns its lifetime. */
     shiitake(): Promise<CloudflareShiitake>;
     /** Stop live execution without constructing a cold owner's runtime. */
@@ -167,9 +170,15 @@ export declare abstract class ShiitakeOwner<Env, State extends CloudflareShiitak
     /** Close owned resources before storage erasure; a cold owner has none. */
     closeShiitake(): Promise<void>;
     /** Indexed owner-local existence check; corrupt stored Sessions remain unavailable. */
-    protected hasStoredSession(sessionId: string): Promise<boolean>;
+    hasStoredSession(sessionId: string): Promise<boolean>;
     /** Bounded strict-after read of this Agent's changed inbox rows. */
     readInboxChanges(after: number, limit: number): Promise<SessionInboxChanges>;
+    /**
+     * One bounded, read-only page of Sessions with stored bytes, last activity
+     * and an idle flag, coldest first. The store keeper's only view of cold
+     * Sessions; it carries no SQL, transaction or write.
+     */
+    readColdSessions(request: ColdSessionPageRequest): Promise<ColdSessionPage>;
     /** Latest inbox revision; read only after the owner has opened. */
     readInboxRevision(): number;
     /** Prune deletion deltas after every current member inbox has acknowledged them. */
@@ -186,7 +195,7 @@ export declare abstract class ShiitakeOwner<Env, State extends CloudflareShiitak
     /** Serve Shiitake's complete transport without subclass routing. */
     private app;
     /**
-     * Shiitake's whole HTTP surface (Session routes, browser and ACP) as one
+     * Shiitake's whole HTTP surface (Session routes and ACP) as one
      * Hono app. A host mounts it behind its own middleware, which alone may
      * set the `shiitakeMeta` variable.
      */
@@ -197,11 +206,12 @@ export declare abstract class ShiitakeOwner<Env, State extends CloudflareShiitak
 /** Native Cloudflare entry points; all runtime lifetime belongs to the owner. */
 export declare abstract class ShiitakeDO<Env> extends DurableObject<Env> {
     #private;
-    protected abstract shiitakeOptions(): CloudflareShiitakeOptions;
+    protected abstract shiitakeOptions(): CloudflareShiitakeOptions | Promise<CloudflareShiitakeOptions>;
     protected runtimeOwner(): ShiitakeOwner<Env>;
     protected shiitake(): Promise<CloudflareShiitake>;
     protected abortActiveSessions(): Promise<void>;
     protected closeShiitake(): Promise<void>;
+    protected hasStoredSession(sessionId: string): Promise<boolean>;
     protected readInboxChanges(after: number, limit: number): Promise<Readonly<{
         rows: readonly (import("./client.js").SessionSummaryRow | Readonly<{
             sessionId: string;
@@ -211,10 +221,19 @@ export declare abstract class ShiitakeDO<Env> extends DurableObject<Env> {
         latest: number;
     }>>;
     protected readInboxRevision(): number;
+    protected readColdSessions(request: ColdSessionPageRequest): Promise<Readonly<{
+        sessions: readonly import("./cold-sessions.js").ColdSessionRow[];
+        next?: string;
+    }>>;
     protected pruneInboxTombstones(through: number): void;
     protected wakeRuntime(): Promise<void>;
     /** Reconcile due runtime and host work through the owner. */
     alarm(): Promise<void>;
-    /** Route an authenticated client request through the owner. */
+    /**
+     * The host's own routes, in front of Shiitake's: return a response to answer
+     * the request, or undefined to let Shiitake serve it. Absent means none.
+     */
+    protected hostFetch?(request: Request): Promise<Response> | undefined;
+    /** Route an authenticated client request through the host's routes, then the owner. */
     fetch(request: Request): Promise<Response>;
 }