@fungi.computer/shiitake 0.2.0 → 0.3.1

package/dist/internal/runtime-coordinator.js

@@ -8,6 +8,7 @@ import { ShiitakeError } from "../errors.js";
 import { agentTurnRecovery, executeAcceptedRun, } from "./accepted-run-executor.js";
 import { openAdmissionDoor } from "./admission-door.js";
 import { openCompactionSettings } from "./compaction/settings.js";
+import { admitExtensionRosterV0, } from "./extension-roster.js";
 import { coreConsumer, openExtensionRuntime, } from "./extension-runtime.js";
 import { reconcileRuntime } from "./runtime-reconciliation.js";
 import { advanceCursor, prepareExtensionStore, projectSessionRun, openStorageAdmission, readCursor, } from "./woodstock/index.js";
@@ -36,6 +37,9 @@ export function openRuntimeCoordinator(options, coreDigest, admitted, mailRoom)
         }).pipe(Effect.uninterruptible);
         const boundRuntime = {};
         const extensionsRef = { current: undefined };
+        let turnOptions = options;
+        let pendingConfiguration;
+        let preparing = false;
         const requestBoundWake = Effect.suspend(() => boundRuntime.requestWake ??
             Effect.fail(runtimeFailure("Runtime host is unavailable")));
         const hostExecutor = { current: undefined };
@@ -64,7 +68,17 @@ export function openRuntimeCoordinator(options, coreDigest, admitted, mailRoom)
                 }), () => job.lane === options.hostJobs?.lane
                     ? (hostExecutor.current?.execute(job) ??
                         Effect.fail(new WatchdogError("execution_failed")))
-                    : executeAcceptedRun(options, coreDigest, job, extensionsRef.current), () => Effect.sync(() => {
+                    : Effect.gen(function* () {
+                        const pending = pendingConfiguration;
+                        if (pending !== undefined) {
+                            yield* pending.apply;
+                            const { tools: oldTools, ...base } = options;
+                            void oldTools;
+                            turnOptions = { ...base, ...pending.configuration };
+                            pendingConfiguration = undefined;
+                        }
+                        return yield* executeAcceptedRun(turnOptions, coreDigest, job, extensionsRef.current);
+                    }).pipe(Effect.tapError((error) => Effect.logError("configuration_apply_failed", error)), Effect.mapError(() => new WatchdogError("execution_failed"))), () => Effect.sync(() => {
                     if (job.lane !== options.hostJobs?.lane)
                         activeSessions.delete(job.queue);
                     runningSlots.delete(job.lane === options.hostJobs?.lane ? "host" : "serial");
@@ -100,7 +114,7 @@ export function openRuntimeCoordinator(options, coreDigest, admitted, mailRoom)
                 : runtimeFailure("Compaction settings are unavailable"),
         });
         const storage = yield* Effect.try({
-            try: () => openStorageAdmission(options.storageBudget),
+            try: () => openStorageAdmission(options.storagePressure),
             catch: (error) => error instanceof ShiitakeError
                 ? error
                 : runtimeFailure("Storage budget is unavailable"),
@@ -160,9 +174,24 @@ export function openRuntimeCoordinator(options, coreDigest, admitted, mailRoom)
                 try: () => extensions.timerWake(now),
                 catch: () => runtimeFailure("Extension timers are unavailable"),
             });
+            const mailWake = mailRoom === undefined
+                ? undefined
+                : yield* mailRoom
+                    .nextWakeAt()
+                    .pipe(Effect.mapError(() => runtimeFailure("Reply retry wake is unavailable")));
+            // Carrier owns reply retry state. Keep it in the same durable answer
+            // as runtime work, so a host cannot erase its wake with an idle result.
+            const nextWakeAt = timers.nextWakeAt === null
+                ? (mailWake ?? null)
+                : mailWake === undefined
+                    ? timers.nextWakeAt
+                    : Math.min(timers.nextWakeAt, mailWake);
             return {
-                pending: watchdogPending || settledLag || timers.due,
-                nextWakeAt: timers.nextWakeAt,
+                pending: watchdogPending ||
+                    settledLag ||
+                    timers.due ||
+                    (mailWake !== undefined && mailWake <= now),
+                nextWakeAt,
             };
         });
         const bound = yield* options.runtime
@@ -179,6 +208,38 @@ export function openRuntimeCoordinator(options, coreDigest, admitted, mailRoom)
         // Every host must get one post-bind tick to recover durable work after a cold reopen.
         yield* bound.requestWake.pipe(Effect.onError(() => Effect.all([bound.close, extensions.close]).pipe(Effect.orDie)));
         return Object.freeze({
+            prepareConfiguration: (configuration) => Effect.gen(function* () {
+                if (lifecycleState !== "open" ||
+                    preparing ||
+                    pendingConfiguration !== undefined)
+                    return yield* Effect.fail(runtimeFailure("A configuration change is already pending, or the Agent is closing"));
+                preparing = true;
+                const staged = yield* admitExtensionRosterV0(configuration.extensions).pipe(Effect.flatMap((next) => extensions.stage(next)), Effect.onError(() => Effect.sync(() => {
+                    preparing = false;
+                })));
+                let settled = false;
+                return {
+                    commit: Effect.try({
+                        try: () => {
+                            if (settled || lifecycleState !== "open")
+                                throw runtimeFailure("Configuration preparation is no longer available");
+                            pendingConfiguration = { configuration, apply: staged.apply };
+                            settled = true;
+                            preparing = false;
+                        },
+                        catch: (cause) => cause instanceof ShiitakeError
+                            ? cause
+                            : runtimeFailure("Configuration commit failed"),
+                    }),
+                    discard: Effect.suspend(() => {
+                        if (settled)
+                            return Effect.void;
+                        settled = true;
+                        preparing = false;
+                        return staged.discard;
+                    }),
+                };
+            }),
             activeSessions: Effect.sync(() => [...activeSessions]),
             runningWork: (jobId) => watchdog.read(jobId).pipe(Effect.map((result) => result.status === "found"
                 ? (runningSlots.get(result.job.lane === options.hostJobs?.lane

package/dist/internal/runtime-core.js

@@ -23,6 +23,7 @@ export function openRuntimeCore(options, mailRoom) {
         });
         const owner = Object.freeze({
             ...agent,
+            prepareConfiguration: runtime.prepareConfiguration,
             grants: coordinator.grants,
             withMeta: (meta) => Object.freeze({
                 ...agent,

package/dist/internal/runtime-reconciliation.js

@@ -7,7 +7,7 @@ import { ShiitakeError } from "../errors.js";
 import { ExtensionId } from "../extension-contract.js";
 import { coreConsumer } from "./extension-runtime.js";
 import { publishOwnerObservation } from "./observation-kernel.js";
-import { advanceCursor, readCursor, readSettledRunFacts, readSettlementContent, readSettlementDiagnostic, readSettlementMeta, recordWorkSettlement, settleControls, } from "./woodstock/index.js";
+import { advanceCursor, readCursor, readExtensionAdmissionOrigin, readSettledRunFacts, readSettlementContent, readSettlementDiagnostic, readSettlementMeta, recordWorkSettlement, sessionLineageRefused, settleControls, } from "./woodstock/index.js";
 const pageSize = 64;
 function runtimeFailure(message) {
     return new ShiitakeError("runtime", "rejected", message);
@@ -66,6 +66,7 @@ function settleTargetedControls(store, watchdog, job) {
             sessionId: payload.work.sessionId,
             parentWorkId: job.jobId,
             outcome,
+            diagnostic: job.failureReason,
             enqueue: (work) => {
                 watchdog.transactional.enqueueAcceptedJob(agentJobFromInput({ work: { ...work, recovery: agentTurnRecovery } }));
             },
@@ -79,10 +80,41 @@ function drainMail(mailRoom) {
         .drainOutbox()
         .pipe(Effect.mapError(() => runtimeFailure("Agent reply delivery is unavailable")));
 }
-/** Join one core-processed settled record with its exact Woodstock facts. */
+/**
+ * Whether the settled work belongs to a Session the lineage audit refused.
+ * Nothing more can be recorded in that Session: its Watchdog settlement, with
+ * the refusal as its failure reason, is the work's whole terminal.
+ */
+function settledInRefusedSession(store, job) {
+    return Effect.gen(function* () {
+        const payload = yield* Effect.try({
+            try: () => decodeAgentJob(job),
+            catch: () => runtimeFailure("Agent work payload is invalid"),
+        });
+        const refused = yield* Effect.try({
+            try: () => sessionLineageRefused(store, payload.work.sessionId),
+            catch: () => runtimeFailure("Session lineage state is unavailable"),
+        });
+        if (refused)
+            yield* Effect.logWarning("shiitake_settlement_session_refused").pipe(Effect.annotateLogs({ workId: job.jobId }));
+        return refused;
+    });
+}
+/**
+ * Join one core-processed settled record with its exact Woodstock facts. A
+ * run of a Session the lineage audit refused reaches extensions with only
+ * Watchdog's outcome and its admission origin: no terminal and no tool
+ * calls can be read from that history.
+ */
 function settledRun(store, record) {
     const payload = decodeAgentJob(record.job);
-    const facts = readSettledRunFacts(store, payload.work.sessionId, payload.work.commandFactId, record.job.jobId);
+    const facts = sessionLineageRefused(store, payload.work.sessionId)
+        ? Object.freeze({
+            terminal: "missing",
+            toolCalls: 0,
+            origin: readExtensionAdmissionOrigin(store, payload.work.sessionId, payload.work.commandFactId, record.job.jobId),
+        })
+        : readSettledRunFacts(store, payload.work.sessionId, payload.work.commandFactId, record.job.jobId);
     return Object.freeze({
         sequence: record.sequence,
         sessionId: payload.work.sessionId,
@@ -111,9 +143,13 @@ function settleCore(store, watchdog, mailRoom, records) {
         // leave live watchers reporting the finished run as active. A replay
         // after a crash repeats the same announcement.
         publishOwnerObservation(store, record.job.queue);
-        yield* repairWorkSettlement(store, record.job);
-        yield* settleTargetedControls(store, watchdog, record.job);
-        yield* fanOutSettlement(store, mailRoom, record.job);
+        // A refused Session can neither record a repair nor give a reply
+        // its content: the failed Watchdog settlement is all there is.
+        if (!(yield* settledInRefusedSession(store, record.job))) {
+            yield* repairWorkSettlement(store, record.job);
+            yield* settleTargetedControls(store, watchdog, record.job);
+            yield* fanOutSettlement(store, mailRoom, record.job);
+        }
         yield* Effect.try({
             try: () => {
                 advanceCursor(store, coreConsumer, record.sequence);

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

@@ -1,11 +1,10 @@
 import * as Effect from "effect/Effect";
 import type { SessionContext } from "../client.js";
 import type { ShiitakeEffectOptions } from "./effect-contracts.js";
-import type { RuntimeCoordinator } from "./runtime-coordinator.js";
 /**
  * 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.
  */
-export declare function readSessionContext(options: ShiitakeEffectOptions, runtime: RuntimeCoordinator, sessionId: string): Effect.Effect<SessionContext | undefined>;
+export declare function readSessionContext(options: ShiitakeEffectOptions, sessionId: string): Effect.Effect<SessionContext | undefined>;

package/dist/internal/session-context.js

@@ -1,5 +1,5 @@
 import * as Effect from "effect/Effect";
-import { estimateThresholdContextTokens } from "./compaction/session-compaction.js";
+import { estimateContextTokens } from "@earendil-works/pi-ai/utils/estimate";
 import { reportCatchFailure } from "./failure.js";
 import { buildSessionContext, readSessionContextPath, readSessionModelPreference, } from "./woodstock/index.js";
 /**
@@ -10,22 +10,7 @@ import { buildSessionContext, readSessionContextPath, readSessionModelPreference
 function settledContextTokens(store, sessionId) {
     const path = readSessionContextPath(store, { sessionId });
     const messages = buildSessionContext(path);
-    return messages.length === 0
-        ? null
-        : estimateThresholdContextTokens(path, messages);
-}
-/**
- * Each runtime keeps the last described window per Session. A saved model
- * preference changes the key, so `/model` is described again at once.
- */
-const describedWindows = new WeakMap();
-function windowsFor(runtime) {
-    const existing = describedWindows.get(runtime);
-    if (existing !== undefined)
-        return existing;
-    const created = new Map();
-    describedWindows.set(runtime, created);
-    return created;
+    return messages.length === 0 ? null : estimateContextTokens(messages).tokens;
 }
 /**
  * The Session's context use as compaction measures it, against the window of
@@ -33,7 +18,7 @@ function windowsFor(runtime) {
  * context or its context cannot be read; a window the host cannot describe is
  * null, never guessed.
  */
-export function readSessionContext(options, runtime, sessionId) {
+export function readSessionContext(options, sessionId) {
     return Effect.gen(function* () {
         // A context too large to read safely has no footer figure.
         const read = yield* Effect.result(Effect.try({
@@ -46,22 +31,15 @@ export function readSessionContext(options, runtime, sessionId) {
         if (read._tag === "Failure" || read.success.tokens === null)
             return undefined;
         const { tokens, preference } = read.success;
-        const windows = windowsFor(runtime);
-        const key = JSON.stringify(preference);
-        const cached = windows.get(sessionId);
-        if (cached?.preference === key)
-            return Object.freeze({ tokens, window: cached.window });
         const describe = options.model.describe;
         if (describe === undefined)
             return Object.freeze({ tokens, window: null });
-        const described = yield* describe({ sessionId, preference }).pipe(Effect.map(({ contextWindow }) => contextWindow), Effect.catch((error) => Effect.sync(() => {
+        // 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 undefined;
+            return null;
         })));
-        // A failed description is retried on the next read, never cached.
-        if (described === undefined)
-            return Object.freeze({ tokens, window: null });
-        windows.set(sessionId, { preference: key, window: described });
-        return Object.freeze({ tokens, window: described });
+        return Object.freeze({ tokens, window });
     });
 }

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

@@ -1,10 +1,11 @@
 import type { WatchdogQueueHead } from "@fungi.computer/watchdog/effect";
-import type { AgentRunningWork, SessionActivity, SessionProgress } from "../client.js";
+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. */
 export type ObservedActivity = Readonly<{
     facts: SessionActivity;
     progress: SessionProgress | null;
+    toolOutput: readonly SessionToolOutput[];
 }>;
 /** 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,4 @@
-import { readProcessProgressForWork, readProcessCompaction, readLatestLiveRetryForWork, readActiveToolForWork, readLastModelChoiceSequence, } from "./woodstock/index.js";
+import { readProcessProgressForWork, readProcessToolOutputForWork, readProcessCompaction, readLatestLiveRetryForWork, readActiveToolForWork, readLastModelChoiceSequence, } from "./woodstock/index.js";
 /** Join Watchdog authority with Woodstock facts and process-local progress. */
 export function readSessionActivity(owner, sessionId, head, runningWork) {
     const lastModelChoiceSequence = readLastModelChoiceSequence(owner, sessionId);
@@ -13,6 +13,7 @@ export function readSessionActivity(owner, sessionId, head, runningWork) {
                 compaction: null,
             },
             progress: null,
+            toolOutput: [],
         };
     if (head.state === "queued")
         // The queue job id is the admitted command id: the one identity a person
@@ -27,6 +28,7 @@ export function readSessionActivity(owner, sessionId, head, runningWork) {
                 compaction: null,
             },
             progress: null,
+            toolOutput: [],
         };
     const latestRetry = readLatestLiveRetryForWork(owner, sessionId, head.jobId);
     const retry = latestRetry?.event.type === "auto_retry_start"
@@ -48,5 +50,6 @@ export function readSessionActivity(owner, sessionId, head, runningWork) {
             compaction: readProcessCompaction(owner, sessionId),
         },
         progress: readProcessProgressForWork(owner, sessionId, head.jobId),
+        toolOutput: readProcessToolOutputForWork(owner, sessionId, head.jobId),
     };
 }

package/dist/internal/woodstock/client-projection.d.ts

@@ -1,14 +1,15 @@
-import type { SessionFrame, SessionExtensionSlots, SessionSnapshot } from "../../client.js";
+import type { SessionFrame, SessionExtensionSlots, SessionPendingPrompts, SessionSnapshot } from "../../client.js";
 import type { ClientReadOptions } from "../client-boundary.js";
 import type { CommandSettlement, SqliteOwner } from "../contracts.js";
 import type { ObservedActivity } from "../session-status.js";
-import { type StoredSessionRow } from "./session-store.js";
+import { type AdmissionIdentity, type StoredSessionRow } from "./session-store.js";
 /**
- * Newest failure message each work recorded: a work-terminal diagnostic, an
- * assistant error or a final retry error. Raw text; clients and the reply
- * fan-out decide how to present and bound it.
+ * Newest owner-produced terminal diagnostic for each work. Pi assistant errors
+ * and retry text can contain private provider bodies, not safe diagnostics.
  */
 export declare function diagnosticsByWorkId(path: readonly StoredSessionRow[]): ReadonlyMap<string, string>;
+/** Same payload projection as the FIFO page, selected independently of that page's bounds. */
+export declare function readLatestPendingPrompt(owner: SqliteOwner, sessionId: string, identity?: AdmissionIdentity): SessionPendingPrompts["prompts"][number] | null;
 /**
  * Read one bounded public baseline from the selected Session lineage. Only
  * the page's rows are decoded; `before` pages back through the whole saved

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

@@ -1,8 +1,9 @@
+import { messageAuthor } from "@fungi.computer/agar/agents";
 import { readSessionAttention } from "./session-attention.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, } from "./session-store.js";
+import { lineageEntrySequence, lineageHasSequence, lineageRowLimit, readLineageWindow, readLineageWorkFacts, readSessionEntriesForWork, readSessionLineage, readPendingSessionCommands, readSessionCommandAdmission, readNewestPendingSessionCommand, } from "./session-store.js";
 const maximumPagePayloadBytes = 2_097_152;
 const replayPageLimit = 200;
 const maximumRowsPerPage = lineageRowLimit;
@@ -80,6 +81,7 @@ function projectMessage(row, work) {
             id: row.id,
             sequence: row.sequence,
             commandId: prompt.workId,
+            requestId: prompt.requestId,
             value: prompt.message,
         };
         let projected = message;
@@ -94,6 +96,7 @@ function projectMessage(row, work) {
             id: row.id,
             sequence: row.sequence,
             commandId: null,
+            requestId: row.entry.requestId,
             value: operatorClientMessage(row.entry),
         };
         let projected = message;
@@ -101,34 +104,30 @@ function projectMessage(row, work) {
             projected = { ...projected, meta: row.entry.meta };
         return Object.freeze(projected);
     }
-    if (row.entry.kind === "message")
-        return Object.freeze({
+    if (row.entry.kind === "message") {
+        const message = {
             id: row.entry.message.value,
             sequence: row.sequence,
             commandId: work.commandIds.get(row.entry.workId) ?? null,
             value: row.entry.value,
-        });
+        };
+        return Object.freeze(row.entry.data === undefined
+            ? message
+            : { ...message, data: row.entry.data });
+    }
     return undefined;
 }
 /**
- * Newest failure message each work recorded: a work-terminal diagnostic, an
- * assistant error or a final retry error. Raw text; clients and the reply
- * fan-out decide how to present and bound it.
+ * Newest owner-produced terminal diagnostic for each work. Pi assistant errors
+ * and retry text can contain private provider bodies, not safe diagnostics.
  */
 export function diagnosticsByWorkId(path) {
     const diagnostics = new Map();
     for (const { entry } of path) {
-        if (entry.kind === "work_terminal" && entry.diagnostic !== undefined) {
+        if ((entry.kind === "work_terminal" || entry.kind === "run_terminal") &&
+            entry.diagnostic !== undefined) {
             diagnostics.set(entry.workId, entry.diagnostic);
         }
-        else if (entry.kind === "message" && entry.value.role === "assistant") {
-            if (entry.value.errorMessage !== undefined)
-                diagnostics.set(entry.workId, entry.value.errorMessage);
-        }
-        else if (entry.kind === "live_retry" &&
-            entry.event.type === "auto_retry_end" &&
-            entry.event.finalError !== undefined)
-            diagnostics.set(entry.workId, entry.event.finalError);
     }
     return diagnostics;
 }
@@ -156,6 +155,8 @@ function projectTerminal(row, { commandIds, diagnostics, cancellations }) {
  * compaction kept (the same boundary `buildSessionContext` resumes from) so
  * the client can render "the agent's memory starts below" accurately even
  * when the kept entries are not the compaction row's immediate predecessors.
+ * A kept entry that is itself one of the validated page rows needs no lineage
+ * lookup; only one outside the page is checked against the lineage.
  */
 function compactionMarkersIn(owner, lineage, rows) {
     const markers = [];
@@ -163,16 +164,17 @@ function compactionMarkersIn(owner, lineage, rows) {
         const entry = row.entry;
         if (entry.kind !== "compaction")
             continue;
-        const kept = lineageEntrySequence(owner, lineage, entry.firstKeptEntryId);
+        const kept = rows.find((candidate) => candidate.id === entry.head)?.sequence ??
+            lineageEntrySequence(owner, lineage, entry.head);
         if (kept === undefined)
             throw unavailable("Session compaction horizon is unavailable");
         markers.push(Object.freeze({
             id: row.id,
             sequence: kept,
             at: row.timestamp,
-            tokensBefore: entry.tokensBefore,
-            tokensAfter: entry.tokensAfter ?? null,
-            trigger: entry.trigger ?? null,
+            tokensBefore: entry.data.tokensBefore,
+            tokensAfter: entry.data.tokensAfter ?? null,
+            trigger: entry.data.reason ?? null,
         }));
     }
     return Object.freeze(markers);
@@ -187,7 +189,9 @@ function compactionNoticesIn(rows) {
                 at: timestamp,
                 trigger: entry.trigger,
                 result: entry.result,
-                diagnostic: entry.diagnostic ?? null,
+                diagnostic: entry.result === "stale" || entry.result === "insufficient"
+                    ? null
+                    : (entry.diagnostic ?? null),
             }),
         ]
         : []));
@@ -268,37 +272,7 @@ function readPendingPrompts(owner, sessionId) {
     const prompts = [];
     let bytes = encoder.encode(JSON.stringify({ prompts: [], hasMore: false, total })).byteLength;
     for (const row of rows) {
-        const entry = promptCommand(row.entry);
-        if (entry === undefined)
-            throw unavailable("Pending Session prompt is unavailable");
-        const content = entry.message.content;
-        const prompt = isPromptParts(content)
-            ? {
-                commandId: row.entry.workId,
-                text: content
-                    .filter((part) => part.type === "text")
-                    .map((part) => part.text)
-                    .join(""),
-                images: content.filter((part) => part.type === "image"),
-                delivery: entry.delivery ?? "followUp",
-            }
-            : {
-                commandId: row.entry.workId,
-                text: content,
-                delivery: entry.delivery ?? "followUp",
-            };
-        const withMeta = row.entry.meta === undefined
-            ? prompt
-            : { ...prompt, meta: row.entry.meta };
-        const attributed = row.origin.kind === "extension"
-            ? {
-                ...withMeta,
-                origin: {
-                    extensionId: row.origin.extensionId,
-                    correlation: row.origin.correlation,
-                },
-            }
-            : withMeta;
+        const attributed = projectPendingPrompt(row);
         const size = encoder.encode(JSON.stringify(attributed)).byteLength +
             (prompts.length === 0 ? 0 : 1);
         if (prompts.length === maximumRowsPerPage ||
@@ -309,6 +283,45 @@ function readPendingPrompts(owner, sessionId) {
     }
     return { prompts, hasMore: false, total };
 }
+/** Same payload projection as the FIFO page, selected independently of that page's bounds. */
+export function readLatestPendingPrompt(owner, sessionId, identity) {
+    const row = readNewestPendingSessionCommand(owner, sessionId, identity);
+    return row === undefined ? null : projectPendingPrompt(row);
+}
+function projectPendingPrompt(row) {
+    const entry = promptCommand(row.entry);
+    if (entry === undefined)
+        throw unavailable("Pending Session prompt is unavailable");
+    const content = entry.message.content;
+    const prompt = isPromptParts(content)
+        ? {
+            commandId: row.entry.workId,
+            requestId: entry.requestId,
+            text: content
+                .filter((part) => part.type === "text")
+                .map((part) => part.text)
+                .join(""),
+            images: content.filter((part) => part.type === "image"),
+            delivery: entry.delivery ?? "followUp",
+        }
+        : {
+            commandId: row.entry.workId,
+            requestId: entry.requestId,
+            text: content,
+            delivery: entry.delivery ?? "followUp",
+        };
+    const withMeta = row.entry.meta === undefined ? prompt : { ...prompt, meta: row.entry.meta };
+    const attributed = row.origin.kind === "extension"
+        ? {
+            ...withMeta,
+            origin: {
+                extensionId: row.origin.extensionId,
+                correlation: row.origin.correlation,
+            },
+        }
+        : withMeta;
+    return attributed;
+}
 /**
  * The exclusive upper sequence a baseline read pages back from: none for the
  * latest page, or exactly the entry a `before` cursor names. Undefined means
@@ -345,6 +358,7 @@ export function readClientSnapshot(owner, sessionId, options, activity, projectE
                 pending,
                 activity: activity.facts,
                 progress: activity.progress,
+                toolOutput: activity.toolOutput,
                 extensions: projectExtensions(),
                 attention: readSessionAttention(owner, sessionId),
             });
@@ -379,6 +393,7 @@ export function readClientSnapshot(owner, sessionId, options, activity, projectE
             pending,
             activity: activity.facts,
             progress: options.before === undefined ? activity.progress : null,
+            toolOutput: options.before === undefined ? activity.toolOutput : [],
             extensions: projectExtensions(),
             attention: readSessionAttention(owner, sessionId),
         };
@@ -433,7 +448,16 @@ function replayFrames(owner, lineage, start, delivery, activity, extensions, att
         }));
     return Object.freeze({
         kind: "page",
-        frames: Object.freeze(frames),
+        frames: Object.freeze(!page.hasMore
+            ? [
+                ...frames,
+                {
+                    kind: "tool_output",
+                    toolOutput: activity.toolOutput,
+                    activity: activity.facts,
+                },
+            ]
+            : frames),
         hasMore: page.hasMore,
     });
 }
@@ -494,7 +518,9 @@ export function projectCommandSettlement(owner, sessionId, commandId) {
         : []);
     const last = answers.at(-1);
     const meta = terminal.outcome === "cancelled" ? terminal.meta : admission.entry.meta;
+    const sender = messageAuthor(admission.entry.meta);
     return {
+        acceptedSender: sender?.kind === "agent" ? sender.id : null,
         terminal: meta === undefined ? terminal : { ...terminal, meta },
         content: terminal.outcome === "cancelled"
             ? ""

package/dist/internal/woodstock/cold-sessions.d.ts

@@ -0,0 +1,4 @@
+import type { ColdSessionPage, ColdSessionPageRequest } from "../../cold-sessions.js";
+import type { SqliteOwner } from "../contracts.js";
+/** Read one bounded page of Sessions with stored bytes, coldest first. */
+export declare function readColdSessionPageOwned(owner: SqliteOwner, request: ColdSessionPageRequest): ColdSessionPage;