@fungi.computer/shiitake 0.2.0 → 0.3.0

package/dist/internal/woodstock/cold-sessions.js

@@ -0,0 +1,90 @@
+import * as Schema from "effect/Schema";
+import { ShiitakeError } from "../../errors.js";
+/**
+ * The store keeper's read of cold Sessions. It is one indexed keyset page over
+ * the inbox, with each Session's bytes summed from its own rows, so no counter
+ * can drift and nothing needs reconciling.
+ */
+const defaultLimit = 50;
+const maxLimit = 200;
+const closed = { onExcessProperty: "error" };
+const encoder = new TextEncoder();
+const timestamp = Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)));
+const boundedId = Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.makeFilter((value) => encoder.encode(value).byteLength <= 256)));
+const RequestSchema = Schema.Struct({
+    limit: Schema.optionalKey(Schema.Int.pipe(Schema.check(Schema.isBetween({ minimum: 1, maximum: maxLimit })))),
+    after: Schema.optionalKey(Schema.String),
+});
+const decodeRequest = Schema.decodeUnknownResult(RequestSchema, closed);
+const CursorSchema = Schema.fromJsonString(Schema.Tuple([timestamp, boundedId]));
+const decodeCursor = Schema.decodeUnknownResult(CursorSchema);
+const encodeCursor = Schema.encodeSync(CursorSchema);
+const RowSchema = Schema.Struct({
+    session_id: boundedId,
+    last_activity_at: timestamp,
+    state: Schema.Literals(["needs_you", "running", "errored", "done"]),
+    bytes: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0))),
+});
+const decodeRow = Schema.decodeUnknownResult(RowSchema, closed);
+const invalid = (message) => new ShiitakeError("contract", "invalid", message);
+const payloadBytes = (table, column) => `(SELECT COALESCE(SUM(LENGTH(CAST(${column} AS BLOB))), 0) FROM ${table} WHERE session_id = p.session_id)`;
+/**
+ * The coldest-first window is chosen from 'session_inbox' alone; stored bytes
+ * are summed only for its first 'limit' rows. The extra lookahead row only
+ * proves another page exists and is discarded, so it is never measured.
+ */
+const selectColdSessions = (where) => `
+  WITH p AS (
+    SELECT i.session_id, i.last_activity_at, i.state,
+      ROW_NUMBER() OVER (ORDER BY i.last_activity_at ASC, i.session_id ASC) AS position
+    FROM session_inbox i
+    ${where}
+    ORDER BY i.last_activity_at ASC, i.session_id ASC LIMIT ?
+  )
+  SELECT p.session_id, p.last_activity_at, p.state,
+    CASE WHEN p.position <= ? THEN
+      ${payloadBytes("session_entries", "data_json")}
+      + ${payloadBytes("session_command_admissions", "data_json")}
+      + ${payloadBytes("session_attention", "value_json")}
+      + ${payloadBytes("session_tool_grants", "grants_json")}
+    ELSE 0 END AS bytes
+  FROM p ORDER BY p.position`;
+/** Read one bounded page of Sessions with stored bytes, coldest first. */
+export function readColdSessionPageOwned(owner, request) {
+    const decodedRequest = decodeRequest(request);
+    if (decodedRequest._tag === "Failure")
+        throw invalid("Cold Session page request is invalid");
+    const limit = decodedRequest.success.limit ?? defaultLimit;
+    const after = decodedRequest.success.after;
+    let cursor;
+    if (after !== undefined) {
+        const decoded = decodeCursor(after);
+        if (decoded._tag === "Failure")
+            throw invalid("Cold Session cursor is invalid");
+        cursor = decoded.success;
+    }
+    // One extra row tells a full last page from a page with more behind it.
+    const raws = cursor === undefined
+        ? owner.sql.exec(selectColdSessions(""), limit + 1, limit).toArray()
+        : owner.sql
+            .exec(selectColdSessions(`WHERE i.last_activity_at > ?
+                 OR (i.last_activity_at = ? AND i.session_id > ?)`), cursor[0], cursor[0], cursor[1], limit + 1, limit)
+            .toArray();
+    const sessions = [];
+    for (const raw of raws.slice(0, limit)) {
+        const decoded = decodeRow(raw);
+        if (decoded._tag === "Failure")
+            throw new ShiitakeError("store", "unavailable", "Stored Session row is invalid");
+        const row = decoded.success;
+        sessions.push({
+            sessionId: row.session_id,
+            bytes: row.bytes,
+            lastActivityAt: row.last_activity_at,
+            idle: row.state === "done" || row.state === "errored",
+        });
+    }
+    const last = sessions.at(-1);
+    return raws.length > limit && last !== undefined
+        ? { sessions, next: encodeCursor([last.lastActivityAt, last.sessionId]) }
+        : { sessions };
+}

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

@@ -43,6 +43,8 @@ export declare function writeStatus(owner: SqliteOwner, extensionId: string, sta
 export declare function writeTimer(owner: SqliteOwner, extensionId: string, key: string, dueAt: number): void;
 /** Delete one timer; absent keys are a no-op. */
 export declare function deleteTimer(owner: SqliteOwner, extensionId: string, key: string): void;
+/** Release all timer registrations when their extension leaves the roster. */
+export declare function deleteExtensionTimers(owner: SqliteOwner, extensionId: string): void;
 /** Read one timer's due instant. */
 export declare function readTimer(owner: SqliteOwner, extensionId: string, key: string): number | undefined;
 /** Due timers of the given extensions, oldest first, bounded by `limit`. */

package/dist/internal/woodstock/extension-store.js

@@ -194,6 +194,10 @@ export function writeTimer(owner, extensionId, key, dueAt) {
 export function deleteTimer(owner, extensionId, key) {
     owner.sql.exec("DELETE FROM shiitake_extension_timers WHERE extension_id = ? AND key = ?", extensionId, key);
 }
+/** Release all timer registrations when their extension leaves the roster. */
+export function deleteExtensionTimers(owner, extensionId) {
+    owner.sql.exec("DELETE FROM shiitake_extension_timers WHERE extension_id = ?", extensionId);
+}
 /** Read one timer's due instant. */
 export function readTimer(owner, extensionId, key) {
     const rows = owner.sql

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

@@ -10,7 +10,7 @@ export declare function createFleetDirectoryStore(sql: WatchdogSqliteOwner["sql"
     findByName: (name: string) => {
         readonly [x: string]: string | number | ArrayBuffer | null;
     } | undefined;
-    reserve(agentId: string, name: string, actorUserId: string, now: number, requestId: string, configuration: string): void;
+    reserve(agentId: string, name: string, actorUserId: string, now: number, requestId: string, configuration: string, createdBy: string | null): void;
     list: () => readonly {
         readonly [x: string]: string | number | ArrayBuffer | null;
     }[];
@@ -27,6 +27,10 @@ export declare function createFleetDelegationStore(storage: WatchdogSqliteOwner)
     read: (requestId: string) => {
         readonly [x: string]: string | number | ArrayBuffer | null;
     } | undefined;
+    /** Every delegation this owner has sent and had accepted, newest first. */
+    sent: () => readonly {
+        readonly [x: string]: string | number | ArrayBuffer | null;
+    }[];
     reserve(requestId: string, input: string, mail: string): void;
     recordReceipt(requestId: string, receipt: string): void;
 };

package/dist/internal/woodstock/fleet-store.js

@@ -6,9 +6,17 @@ export function createFleetDirectoryStore(sql) {
         agent_id TEXT PRIMARY KEY,
         name TEXT NOT NULL UNIQUE,
         actor_user_id TEXT NOT NULL,
+        created_by TEXT,
         created_at INTEGER NOT NULL,
         updated_at INTEGER NOT NULL
       ) STRICT`);
+    // Existing pre-release Agents have no recorded maker. Never infer one from
+    // correspondence or actor_user_id (the human credential owner).
+    const columns = input.sql
+        .exec("PRAGMA table_info(hub_team_agents)")
+        .toArray();
+    if (!columns.some((column) => column.name === "created_by"))
+        input.sql.exec("ALTER TABLE hub_team_agents ADD COLUMN created_by TEXT");
     input.sql.exec(`CREATE TABLE IF NOT EXISTS hub_team_agent_create_receipts (
         request_id TEXT PRIMARY KEY,
         actor_user_id TEXT NOT NULL,
@@ -28,21 +36,21 @@ export function createFleetDirectoryStore(sql) {
     input.sql.exec("INSERT OR IGNORE INTO hub_team_agent_erasure_scope(singleton,complete) VALUES (1,1)");
     return {
         read: (agentId) => input.sql
-            .exec("SELECT agent_id, name, actor_user_id, created_at, updated_at FROM hub_team_agents WHERE agent_id = ?", agentId)
+            .exec("SELECT agent_id, name, actor_user_id, created_by, created_at, updated_at FROM hub_team_agents WHERE agent_id = ?", agentId)
             .toArray()[0],
         readReceipt: (requestId) => input.sql
             .exec("SELECT request_id, actor_user_id, name, agent_id, computer_mode FROM hub_team_agent_create_receipts WHERE request_id = ?", requestId)
             .toArray()[0],
         findByName: (name) => input.sql
-            .exec("SELECT agent_id, name, actor_user_id, created_at, updated_at FROM hub_team_agents WHERE name = ?", name)
+            .exec("SELECT agent_id, name, actor_user_id, created_by, created_at, updated_at FROM hub_team_agents WHERE name = ?", name)
             .toArray()[0],
-        reserve(agentId, name, actorUserId, now, requestId, configuration) {
-            input.sql.exec("INSERT INTO hub_team_agents (agent_id, name, actor_user_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?)", agentId, name, actorUserId, now, now);
+        reserve(agentId, name, actorUserId, now, requestId, configuration, createdBy) {
+            input.sql.exec("INSERT INTO hub_team_agents (agent_id, name, actor_user_id, created_by, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)", agentId, name, actorUserId, createdBy, now, now);
             input.sql.exec("INSERT INTO hub_team_agent_erasure_ids(agent_id) VALUES (?)", agentId);
             input.sql.exec("INSERT INTO hub_team_agent_create_receipts (request_id, actor_user_id, name, agent_id, computer_mode) VALUES (?, ?, ?, ?, ?)", requestId, actorUserId, name, agentId, configuration);
         },
         list: () => input.sql
-            .exec("SELECT agent_id, name, actor_user_id, created_at, updated_at FROM hub_team_agents ORDER BY created_at DESC, agent_id DESC")
+            .exec("SELECT agent_id, name, actor_user_id, created_by, created_at, updated_at FROM hub_team_agents ORDER BY created_at DESC, agent_id DESC")
             .toArray(),
         rename(agentId, name, now) {
             input.sql.exec("UPDATE hub_team_agents SET name = ?, updated_at = ? WHERE agent_id = ?", name, now, agentId);
@@ -79,6 +87,10 @@ export function createFleetDelegationStore(storage) {
         read: (requestId) => storage.sql
             .exec("SELECT input, mail, receipt FROM shiitake_fleet_delegations WHERE request_id = ?", requestId)
             .toArray()[0],
+        /** Every delegation this owner has sent and had accepted, newest first. */
+        sent: () => storage.sql
+            .exec("SELECT input, mail, receipt FROM shiitake_fleet_delegations WHERE receipt IS NOT NULL ORDER BY rowid DESC")
+            .toArray(),
         reserve(requestId, input, mail) {
             storage.transactionSync(() => {
                 storage.sql.exec("INSERT OR IGNORE INTO shiitake_fleet_delegations(request_id, input, mail) VALUES (?, ?, ?)", requestId, input, mail);

package/dist/internal/woodstock/index.d.ts

@@ -1,8 +1,9 @@
 import type { SandboxFailureEvent } from "@fungi.computer/mycelium";
 import type { Json } from "../../extensions.js";
-import type { MuleError, MuleIdentity, MuleListener } from "@fungi.computer/mule/effect";
+import type { MuleError, MuleEvent, MuleIdentity } from "@fungi.computer/mule/effect";
 import * as Effect from "effect/Effect";
 import type * as Scope from "effect/Scope";
+import type { ColdSessionPage, ColdSessionPageRequest } from "../../cold-sessions.js";
 import type { ReadOptions, SessionExtensionSlots, SessionSnapshot } from "../../client.js";
 import { ShiitakeError } from "../../errors.js";
 import type { CommandSettlement, SqliteOwner } from "../contracts.js";
@@ -11,6 +12,7 @@ import { type ClientReplayPage } from "./client-projection.js";
 import { type LiveRetryEvent } from "./session-entry.js";
 import { type CompactionNoticeInput, type AcceptedCommand, type EnqueueAcceptedWork, type AppendCompactionInput, type PreparedSessionRun, type RunContract, type RecordAcceptedCancellation, type SessionQueueHead, type StoredSessionRow } from "./session-store.js";
 export * from "./extension-store.js";
+export { readLatestPendingPrompt } from "./client-projection.js";
 export { createFleetDirectoryStore, createFleetDelegationStore, } from "./fleet-store.js";
 export * from "./session-attention.js";
 export { deliverSessionGrants, prepareSessionGrants, readSessionGrants, type GrantsDelivery, type GrantsDeliveryResult, } from "./session-grants.js";
@@ -26,6 +28,8 @@ export * from "./storage-admission.js";
 export declare function appendCompactionNotice(owner: SqliteOwner, input: CompactionNoticeInput): StoredSessionRow;
 /** Append compaction through Woodstock's ordinary owner-observation boundary. */
 export declare function appendCompactionTransition(owner: SqliteOwner, input: AppendCompactionInput): StoredSessionRow;
+/** Place a background summary, head-checked in the append transaction. */
+export declare function placeCompactionTransition(owner: SqliteOwner, input: AppendCompactionInput): StoredSessionRow | "stale";
 /** Prepare Woodstock's retained Session and private admission schema. */
 export declare function prepareWoodstockSchema(owner: SqliteOwner): Effect.Effect<void, ShiitakeError>;
 /** Atomically cancel one exact owner-issued command. */
@@ -52,6 +56,7 @@ export declare function settleControls(owner: SqliteOwner, input: Readonly<{
     sessionId: string;
     parentWorkId: string;
     outcome: "completed" | "cancelled" | "failed" | "interrupted";
+    diagnostic: string | undefined;
     enqueue: EnqueueAcceptedWork;
 }>): Effect.Effect<void, ShiitakeError>;
 /** Resolve Session-scoped abort to private work and record it atomically. */
@@ -127,6 +132,8 @@ export declare function deleteSession(owner: SqliteOwner, input: Readonly<{
 }>): Effect.Effect<boolean, ShiitakeError>;
 /** Read a page of stored conversation facts; status needs the Session owner. */
 export declare function readSessionFactPage(owner: SqliteOwner, after?: string): Effect.Effect<import("./session-store.js").StoredSessionSummaryPage, ShiitakeError>;
+/** Read one bounded page of Sessions with stored bytes, coldest first. */
+export declare function readColdSessionPage(owner: SqliteOwner, request: ColdSessionPageRequest): Effect.Effect<ColdSessionPage, ShiitakeError>;
 /** Read one bounded inbox page in tier, then newest-activity order. */
 export declare function readSessionInbox(owner: SqliteOwner, after: string | undefined): Effect.Effect<import("../../client.js").SessionSummaryPage, ShiitakeError>;
 /** Read one strict-after page from Woodstock's selected lineage. */
@@ -149,7 +156,7 @@ export type SettledRunFacts = Readonly<{
 export declare function readExtensionAdmissionOrigin(owner: SqliteOwner, sessionId: string, commandFactId: string, workId: string): ExtensionAdmissionOrigin;
 /** Read the terminal and admission origin of one settled accepted command. */
 export declare function readSettledRunFacts(owner: SqliteOwner, sessionId: string, commandFactId: string, workId: string): SettledRunFacts;
-/** Record unsuccessful Watchdog settlement when Mule has no recorded terminal. */
+/** Record settlement only when Mule has no matching recorded terminal. */
 export declare function recordWorkSettlement(owner: SqliteOwner, input: Readonly<{
     sessionId: string;
     commandFactId: string;
@@ -160,11 +167,12 @@ export declare function recordWorkSettlement(owner: SqliteOwner, input: Readonly
 }>): Effect.Effect<void, ShiitakeError>;
 /** Record one retained live Pi retry observation on the Session lineage. */
 export declare function recordLiveRetryEvent(owner: SqliteOwner, accepted: AcceptedCommand, event: LiveRetryEvent, turn: MuleIdentity): Effect.Effect<void, MuleError>;
+export type MuleRecorder = (event: MuleEvent, diagnostic?: string) => Effect.Effect<void, MuleError>;
 /**
  * Open the one scoped listener that projects Mule's exact event stream into
  * retained Session facts and bounded process-local progress.
  */
-export declare function openMuleRecorder(owner: SqliteOwner, accepted: AcceptedCommand, contract: RunContract): Effect.Effect<MuleListener, never, Scope.Scope>;
+export declare function openMuleRecorder(owner: SqliteOwner, accepted: AcceptedCommand, contract: RunContract): Effect.Effect<MuleRecorder, never, Scope.Scope>;
 export { declareSessionDocument } from "./session-documents.js";
 /** Read exact settled work facts through Woodstock's native command/work indexes. */
 export declare function readCommandSettlement(owner: SqliteOwner, sessionId: string, commandId: string): Effect.Effect<CommandSettlement | undefined, ShiitakeError>;

package/dist/internal/woodstock/index.js

@@ -2,13 +2,15 @@ import * as Effect from "effect/Effect";
 import { ShiitakeError } from "../../errors.js";
 import { decodeClientReadOptions, decodeClientSessionCreationRequestId, decodeClientSessionId, } from "../client-boundary.js";
 import { publishOwnerObservation } from "../observation-kernel.js";
+import { readColdSessionPageOwned } from "./cold-sessions.js";
 import { diagnosticsByWorkId, projectCommandSettlement, readClientReplayPage, readClientSnapshot, } from "./client-projection.js";
 import { sessionIds } from "./identities.js";
-import { openProgress } from "./progress.js";
+import { openProgress, openToolProgress } from "./progress.js";
 import { encodeStoredSessionEntry, } from "./session-entry.js";
-import { appendSessionEntry, appendCompactionTransitionOwned, appendCompactionNoticeOwned, acceptSessionAbort, acceptSessionCancellation, completeSessionLeaf, prepareSessionRun, prepareSessionStore, readSessionEntriesForWork, readSessionCommandAdmission, settleSessionControls, takePendingSessionControls, readSessionEntryById, selectSessionBranch, forkSessionAt, readStoredSessionSummary as readSessionSummaryOwned, readStoredSessionFactPage, createStoredSession, deleteStoredSession, appendOperatorEntry, } from "./session-store.js";
+import { appendSessionEntry, appendCompactionTransitionOwned, appendCompactionNoticeOwned, placeCompactionTransitionOwned, acceptSessionAbort, acceptSessionCancellation, completeSessionLeaf, prepareSessionRun, prepareSessionStore, readSessionEntriesForWork, readSessionCommandAdmission, settleSessionControls, takePendingSessionControls, readSessionEntryById, selectSessionBranch, forkSessionAt, readStoredSessionSummary as readSessionSummaryOwned, readStoredSessionFactPage, createStoredSession, deleteStoredSession, appendOperatorEntry, } from "./session-store.js";
 import { readSessionInboxPage, recordSessionInboxDeletion, } from "./session-inbox.js";
 export * from "./extension-store.js";
+export { readLatestPendingPrompt } from "./client-projection.js";
 export { createFleetDirectoryStore, createFleetDelegationStore, } from "./fleet-store.js";
 export * from "./session-attention.js";
 export { deliverSessionGrants, prepareSessionGrants, readSessionGrants, } from "./session-grants.js";
@@ -32,6 +34,13 @@ export function appendCompactionTransition(owner, input) {
     publishOwnerObservation(owner, input.sessionId);
     return row;
 }
+/** Place a background summary, head-checked in the append transaction. */
+export function placeCompactionTransition(owner, input) {
+    const placed = placeCompactionTransitionOwned(owner, input);
+    if (placed !== "stale")
+        publishOwnerObservation(owner, input.sessionId);
+    return placed;
+}
 function rejected(message) {
     return new ShiitakeError("store", "rejected", message);
 }
@@ -207,6 +216,10 @@ export function deleteSession(owner, input) {
 export function readSessionFactPage(owner, after) {
     return storeEffect(() => readStoredSessionFactPage(owner, after === undefined ? undefined : decodeClientSessionId(after)));
 }
+/** Read one bounded page of Sessions with stored bytes, coldest first. */
+export function readColdSessionPage(owner, request) {
+    return storeEffect(() => readColdSessionPageOwned(owner, request));
+}
 /** Read one bounded inbox page in tier, then newest-activity order. */
 export function readSessionInbox(owner, after) {
     return storeEffect(() => readSessionInboxPage(owner, after));
@@ -300,7 +313,7 @@ export function readSettledRunFacts(owner, sessionId, commandFactId, workId) {
         toolCalls,
     });
 }
-/** Record unsuccessful Watchdog settlement when Mule has no recorded terminal. */
+/** Record settlement only when Mule has no matching recorded terminal. */
 export function recordWorkSettlement(owner, input) {
     return storeEffect(() => {
         const admission = readSessionCommandAdmission(owner, input.sessionId, input.commandFactId);
@@ -319,9 +332,9 @@ export function recordWorkSettlement(owner, input) {
         });
     });
 }
-function recordLifecycle(owner, accepted, contract, event) {
+function recordLifecycle(owner, accepted, contract, event, diagnostic) {
     return storeEffect(() => {
-        const entry = event.type === "run_start"
+        let entry = event.type === "run_start"
             ? {
                 kind: "run_started",
                 workId: accepted.commandId,
@@ -342,6 +355,8 @@ function recordLifecycle(owner, accepted, contract, event) {
                     terminal: event.terminal,
                     outcome: event.outcome,
                 };
+        if (entry.kind === "run_terminal" && diagnostic !== undefined)
+            entry = { ...entry, diagnostic };
         appendRecordedEntry(owner, accepted, entry, ({ entry: current }) => {
             if (current.kind !== entry.kind)
                 return false;
@@ -422,18 +437,19 @@ function recordMessageEnd(owner, accepted, event) {
             message: event.message,
             value: event.value,
         };
+        const completed = event.data === undefined ? entry : { ...entry, data: event.data };
         const delivery = owner.transactionSync(() => {
             const existing = readSessionEntriesForWork(owner, accepted.sessionId, accepted.commandId).find(({ entry: current }) => (current.kind === "message_start" || current.kind === "message") &&
                 sameIdentity(current.message, event.message));
             if (existing?.entry.kind === "message") {
-                if (!sameEntry(existing.entry, entry))
+                if (!sameEntry(existing.entry, completed))
                     throw conflict("Mule completed-message identity conflicts");
                 return "replay";
             }
             completeSessionLeaf(owner, {
                 sessionId: accepted.sessionId,
                 id: event.message.value,
-                entry,
+                entry: completed,
             });
             return "new";
         });
@@ -460,6 +476,7 @@ function recordToolIntent(owner, accepted, contract, event) {
 }
 function recordToolOutcome(owner, accepted, event) {
     return storeEffect(() => {
+        const { data, ...result } = event.result;
         const entry = {
             kind: "tool_outcome",
             workId: accepted.commandId,
@@ -467,9 +484,9 @@ function recordToolOutcome(owner, accepted, event) {
             turn: event.turn,
             toolCall: event.toolCall,
             call: event.call,
-            result: event.result,
+            result,
         };
-        appendRecordedEntry(owner, accepted, entry, ({ entry: current }) => current.kind === "tool_outcome" &&
+        appendRecordedEntry(owner, accepted, data === undefined ? entry : { ...entry, data }, ({ entry: current }) => current.kind === "tool_outcome" &&
             sameIdentity(current.toolCall, event.toolCall));
     });
 }
@@ -505,14 +522,15 @@ const listenerFailure = () => ({
 export function openMuleRecorder(owner, accepted, contract) {
     return Effect.gen(function* () {
         const progress = yield* openProgress(owner, accepted, (event) => recordMessageEnd(owner, accepted, event));
-        const record = (event) => {
+        const toolProgress = yield* openToolProgress(owner, accepted);
+        const record = (event, diagnostic) => {
             switch (event.type) {
                 case "model_prompt":
                     return recordModelPrompt(owner, accepted, contract, event);
                 case "run_start":
                 case "turn_start":
                 case "run_end":
-                    return recordLifecycle(owner, accepted, contract, event);
+                    return recordLifecycle(owner, accepted, contract, event, diagnostic);
                 case "message_start":
                     if (event.value.role === "user")
                         return Effect.void;
@@ -528,15 +546,16 @@ export function openMuleRecorder(owner, accepted, contract) {
                         ? progress.terminal(event)
                         : recordMessageEnd(owner, accepted, event);
                 case "tool_execution_start":
-                    return recordToolIntent(owner, accepted, contract, event);
+                    return recordToolIntent(owner, accepted, contract, event).pipe(Effect.andThen(toolProgress.started(event)));
                 case "tool_execution_end":
-                    return recordToolOutcome(owner, accepted, event);
+                    return recordToolOutcome(owner, accepted, event).pipe(Effect.andThen(toolProgress.terminal(event)));
                 case "tool_execution_update":
+                    return toolProgress.update(event);
                 case "turn_end":
                     return Effect.void;
             }
         };
-        return (event) => record(event).pipe(Effect.mapError(listenerFailure));
+        return (event, diagnostic) => record(event, diagnostic).pipe(Effect.mapError(listenerFailure));
     });
 }
 export { declareSessionDocument } from "./session-documents.js";

package/dist/internal/woodstock/progress.d.ts

@@ -1,10 +1,23 @@
 import type { MuleEvent } from "@fungi.computer/mule";
 import * as Effect from "effect/Effect";
 import type * as Scope from "effect/Scope";
-import type { SessionProgress } from "../../client.js";
+import type { SessionProgress, SessionToolOutput } from "../../client.js";
 import { ShiitakeError } from "../../errors.js";
 import type { SqliteOwner } from "../contracts.js";
 import type { AcceptedCommand } from "./session-store.js";
+export declare function readProcessToolOutputForWork(owner: SqliteOwner, sessionId: string, workId: string): readonly SessionToolOutput[];
+/** Run-scoped, replaceable tool snapshots: never stored in Woodstock. */
+export declare function openToolProgress(owner: SqliteOwner, accepted: AcceptedCommand): Effect.Effect<{
+    started: (event: Extract<MuleEvent, {
+        type: "tool_execution_start";
+    }>) => Effect.Effect<void, never, never>;
+    update: (event: Extract<MuleEvent, {
+        type: "tool_execution_update";
+    }>) => Effect.Effect<void, never, never>;
+    terminal: (event: Extract<MuleEvent, {
+        type: "tool_execution_end";
+    }>) => Effect.Effect<void, never, never>;
+}, never, Scope.Scope>;
 /** Read the current process-local progress value for one addressed Session. */
 export declare function readProcessProgress(owner: SqliteOwner, sessionId: string): SessionProgress | null;
 /** Read progress only when it belongs to the current durable work head. */

package/dist/internal/woodstock/progress.js

@@ -1,7 +1,65 @@
 import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Result from "effect/Result";
 import { ShiitakeError } from "../../errors.js";
 import { publishOwnerObservation } from "../observation-kernel.js";
 const progressByOwner = new WeakMap();
+export function readProcessToolOutputForWork(owner, sessionId, workId) {
+    const current = progressByOwner.get(owner)?.get(sessionId);
+    return current?.workId === workId
+        ? [...current.slots.values()].filter((value) => value !== null)
+        : [];
+}
+const decodeOutputDetails = Schema.decodeUnknownResult(Schema.Struct({
+    droppedBytes: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    totalBytes: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+}), { onExcessProperty: "error" });
+/** Run-scoped, replaceable tool snapshots: never stored in Woodstock. */
+export function openToolProgress(owner, accepted) {
+    return Effect.gen(function* () {
+        const current = yield* openProcessProgress(owner, accepted);
+        const publish = () => {
+            publishOwnerObservation(owner, accepted.sessionId, "progress");
+        };
+        return {
+            started: (event) => Effect.sync(() => {
+                if (current.slots.size < 4 &&
+                    !current.slots.has(event.toolCall.value))
+                    current.slots.set(event.toolCall.value, null);
+            }),
+            update: (event) => Effect.sync(() => {
+                const previous = current.slots.get(event.toolCall.value);
+                if (previous === undefined)
+                    return;
+                const details = decodeOutputDetails(event.result.data);
+                // Other tool-specific update contracts do not represent output tails.
+                if (Result.isFailure(details))
+                    return;
+                const tail = event.result.content
+                    .filter((part) => part.type === "text")
+                    .map((part) => part.text)
+                    .join("");
+                if (new TextEncoder().encode(tail).byteLength > 8192 ||
+                    tail.split("\n").length > 200 ||
+                    details.success.droppedBytes > details.success.totalBytes)
+                    return;
+                current.slots.set(event.toolCall.value, {
+                    // Slots follow Mule execution identity; clients join the provider's
+                    // call ID carried by assistant calls and durable tool results.
+                    toolCallId: event.call.id,
+                    revision: (previous?.revision ?? 0) + 1,
+                    tail,
+                    ...details.success,
+                });
+                publish();
+            }),
+            terminal: (event) => Effect.sync(() => {
+                if (current.slots.delete(event.toolCall.value))
+                    publish();
+            }),
+        };
+    });
+}
 function progressFor(owner) {
     const existing = progressByOwner.get(owner);
     if (existing !== undefined)
@@ -10,6 +68,29 @@ function progressFor(owner) {
     progressByOwner.set(owner, created);
     return created;
 }
+/** One run-scoped owner for message progress and tool tails. */
+function openProcessProgress(owner, accepted) {
+    return Effect.gen(function* () {
+        const sessions = progressFor(owner);
+        const existing = sessions.get(accepted.sessionId);
+        if (existing?.workId === accepted.commandId)
+            return existing;
+        const current = {
+            workId: accepted.commandId,
+            value: null,
+            slots: new Map(),
+        };
+        sessions.set(accepted.sessionId, current);
+        yield* Effect.addFinalizer(() => Effect.sync(() => {
+            if (sessions.get(accepted.sessionId) !== current)
+                return;
+            sessions.delete(accepted.sessionId);
+            if (current.value !== null || current.slots.size > 0)
+                publishOwnerObservation(owner, accepted.sessionId, "progress");
+        }));
+        return current;
+    });
+}
 function rejected(message) {
     return new ShiitakeError("runtime", "rejected", message);
 }
@@ -41,9 +122,12 @@ function textFor(event) {
  */
 export function openProgress(owner, accepted, complete) {
     return Effect.gen(function* () {
+        const current = yield* openProcessProgress(owner, accepted);
         let started;
         const clear = Effect.sync(() => {
-            if (progressFor(owner).delete(accepted.sessionId))
+            const hadProgress = current.value !== null;
+            current.value = null;
+            if (hadProgress)
                 publishOwnerObservation(owner, accepted.sessionId, "progress");
             started = undefined;
         });
@@ -51,7 +135,7 @@ export function openProgress(owner, accepted, complete) {
         return Object.freeze({
             started: (event) => Effect.sync(() => {
                 started = event;
-                progressFor(owner).delete(accepted.sessionId);
+                current.value = null;
             }),
             update: (event) => Effect.suspend(() => {
                 const messageStart = started;
@@ -61,25 +145,19 @@ export function openProgress(owner, accepted, complete) {
                     messageStart.turn.value !== event.turn.value ||
                     messageStart.message.value !== event.message.value)
                     return Effect.fail(rejected("Mule progress identity conflicts"));
-                const previous = progressFor(owner).get(accepted.sessionId);
+                const previous = current.value;
                 const content = textFor(event);
-                if (previous?.workId === accepted.commandId &&
-                    previous.value.text === content.text &&
-                    previous.value.thinking === content.thinking)
+                if (previous?.text === content.text &&
+                    previous.thinking === content.thinking)
                     return Effect.void;
-                progressFor(owner).set(accepted.sessionId, Object.freeze({
-                    workId: accepted.commandId,
-                    value: Object.freeze({
-                        messageId: event.message.value,
-                        revision: (previous?.workId === accepted.commandId
-                            ? previous.value.revision
-                            : 0) + 1,
-                        text: content.text,
-                        thinking: content.thinking,
-                        textTruncated: false,
-                        thinkingTruncated: false,
-                    }),
-                }));
+                current.value = Object.freeze({
+                    messageId: event.message.value,
+                    revision: (previous?.revision ?? 0) + 1,
+                    text: content.text,
+                    thinking: content.thinking,
+                    textTruncated: false,
+                    thinkingTruncated: false,
+                });
                 publishOwnerObservation(owner, accepted.sessionId, "progress");
                 return Effect.void;
             }),

package/dist/internal/woodstock/run-recovery.js

@@ -10,7 +10,7 @@ export function recoverAssistantTurn(rows) {
     // A later request was already dispatched. Resend that request from the
     // completed transcript, not the previous assistant turn.
     if (after.some(({ entry }) => entry.kind === "turn_started" ||
-        (entry.kind === "compaction" && entry.resumesRun === true) ||
+        (entry.kind === "compaction" && entry.data.resumesRun) ||
         (entry.kind === "live_retry" &&
             entry.event.type === "auto_retry_start")))
         return undefined;
@@ -28,7 +28,9 @@ export function recoverAssistantTurn(rows) {
                 {
                     call,
                     state: "completed",
-                    result: outcome.result,
+                    result: outcome.data === undefined
+                        ? outcome.result
+                        : { ...outcome.result, data: outcome.data },
                     message: toolResults.find((result) => result.toolCallId === call.id),
                 },
             ];
@@ -57,7 +59,7 @@ export function contextMessageIds(path, activeWorkId) {
             if (terminalWork.has(entry.workId) || entry.workId === activeWorkId)
                 messages.add(row.id);
         }
-        if ((entry.kind === "compaction" && entry.resumesRun === true) ||
+        if ((entry.kind === "compaction" && entry.data.resumesRun) ||
             (entry.kind === "live_retry" && entry.event.type === "auto_retry_start")) {
             const failed = lastWorkAssistant.get(entry.workId);
             if (failed !== undefined)
@@ -74,7 +76,7 @@ export function abnormalTerminal(rows) {
         return undefined;
     if (rows.some(({ sequence, entry }) => sequence > terminal.sequence &&
         (entry.kind === "run_started" ||
-            (entry.kind === "compaction" && entry.resumesRun === true))))
+            (entry.kind === "compaction" && entry.data.resumesRun))))
         return undefined;
     if (terminal.entry.outcome === "cancelled")
         return "cancelled";

package/dist/internal/woodstock/session-attention.d.ts

@@ -4,7 +4,7 @@ import type { SqliteOwner } from "../contracts.js";
 export declare function prepareSessionAttention(owner: SqliteOwner): void;
 /** Read the complete bounded attention projection inside the owner's transaction. */
 export declare function readSessionAttention(owner: SqliteOwner, sessionId: string): readonly SessionAttention[];
-/** Whether any owner still requests attention; no wall-clock expiry heuristic. */
+/** Whether any owner requests inbox attention; drawer-only items stay visible. */
 export declare function hasSessionAttention(owner: SqliteOwner, sessionId: string): boolean;
 /** Upsert only the calling extension's item, in the calling transaction. */
 export declare function setSessionAttention(owner: SqliteOwner, sessionId: string, extensionId: string, item: AttentionItem): void;