@fungi.computer/shiitake 0.6.0 → 0.8.0

package/README.md

@@ -55,10 +55,12 @@ without waiting for the command response or matching text.
 npm install @fungi.computer/shiitake
 ```
 
-The package ships ESM only and depends on Effect, Zod, and Hono, plus the Fungi
-packages [Cairn](../cairn/README.md), [Mule](../mule/README.md),
+The package ships ESM only. Its runtime dependencies include Effect, Zod, Pi and
+the Fungi packages [Cairn](../cairn/README.md), [Mule](../mule/README.md),
 [Mycelium](../mycelium/README.md), [Watchdog](../watchdog/README.md),
-[Bird Dog](../bird-dog/README.md) and Knapsack, all installed automatically.
+[Bird Dog](../bird-dog/README.md) and Knapsack. See the [manifest](package.json)
+for the complete list. Hono `^4.13.5` is a peer dependency for the HTTP
+adapters.
 
 `Shiitake.make(options)` is the Promise constructor. The Effect 4 constructor is
 `make` from `@fungi.computer/shiitake/effect`. Both use the same owner. The host
@@ -134,6 +136,17 @@ a Session performs no I/O. A client uses `createShiitakeClient` from the
 `/client` entry with the host's authorized transport. Releasing that client does
 not cancel host work.
 
+Live `progress` frames carry `SessionProgressDelta`: independent text and
+thinking `{ offset, append }` values, with offsets in UTF-16 string units.
+`appendSessionProgress` from `/client` folds appends idempotently; a gap waits
+for the owner's reset. A read/watch/reset baseline carries only the latest 64
+KiB per channel, its start offsets, and accurate truncation flags. A watch
+continues after that tail; the eventual durable message is always complete.
+Progress stays process-local, in bounded chunks, and never writes SQLite. Tiny
+provider deltas are coalesced (first append immediately, then each 4,096 string
+units or within 100 ms); durable completion carries any remaining partial chunk.
+Tool tails travel only in `tool_output`, not in message progress.
+
 `session.readSettlement(commandId, { timeoutMs, signal })` returns that exact
 command's `CommandSettlement` (terminal, answer, usage and tool-call count),
 independent of the selected transcript branch. `timeoutMs` defaults to zero and
@@ -354,24 +367,31 @@ The `/agent-control` source exposes
 `agents.setModel({agentId, model, reasoning?})` and `agents.models({})` when its
 host authorizes those operations. `name` labels the new Agent and `reasoning`
 (`minimal` to `max`, one of `modelReasoningLevels`) needs a `model`.
-`agents.create` returns the Agent's `name`, the requested `model` and
-`reasoning` (the stored default; absent when it inherits), and the
-`workingDirectory` its tools use; `agents.list` reports the same facts for
-existing Agents. A host that can archive also accepts `archived: true` there to
-list only the archived ones (other hosts refuse that input). A host can offer
-`agents.archive({agentId})` and `agents.unarchive`: an Agent archiving an Agent
-it created hides it from lists and delegation without deleting anything, and the
-host refuses any other target, the caller itself, or an Agent with a running
-command or delegated work still waiting. Each refusal, and a send to an archived
-Agent, reaches the caller as a `CapabilityFailed` diagnostic such as
-`archive:not_creator: …`, `archive:self`, `archive:running`, `archive:pending`,
-`archive:unreadable` (its store predates the schema) or `archive:archived`.
-`agents.wait` accepts `timeoutMs` from 1 to 30000. Models use `provider/model`
-spelling and must be offered by that host; `agents.models` returns at most 200
-offered addresses from signed-in or configured providers. A host model refusal
-reaches the caller as a `CapabilityFailed` diagnostic such as
-`model:rejected: …`, while other failures propagate unchanged. The
-`/model-preference` resolver orders explicit Session, explicit Agent, the
+`agents.create` creates the Agent and its first Session through the same
+idempotent Session-creation door as `agents.createSession`. It returns `agentId`
+and a usable `sessionId`: send work immediately with `agents.send` and
+`delivery: "steer"`, without a separate `createSession` call. Retrying the same
+creation request reuses that first Session.
+
+It also returns the Agent's `name`, the requested `model` and `reasoning` (the
+stored default; absent when it inherits), and the `workingDirectory` its tools
+use; `agents.list` reports the same facts for existing Agents. A host that can
+archive also accepts `archived: true` there to list only the archived ones
+(other hosts refuse that input). A host can offer `agents.archive({agentId})`
+and `agents.unarchive`: an Agent archiving an Agent it created hides it from
+lists and delegation without deleting anything, and the host refuses any other
+target, the caller itself, or an Agent with a running command or delegated work
+still waiting. Each refusal, and a send to an archived Agent, reaches the caller
+as a `CapabilityFailed` diagnostic such as `archive:not_creator: …`,
+`archive:self`, `archive:running`, `archive:pending`, `archive:unreadable` (its
+store predates the schema) or `archive:archived`. `agents.wait` accepts
+`timeoutMs` from 1 to 30000. Models use `provider/model` spelling and must be
+offered by that host; `agents.models` returns at most 200 offered addresses from
+signed-in or configured providers. A host model refusal reaches the caller as a
+`CapabilityFailed` diagnostic such as `model:rejected: …` with up to ten
+addresses from the host's offered catalog. If catalog diagnostics are
+unavailable, the original refusal remains; other failures propagate unchanged.
+The `/model-preference` resolver orders explicit Session, explicit Agent, the
 person's last manual switch, Team default, then available login. Hosts own those
 stored layers and credential admission: choosing a model never bypasses an
 owner's Team or Agent key-source restriction. A host can refuse an unrunnable
@@ -402,6 +422,24 @@ a host-supplied fetch.
 interrupted tools against the existing replay rules. They are local proofs, not
 a guarantee about another deployment's storage or sandbox.
 
+## Breaking live-progress API
+
+The S4 offset/append contract replaces cumulative progress frames:
+
+- `progress` frames carry `SessionProgressDelta`, with separate text and
+  thinking `{ offset, append }` channels. Offsets count UTF-16 code units.
+- `SessionProgress` is the bounded snapshot shape and now requires `textOffset`
+  and `thinkingOffset`, alongside its truncation flags.
+- `appendSessionProgress(current, delta)` is the new shared fold for progress
+  frames. Seed it from the **same watch's `snapshot.progress`**, replace it on a
+  reset, and retain it across unrelated updates until the message completes or
+  the queue becomes idle. A separate earlier `read()` is not a watch baseline.
+- The visitor stream sends live `activity` frames as well as `progress` frames.
+  An activity frame updates activity facts; it is not a replacement snapshot.
+
+All producers and consumers must use this contract together. There is no
+cumulative-frame compatibility format.
+
 ## Client entries
 
 A host selects client entries separately from its durable extension roster.

package/dist/agent-control.d.ts

@@ -127,7 +127,7 @@ export type AgentDelegationInput = Readonly<{
     sessionId: string;
     delivery: "steer";
 }> | Readonly<{
-    /** Omitted for an Agent whose first Session is created on acceptance. */
+    /** Omitted to open a new Session when the recipient accepts. */
     sessionId?: string;
     delivery: "followUp";
     /**

package/dist/agent-control.js

@@ -1,6 +1,7 @@
 import { CapabilityFailed, Mycelium, } from "@fungi.computer/mycelium";
 import { z } from "zod";
 import { ShiitakeError } from "./errors.js";
+import { reportCatchFailure } from "./internal/failure.js";
 import { AGENT_REPLY_TAG } from "./internal/woodstock/index.js";
 import { modelReasoningLevels, parseModelAddress, } from "./model-preference.js";
 const id = z.string().min(1).max(256);
@@ -149,6 +150,7 @@ const agentOutput = z.strictObject({
     workingDirectory: z.string().min(1).max(4096).exactOptional(),
 });
 const agentsOutput = z.array(agentOutput);
+const createdAgentOutput = agentOutput.extend({ sessionId: id });
 const offeredModelLimit = 200;
 const modelsOutput = z.strictObject({
     models: z
@@ -340,21 +342,32 @@ export class AgentCreateRefused extends Error {
     }
 }
 /** Admit the host's model refusal as a typed capability failure; rethrow anything else. */
-function admitModelRefusal(operation, cause) {
-    if (cause instanceof ShiitakeError && cause.boundary === "model")
-        throw new CapabilityFailed({
-            namespace: "agents",
-            operation,
-            cause: {
-                kind: "OperationFailed",
-                message: `model:${cause.cause}: ${cause.message}`,
-            },
-            rawCause: cause,
-        });
-    throw cause;
+async function admitModelRefusal(operation, cause, models, signal) {
+    if (!(cause instanceof ShiitakeError && cause.boundary === "model"))
+        throw cause;
+    let offered = [];
+    try {
+        offered = (await models?.(signal)) ?? [];
+    }
+    catch (catalogFailure) {
+        // Catalog diagnostics must not replace the original model refusal.
+        signal.throwIfAborted();
+        reportCatchFailure("agent-control.model-catalog", catalogFailure);
+    }
+    const addresses = offered.slice(0, 10).map((model) => model.address);
+    const suffix = addresses.length === 0 ? "" : ` Offered: ${addresses.join(", ")}.`;
+    throw new CapabilityFailed({
+        namespace: "agents",
+        operation,
+        cause: {
+            kind: "OperationFailed",
+            message: `model:${cause.cause}: ${cause.message}${suffix}`,
+        },
+        rawCause: cause,
+    });
 }
 /** Admit a creation refusal or a model refusal as a typed failure; rethrow anything else. */
-function admitCreateFailure(cause) {
+function admitCreateFailure(cause, models, signal) {
     if (cause instanceof AgentCreateRefused)
         throw new CapabilityFailed({
             namespace: "agents",
@@ -365,10 +378,11 @@ function admitCreateFailure(cause) {
             },
             rawCause: cause,
         });
-    return admitModelRefusal("create", cause);
+    return admitModelRefusal("create", cause, models, signal);
 }
 /** Compose one authorized Agent-control projection for a single run lease. */
 export function createAgentControlSource(directory) {
+    const createSession = (operation, agentId, requestId, signal) => withAgent(directory, operation, agentId, signal, (agent) => agent.createSession(requestId));
     const create = directory.create;
     const send = directory.send;
     const recall = directory.recall;
@@ -378,9 +392,9 @@ export function createAgentControlSource(directory) {
         ? undefined
         : Mycelium.operation({
             replay: "unsafe",
-            description: "Create one ordinary Agent (a subagent to spawn work on) in the current authorized scope, optionally with a display name, a host-offered provider/model from agents.models, and a thinking level (reasoning: minimal, low, medium, high, xhigh or max; needs model). The new Agent works in the project directory this host runs in; the result returns that workingDirectory, the name, and the model and reasoning requested for it (the stored default, absent when it inherits). Then send it work with agents.send and collect the reply with agents.wait. Reuse requestId when retrying the same creation. A model the host does not offer fails with model:rejected. An Agent creating an Agent starts the new Agent with the base roster only; it can pass extensions, a list of extension ids it holds itself, to enable on the new Agent. Asking for one it does not hold fails with create:exceeds_creator and creates nothing.",
+            description: "Create one ordinary Agent (a subagent to spawn work on) and its first Session in the current authorized scope. Returns agentId and a usable sessionId: immediately agents.send with delivery: steer, then collect the reply with agents.wait; no separate createSession is needed. Reuse requestId when retrying the same creation and first Session. Optional name labels the Agent; model is a host-offered provider/model from agents.models; reasoning (minimal, low, medium, high, xhigh or max) needs model. The result also returns name, workingDirectory (the host's project directory), and the requested model/reasoning default, absent when inherited. An unoffered model fails with model:rejected and up to ten offered addresses. A new Agent starts with the base roster; extensions may enable only extension ids the creating Agent holds. An unheld extension fails with create:exceeds_creator and creates nothing.",
             input: createInput,
-            output: agentOutput,
+            output: createdAgentOutput,
             execute: async ({ requestId, name, model, reasoning, extensions }, context) => {
                 let request = { requestId };
                 if (name !== undefined)
@@ -394,7 +408,12 @@ export function createAgentControlSource(directory) {
                         model: reasoning === undefined ? address : { ...address, reasoning },
                     };
                 }
-                return agentOutput.parse(agentAnswer(await create(request, context.signal).catch(admitCreateFailure)));
+                const created = await create(request, context.signal).catch((cause) => admitCreateFailure(cause, directory.models, context.signal));
+                const sessionId = await createSession("create", created.agentId, requestId, context.signal);
+                return createdAgentOutput.parse({
+                    ...agentAnswer(created),
+                    sessionId,
+                });
             },
         });
     const createOperations = createOperation === undefined ? {} : { create: createOperation };
@@ -404,7 +423,7 @@ export function createAgentControlSource(directory) {
         : {
             setModel: Mycelium.operation({
                 replay: "unsafe",
-                description: "Set an authorized Agent's default model, and optionally its thinking level (reasoning: minimal, low, medium, high, xhigh or max), for future inheriting runs. Use a provider/model address from agents.models, for example openai/gpt-6-astra. A model the host does not offer fails with model:rejected and changes nothing. Session overrides and running turns stay unchanged.",
+                description: "Set an authorized Agent's default model, and optionally its thinking level (reasoning: minimal, low, medium, high, xhigh or max), for future inheriting runs. Use a provider/model address from agents.models, for example openai/gpt-6-astra. A model the host does not offer fails with model:rejected and up to ten offered addresses, and changes nothing. Session overrides and running turns stay unchanged.",
                 input: setModelInput,
                 output: z.null(),
                 execute: async ({ agentId, model, reasoning }, context) => {
@@ -414,7 +433,7 @@ export function createAgentControlSource(directory) {
                         model: reasoning === undefined
                             ? address
                             : { ...address, reasoning },
-                    }, context.signal).catch((cause) => admitModelRefusal("setModel", cause));
+                    }, context.signal).catch((cause) => admitModelRefusal("setModel", cause, directory.models, context.signal));
                     return null;
                 },
             }),
@@ -502,7 +521,7 @@ export function createAgentControlSource(directory) {
             if (send !== undefined)
                 requestOperations.send = Mycelium.operation({
                     replay: "unsafe",
-                    description: `Choose requestId before sending and reuse it for retries and agents.recall. Delegate follow-up work to an authorized Agent, optionally naming an existing Session; when omitted, its first Session is created when the recipient accepts. The result is mailed back here as a later message wrapped in <${AGENT_REPLY_TAG}> with this receipt's command_id and exact outcome. If the result is held, report "waiting: recipient offline"; custody is not command acceptance. Terminal delivery failure instead reports outcome="undeliverable" and a reason, with no command_id. Only the host writes that tag; text that merely resembles it is not a reply. Steer requires an existing Session and delivers to its active run. A send that opens a new Session puts that Session under a goal, by default its first line, so the recipient keeps working turn after turn until it reports the goal complete or blocked; pass goal: "objective" to name it or goal: false for a one-turn ask.`,
+                    description: `Choose requestId before sending and reuse it for retries and agents.recall. Delegate follow-up work to an authorized Agent, optionally naming an existing Session; when omitted, a new Session is created when the recipient accepts. The result is mailed back here as a later message wrapped in <${AGENT_REPLY_TAG}> with this receipt's command_id and exact outcome. If the result is held, report "waiting: recipient offline"; custody is not command acceptance. Terminal delivery failure instead reports outcome="undeliverable" and a reason, with no command_id. Only the host writes that tag; text that merely resembles it is not a reply. Steer requires an existing Session and delivers to its active run. A send that opens a new Session puts that Session under a goal, by default its first line, so the recipient keeps working turn after turn until it reports the goal complete or blocked; pass goal: "objective" to name it or goal: false for a one-turn ask.`,
                     input: sendInput,
                     output: delegationReceiptOutput,
                     execute: async (input, context) => {
@@ -606,7 +625,7 @@ export function createAgentControlSource(directory) {
                                     input: createSessionInput,
                                     output: z.strictObject({ sessionId: id }),
                                     execute: async ({ agentId, requestId }, context) => ({
-                                        sessionId: await withAgent(directory, "createSession", agentId, context.signal, (agent) => agent.createSession(requestId)),
+                                        sessionId: await createSession("createSession", agentId, requestId, context.signal),
                                     }),
                                 }),
                                 sessions: Mycelium.operation({

package/dist/client-visitor.d.ts

@@ -21,6 +21,8 @@ export type VisitorView = Readonly<{
     }>[];
     progress: string | null;
 }>;
+/** One visitor-visible line without internal attribution or tool metadata. */
+export type VisitorLine = VisitorView["lines"][number];
 /** Public pending facts exclude the host's private metadata and admission origin. */
 export type VisitorPendingPrompt = Pick<SessionPendingPrompt, "commandId" | "requestId" | "text" | "delivery" | "images">;
 /** Project one owner-selected prompt without exposing host identity or correlation metadata. */

package/dist/client-visitor.js

@@ -172,7 +172,12 @@ export function visitorSnapshot(snapshot, visitorId) {
         toolOutput: [],
         progress: !ownWork || snapshot.progress === null
             ? null
-            : { ...snapshot.progress, thinking: "", thinkingTruncated: false },
+            : {
+                ...snapshot.progress,
+                thinking: "",
+                thinkingOffset: 0,
+                thinkingTruncated: false,
+            },
         extensions: {},
         attention: [],
     };

package/dist/client-wire.d.ts

@@ -149,6 +149,8 @@ export declare const SessionSnapshotSchema: Schema.Struct<{
         revision: number;
         text: string;
         thinking: string;
+        textOffset: number;
+        thinkingOffset: number;
         textTruncated: boolean;
         thinkingTruncated: boolean;
     }>, Readonly<{
@@ -156,6 +158,8 @@ export declare const SessionSnapshotSchema: Schema.Struct<{
         revision: number;
         text: string;
         thinking: string;
+        textOffset: number;
+        thinkingOffset: number;
         textTruncated: boolean;
         thinkingTruncated: boolean;
     }>, never, never>>;

package/dist/client-wire.js

@@ -28,18 +28,15 @@ const SessionActivitySchema = Schema.Struct({
         Schema.Struct({
             state: Schema.Literal("queued"),
             commandId: Schema.NonEmptyString,
-            runningWork: Schema.NullOr(Schema.Union([
-                Schema.Struct({
-                    kind: Schema.Literal("session"),
-                    sessionId: Schema.NonEmptyString,
-                    commandId: Schema.NonEmptyString,
-                }),
-                Schema.Struct({
-                    kind: Schema.Literal("host"),
-                    lane: Schema.NonEmptyString,
-                    jobId: Schema.NonEmptyString,
-                }),
-            ])),
+            runningWork: Schema.NullOr(Schema.Struct({
+                phase: Schema.Literals([
+                    "thinking",
+                    "streaming",
+                    "running_tool",
+                    "waiting_on_you",
+                    "cancelling",
+                ]),
+            })),
         }),
         Schema.Struct({
             state: Schema.Literal("running"),
@@ -110,11 +107,14 @@ const SessionCompactionNoticeSchema = Schema.Struct({
     ]),
     diagnostic: Schema.NullOr(Schema.String),
 });
+const ProgressTailSchema = Schema.String.check(Schema.makeFilter((value) => new TextEncoder().encode(value).byteLength <= 65_536));
 const SessionProgressSchema = Schema.Struct({
     messageId: Schema.String,
     revision: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-    text: Schema.String,
-    thinking: Schema.String,
+    text: ProgressTailSchema,
+    thinking: ProgressTailSchema,
+    textOffset: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    thinkingOffset: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
     textTruncated: Schema.Boolean,
     thinkingTruncated: Schema.Boolean,
 });
@@ -190,7 +190,18 @@ export const SessionFrameSchema = Schema.Union([
     }),
     Schema.Struct({
         kind: Schema.Literal("progress"),
-        progress: SessionProgressSchema,
+        progress: Schema.Struct({
+            messageId: Schema.String,
+            revision: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+            text: Schema.Struct({
+                offset: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+                append: ProgressTailSchema,
+            }),
+            thinking: Schema.Struct({
+                offset: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+                append: ProgressTailSchema,
+            }),
+        }),
         activity: SessionActivitySchema,
     }),
     Schema.Struct({

package/dist/client.d.ts

@@ -11,7 +11,7 @@ export { createShiitakeClient, type ShiitakeClientOptions, } from "./remote-clie
 export { bindAgentExtension, bindSessionExtension, type BoundAgentExtensionV0, type BoundCallV0, type BoundSessionExtensionV0, type ExtensionViewV0, type ScopedCommandsV0, } from "./extension-client.js";
 export { AcceptedSchema, DelegationReceiptSchema, HeldSchema, parseAccepted, parseDelegationReceipt, 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";
-export { participantSnapshot, visitorPendingPrompt, visitorSnapshot, visitorView, type ParticipantPolicy, type VisitorPendingPrompt, type VisitorView, } from "./client-visitor.js";
+export { participantSnapshot, visitorPendingPrompt, visitorSnapshot, visitorView, type ParticipantPolicy, type VisitorLine, type VisitorPendingPrompt, type VisitorView, } from "./client-visitor.js";
 /** Semantic acknowledgement returned after one durable acceptance commit. */
 export type Accepted = Readonly<{
     /** Indicates that the owner transaction committed. */
@@ -132,15 +132,9 @@ export type SessionTerminal = Readonly<{
      */
     meta?: Json;
 }>;
-/** Work occupying the executor partition that this queued command requires, without message or provider data. */
+/** The occupying work's current phase; never its identity or transcript. */
 export type AgentRunningWork = Readonly<{
-    kind: "session";
-    sessionId: string;
-    commandId: string;
-}> | Readonly<{
-    kind: "host";
-    lane: string;
-    jobId: string;
+    phase: "thinking" | "streaming" | "running_tool" | "waiting_on_you" | "cancelling";
 }>;
 /**
  * Raw facts about what a Session is doing now. Shiitake publishes facts only;
@@ -213,9 +207,27 @@ export type SessionProgress = Readonly<{
     revision: number;
     text: string;
     thinking: string;
+    /** UTF-16 offsets of the retained tails, not byte offsets. */
+    textOffset: number;
+    thinkingOffset: number;
     textTruncated: boolean;
     thinkingTruncated: boolean;
 }>;
+/** Append-only progress on the wire. Offsets count JavaScript string units. */
+export type SessionProgressDelta = Readonly<{
+    messageId: string;
+    revision: number;
+    text: Readonly<{
+        offset: number;
+        append: string;
+    }>;
+    thinking: Readonly<{
+        offset: number;
+        append: string;
+    }>;
+}>;
+/** Fold a decoded append once; a missing prefix waits for an owner reset. */
+export declare function appendSessionProgress(current: SessionProgress | null, delta: SessionProgressDelta): SessionProgress | null;
 /** 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. */
@@ -370,9 +382,9 @@ export type SessionFrame = Readonly<{
      */
     context?: SessionContext;
 }> | Readonly<{
-    /** Bounded process-local assistant progress. */
+    /** Only new text/thinking; snapshots, not frames, carry retained tails. */
     kind: "progress";
-    progress: SessionProgress;
+    progress: SessionProgressDelta;
     /** Raw facts about the Session's activity read with this progress. */
     activity: SessionActivity;
 }> | Readonly<{

package/dist/client.js

@@ -3,3 +3,25 @@ export { createShiitakeClient, } from "./remote-client.js";
 export { bindAgentExtension, bindSessionExtension, } from "./extension-client.js";
 export { AcceptedSchema, DelegationReceiptSchema, HeldSchema, parseAccepted, parseDelegationReceipt, parseCancelResult, parseLatestPendingPrompt, parseWithdrawResult, parseForkedSession, parseSessionFrame, parseSessionSnapshot, parseSessionSummaryPage, parseShiitakeError, } from "./client-wire.js";
 export { participantSnapshot, visitorPendingPrompt, visitorSnapshot, visitorView, } from "./client-visitor.js";
+/** Fold a decoded append once; a missing prefix waits for an owner reset. */
+export function appendSessionProgress(current, delta) {
+    const previous = current?.messageId === delta.messageId ? current : null;
+    if (previous !== null && previous.revision >= delta.revision)
+        return current;
+    const textEnd = previous === null ? 0 : previous.textOffset + previous.text.length;
+    const thinkingEnd = previous === null ? 0 : previous.thinkingOffset + previous.thinking.length;
+    if (delta.text.offset > textEnd || delta.thinking.offset > thinkingEnd)
+        return current;
+    return {
+        messageId: delta.messageId,
+        revision: delta.revision,
+        text: (previous?.text ?? "") +
+            delta.text.append.slice(Math.max(0, textEnd - delta.text.offset)),
+        thinking: (previous?.thinking ?? "") +
+            delta.thinking.append.slice(Math.max(0, thinkingEnd - delta.thinking.offset)),
+        textOffset: previous?.textOffset ?? 0,
+        thinkingOffset: previous?.thinkingOffset ?? 0,
+        textTruncated: previous?.textTruncated ?? false,
+        thinkingTruncated: previous?.thinkingTruncated ?? false,
+    };
+}

package/dist/cloudflare.d.ts

@@ -102,6 +102,11 @@ export type CloudflareShiitakeOptions = Readonly<{
      * refuses for storage pressure. The budget and thresholds are the host's.
      */
     storagePressure?: StoragePressureCheck;
+    /** Host-owned synchronous check at the single new-work admission 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;
     /** The host's explicit extension roster and grants; there is no default. */
@@ -127,6 +132,21 @@ export type CloudflareShiitakeOptions = Readonly<{
 }>;
 /** Cloudflare host lifecycle; alarm forwarding stays outside the neutral client. */
 export type CloudflareShiitake = ShiitakeOwnerAgent & Readonly<{
+    /** Read durable queued/running Session or unresolved delegated work in the
+     * host's SQLite transaction, immediately before changing archived state.
+     * A confirmed remote settlement must be recorded locally first; unavailable
+     * remote settlement remains busy, not idle. Never use an in-memory counter.
+     */
+    busySync: () => Readonly<{
+        kind: "session";
+        sessionId: string;
+        commandId: string;
+    }> | Readonly<{
+        kind: "delegation";
+        agentId: string;
+        sessionId: string;
+        commandId: string;
+    }> | undefined;
     /** Exact settled command facts, outside the neutral Session transport. */
     readSettlement: (sessionId: string, commandId: string) => Promise<CommandSettlement | undefined>;
     /**

package/dist/cloudflare.js

@@ -277,6 +277,8 @@ function effectOptions(state, 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 });
     return tools === undefined ? base : { ...base, tools };
@@ -319,7 +321,7 @@ export function makeCloudflareShiitake(unnamed, options) {
     const coreOptions = effectOptions(state, options, host.runtime);
     return import("./internal/runtime-core.js")
         .then(({ openRuntimeCore }) => runShiitakePromise(openRuntimeCore(coreOptions, options.mailRoom)))
-        .then(async ({ agent, activeSessions, acceptMail, readSettlement }) => {
+        .then(async ({ agent, activeSessions, busySync, acceptMail, readSettlement, }) => {
         const handle = toPromiseOwner(agent);
         try {
             await options.initialize?.(handle);
@@ -340,6 +342,7 @@ export function makeCloudflareShiitake(unnamed, options) {
             },
             alarm: host.alarm,
             activeSessions: () => runShiitakePromise(activeSessions),
+            busySync,
             abortActive: async () => {
                 for (const sessionId of await runShiitakePromise(activeSessions))
                     await runShiitakePromise(agent.session(sessionId).abort);

package/dist/delegation.d.ts

@@ -31,6 +31,11 @@ export declare class AgentDelegation {
     }>);
     private fleetOwner;
     private fleet;
+    /** Best-effort remote refresh before an owner-local archive transaction.
+     * Confirmed settlements are recorded by Shiitake; unreadable targets leave
+     * their local accepted receipt outstanding for busySync to refuse.
+     */
+    refreshOutstanding(readSettlement: (agentId: string, sessionId: string, commandId: string) => Promise<CommandSettlement | undefined>): Promise<void>;
     private scope;
     /** Recipient-local disclosure through the public host, never another Agent's RPC. */
     settlement(sender: DelegationIdentity, sessionId: string, commandId: string, host: Pick<ShiitakeHost, "readSettlement">): Promise<CommandSettlement | undefined>;

package/dist/delegation.js

@@ -3,7 +3,7 @@
  * addressed Agent mail over Carrier Post, and the Agent grammar a host hands
  * to Oyster's machine link as ports. Oyster core never imports this engine.
  */
-import { commandSettlementSchema, createAgentDirectory, createFleetCorrespondence, agentDelegationRequestKey, delegationProvenance, delegationReplyMeta, delegationSendMeta, settlementReadableBy, } from "./fleet.js";
+import { commandSettlementSchema, createAgentDirectory, createFleetCorrespondence, createFleetDelegation, agentDelegationRequestKey, delegationProvenance, delegationReplyMeta, delegationSendMeta, settlementReadableBy, } from "./fleet.js";
 import * as Schema from "effect/Schema";
 import { agentMailAddressSchema } from "@fungi.computer/seam/machine-link-protocol";
 import { BirdDogMailSchema, BirdDogError, settlementReplies, } from "@fungi.computer/bird-dog/effect";
@@ -27,6 +27,19 @@ export class AgentDelegation {
             deliver: this.deps.deliver,
         }));
     }
+    /** Best-effort remote refresh before an owner-local archive transaction.
+     * Confirmed settlements are recorded by Shiitake; unreadable targets leave
+     * their local accepted receipt outstanding for busySync to refuse.
+     */
+    async refreshOutstanding(readSettlement) {
+        const fleet = createFleetDelegation({
+            storage: this.deps.storage,
+            deliver: this.deps.deliver,
+            open: (agentId) => this.deps.directory().open(agentId, new AbortController().signal),
+            readSettlement,
+        });
+        await fleet.outstanding();
+    }
     async scope(signal) {
         const agents = await this.deps.directory().list(signal);
         const identity = await this.deps.identity();
@@ -72,19 +85,22 @@ export class AgentDelegation {
         });
         const meta = delegationSendMeta({ id: scope.agentId, name: scope.source.name }, invocation.meta);
         signal.throwIfAborted();
+        let task = {
+            agentId: input.agentId,
+            sessionId: input.sessionId,
+            delivery: input.delivery,
+            text: input.text,
+            requestId,
+        };
+        if (input.delivery === "followUp" && input.goal !== undefined)
+            task = { ...task, goal: input.goal };
         const accepted = await this.fleet().start({
             agents: scope.agents.map(({ agentId }) => agentId),
             actions: ["delegate"],
             expiresAt: this.deps.expiresAt(),
             provenance,
             meta,
-        }, {
-            agentId: input.agentId,
-            sessionId: input.sessionId,
-            delivery: input.delivery,
-            text: input.text,
-            requestId,
-        });
+        }, task);
         return accepted;
     }
     /** Resolve this sender's exact request, then let the recipient guard pending work. */

package/dist/effect.d.ts

@@ -8,7 +8,7 @@ import type { Accepted } from "./client.js";
 import type { ShiitakeError } from "./errors.js";
 import type { ShiitakeEffectOptions, ShiitakeEffectOwner } from "./internal/effect-contracts.js";
 import type { SqliteOwner } from "./internal/contracts.js";
-export type { AbortCommand, BranchCommand, CompactCommand, CancelCommand, CancelResult, Accepted, ForkCommand, ForkedSession, PromptCommand, PromptDelivery, ReadOptions, SessionCommand, SessionCommandHandler, SessionFrame, SessionMessage, SessionProgress, SessionToolOutput, SessionSnapshot, SessionActivity, AgentRunningWork, SubscribeOptions, TooLate, WatchOptions, } from "./client.js";
+export type { AbortCommand, BranchCommand, CompactCommand, CancelCommand, CancelResult, Accepted, ForkCommand, ForkedSession, PromptCommand, PromptDelivery, ReadOptions, SessionCommand, SessionCommandHandler, SessionFrame, SessionMessage, SessionProgress, SessionProgressDelta, SessionToolOutput, SessionSnapshot, SessionActivity, AgentRunningWork, SubscribeOptions, TooLate, WatchOptions, } from "./client.js";
 export type { InstructionSnapshot, InstructionSource, ModelAcquisition, ModelDescription, ModelSource, RuntimeHost, RuntimePendingWork, SqliteCursor, SqliteOwner, SqliteValue, SqliteRow, GrantsDelivery, GrantsDeliveryResult, ShiitakeOptions, ToolAccess, HostMetaOptions, StandardHostMetaResult, StandardHostMetaSchema, ToolSource, } from "./internal/contracts.js";
 export type { InstructionSourceEffect, ModelAcquisitionEffect, ModelSourceEffect, RuntimeHostEffect, ShiitakeEffectAgent, ShiitakeEffectAgentExtensions, ShiitakeEffectCommandHandler, ShiitakeEffectOptions, ShiitakeEffectOwner, ShiitakeEffectSession, ShiitakeEffectSessionExtension, ShiitakeEffectSendOptions, ShiitakeEffectWatch, ToolSourceEffect, } from "./internal/effect-contracts.js";
 export type { SessionSummary } from "./client.js";

package/dist/errors.d.ts

@@ -4,14 +4,14 @@ declare const ShiitakeErrorBoundarySchema: Schema.Literals<readonly ["contract",
 /** Stable boundary that rejected a Shiitake operation. */
 export type ShiitakeErrorBoundary = Schema.Schema.Type<typeof ShiitakeErrorBoundarySchema>;
 /** Safe failure category exposed by both Shiitake facades. */
-declare const ShiitakeErrorCauseSchema: Schema.Literals<readonly ["closed", "conflict", "incompatible", "invalid", "rejected", "unavailable", "state_reset_required", "storage_pressure"]>;
+declare const ShiitakeErrorCauseSchema: Schema.Literals<readonly ["closed", "conflict", "incompatible", "invalid", "rejected", "unavailable", "state_reset_required", "storage_pressure", "archived"]>;
 /** Safe failure category exposed by both Shiitake facades. */
 export type ShiitakeErrorCause = Schema.Schema.Type<typeof ShiitakeErrorCauseSchema>;
 /** Canonical serialized Shiitake failure. */
 export declare const ShiitakeErrorWireSchema: Schema.Struct<{
     readonly _tag: Schema.Literal<"ShiitakeError">;
     readonly boundary: Schema.Literals<readonly ["contract", "extensions", "instructions", "model", "runtime", "store", "tools"]>;
-    readonly cause: Schema.Literals<readonly ["closed", "conflict", "incompatible", "invalid", "rejected", "unavailable", "state_reset_required", "storage_pressure"]>;
+    readonly cause: Schema.Literals<readonly ["closed", "conflict", "incompatible", "invalid", "rejected", "unavailable", "state_reset_required", "storage_pressure", "archived"]>;
     readonly message: Schema.String;
     readonly requestId: Schema.optionalKey<Schema.String>;
 }>;