@fungi.computer/shiitake 0.6.0 → 0.7.0

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);

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

package/dist/internal/woodstock/progress.js

@@ -3,6 +3,92 @@ import * as Schema from "effect/Schema";
 import * as Result from "effect/Result";
 import { ShiitakeError } from "../../errors.js";
 import { publishOwnerObservation } from "../observation-kernel.js";
+const tailBytes = 65_536;
+const chunkUnits = 2048;
+const encoder = new TextEncoder();
+const emptyTail = () => ({ chunks: [], length: 0, bytes: 0 });
+/** Bounded chunks: no concatenation or encoding of the reply-so-far. */
+function appendTail(tail, append) {
+    for (let index = 0; index < append.length;) {
+        let end = Math.min(index + chunkUnits, append.length);
+        // Do not cut a Unicode scalar when bounding a provider's large delta.
+        const code = append.charCodeAt(end - 1);
+        if (end < append.length && code >= 0xd800 && code <= 0xdbff)
+            end--;
+        const text = append.slice(index, end);
+        const bytes = encoder.encode(text).byteLength;
+        const last = tail.chunks.at(-1);
+        if (last !== undefined && last.text.length + text.length <= chunkUnits) {
+            last.text += text;
+            last.bytes += bytes;
+        }
+        else {
+            tail.chunks.push({ offset: tail.length, text, bytes });
+        }
+        tail.length += text.length;
+        tail.bytes += bytes;
+        index = end;
+        while (tail.bytes > tailBytes && tail.chunks.length > 1) {
+            const dropped = tail.chunks.shift();
+            if (dropped !== undefined)
+                tail.bytes -= dropped.bytes;
+        }
+    }
+}
+function tailOffset(tail) {
+    return tail.chunks[0]?.offset ?? 0;
+}
+function tailAfter(tail, offset) {
+    return tail.chunks
+        .flatMap((chunk) => chunk.offset + chunk.text.length <= offset
+        ? []
+        : [chunk.text.slice(Math.max(0, offset - chunk.offset))])
+        .join("");
+}
+function snapshot(value) {
+    return value === null
+        ? null
+        : {
+            messageId: value.messageId,
+            revision: value.revision,
+            text: tailAfter(value.text, tailOffset(value.text)),
+            thinking: tailAfter(value.thinking, tailOffset(value.thinking)),
+            textOffset: tailOffset(value.text),
+            thinkingOffset: tailOffset(value.thinking),
+            textTruncated: tailOffset(value.text) > 0,
+            thinkingTruncated: tailOffset(value.thinking) > 0,
+        };
+}
+export function progressPosition(value) {
+    return value === null
+        ? null
+        : {
+            messageId: value.messageId,
+            revision: value.revision,
+            text: value.textOffset + value.text.length,
+            thinking: value.thinkingOffset + value.thinking.length,
+        };
+}
+/** Undefined means continuity was lost; null means no new model progress. */
+export function readProcessProgressDelta(owner, sessionId, workId, after) {
+    const current = progressByOwner.get(owner)?.get(sessionId);
+    const value = current?.workId === workId ? current.value : null;
+    if (value === null)
+        return null;
+    const position = after?.messageId === value.messageId ? after : null;
+    if (position !== null && position.revision >= value.revision)
+        return null;
+    const text = position?.text ?? 0;
+    const thinking = position?.thinking ?? 0;
+    if (text < tailOffset(value.text) || thinking < tailOffset(value.thinking))
+        return undefined;
+    return {
+        messageId: value.messageId,
+        revision: value.revision,
+        text: { offset: text, append: tailAfter(value.text, text) },
+        thinking: { offset: thinking, append: tailAfter(value.thinking, thinking) },
+    };
+}
 const progressByOwner = new WeakMap();
 export function readProcessToolOutputForWork(owner, sessionId, workId) {
     const current = progressByOwner.get(owner)?.get(sessionId);
@@ -96,23 +182,12 @@ function rejected(message) {
 }
 /** Read the current process-local progress value for one addressed Session. */
 export function readProcessProgress(owner, sessionId) {
-    return progressFor(owner).get(sessionId)?.value ?? null;
+    return snapshot(progressFor(owner).get(sessionId)?.value ?? null);
 }
 /** Read progress only when it belongs to the current durable work head. */
 export function readProcessProgressForWork(owner, sessionId, workId) {
     const current = progressFor(owner).get(sessionId);
-    return current?.workId === workId ? current.value : null;
-}
-function textFor(event) {
-    let text = "";
-    let thinking = "";
-    for (const content of event.value.content) {
-        if (content.type === "text")
-            text += content.text;
-        if (content.type === "thinking")
-            thinking += content.thinking;
-    }
-    return { text, thinking };
+    return snapshot(current?.workId === workId ? current.value : null);
 }
 /**
  * Keep live model progress in the current process only.
@@ -124,7 +199,23 @@ export function openProgress(owner, accepted, complete) {
     return Effect.gen(function* () {
         const current = yield* openProcessProgress(owner, accepted);
         let started;
+        let publishedLength = 0;
+        let flushTimer;
+        const cancelFlush = () => {
+            if (flushTimer !== undefined)
+                clearTimeout(flushTimer);
+            flushTimer = undefined;
+        };
+        const publish = () => {
+            cancelFlush();
+            const value = current.value;
+            if (value === null)
+                return;
+            publishedLength = value.text.length + value.thinking.length;
+            publishOwnerObservation(owner, accepted.sessionId, "progress");
+        };
         const clear = Effect.sync(() => {
+            cancelFlush();
             const hadProgress = current.value !== null;
             current.value = null;
             if (hadProgress)
@@ -134,8 +225,10 @@ export function openProgress(owner, accepted, complete) {
         yield* Effect.addFinalizer(() => clear);
         return Object.freeze({
             started: (event) => Effect.sync(() => {
+                cancelFlush();
                 started = event;
                 current.value = null;
+                publishedLength = 0;
             }),
             update: (event) => Effect.suspend(() => {
                 const messageStart = started;
@@ -145,20 +238,28 @@ 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 = current.value;
-                const content = textFor(event);
-                if (previous?.text === content.text &&
-                    previous.thinking === content.thinking)
+                const delta = event.event;
+                if ((delta.type !== "text_delta" && delta.type !== "thinking_delta") ||
+                    delta.delta.length === 0)
                     return Effect.void;
-                current.value = Object.freeze({
+                const first = current.value === null;
+                const value = current.value ?? {
                     messageId: event.message.value,
-                    revision: (previous?.revision ?? 0) + 1,
-                    text: content.text,
-                    thinking: content.thinking,
-                    textTruncated: false,
-                    thinkingTruncated: false,
-                });
-                publishOwnerObservation(owner, accepted.sessionId, "progress");
+                    revision: 0,
+                    text: emptyTail(),
+                    thinking: emptyTail(),
+                };
+                appendTail(delta.type === "text_delta" ? value.text : value.thinking, delta.delta);
+                value.revision++;
+                current.value = value;
+                const length = value.text.length + value.thinking.length;
+                // Coalesce tiny tokens, but flush a paused provider within 100 ms.
+                // One scope-owned timer holds no reply text and never writes SQLite.
+                if (first || length - publishedLength >= 4096) {
+                    publish();
+                }
+                else
+                    flushTimer ??= setTimeout(publish, 100);
                 return Effect.void;
             }),
             terminal: (event) => clear.pipe(Effect.andThen(complete(event))),

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

@@ -1,4 +1,5 @@
 import type { BirdDogDelegator, BirdDogMail } from "@fungi.computer/bird-dog";
+import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
 import type { SqliteOwner } from "../contracts.js";
 /** Woodstock keeps each Session's delegator of record beside the Session. */
 export declare function prepareSessionDelegators(owner: SqliteOwner): void;
@@ -9,4 +10,4 @@ export declare function prepareSessionDelegators(owner: SqliteOwner): void;
  */
 export declare function recordSessionDelegator(owner: SqliteOwner, sessionId: string, mail: BirdDogMail | undefined): void;
 /** The Session's delegator of record, if any Agent has sent it work. */
-export declare function readSessionDelegator(owner: SqliteOwner, sessionId: string): BirdDogDelegator | undefined;
+export declare function readSessionDelegator(owner: WatchdogSqliteOwner, sessionId: string): BirdDogDelegator | undefined;

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

@@ -167,6 +167,7 @@ export type EnqueueAcceptedWork = (work: Readonly<{
     jobId: string;
     sessionId: string;
     commandFactId: string;
+    delivery: "steer" | "followUp";
 }>) => void;
 export type RecordAcceptedCancellation = (input: Readonly<{
     jobId: string;
@@ -192,6 +193,8 @@ export type ForkSessionAtInput = SelectSessionBranchInput;
 export declare function hasStoredSession(owner: SqliteOwner, sessionId: string): boolean;
 /** Read one retained Session entry by its globally unique row identity. */
 export declare function readSessionEntryById(owner: SqliteOwner, id: string): StoredSessionRow | undefined;
+/** A written run terminal closes the window for attaching another steer. */
+export declare function hasRecordedRunTerminal(owner: SqliteOwner, sessionId: string, workId: string): boolean;
 /** Host-owned metadata identity, interpreted by SQLite's JSON decoder only. */
 export type AdmissionIdentity = Readonly<{
     path: string;
@@ -332,9 +335,18 @@ export declare const lineageRowLimit = 200;
  * deduplicating; the fork walk keeps every link for its whole-lineage check.
  */
 declare const lineageWalks: {
-    readonly selected: "WITH RECURSIVE branch (id, parent_id, sequence, state) AS (\n       SELECT id, parent_id, sequence, state\n         FROM session_entries\n        WHERE session_id = ? AND id = ?\n       UNION ALL\n       SELECT parent.id, parent.parent_id, parent.sequence, parent.state\n         FROM session_entries AS parent\n         JOIN branch AS child ON parent.id = child.parent_id\n        WHERE parent.session_id = ? AND child.sequence > ?\n          AND +parent.sequence < child.sequence\n     )";
-    readonly fork: "WITH RECURSIVE branch (id, parent_id, sequence, state) AS (\n       SELECT id, parent_id, sequence, state\n         FROM session_entries\n        WHERE session_id = ? AND id = ? AND state != 'streaming'\n       UNION\n       SELECT parent.id, parent.parent_id, parent.sequence, parent.state\n         FROM session_entries AS parent\n         JOIN branch AS child ON parent.id = child.parent_id\n        WHERE parent.session_id = ? AND child.sequence > ?\n          AND parent.state != 'streaming'\n     )";
+    readonly selected: "WITH RECURSIVE branch (id, parent_id, sequence, state) AS (\n       SELECT id, parent_id, sequence, state\n         FROM session_entries\n        WHERE session_id = ? AND id = ?\n       UNION ALL\n       SELECT parent.id, parent.parent_id, parent.sequence, parent.state\n         FROM branch AS child\n         CROSS JOIN session_entries AS parent\n        WHERE parent.id = child.parent_id AND parent.session_id = ?\n          AND child.sequence > ?\n          AND +parent.sequence < child.sequence\n     )";
+    readonly fork: "WITH RECURSIVE branch (id, parent_id, sequence, state) AS (\n       SELECT id, parent_id, sequence, state\n         FROM session_entries\n        WHERE session_id = ? AND id = ? AND state != 'streaming'\n       UNION\n       SELECT parent.id, parent.parent_id, parent.sequence, parent.state\n         FROM branch AS child\n         CROSS JOIN session_entries AS parent\n        WHERE parent.id = child.parent_id AND parent.session_id = ?\n          AND child.sequence > ?\n          AND parent.state != 'streaming'\n     )";
 };
+/**
+ * One synchronous, transaction-consistent Session baseline. Activity, timeline,
+ * extension projections and context figures share its identity-only ancestry;
+ * asynchronous model description runs after this scope has ended. Nothing is
+ * retained between reads, and payload windows keep their row and byte bounds.
+ */
+export declare function withSessionRead<A>(owner: SqliteOwner, sessionId: string, read: () => A, before?: number): A;
+/** Join the shared Session baseline, or keep a direct projection atomic. */
+export declare function withSessionReadTransaction<A>(owner: SqliteOwner, sessionId: string, read: () => A): A;
 /**
  * One root-to-tip lineage. Its integrity is enforced where entries are
  * written (`guardSessionLineage`), so locating it reads only its tip and its