@fungi.computer/shiitake 0.6.0 → 0.8.0

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,17 @@ 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;
+    return snapshot(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 };
+/** Read a phase fact without flattening another Session's private text tails. */
+export function hasProcessTextForWork(owner, sessionId, workId) {
+    const current = progressByOwner.get(owner)?.get(sessionId);
+    return current?.workId === workId && (current.value?.text.length ?? 0) > 0;
 }
 /**
  * Keep live model progress in the current process only.
@@ -124,7 +204,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 +230,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 +243,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