@fungi.computer/shiitake 0.6.0 → 0.8.0

package/dist/internal/session-context.js

@@ -14,103 +14,100 @@ function settledContextTokens(store, sessionId) {
     return messages.length === 0 ? null : estimateContextTokens(messages).tokens;
 }
 /**
- * The Session's context use as compaction measures it, against the window of
- * the model a run would select now. Undefined while the Session has no
- * context or its context cannot be read; a window the host cannot describe is
- * null, never guessed.
+ * Read the stored figure synchronously with the Session baseline. Only model
+ * description remains in the returned Effect, outside the SQLite transaction
+ * and the request's ancestry scope. Undefined without readable context; a model
+ * window the host cannot describe is null, never guessed.
  */
-export function readSessionContext(options, sessionId, cursor, cache = true) {
-    return Effect.gen(function* () {
-        const savedPreference = yield* Effect.result(Effect.try({
-            try: () => readSessionModelPreference(options.store, sessionId),
-            catch: (error) => error,
-        }));
-        if (savedPreference._tag === "Failure") {
-            reportCatchFailure("session-context.preference", savedPreference.failure);
-            return undefined;
-        }
-        const preference = savedPreference.success;
-        const preferenceKey = JSON.stringify(preference);
-        const ownerCache = contextByOwner.get(options) ?? new Map();
-        contextByOwner.set(options, ownerCache);
-        const previous = cache ? ownerCache.get(sessionId) : undefined;
-        const describe = options.model.describe;
-        if (previous?.cursor === cursor && previous.preference === preferenceKey) {
-            if (previous.value === undefined || describe === undefined)
-                return previous.value;
-            const previousValue = previous.value;
-            // A null Session override follows a mutable Agent default. Check the
-            // selected window without decoding history again; a changed window is
-            // a distinct effective preference for this cursor.
-            return yield* describe({ sessionId, preference }).pipe(Effect.map(({ contextWindow }) => {
-                if (previousValue.window === contextWindow)
-                    return previousValue;
-                const value = Object.freeze({
-                    tokens: previousValue.tokens,
-                    window: contextWindow,
-                });
-                if (cache && ownerCache.get(sessionId)?.cursor === cursor)
-                    ownerCache.set(sessionId, {
-                        cursor,
-                        preference: preferenceKey,
-                        value,
-                    });
-                return value;
-            }), Effect.catch((error) => Effect.sync(() => {
-                reportCatchFailure("session-context.describe", error);
+export function prepareSessionContext(options, sessionId, cursor, cache = true) {
+    let preference;
+    try {
+        preference = readSessionModelPreference(options.store, sessionId);
+    }
+    catch (error) {
+        reportCatchFailure("session-context.preference", error);
+        return Effect.succeed(undefined);
+    }
+    const preferenceKey = JSON.stringify(preference);
+    const ownerCache = contextByOwner.get(options) ?? new Map();
+    contextByOwner.set(options, ownerCache);
+    const previous = cache ? ownerCache.get(sessionId) : undefined;
+    const describe = options.model.describe;
+    if (previous?.cursor === cursor && previous.preference === preferenceKey) {
+        if (previous.value === undefined || describe === undefined)
+            return Effect.succeed(previous.value);
+        const previousValue = previous.value;
+        // A null Session override follows a mutable Agent default. Check the
+        // selected window without decoding history again; a changed window is
+        // a distinct effective preference for this cursor.
+        return describe({ sessionId, preference }).pipe(Effect.map(({ contextWindow }) => {
+            if (previousValue.window === contextWindow)
                 return previousValue;
-            })));
-        }
-        // At most one cached whole-window read per Session, cursor, and
-        // preference: a late describe may publish only while this cursor still
-        // owns the cache entry. Reads before the tip bypass the cache and each read
-        // the whole window. A cold-cache connection also reads the whole kept
-        // window.
-        const contextRead = yield* Effect.result(Effect.try({
-            try: () => settledContextTokens(options.store, sessionId),
-            catch: (error) => error,
-        }));
-        if (contextRead._tag === "Failure") {
-            reportCatchFailure("session-context.figure", contextRead.failure);
-            return undefined;
-        }
-        const tokens = contextRead.success;
-        if (tokens === null) {
-            if (cache)
+            const value = Object.freeze({
+                tokens: previousValue.tokens,
+                window: contextWindow,
+            });
+            if (cache && ownerCache.get(sessionId)?.cursor === cursor)
                 ownerCache.set(sessionId, {
                     cursor,
                     preference: preferenceKey,
-                    value: undefined,
+                    value,
                 });
-            return undefined;
-        }
-        if (describe === undefined) {
-            const value = Object.freeze({ tokens, window: null });
-            if (cache)
-                ownerCache.set(sessionId, { cursor, preference: preferenceKey, value });
             return value;
-        }
-        // Publish the decoded figure before yielding to the host's model
-        // description. Concurrent watchers then reuse these tokens rather than
-        // decoding the same Session window while `describe` is in flight.
+        }), Effect.catch((error) => Effect.sync(() => {
+            reportCatchFailure("session-context.describe", error);
+            return previousValue;
+        })));
+    }
+    // At most one cached whole-window read per Session, cursor, and
+    // preference: a late describe may publish only while this cursor still
+    // owns the cache entry. Reads before the tip bypass the cache and each read
+    // the whole window. A cold-cache connection also reads the whole kept
+    // window.
+    let tokens;
+    try {
+        tokens = settledContextTokens(options.store, sessionId);
+    }
+    catch (error) {
+        reportCatchFailure("session-context.figure", error);
+        return Effect.succeed(undefined);
+    }
+    if (tokens === null) {
         if (cache)
             ownerCache.set(sessionId, {
                 cursor,
                 preference: preferenceKey,
-                value: Object.freeze({ tokens, window: null }),
+                value: undefined,
             });
-        // A null Session override follows a mutable Agent default. Resolve through
-        // the host's turn-model selector on every read, without acquiring a turn.
-        const window = yield* describe({
-            sessionId,
-            preference,
-        }).pipe(Effect.map(({ contextWindow }) => contextWindow), Effect.catch((error) => Effect.sync(() => {
-            reportCatchFailure("session-context.describe", error);
-            return null;
-        })));
+        return Effect.succeed(undefined);
+    }
+    if (describe === undefined) {
+        const value = Object.freeze({ tokens, window: null });
+        if (cache)
+            ownerCache.set(sessionId, { cursor, preference: preferenceKey, value });
+        return Effect.succeed(value);
+    }
+    // Publish the decoded figure before yielding to the host's model
+    // description. Concurrent watchers then reuse these tokens rather than
+    // decoding the same Session window while `describe` is in flight.
+    if (cache)
+        ownerCache.set(sessionId, {
+            cursor,
+            preference: preferenceKey,
+            value: Object.freeze({ tokens, window: null }),
+        });
+    // A null Session override follows a mutable Agent default. Resolve through
+    // the host's turn-model selector on every read, without acquiring a turn.
+    return describe({
+        sessionId,
+        preference,
+    }).pipe(Effect.map(({ contextWindow }) => contextWindow), Effect.catch((error) => Effect.sync(() => {
+        reportCatchFailure("session-context.describe", error);
+        return null;
+    })), Effect.map((window) => {
         const value = Object.freeze({ tokens, window });
         if (cache && ownerCache.get(sessionId)?.cursor === cursor)
             ownerCache.set(sessionId, { cursor, preference: preferenceKey, value });
         return value;
-    });
+    }));
 }

package/dist/internal/session-status.d.ts

@@ -1,11 +1,13 @@
 import type { WatchdogQueueHead } from "@fungi.computer/watchdog/effect";
 import type { AgentRunningWork, SessionActivity, SessionProgress, SessionToolOutput } from "../client.js";
 import type { SqliteOwner } from "./contracts.js";
-/** Public activity facts plus the process-local progress read with them. */
+/** Activity facts plus an explicit, on-demand bounded progress read. */
 export type ObservedActivity = Readonly<{
     facts: SessionActivity;
-    progress: SessionProgress | null;
+    readProgress: () => SessionProgress | null;
     toolOutput: readonly SessionToolOutput[];
 }>;
+/** Project only the occupying Session's activity, without disclosing its data. */
+export declare function readSessionPhase(owner: SqliteOwner, sessionId: string, head: WatchdogQueueHead): AgentRunningWork["phase"];
 /** Join Watchdog authority with Woodstock facts and process-local progress. */
 export declare function readSessionActivity(owner: SqliteOwner, sessionId: string, head: WatchdogQueueHead, runningWork: AgentRunningWork | null): ObservedActivity;

package/dist/internal/session-status.js

@@ -1,4 +1,20 @@
-import { readProcessProgressForWork, readProcessToolOutputForWork, readProcessCompaction, readLatestLiveRetryForWork, readActiveToolForWork, readLastModelChoiceSequence, } from "./woodstock/index.js";
+import { readProcessProgressForWork, readProcessToolOutputForWork, readProcessCompaction, readLatestLiveRetryForWork, readActiveToolForWork, readLastModelChoiceSequence, readSessionAttention, hasProcessTextForWork, } from "./woodstock/index.js";
+/** Project only the occupying Session's activity, without disclosing its data. */
+export function readSessionPhase(owner, sessionId, head) {
+    const { facts } = readSessionActivity(owner, sessionId, head, null);
+    if (facts.cancellationRequested)
+        return "cancelling";
+    if (readSessionAttention(owner, sessionId).some((item) => item.inbox !== false && item.waitingOn === undefined))
+        return "waiting_on_you";
+    if (facts.compaction !== null || facts.retry !== null)
+        return "thinking";
+    if (facts.activeTool !== null)
+        return "running_tool";
+    if (head.state === "running" &&
+        hasProcessTextForWork(owner, sessionId, head.jobId))
+        return "streaming";
+    return "thinking";
+}
 /** Join Watchdog authority with Woodstock facts and process-local progress. */
 export function readSessionActivity(owner, sessionId, head, runningWork) {
     const lastModelChoiceSequence = readLastModelChoiceSequence(owner, sessionId);
@@ -12,7 +28,7 @@ export function readSessionActivity(owner, sessionId, head, runningWork) {
                 lastModelChoiceSequence,
                 compaction: null,
             },
-            progress: null,
+            readProgress: () => null,
             toolOutput: [],
         };
     if (head.state === "queued")
@@ -27,7 +43,7 @@ export function readSessionActivity(owner, sessionId, head, runningWork) {
                 lastModelChoiceSequence,
                 compaction: null,
             },
-            progress: null,
+            readProgress: () => null,
             toolOutput: [],
         };
     const latestRetry = readLatestLiveRetryForWork(owner, sessionId, head.jobId);
@@ -49,7 +65,9 @@ export function readSessionActivity(owner, sessionId, head, runningWork) {
             lastModelChoiceSequence,
             compaction: readProcessCompaction(owner, sessionId),
         },
-        progress: readProcessProgressForWork(owner, sessionId, head.jobId),
+        // Only baselines need a flattened bounded tail. Live subscribers read
+        // appends directly and must not materialize it on every token.
+        readProgress: () => readProcessProgressForWork(owner, sessionId, head.jobId),
         toolOutput: readProcessToolOutputForWork(owner, sessionId, head.jobId),
     };
 }

package/dist/internal/woodstock/client-projection.js

@@ -5,7 +5,7 @@ import { readSessionDelegator } from "./session-delegator.js";
 import { ShiitakeError } from "../../errors.js";
 import { decodeWoodstockCursor, encodeWoodstockCursor } from "./cursor.js";
 import { operatorClientMessage, promptCommand } from "./session-entry.js";
-import { lineageEntrySequence, lineageHasSequence, lineageRowLimit, readLineageWindow, readLineageWorkFacts, hasSessionWorkTerminal, readSessionEntriesForWork, readSessionLineage, readPendingSessionCommands, readSessionCommandAdmission, readNewestPendingSessionCommand, } from "./session-store.js";
+import { lineageEntrySequence, lineageHasSequence, lineageRowLimit, readLineageWindow, readLineageWorkFacts, hasSessionWorkTerminal, readSessionEntriesForWork, readSessionLineage, readPendingSessionCommands, readSessionCommandAdmission, readNewestPendingSessionCommand, withSessionReadTransaction, } from "./session-store.js";
 const maximumPagePayloadBytes = 2_097_152;
 const replayPageLimit = 200;
 const maximumRowsPerPage = lineageRowLimit;
@@ -344,7 +344,7 @@ function resolveHistoryAnchor(owner, lineage, before) {
  * history, including what compaction summarized away.
  */
 export function readClientSnapshot(owner, sessionId, options, activity, projectExtensions = () => ({})) {
-    return owner.transactionSync(() => {
+    return withSessionReadTransaction(owner, sessionId, () => {
         const pending = readPendingPrompts(owner, sessionId);
         const lineage = readSessionLineage(owner, { sessionId });
         if (lineage === undefined)
@@ -359,7 +359,7 @@ export function readClientSnapshot(owner, sessionId, options, activity, projectE
                 compactionNotices: Object.freeze([]),
                 pending,
                 activity: activity.facts,
-                progress: activity.progress,
+                progress: activity.readProgress(),
                 toolOutput: activity.toolOutput,
                 extensions: projectExtensions(),
                 attention: readSessionAttention(owner, sessionId),
@@ -394,7 +394,7 @@ export function readClientSnapshot(owner, sessionId, options, activity, projectE
             compactionNotices: compactionNoticesIn(consumedRows),
             pending,
             activity: activity.facts,
-            progress: options.before === undefined ? activity.progress : null,
+            progress: options.before === undefined ? activity.readProgress() : null,
             toolOutput: options.before === undefined ? activity.toolOutput : [],
             extensions: projectExtensions(),
             attention: readSessionAttention(owner, sessionId),
@@ -442,12 +442,6 @@ function replayFrames(owner, lineage, start, delivery, activity, extensions, att
             ? { ...frame, sandboxFailures: page.sandboxFailures }
             : frame),
     ];
-    if (delivery === "live" && !page.hasMore && activity.progress !== null)
-        frames.push(Object.freeze({
-            kind: "progress",
-            progress: activity.progress,
-            activity: activity.facts,
-        }));
     return Object.freeze({
         kind: "page",
         frames: Object.freeze(!page.hasMore
@@ -468,7 +462,7 @@ export function readClientReplayPage(owner, sessionId, after, delivery, activity
     const position = after === undefined ? undefined : decodeWoodstockCursor(after);
     if (after !== undefined && position === undefined)
         return resetReplayPage;
-    return owner.transactionSync(() => {
+    return withSessionReadTransaction(owner, sessionId, () => {
         const pending = readPendingPrompts(owner, sessionId);
         const lineage = readSessionLineage(owner, { sessionId });
         if (lineage === undefined) {

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

@@ -27,10 +27,11 @@ export declare function createFleetDelegationStore(storage: WatchdogSqliteOwner)
     read: (requestId: string) => {
         readonly [x: string]: string | number | ArrayBuffer | null;
     } | undefined;
-    /** Every recipient-accepted delegation, newest first. */
-    sent: () => readonly {
+    /** Accepted sends not yet observed settled, for owner-local archive admission. */
+    unsettled: () => readonly {
         readonly [x: string]: string | number | ArrayBuffer | null;
     }[];
+    recordSettled(requestId: string): void;
     reserve(requestId: string, input: string, mail: string): void;
     recordReceipt(requestId: string, receipt: string, expectedMail: string, acceptedMail: string): void;
     recordHeld(requestId: string): void;

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

@@ -90,6 +90,12 @@ export function createFleetDelegationStore(storage) {
     storage.sql
         .exec(`CREATE TABLE IF NOT EXISTS shiitake_fleet_undeliverable_delegations (
     request_id TEXT PRIMARY KEY
+  ) STRICT`);
+    // A remote settlement confirmed by this owner. Without this local fact an
+    // accepted sender receipt remains indistinguishable from outstanding work.
+    storage.sql
+        .exec(`CREATE TABLE IF NOT EXISTS shiitake_fleet_settled_delegations (
+    request_id TEXT PRIMARY KEY
   ) STRICT`);
     return {
         read: (requestId) => storage.sql
@@ -108,13 +114,27 @@ export function createFleetDelegationStore(storage) {
             ON terminal.request_id = delegation.request_id
           WHERE delegation.request_id = ?`, requestId)
             .toArray()[0],
-        /** Every recipient-accepted delegation, newest first. */
-        sent: () => storage.sql
+        /** Accepted sends not yet observed settled, for owner-local archive admission. */
+        unsettled: () => storage.sql
             .exec(`SELECT input, mail, 'accepted' AS state, receipt
-          FROM shiitake_fleet_delegations
+          FROM shiitake_fleet_delegations AS delegation
           WHERE receipt IS NOT NULL
-          ORDER BY rowid DESC`)
+            AND NOT EXISTS (
+              SELECT 1 FROM shiitake_fleet_settled_delegations AS settled
+              WHERE settled.request_id = delegation.request_id
+            )
+          ORDER BY delegation.rowid DESC`)
             .toArray(),
+        recordSettled(requestId) {
+            storage.transactionSync(() => {
+                const accepted = storage.sql
+                    .exec("SELECT 1 FROM shiitake_fleet_delegations WHERE request_id = ? AND receipt IS NOT NULL", requestId)
+                    .toArray();
+                if (accepted.length !== 1)
+                    throw new Error("Cannot record settlement without acceptance");
+                storage.sql.exec("INSERT OR IGNORE INTO shiitake_fleet_settled_delegations(request_id) VALUES(?)", requestId);
+            });
+        },
         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

@@ -119,7 +119,7 @@ export declare function readSettlementDiagnostic(owner: SqliteOwner, input: Read
     commandFactId: string;
 }>): Effect.Effect<string | undefined, ShiitakeError>;
 /** Read one bounded public Session snapshot. */
-export declare function readSession(owner: SqliteOwner, sessionId: string, activity: ObservedActivity, input?: ReadOptions, projectExtensions?: () => SessionExtensionSlots): Effect.Effect<SessionSnapshot, ShiitakeError>;
+export declare function readSession<A>(owner: SqliteOwner, sessionId: string, activity: () => ObservedActivity, input: ReadOptions | undefined, projectExtensions: () => SessionExtensionSlots, complete: (snapshot: SessionSnapshot) => A): Effect.Effect<A, ShiitakeError>;
 /** Read one bounded folder-resume summary through Woodstock's Effect boundary. */
 export declare function readSessionSummary(owner: SqliteOwner, sessionId: string): Effect.Effect<import("./session-store.js").StoredSessionSummary | undefined, ShiitakeError>;
 /**
@@ -142,8 +142,8 @@ export declare function readColdSessionPage(owner: SqliteOwner, request: ColdSes
 export declare function readSessionInbox(owner: SqliteOwner, after: string | undefined): Effect.Effect<import("../../client.js").SessionSummaryPage, ShiitakeError>;
 /** Read a Session's open attention items from the store alone. */
 export declare function readStoredSessionAttention(owner: SqliteOwner, sessionId: string): Effect.Effect<readonly import("../../client.js").SessionAttention[], ShiitakeError>;
-/** Read one strict-after page from Woodstock's selected lineage. */
-export declare function readSessionReplayPage(owner: SqliteOwner, sessionId: string, after: string | undefined, delivery: "replay" | "live", activity: ObservedActivity, projectExtensions?: () => SessionExtensionSlots, includeSandboxFailures?: boolean): Effect.Effect<ClientReplayPage, ShiitakeError>;
+/** Read and complete one strict-after page in the same Session transaction. */
+export declare function readSessionReplayPage<A>(owner: SqliteOwner, sessionId: string, after: string | undefined, delivery: "replay" | "live", activity: ObservedActivity, projectExtensions: () => SessionExtensionSlots, includeSandboxFailures: boolean, complete: (page: ClientReplayPage) => A): Effect.Effect<A, ShiitakeError>;
 /** Persist an operator-only sandbox diagnostic beside its accepted Session work. */
 export declare function recordSandboxFailure(owner: SqliteOwner, accepted: Pick<AcceptedCommand, "sessionId" | "commandId">, event: SandboxFailureEvent): Effect.Effect<void, ShiitakeError>;
 /** Extension that admitted one accepted command; null for other producers. */

package/dist/internal/woodstock/index.js

@@ -5,9 +5,10 @@ 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 { decodeWoodstockCursor } from "./cursor.js";
 import { openProgress, openToolProgress } from "./progress.js";
 import { encodeStoredSessionEntry, } from "./session-entry.js";
-import { appendSessionEntry, appendCompactionTransitionOwned, appendCompactionNoticeOwned, placeCompactionTransitionOwned, acceptSessionAbort, acceptSessionCancellation, completeSessionLeaf, prepareSessionRun, prepareSessionStore, readSessionEntriesForWork, readSessionCommandAdmission, settleSessionControls, takePendingSessionControls, readSessionEntryById, selectSessionBranch, forkSessionAt, readStoredSessionSummary as readSessionSummaryOwned, readStoredSessionFactPage, createStoredSession, createStoredSessionWithinTransaction, 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, createStoredSessionWithinTransaction, deleteStoredSession, appendOperatorEntry, withSessionRead, } from "./session-store.js";
 import { readSessionInboxPage, recordSessionInboxDeletion, } from "./session-inbox.js";
 import { readSessionAttention } from "./session-attention.js";
 export * from "./extension-store.js";
@@ -191,8 +192,14 @@ export function readSettlementDiagnostic(owner, input) {
     });
 }
 /** Read one bounded public Session snapshot. */
-export function readSession(owner, sessionId, activity, input, projectExtensions = () => ({})) {
-    return storeEffect(() => readClientSnapshot(owner, decodeClientSessionId(sessionId), decodeClientReadOptions(input), activity, projectExtensions));
+export function readSession(owner, sessionId, activity, input, projectExtensions, complete) {
+    return storeEffect(() => {
+        const id = decodeClientSessionId(sessionId);
+        const options = decodeClientReadOptions(input);
+        return withSessionRead(owner, id, () => complete(readClientSnapshot(owner, id, options, activity(), projectExtensions)), options.before === undefined
+            ? undefined
+            : decodeWoodstockCursor(options.before)?.sequence);
+    });
 }
 /** Read one bounded folder-resume summary through Woodstock's Effect boundary. */
 export function readSessionSummary(owner, sessionId) {
@@ -235,9 +242,12 @@ export function readSessionInbox(owner, after) {
 export function readStoredSessionAttention(owner, sessionId) {
     return storeEffect(() => readSessionAttention(owner, sessionId));
 }
-/** Read one strict-after page from Woodstock's selected lineage. */
-export function readSessionReplayPage(owner, sessionId, after, delivery, activity, projectExtensions = () => ({}), includeSandboxFailures = false) {
-    return storeEffect(() => readClientReplayPage(owner, decodeClientSessionId(sessionId), after, delivery, activity, projectExtensions, includeSandboxFailures));
+/** Read and complete one strict-after page in the same Session transaction. */
+export function readSessionReplayPage(owner, sessionId, after, delivery, activity, projectExtensions, includeSandboxFailures, complete) {
+    return storeEffect(() => {
+        const id = decodeClientSessionId(sessionId);
+        return withSessionRead(owner, id, () => complete(readClientReplayPage(owner, id, after, delivery, activity, projectExtensions, includeSandboxFailures)));
+    });
 }
 function sameEntry(left, right) {
     return encodeStoredSessionEntry(left) === encodeStoredSessionEntry(right);
@@ -523,10 +533,11 @@ export function recordLiveRetryEvent(owner, accepted, event, turn) {
             sameIdentity(current.event.run, event.run));
     }).pipe(Effect.mapError(listenerFailure));
 }
-const listenerFailure = () => ({
+const listenerFailure = (cause) => ({
     _tag: "MuleError",
     phase: "listener",
     message: "Woodstock could not record the Mule event",
+    cause,
 });
 /**
  * Open the one scoped listener that projects Mule's exact event stream into

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

@@ -1,10 +1,20 @@
 import type { MuleEvent } from "@fungi.computer/mule";
 import * as Effect from "effect/Effect";
 import type * as Scope from "effect/Scope";
-import type { SessionProgress, SessionToolOutput } from "../../client.js";
+import type { SessionProgress, SessionProgressDelta, SessionToolOutput } from "../../client.js";
 import { ShiitakeError } from "../../errors.js";
 import type { SqliteOwner } from "../contracts.js";
 import type { AcceptedCommand } from "./session-store.js";
+/** Per-watch position; a gap in the retained tail requires a fresh baseline. */
+export type ProgressPosition = Readonly<{
+    messageId: string;
+    revision: number;
+    text: number;
+    thinking: number;
+}>;
+export declare function progressPosition(value: SessionProgress | null): ProgressPosition | null;
+/** Undefined means continuity was lost; null means no new model progress. */
+export declare function readProcessProgressDelta(owner: SqliteOwner, sessionId: string, workId: string, after: ProgressPosition | null): SessionProgressDelta | null | undefined;
 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<{
@@ -22,6 +32,8 @@ export declare function openToolProgress(owner: SqliteOwner, accepted: AcceptedC
 export declare function readProcessProgress(owner: SqliteOwner, sessionId: string): SessionProgress | null;
 /** Read progress only when it belongs to the current durable work head. */
 export declare function readProcessProgressForWork(owner: SqliteOwner, sessionId: string, workId: string): SessionProgress | null;
+/** Read a phase fact without flattening another Session's private text tails. */
+export declare function hasProcessTextForWork(owner: SqliteOwner, sessionId: string, workId: string): boolean;
 export type ProgressMessageStart = Extract<MuleEvent, {
     type: "message_start";
 }>;