@fungi.computer/shiitake 0.5.0 → 0.7.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,10 +1,10 @@
 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[];
 }>;
 /** Join Watchdog authority with Woodstock facts and process-local progress. */

package/dist/internal/session-status.js

@@ -12,7 +12,7 @@ export function readSessionActivity(owner, sessionId, head, runningWork) {
                 lastModelChoiceSequence,
                 compaction: null,
             },
-            progress: null,
+            readProgress: () => null,
             toolOutput: [],
         };
     if (head.state === "queued")
@@ -27,7 +27,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 +49,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/agent-reply.d.ts

@@ -9,6 +9,11 @@ export declare const VerifiedAgentReplySchema: Schema.Union<readonly [Schema.Str
     readonly commandId: Schema.String;
     readonly outcome: Schema.Literals<readonly ["completed", "failed", "interrupted", "cancelled", "outcome_unknown"]>;
     readonly diagnostic: Schema.optionalKey<Schema.String>;
+    readonly waitingOnYou: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly itemId: Schema.String;
+        readonly kind: Schema.String;
+        readonly summary: Schema.String;
+    }>>>;
     readonly agentId: Schema.String;
     readonly sessionId: Schema.String;
 }>, Schema.Struct<{

package/dist/internal/woodstock/agent-reply.js

@@ -42,6 +42,9 @@ function opening(reply) {
     attributes.push(["outcome", reply.outcome]);
     if (reply.outcome !== "undeliverable" && reply.diagnostic !== undefined)
         attributes.push(["diagnostic", reply.diagnostic]);
+    if (reply.outcome !== "undeliverable" && reply.waitingOnYou !== undefined)
+        // A host fact, outside the child's text: the items the child left waiting on the recipient.
+        attributes.push(["waiting_on_you", JSON.stringify(reply.waitingOnYou)]);
     if (reply.outcome === "undeliverable")
         attributes.push(["reason", reply.reason]);
     const rendered = attributes

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

@@ -1,9 +1,11 @@
 import { messageAuthor } from "@fungi.computer/agar/agents";
 import { readSessionAttention } from "./session-attention.js";
+import { readWaitingOnSender } from "./work-senders.js";
+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, 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;
@@ -342,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)
@@ -357,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),
@@ -392,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),
@@ -440,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
@@ -466,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) {
@@ -503,6 +499,10 @@ export function projectCommandSettlement(owner, sessionId, commandId) {
     const admission = readSessionCommandAdmission(owner, sessionId, commandId);
     if (admission === undefined)
         throw unavailable("Accepted Session command is unavailable");
+    // A live work has no settlement to project. The owner's terminal index
+    // answers this without decoding the work again on every polling tick.
+    if (!hasSessionWorkTerminal(owner, sessionId, admission.entry.workId))
+        return undefined;
     const rows = readSessionEntriesForWork(owner, sessionId, admission.entry.workId);
     const work = workFacts(owner, sessionId, rows);
     const terminal = rows
@@ -521,6 +521,7 @@ export function projectCommandSettlement(owner, sessionId, commandId) {
     const sender = messageAuthor(admission.entry.meta);
     return {
         acceptedSender: sender?.kind === "agent" ? sender.id : null,
+        delegator: readSessionDelegator(owner, sessionId)?.replyTo[0]?.agentId ?? null,
         terminal: meta === undefined ? terminal : { ...terminal, meta },
         content: terminal.outcome === "cancelled"
             ? ""
@@ -534,5 +535,6 @@ export function projectCommandSettlement(owner, sessionId, commandId) {
             usage,
         })),
         toolCalls: new Set(rows.flatMap(({ entry }) => entry.kind === "tool_intent" ? [entry.call.id] : [])).size,
+        waitingOnYou: readWaitingOnSender(owner, sessionId, admission.entry.workId),
     };
 }

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

@@ -15,6 +15,8 @@ export * from "./extension-store.js";
 export { readLatestPendingPrompt } from "./client-projection.js";
 export { createFleetDirectoryStore, createFleetDelegationStore, } from "./fleet-store.js";
 export * from "./session-attention.js";
+export * from "./work-senders.js";
+export * from "./session-delegator.js";
 export { deliverSessionGrants, prepareSessionGrants, readSessionGrants, type GrantsDelivery, type GrantsDeliveryResult, } from "./session-grants.js";
 export * from "./progress.js";
 export * from "./compaction-activity.js";
@@ -117,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>;
 /**
@@ -138,8 +140,10 @@ export declare function readSessionFactPage(owner: SqliteOwner, after?: string):
 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. */
-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 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 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,14 +5,18 @@ 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";
 export { readLatestPendingPrompt } from "./client-projection.js";
 export { createFleetDirectoryStore, createFleetDelegationStore, } from "./fleet-store.js";
 export * from "./session-attention.js";
+export * from "./work-senders.js";
+export * from "./session-delegator.js";
 export { deliverSessionGrants, prepareSessionGrants, readSessionGrants, } from "./session-grants.js";
 export * from "./progress.js";
 export * from "./compaction-activity.js";
@@ -188,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) {
@@ -228,9 +238,16 @@ export function readColdSessionPage(owner, request) {
 export function readSessionInbox(owner, after) {
     return storeEffect(() => readSessionInboxPage(owner, after));
 }
-/** 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 a Session's open attention items from the store alone. */
+export function readStoredSessionAttention(owner, sessionId) {
+    return storeEffect(() => readSessionAttention(owner, sessionId));
+}
+/** 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);

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<{