@fungi.computer/shiitake 0.5.0 → 0.7.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,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

@@ -0,0 +1,13 @@
+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;
+/**
+ * Record who sent a Session its work first, in the admitting transaction.
+ * Only an original mail that asks for replies names a delegator; the first one
+ * stays, so the relationship never moves once it exists.
+ */
+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: WatchdogSqliteOwner, sessionId: string): BirdDogDelegator | undefined;

package/dist/internal/woodstock/session-delegator.js

@@ -0,0 +1,44 @@
+import { BirdDogAgentReferenceSchema } from "@fungi.computer/bird-dog/effect";
+import * as Schema from "effect/Schema";
+const decodeRow = Schema.decodeUnknownSync(Schema.Struct({
+    mail_key: Schema.String,
+    agent_id: Schema.String,
+    reply_to_json: Schema.fromJsonString(Schema.Array(BirdDogAgentReferenceSchema)),
+}));
+const encodeReplyTo = Schema.encodeSync(Schema.fromJsonString(Schema.Array(BirdDogAgentReferenceSchema)));
+/** Woodstock keeps each Session's delegator of record beside the Session. */
+export function prepareSessionDelegators(owner) {
+    owner.sql.exec(`CREATE TABLE IF NOT EXISTS session_delegators (
+    session_id TEXT PRIMARY KEY,
+    mail_key TEXT NOT NULL,
+    agent_id TEXT NOT NULL,
+    reply_to_json TEXT NOT NULL
+  )`);
+}
+/**
+ * Record who sent a Session its work first, in the admitting transaction.
+ * Only an original mail that asks for replies names a delegator; the first one
+ * stays, so the relationship never moves once it exists.
+ */
+export function recordSessionDelegator(owner, sessionId, mail) {
+    if (mail === undefined ||
+        mail.reply !== undefined ||
+        mail.from.kind !== "agent" ||
+        mail.replyTo.length === 0)
+        return;
+    owner.sql.exec("INSERT OR IGNORE INTO session_delegators (session_id, mail_key, agent_id, reply_to_json) VALUES (?, ?, ?, ?)", sessionId, mail.key, mail.to.agentId, encodeReplyTo(mail.replyTo));
+}
+/** The Session's delegator of record, if any Agent has sent it work. */
+export function readSessionDelegator(owner, sessionId) {
+    const [row] = owner.sql
+        .exec("SELECT mail_key, agent_id, reply_to_json FROM session_delegators WHERE session_id = ?", sessionId)
+        .toArray();
+    if (row === undefined)
+        return undefined;
+    const decoded = decodeRow(row);
+    return {
+        key: decoded.mail_key,
+        agentId: decoded.agent_id,
+        replyTo: decoded.reply_to_json,
+    };
+}

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

@@ -74,6 +74,11 @@ declare const StoredSessionEntrySchema: Schema.Union<readonly [Schema.Struct<{
         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<{
@@ -357,15 +362,20 @@ export declare function decodeStoredSessionEntry(value: string): Result.Result<{
     readonly delivery?: "followUp" | "steer";
     readonly meta?: import("../../extensions.js").Json;
     readonly reply?: {
+        readonly agentId: string;
         readonly sessionId: string;
         readonly commandId: string;
         readonly outcome: "completed" | "failed" | "cancelled" | "interrupted" | "outcome_unknown";
-        readonly agentId: string;
         readonly diagnostic?: string;
+        readonly waitingOnYou?: readonly {
+            readonly itemId: string;
+            readonly kind: string;
+            readonly summary: string;
+        }[];
     } | {
+        readonly agentId: string;
         readonly reason: "recipient_offline" | "recipient_left";
         readonly outcome: "undeliverable";
-        readonly agentId: string;
         readonly sessionId?: string;
     };
     readonly targetWorkId?: string;

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;
@@ -237,6 +240,8 @@ export declare function settleSessionControls(owner: SqliteOwner, input: Readonl
 export declare function readSessionCommandAdmission(owner: SqliteOwner, sessionId: string, id: string): StoredCommandAdmission | undefined;
 /** Read one stable private command admission by accepted request identity. */
 export declare function readSessionCommandAdmissionByRequest(owner: SqliteOwner, sessionId: string, requestId: string): StoredCommandAdmission | undefined;
+/** Probe the indexed terminal facts without materializing a live work's body. */
+export declare function hasSessionWorkTerminal(owner: SqliteOwner, sessionId: string, workId: string): boolean;
 /** Read entries correlated to one accepted work identity in Session order. */
 export declare function readSessionEntriesForWork(owner: SqliteOwner, sessionId: string, workId: string): readonly StoredSessionRow[];
 /** Read the latest retained live-retry event for one accepted work item. */
@@ -330,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