@fungi.computer/shiitake 0.0.0-stage → 0.1.0

package/dist/internal/woodstock/index.js

@@ -0,0 +1,546 @@
+import * as Effect from "effect/Effect";
+import { ShiitakeError } from "../../errors.js";
+import { decodeClientReadOptions, decodeClientSessionCreationRequestId, decodeClientSessionId, } from "../client-boundary.js";
+import { publishOwnerObservation } from "../observation-kernel.js";
+import { diagnosticsByWorkId, projectCommandSettlement, readClientReplayPage, readClientSnapshot, } from "./client-projection.js";
+import { sessionIds } from "./identities.js";
+import { openProgress } from "./progress.js";
+import { encodeStoredSessionEntry, } from "./session-entry.js";
+import { appendSessionEntry, appendCompactionTransitionOwned, appendCompactionNoticeOwned, acceptSessionAbort, acceptSessionCancellation, completeSessionLeaf, prepareSessionRun, prepareSessionStore, readSessionEntriesForWork, readSessionCommandAdmission, settleSessionControls, takePendingSessionControls, readSessionEntryById, selectSessionBranch, forkSessionAt, readStoredSessionSummary as readSessionSummaryOwned, readStoredSessionFactPage, createStoredSession, deleteStoredSession, appendOperatorEntry, } from "./session-store.js";
+import { readSessionInboxPage, recordSessionInboxDeletion, } from "./session-inbox.js";
+export * from "./extension-store.js";
+export { createFleetDirectoryStore, createFleetDelegationStore, } from "./fleet-store.js";
+export * from "./session-attention.js";
+export { deliverSessionGrants, prepareSessionGrants, readSessionGrants, } from "./session-grants.js";
+export * from "./progress.js";
+export * from "./compaction-activity.js";
+export * from "./agent-reply.js";
+export * from "./session-entry.js";
+export * from "./session-store.js";
+export * from "./session-inbox.js";
+export { contextMessageIds } from "./run-recovery.js";
+export * from "./storage-admission.js";
+/** Record one compaction notice and publish it to observers. */
+export function appendCompactionNotice(owner, input) {
+    const row = appendCompactionNoticeOwned(owner, input);
+    publishOwnerObservation(owner, input.sessionId);
+    return row;
+}
+/** Append compaction through Woodstock's ordinary owner-observation boundary. */
+export function appendCompactionTransition(owner, input) {
+    const row = appendCompactionTransitionOwned(owner, input);
+    publishOwnerObservation(owner, input.sessionId);
+    return row;
+}
+function rejected(message) {
+    return new ShiitakeError("store", "rejected", message);
+}
+function conflict(message) {
+    return new ShiitakeError("store", "conflict", message);
+}
+function storeEffect(operation) {
+    return Effect.try({
+        try: operation,
+        catch: (error) => error instanceof ShiitakeError
+            ? error
+            : new ShiitakeError("store", "rejected", "Native Session store operation failed", undefined, error),
+    });
+}
+/** Prepare Woodstock's retained Session and private admission schema. */
+export function prepareWoodstockSchema(owner) {
+    return storeEffect(() => {
+        prepareSessionStore(owner);
+    });
+}
+/** Atomically cancel one exact owner-issued command. */
+export function cancelSession(owner, sessionId, commandId, onlyIfPending, readQueueHead, record, meta) {
+    return storeEffect(() => {
+        const cancellation = acceptSessionCancellation(owner, sessionId, commandId, readQueueHead, record, onlyIfPending, meta);
+        if (cancellation?.delivery === "new")
+            publishOwnerObservation(owner, sessionId);
+        return cancellation;
+    });
+}
+/** Deliver one pending control through an active Mule safe point. */
+export function takeSessionControls(owner, input) {
+    return storeEffect(() => {
+        const messages = takePendingSessionControls(owner, input.sessionId, input.delivery, input.workId);
+        if (messages.length > 0)
+            publishOwnerObservation(owner, input.sessionId);
+        return messages;
+    });
+}
+/** Record terminals for controls delivered through one settled parent run. */
+export function settleControls(owner, input) {
+    return storeEffect(() => {
+        settleSessionControls(owner, input);
+        publishOwnerObservation(owner, input.sessionId);
+    });
+}
+/** Resolve Session-scoped abort to private work and record it atomically. */
+export function abortSession(owner, sessionId, readQueueHead, record, meta) {
+    return storeEffect(() => {
+        const cancellation = acceptSessionAbort(owner, sessionId, readQueueHead, record, meta);
+        publishOwnerObservation(owner, sessionId);
+        return cancellation?.accepted;
+    });
+}
+/** Select one complete entry as the active Session lineage leaf. */
+export function branchSession(owner, input) {
+    return storeEffect(() => {
+        selectSessionBranch(owner, {
+            sessionId: input.sessionId,
+            entryId: input.entryId,
+            assertIdleSession: input.assertIdleSession,
+        });
+        publishOwnerObservation(owner, input.sessionId);
+    });
+}
+/** Record one operator or party line on an idle Session; false on replay. */
+export function recordOperatorLine(owner, input) {
+    return storeEffect(() => {
+        if (appendOperatorEntry(owner, input))
+            publishOwnerObservation(owner, input.sessionId);
+    });
+}
+/** Fork one complete entry lineage into a new cold-readable Session. */
+export function forkSession(owner, input) {
+    return storeEffect(() => {
+        const forkedSessionId = forkSessionAt(owner, {
+            sessionId: input.sessionId,
+            entryId: input.entryId,
+            assertIdleSession: input.assertIdleSession,
+        });
+        publishOwnerObservation(owner, forkedSessionId);
+        return Object.freeze({ sessionId: forkedSessionId });
+    });
+}
+/** Load the exact retained lineage ending at one accepted command. */
+export function loadAcceptedRun(owner, input) {
+    return storeEffect(() => {
+        const prepared = prepareSessionRun(owner, {
+            sessionId: decodeClientSessionId(input.sessionId),
+            commandFactId: input.commandFactId,
+        });
+        if (prepared.entryDelivery === "new")
+            publishOwnerObservation(owner, input.sessionId);
+        return prepared;
+    });
+}
+function assistantText(message) {
+    return message.content
+        .flatMap((part) => (part.type === "text" ? [part.text] : []))
+        .join("")
+        .trim();
+}
+/** Read the last exact completed assistant text produced by accepted work. */
+export function readSettlementContent(owner, input) {
+    return storeEffect(() => {
+        const admission = readSessionCommandAdmission(owner, input.sessionId, input.commandFactId);
+        if (admission === undefined)
+            throw rejected("Accepted Session command is unavailable");
+        const entries = readSessionEntriesForWork(owner, input.sessionId, admission.entry.workId);
+        for (let index = entries.length - 1; index >= 0; index -= 1) {
+            const entry = entries[index]?.entry;
+            if (entry?.kind === "message" && entry.value.role === "assistant")
+                return assistantText(entry.value);
+        }
+        return "";
+    });
+}
+/**
+ * The host metadata that settles with one accepted command: the
+ * cancellation's when a host-attributed cancel ended it, otherwise the
+ * command's own. Absent when the host attached none.
+ */
+export function readSettlementMeta(owner, input, outcome) {
+    return storeEffect(() => {
+        const admission = readSessionCommandAdmission(owner, input.sessionId, input.commandFactId);
+        if (admission === undefined)
+            throw rejected("Accepted Session command is unavailable");
+        if (outcome !== "cancelled")
+            return admission.entry.meta;
+        const cancellation = readSessionEntriesForWork(owner, input.sessionId, admission.entry.workId).find(({ entry }) => entry.kind === "cancellation");
+        return cancellation?.entry.kind === "cancellation"
+            ? cancellation.entry.meta
+            : undefined;
+    });
+}
+/**
+ * The Session's recorded terminal diagnostic for one accepted command, the
+ * same text `agents.wait` and clients see; absent when none was recorded.
+ */
+export function readSettlementDiagnostic(owner, input) {
+    return storeEffect(() => {
+        const admission = readSessionCommandAdmission(owner, input.sessionId, input.commandFactId);
+        if (admission === undefined)
+            throw rejected("Accepted Session command is unavailable");
+        return diagnosticsByWorkId(readSessionEntriesForWork(owner, input.sessionId, admission.entry.workId)).get(admission.entry.workId);
+    });
+}
+/** Read one bounded public Session snapshot. */
+export function readSession(owner, sessionId, activity, input, projectExtensions = () => ({})) {
+    return storeEffect(() => readClientSnapshot(owner, decodeClientSessionId(sessionId), decodeClientReadOptions(input), activity, projectExtensions));
+}
+/** Read one bounded folder-resume summary through Woodstock's Effect boundary. */
+export function readSessionSummary(owner, sessionId) {
+    return storeEffect(() => readSessionSummaryOwned(owner, decodeClientSessionId(sessionId)));
+}
+/**
+ * Persist or replay the Session reserved for a creation request ID.
+ * `admitNew` may refuse a new Session; a replayed request is never refused.
+ */
+export function createSession(owner, requestId, admitNew) {
+    return storeEffect(() => createStoredSession(owner, decodeClientSessionCreationRequestId({ requestId }), admitNew));
+}
+/** Permanently delete one idle Session; false when it does not exist. */
+export function deleteSession(owner, input) {
+    return storeEffect(() => deleteStoredSession(owner, {
+        sessionId: decodeClientSessionId(input.sessionId),
+        assertIdleSession: input.assertIdleSession,
+        recordInboxDeletion: (sessionId) => {
+            recordSessionInboxDeletion(owner, sessionId);
+        },
+    }));
+}
+/** Read a page of stored conversation facts; status needs the Session owner. */
+export function readSessionFactPage(owner, after) {
+    return storeEffect(() => readStoredSessionFactPage(owner, after === undefined ? undefined : decodeClientSessionId(after)));
+}
+/** Read one bounded inbox page in tier, then newest-activity order. */
+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));
+}
+function sameEntry(left, right) {
+    return encodeStoredSessionEntry(left) === encodeStoredSessionEntry(right);
+}
+function sameIdentity(left, right) {
+    return (left.kind === right.kind &&
+        left.value === right.value &&
+        left.parent?.kind === right.parent?.kind &&
+        left.parent?.value === right.parent?.value);
+}
+function sameContract(left, right) {
+    return (left.core === right.core &&
+        left.extensions.length === right.extensions.length &&
+        left.extensions.every(([id, fingerprint], index) => {
+            const selected = right.extensions[index];
+            return selected?.[0] === id && selected[1] === fingerprint;
+        }));
+}
+function appendRecordedEntry(owner, accepted, entry, findExisting, beforeAppend) {
+    const delivery = owner.transactionSync(() => {
+        beforeAppend?.();
+        const existing = readSessionEntriesForWork(owner, accepted.sessionId, accepted.commandId).find(findExisting);
+        if (existing !== undefined) {
+            if (entry.kind === "work_terminal" &&
+                existing.entry.kind === "run_terminal")
+                return "replay";
+            if (sameEntry(existing.entry, entry))
+                return "replay";
+            throw conflict("Mule event identity conflicts");
+        }
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            const factId = sessionIds.fact.generate();
+            if (readSessionEntryById(owner, factId) !== undefined ||
+                readSessionCommandAdmission(owner, accepted.sessionId, factId) !==
+                    undefined)
+                continue;
+            appendSessionEntry(owner, {
+                sessionId: accepted.sessionId,
+                id: factId,
+                entry,
+            });
+            return "new";
+        }
+        throw rejected("Session fact identity allocation failed");
+    });
+    if (delivery === "new")
+        publishOwnerObservation(owner, accepted.sessionId);
+}
+/** Persist an operator-only sandbox diagnostic beside its accepted Session work. */
+export function recordSandboxFailure(owner, accepted, event) {
+    return storeEffect(() => {
+        appendRecordedEntry(owner, accepted, {
+            kind: "sandbox_failure",
+            workId: accepted.commandId,
+            event,
+        }, ({ entry }) => entry.kind === "sandbox_failure" && entry.event.ref === event.ref);
+    });
+}
+/** Read the admitting extension of one accepted command. */
+export function readExtensionAdmissionOrigin(owner, sessionId, commandFactId, workId) {
+    const admission = readSessionCommandAdmission(owner, sessionId, commandFactId);
+    if (admission?.entry.workId !== workId)
+        throw rejected("Accepted Session work is unavailable");
+    return admission.origin.kind === "extension"
+        ? Object.freeze({
+            extensionId: admission.origin.extensionId,
+            correlation: admission.origin.correlation,
+        })
+        : null;
+}
+/** Read the terminal and admission origin of one settled accepted command. */
+export function readSettledRunFacts(owner, sessionId, commandFactId, workId) {
+    const origin = readExtensionAdmissionOrigin(owner, sessionId, commandFactId, workId);
+    const entries = readSessionEntriesForWork(owner, sessionId, workId).map(({ entry }) => entry);
+    const toolCalls = new Set(entries.flatMap((entry) => entry.kind === "tool_intent" ? [entry.call.id] : [])).size;
+    const terminal = entries
+        .filter((entry) => entry.kind === "run_terminal" || entry.kind === "work_terminal")
+        .at(-1);
+    return Object.freeze({
+        terminal: terminal?.kind === "run_terminal" || terminal?.kind === "work_terminal"
+            ? terminal.outcome
+            : "missing",
+        origin,
+        toolCalls,
+    });
+}
+/** Record unsuccessful Watchdog settlement when Mule has no recorded terminal. */
+export function recordWorkSettlement(owner, input) {
+    return storeEffect(() => {
+        const admission = readSessionCommandAdmission(owner, input.sessionId, input.commandFactId);
+        if (admission?.entry.workId !== input.workId)
+            throw rejected("Settled Session work is unavailable");
+        const entry = {
+            workId: input.workId,
+            kind: "work_terminal",
+            outcome: input.outcome,
+        };
+        appendRecordedEntry(owner, { sessionId: input.sessionId, commandId: input.workId }, input.diagnostic === undefined
+            ? entry
+            : { ...entry, diagnostic: input.diagnostic }, ({ entry: current }) => current.kind === "work_terminal" ||
+            (current.kind === "run_terminal" && current.outcome === input.outcome), () => {
+            owner.sql.exec("DELETE FROM session_entries WHERE session_id = ? AND work_id = ? AND state = 'streaming' AND type = 'message_start'", input.sessionId, input.workId);
+        });
+    });
+}
+function recordLifecycle(owner, accepted, contract, event) {
+    return storeEffect(() => {
+        const entry = event.type === "run_start"
+            ? {
+                kind: "run_started",
+                workId: accepted.commandId,
+                run: event.run,
+                contract,
+            }
+            : event.type === "turn_start"
+                ? {
+                    kind: "turn_started",
+                    workId: accepted.commandId,
+                    run: event.run,
+                    turn: event.turn,
+                }
+                : {
+                    kind: "run_terminal",
+                    workId: accepted.commandId,
+                    run: event.run,
+                    terminal: event.terminal,
+                    outcome: event.outcome,
+                };
+        appendRecordedEntry(owner, accepted, entry, ({ entry: current }) => {
+            if (current.kind !== entry.kind)
+                return false;
+            if (current.kind === "run_started" && entry.kind === "run_started")
+                return (sameIdentity(current.run, entry.run) &&
+                    sameContract(current.contract, contract));
+            if (current.kind === "turn_started" && entry.kind === "turn_started")
+                return sameIdentity(current.turn, entry.turn);
+            if (current.kind === "run_terminal" && entry.kind === "run_terminal")
+                return sameIdentity(current.terminal, entry.terminal);
+            return false;
+        });
+    });
+}
+function recordMessageStart(owner, accepted, event) {
+    return storeEffect(() => {
+        const entry = {
+            kind: "message_start",
+            workId: accepted.commandId,
+            run: event.run,
+            turn: event.turn,
+            message: event.message,
+            role: event.value.role,
+        };
+        const delivery = owner.transactionSync(() => {
+            const existing = readSessionEntriesForWork(owner, accepted.sessionId, accepted.commandId).find(({ entry: current }) => (current.kind === "message_start" || current.kind === "message") &&
+                sameIdentity(current.message, event.message));
+            if (existing !== undefined) {
+                if (existing.entry.kind === "message") {
+                    if (existing.entry.workId !== entry.workId ||
+                        !sameIdentity(existing.entry.run, entry.run) ||
+                        !sameIdentity(existing.entry.turn, entry.turn) ||
+                        existing.entry.value.role !== entry.role)
+                        throw conflict("Mule message-start identity conflicts");
+                    return "replay";
+                }
+                if (!sameEntry(existing.entry, entry))
+                    throw conflict("Mule message-start identity conflicts");
+                return "replay";
+            }
+            appendSessionEntry(owner, {
+                sessionId: accepted.sessionId,
+                id: event.message.value,
+                entry,
+                state: "streaming",
+            });
+            return "new";
+        });
+        if (delivery === "new")
+            publishOwnerObservation(owner, accepted.sessionId);
+    });
+}
+/** Persist exactly the system prompt before a provider attempt is sent. */
+function recordModelPrompt(owner, accepted, contract, event) {
+    return storeEffect(() => {
+        const entry = {
+            kind: "model_prompt",
+            workId: accepted.commandId,
+            run: event.run,
+            turn: event.turn,
+            attempt: event.attempt,
+            contract,
+            systemPrompt: event.systemPrompt,
+        };
+        appendRecordedEntry(owner, accepted, entry, ({ entry: current }) => current.kind === "model_prompt" &&
+            sameIdentity(current.turn, event.turn) &&
+            current.attempt === event.attempt &&
+            sameContract(current.contract, contract));
+    });
+}
+function recordMessageEnd(owner, accepted, event) {
+    return storeEffect(() => {
+        const entry = {
+            kind: "message",
+            workId: accepted.commandId,
+            run: event.run,
+            turn: event.turn,
+            message: event.message,
+            value: event.value,
+        };
+        const delivery = owner.transactionSync(() => {
+            const existing = readSessionEntriesForWork(owner, accepted.sessionId, accepted.commandId).find(({ entry: current }) => (current.kind === "message_start" || current.kind === "message") &&
+                sameIdentity(current.message, event.message));
+            if (existing?.entry.kind === "message") {
+                if (!sameEntry(existing.entry, entry))
+                    throw conflict("Mule completed-message identity conflicts");
+                return "replay";
+            }
+            completeSessionLeaf(owner, {
+                sessionId: accepted.sessionId,
+                id: event.message.value,
+                entry,
+            });
+            return "new";
+        });
+        if (delivery === "new")
+            publishOwnerObservation(owner, accepted.sessionId);
+    });
+}
+function recordToolIntent(owner, accepted, contract, event) {
+    return storeEffect(() => {
+        const entry = {
+            kind: "tool_intent",
+            replay: event.replay,
+            contract,
+            workId: accepted.commandId,
+            run: event.run,
+            turn: event.turn,
+            toolCall: event.toolCall,
+            call: event.call,
+        };
+        appendRecordedEntry(owner, accepted, entry, ({ entry: current }) => current.kind === "tool_intent" &&
+            sameIdentity(current.toolCall, event.toolCall) &&
+            sameContract(current.contract, contract));
+    });
+}
+function recordToolOutcome(owner, accepted, event) {
+    return storeEffect(() => {
+        const entry = {
+            kind: "tool_outcome",
+            workId: accepted.commandId,
+            run: event.run,
+            turn: event.turn,
+            toolCall: event.toolCall,
+            call: event.call,
+            result: event.result,
+        };
+        appendRecordedEntry(owner, accepted, entry, ({ entry: current }) => current.kind === "tool_outcome" &&
+            sameIdentity(current.toolCall, event.toolCall));
+    });
+}
+/** Record one retained live Pi retry observation on the Session lineage. */
+export function recordLiveRetryEvent(owner, accepted, event, turn) {
+    return storeEffect(() => {
+        // Pi numbers retries per assistant turn, not per run. The retained turn
+        // boundary scopes replay identity without changing older event payloads.
+        const boundary = readSessionEntriesForWork(owner, accepted.sessionId, accepted.commandId).find(({ entry }) => entry.kind === "turn_started" && sameIdentity(entry.turn, turn));
+        if (boundary === undefined)
+            throw conflict("Retry has no recorded turn");
+        const entry = {
+            kind: "live_retry",
+            workId: accepted.commandId,
+            event,
+        };
+        appendRecordedEntry(owner, accepted, entry, ({ entry: current, sequence }) => sequence > boundary.sequence &&
+            current.kind === "live_retry" &&
+            current.event.type === event.type &&
+            current.event.attempt === event.attempt &&
+            sameIdentity(current.event.run, event.run));
+    }).pipe(Effect.mapError(listenerFailure));
+}
+const listenerFailure = () => ({
+    _tag: "MuleError",
+    phase: "listener",
+    message: "Woodstock could not record the Mule event",
+});
+/**
+ * Open the one scoped listener that projects Mule's exact event stream into
+ * retained Session facts and bounded process-local progress.
+ */
+export function openMuleRecorder(owner, accepted, contract) {
+    return Effect.gen(function* () {
+        const progress = yield* openProgress(owner, accepted, (event) => recordMessageEnd(owner, accepted, event));
+        const record = (event) => {
+            switch (event.type) {
+                case "model_prompt":
+                    return recordModelPrompt(owner, accepted, contract, event);
+                case "run_start":
+                case "turn_start":
+                case "run_end":
+                    return recordLifecycle(owner, accepted, contract, event);
+                case "message_start":
+                    if (event.value.role === "user")
+                        return Effect.void;
+                    return recordMessageStart(owner, accepted, event).pipe(Effect.andThen(event.value.role === "assistant"
+                        ? progress.started(event)
+                        : Effect.void));
+                case "message_update":
+                    return progress.update(event);
+                case "message_end":
+                    if (event.value.role === "user")
+                        return Effect.void;
+                    return event.value.role === "assistant"
+                        ? progress.terminal(event)
+                        : recordMessageEnd(owner, accepted, event);
+                case "tool_execution_start":
+                    return recordToolIntent(owner, accepted, contract, event);
+                case "tool_execution_end":
+                    return recordToolOutcome(owner, accepted, event);
+                case "tool_execution_update":
+                case "turn_end":
+                    return Effect.void;
+            }
+        };
+        return (event) => record(event).pipe(Effect.mapError(listenerFailure));
+    });
+}
+export { declareSessionDocument } from "./session-documents.js";
+/** Read exact settled work facts through Woodstock's native command/work indexes. */
+export function readCommandSettlement(owner, sessionId, commandId) {
+    return storeEffect(() => projectCommandSettlement(owner, decodeClientSessionId(sessionId), decodeClientSessionId(commandId)));
+}

package/dist/internal/woodstock/progress.d.ts

@@ -0,0 +1,32 @@
+import type { MuleEvent } from "@fungi.computer/mule";
+import * as Effect from "effect/Effect";
+import type * as Scope from "effect/Scope";
+import type { SessionProgress } from "../../client.js";
+import { ShiitakeError } from "../../errors.js";
+import type { SqliteOwner } from "../contracts.js";
+import type { AcceptedCommand } from "./session-store.js";
+/** Read the current process-local progress value for one addressed Session. */
+export declare function readProcessProgress(owner: SqliteOwner, sessionId: string): SessionProgress | null;
+/** Read progress only when it belongs to the current durable work head. */
+export declare function readProcessProgressForWork(owner: SqliteOwner, sessionId: string, workId: string): SessionProgress | null;
+export type ProgressMessageStart = Extract<MuleEvent, {
+    type: "message_start";
+}>;
+export type ProgressMessageUpdate = Extract<MuleEvent, {
+    type: "message_update";
+}>;
+export type ProgressMessageEnd = Extract<MuleEvent, {
+    type: "message_end";
+}>;
+export type ProgressController = Readonly<{
+    started: (event: ProgressMessageStart) => Effect.Effect<void, ShiitakeError>;
+    update: (event: ProgressMessageUpdate) => Effect.Effect<void, ShiitakeError>;
+    terminal: (event: ProgressMessageEnd) => Effect.Effect<void, ShiitakeError>;
+}>;
+/**
+ * Keep live model progress in the current process only.
+ *
+ * Woodstock durably owns one empty assistant placeholder and the exact Pi
+ * message at completion. Updates deliberately perform no SQLite writes.
+ */
+export declare function openProgress(owner: SqliteOwner, accepted: AcceptedCommand, complete: (event: ProgressMessageEnd) => Effect.Effect<void, ShiitakeError>): Effect.Effect<ProgressController, never, Scope.Scope>;

package/dist/internal/woodstock/progress.js

@@ -0,0 +1,89 @@
+import * as Effect from "effect/Effect";
+import { ShiitakeError } from "../../errors.js";
+import { publishOwnerObservation } from "../observation-kernel.js";
+const progressByOwner = new WeakMap();
+function progressFor(owner) {
+    const existing = progressByOwner.get(owner);
+    if (existing !== undefined)
+        return existing;
+    const created = new Map();
+    progressByOwner.set(owner, created);
+    return created;
+}
+function rejected(message) {
+    return new ShiitakeError("runtime", "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;
+}
+/** 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 };
+}
+/**
+ * Keep live model progress in the current process only.
+ *
+ * Woodstock durably owns one empty assistant placeholder and the exact Pi
+ * message at completion. Updates deliberately perform no SQLite writes.
+ */
+export function openProgress(owner, accepted, complete) {
+    return Effect.gen(function* () {
+        let started;
+        const clear = Effect.sync(() => {
+            if (progressFor(owner).delete(accepted.sessionId))
+                publishOwnerObservation(owner, accepted.sessionId, "progress");
+            started = undefined;
+        });
+        yield* Effect.addFinalizer(() => clear);
+        return Object.freeze({
+            started: (event) => Effect.sync(() => {
+                started = event;
+                progressFor(owner).delete(accepted.sessionId);
+            }),
+            update: (event) => Effect.suspend(() => {
+                const messageStart = started;
+                if (messageStart === undefined)
+                    return Effect.fail(rejected("Mule progress arrived before its message start"));
+                if (messageStart.run.value !== event.run.value ||
+                    messageStart.turn.value !== event.turn.value ||
+                    messageStart.message.value !== event.message.value)
+                    return Effect.fail(rejected("Mule progress identity conflicts"));
+                const previous = progressFor(owner).get(accepted.sessionId);
+                const content = textFor(event);
+                if (previous?.workId === accepted.commandId &&
+                    previous.value.text === content.text &&
+                    previous.value.thinking === content.thinking)
+                    return Effect.void;
+                progressFor(owner).set(accepted.sessionId, Object.freeze({
+                    workId: accepted.commandId,
+                    value: Object.freeze({
+                        messageId: event.message.value,
+                        revision: (previous?.workId === accepted.commandId
+                            ? previous.value.revision
+                            : 0) + 1,
+                        text: content.text,
+                        thinking: content.thinking,
+                        textTruncated: false,
+                        thinkingTruncated: false,
+                    }),
+                }));
+                publishOwnerObservation(owner, accepted.sessionId, "progress");
+                return Effect.void;
+            }),
+            terminal: (event) => clear.pipe(Effect.andThen(complete(event))),
+        });
+    });
+}

package/dist/internal/woodstock/run-recovery.d.ts

@@ -0,0 +1,8 @@
+import type { MuleResume } from "@fungi.computer/mule/effect";
+import type { StoredSessionRow } from "./session-store.js";
+/** Derive continuation from facts, without introducing a second checkpoint store. */
+export declare function recoverAssistantTurn(rows: readonly StoredSessionRow[]): MuleResume | undefined;
+/** One visibility rule for model context and compaction, including recovered runs. */
+export declare function contextMessageIds(path: readonly StoredSessionRow[], activeWorkId?: string): ReadonlySet<string>;
+/** Returned assistant failures still pass through compaction; abnormal exits do not. */
+export declare function abnormalTerminal(rows: readonly StoredSessionRow[]): "failed" | "cancelled" | undefined;