@fungi.computer/shiitake 0.7.0 → 0.9.0

package/dist/internal/observation-kernel.js

@@ -1,8 +1,128 @@
 import * as Effect from "effect/Effect";
+import * as Pull from "effect/Pull";
+import * as Queue from "effect/Queue";
 import { ShiitakeError } from "../errors.js";
 import { reportCatchFailure } from "./failure.js";
 const MAX_OBSERVATIONS = 64;
 const MAX_PENDING_HINTS = 256;
+const encodedFrames = new WeakMap();
+const frameEncoder = new TextEncoder();
+/** The feed shares one frame's JSON and byte accounting across its watchers. */
+export function encodeSessionFrame(frame) {
+    const cached = encodedFrames.get(frame);
+    if (cached !== undefined)
+        return cached;
+    const data = JSON.stringify(frame);
+    const encoded = Object.freeze({
+        data,
+        bytes: frameEncoder.encode(data).byteLength,
+    });
+    encodedFrames.set(frame, encoded);
+    return encoded;
+}
+function withoutSandboxFailures(frame) {
+    if (frame.kind === "update" && frame.sandboxFailures !== undefined) {
+        const value = { ...frame };
+        delete value.sandboxFailures;
+        return value;
+    }
+    if (frame.kind === "reset" && frame.baseline.sandboxFailures !== undefined) {
+        const baseline = { ...frame.baseline };
+        delete baseline.sandboxFailures;
+        return { ...frame, baseline };
+    }
+    return frame;
+}
+/** Bounded dropping fan-out; Woodstock, never this queue, owns replay. */
+export function openSessionFrameFeed(onIdle) {
+    const listeners = new Set();
+    let ended = false;
+    let failure;
+    const clear = (listener) => {
+        Effect.runSync(Queue.clear(listener.frames));
+        listener.bytes = 0;
+    };
+    return {
+        register(includeSandboxFailures = false) {
+            const listener = {
+                frames: Effect.runSync(Queue.dropping(256)),
+                bytes: 0,
+                lagged: false,
+                closed: false,
+                observed: -1,
+                includeSandboxFailures,
+            };
+            listeners.add(listener);
+            const take = Effect.suspend(() => {
+                if (listener.closed)
+                    return Effect.succeed("closed");
+                if (failure !== undefined)
+                    return Effect.fail(failure);
+                if (listener.lagged)
+                    return Effect.succeed("reset");
+                if (ended)
+                    return Effect.succeed("closed");
+                return Queue.take(listener.frames).pipe(Pull.catchDone(() => Effect.succeed("closed")), Effect.flatMap((frame) => {
+                    if (failure !== undefined)
+                        return Effect.fail(failure);
+                    if (frame !== "reset" && frame !== "closed")
+                        listener.bytes -= encodeSessionFrame(frame).bytes;
+                    return Effect.succeed(frame);
+                }));
+            });
+            return Object.freeze({
+                take,
+                checkpoint: (revision = -1) => {
+                    clear(listener);
+                    listener.lagged = false;
+                    listener.observed = revision;
+                },
+                close: () => {
+                    if (listener.closed)
+                        return;
+                    listener.closed = true;
+                    clear(listener);
+                    listeners.delete(listener);
+                    Queue.endUnsafe(listener.frames);
+                    if (listeners.size === 0)
+                        onIdle();
+                },
+            });
+        },
+        publish(frame, revision = Infinity) {
+            if (ended)
+                return;
+            const publicFrame = withoutSandboxFailures(frame);
+            for (const listener of listeners) {
+                if (listener.closed || listener.lagged || revision <= listener.observed)
+                    continue;
+                const value = listener.includeSandboxFailures ? frame : publicFrame;
+                const { bytes } = encodeSessionFrame(value);
+                if (listener.bytes + bytes > 1_048_576 ||
+                    !Queue.offerUnsafe(listener.frames, value)) {
+                    clear(listener);
+                    // Keep exactly one reset obligation; no incoming backlog can grow it.
+                    listener.lagged = true;
+                    Queue.offerUnsafe(listener.frames, "reset");
+                }
+                else {
+                    listener.bytes += bytes;
+                }
+            }
+        },
+        end(error) {
+            if (ended)
+                return;
+            ended = true;
+            failure = error;
+            for (const listener of listeners) {
+                clear(listener);
+                listener.lagged = false;
+                Queue.endUnsafe(listener.frames);
+            }
+        },
+    };
+}
 const ownerPublishers = new WeakMap();
 /** Actual live-view demand, excluding exact-command settlement waiters. */
 export function hasOwnerObservers(store, sessionId) {
@@ -39,7 +159,10 @@ function queueObservation(listener, reason) {
                 : "progress";
 }
 function deliverObservation(listener, reason) {
-    if (listener.closed || listener.reset)
+    if (listener.closed)
+        return;
+    listener.revision += 1;
+    if (listener.reset)
         return;
     const wake = listener.wake;
     if (wake === undefined) {
@@ -57,6 +180,14 @@ function deliverObservation(listener, reason) {
         listener.reset = true;
     }
 }
+/** Queued views reconcile occupancy without replaying another Session's facts. */
+function notifyQueuedViews(listeners, sourceSessionId) {
+    for (const listener of listeners)
+        if (listener.queued &&
+            !listener.settlementOnly &&
+            listener.sessionId !== sourceSessionId)
+            deliverObservation(listener, "activity");
+}
 /** Notify observers of one Session's durable or process-local change. */
 export function publishOwnerObservation(store, sessionId, reason = "durable") {
     const publishers = ownerPublishers.get(store);
@@ -131,11 +262,12 @@ export function openObservationKernel(store) {
     };
     const publish = (publication) => {
         if (publication.kind === "agent-execution") {
-            for (const listener of active)
-                if (listener.queued && !listener.settlementOnly)
-                    deliverObservation(listener, "activity");
+            notifyQueuedViews(active, null);
             return;
         }
+        // Reuse bounded activity hints for the occupant's changing phase.
+        if (publication.sessionId !== null && publication.reason !== "settlement")
+            notifyQueuedViews(active, publication.sessionId);
         const listeners = publication.sessionId === null
             ? active
             : sessions.get(publication.sessionId);
@@ -160,6 +292,7 @@ export function openObservationKernel(store) {
             if (active.size >= MAX_OBSERVATIONS)
                 return Effect.fail(new ShiitakeError("runtime", "rejected", "Observation capacity is exhausted"));
             const listener = {
+                revision: 0,
                 sessionId,
                 settlementOnly: interest === "settlement",
                 closed: false,
@@ -190,6 +323,9 @@ export function openObservationKernel(store) {
                 });
             });
             return Effect.succeed(Object.freeze({
+                get revision() {
+                    return listener.revision;
+                },
                 pollSignal,
                 awaitSignal,
                 close: () => {

package/dist/internal/run-scope.d.ts

@@ -7,6 +7,7 @@ import type { ShiitakeEffectOptions } from "./effect-contracts.js";
 import type { CompactionHandoffV0, PromptSectionV0 } from "../extensions.js";
 import { type ManualCompactionOutcome } from "./compaction/session-compaction.js";
 import { type PreparedSessionRun, type RunContract } from "./woodstock/index.js";
+export declare const runFinalizerGraceMs = 1000;
 declare const toolSetupMessages: {
     readonly missing: "Instruction capabilities have no tool runtime";
     readonly runtime: "Tool runtime failed";

package/dist/internal/run-scope.js

@@ -12,9 +12,11 @@ import { openCompactionSettings } from "./compaction/settings.js";
 import { acquireOwnedModel } from "./model-acquisition.js";
 import { returnedFailureReason, unavailableRunReason, } from "./run-failure-reason.js";
 import { isCompactCommand, openMuleRecorder, readSessionGrants, recordLiveRetryEvent, recordSandboxFailure, takeSessionControls, } from "./woodstock/index.js";
-// A run writes its terminal before scope release. Give each foreign release
-// one second to clean up without blocking the next Watchdog job indefinitely.
-const runFinalizerGraceMs = 1_000;
+// A run writes its terminal before scope release. Allow one second per foreign
+// release before detaching it: the held-model regression exercises the full
+// grace and proves Watchdog can settle and claim the next priority-1 steer.
+// Keep the test's eventual queue-idle budget tied to this product bound.
+export const runFinalizerGraceMs = 1_000;
 function boundedRunFinalizer(name, workId, release) {
     return Effect.gen(function* () {
         // A detached release may finish later; interrupting a finalizer itself

package/dist/internal/runtime-coordinator.js

@@ -3,6 +3,7 @@ import { WatchdogError } from "@fungi.computer/watchdog";
 import { makeRuntime as makeWatchdogRuntime, } from "@fungi.computer/watchdog/effect";
 import * as Effect from "effect/Effect";
 import * as Latch from "effect/Latch";
+import { readSessionPhase } from "./session-status.js";
 import { readOutstandingDelegationSync } from "../fleet.js";
 import { publishAgentExecutionChange } from "./observation-kernel.js";
 import { ShiitakeError } from "../errors.js";
@@ -12,7 +13,7 @@ import { openCompactionSettings } from "./compaction/settings.js";
 import { admitExtensionRosterV0, } from "./extension-roster.js";
 import { coreConsumer, reportConsumer, openExtensionRuntime, } from "./extension-runtime.js";
 import { reconcileRuntime } from "./runtime-reconciliation.js";
-import { advanceCursor, createSessionWithinTransaction, deliverSessionGrants, prepareExtensionStore, recordSessionDelegator, projectSessionRun, openStorageAdmission, readCursor, readSessionInboxPage, readSessionSummary, } from "./woodstock/index.js";
+import { advanceCursor, createSessionWithinTransaction, deliverSessionGrants, prepareExtensionStore, recordSessionDelegator, projectSessionRun, openStorageAdmission, readCursor, readSessionInboxPage, } from "./woodstock/index.js";
 function runtimeFailure(message) {
     return new ShiitakeError("runtime", "rejected", message);
 }
@@ -285,12 +286,16 @@ export function openRuntimeCoordinator(options, coreDigest, admitted, mailRoom)
                         ? "host"
                         : "serial")
                     : undefined;
-                if (work === undefined || work.kind === "host")
-                    return Effect.succeed(work ?? null);
-                return readSessionSummary(options.store, work.sessionId).pipe(Effect.map((summary) => ({
-                    ...work,
-                    title: summary?.title ?? "",
-                })));
+                if (work === undefined)
+                    return Effect.succeed(null);
+                if (work.kind === "host")
+                    return Effect.succeed({ phase: "thinking" });
+                return Effect.try({
+                    try: () => ({
+                        phase: readSessionPhase(options.store, work.sessionId, watchdog.transactional.readQueueHead(work.sessionId)),
+                    }),
+                    catch: (cause) => new ShiitakeError("runtime", "rejected", "Running phase is unavailable", undefined, cause),
+                });
             }), Effect.mapError((cause) => new ShiitakeError("runtime", "rejected", "Running work is unavailable", undefined, cause))),
             extensions,
             commit: bound.commit,

package/dist/internal/runtime-core.js

@@ -12,7 +12,8 @@ export function openRuntimeCore(options, mailRoom) {
         const coreDigest = yield* coreProtocolDigest([]);
         yield* prepareWoodstockSchema(options.store);
         const runtime = yield* openRuntimeCoordinator(options, coreDigest, admitted, mailRoom);
-        const coordinator = openCoordinator(options, runtime);
+        const ownerContext = yield* Effect.context();
+        const coordinator = openCoordinator(options, runtime, ownerContext);
         const agent = Object.freeze({
             session: coordinator.session,
             createSession: coordinator.createSession,

package/dist/internal/runtime-reconciliation.js

@@ -7,7 +7,7 @@ import { ShiitakeError } from "../errors.js";
 import { ExtensionId } from "../extension-contract.js";
 import { coreConsumer, reportConsumer, } from "./extension-runtime.js";
 import { publishOwnerObservation } from "./observation-kernel.js";
-import { advanceCursor, readCursor, readExtensionAdmissionOrigin, readSettledRunFacts, readSettlementContent, readSettlementDiagnostic, readSessionDelegator, readSettlementMeta, readWaitingOn, readWaitingOnSender, recordWorkSettlement, sessionLineageRefused, settleControls, } from "./woodstock/index.js";
+import { advanceCursor, readCursor, readExtensionAdmissionOrigin, readSettledRunFacts, readSettlementContent, readSettlementStretchContent, readSettlementDiagnostic, readSessionDelegator, readSettlementMeta, readWaitingOn, readWaitingOnSender, recordWorkSettlement, sessionLineageRefused, settleControls, } from "./woodstock/index.js";
 const pageSize = 64;
 function runtimeFailure(message) {
     return new ShiitakeError("runtime", "rejected", message);
@@ -100,7 +100,10 @@ function reportToDelegator(store, watchdog, mailRoom, job) {
             catch: () => runtimeFailure("Session attention is unavailable"),
         });
         const settled = yield* settlementFacts(store, job, waiting);
-        yield* fanOut(mailRoom, { ...settled, delegator });
+        const content = job.outcome === "cancelled"
+            ? ""
+            : yield* readSettlementStretchContent(store, payload.work);
+        yield* fanOut(mailRoom, { ...settled, content, delegator });
     });
 }
 /**

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

@@ -0,0 +1,37 @@
+import * as Effect from "effect/Effect";
+import type * as Context from "effect/Context";
+import * as Stream from "effect/Stream";
+import type { SessionContext, SessionFrame, SessionSnapshot, SubscribeOptions, WatchOptions } from "../client.js";
+import { ShiitakeError } from "../errors.js";
+import type { ShiitakeEffectOptions } from "./effect-contracts.js";
+import { type ObservationKernel } from "./observation-kernel.js";
+import type { RuntimeCoordinator } from "./runtime-coordinator.js";
+import { readSession } from "./woodstock/index.js";
+/** Shared live observation; Woodstock remains the bounded baseline and replay owner. */
+export declare function openSessionObservation(options: ShiitakeEffectOptions, runtime: RuntimeCoordinator, observation: ObservationKernel, ownerContext: Context.Context<never>): Readonly<{
+    read: (sessionId: string, input: Parameters<typeof readSession>[3]) => Effect.Effect<Readonly<{
+        sessionId: string;
+        cursor: string | null;
+        hasMore: boolean;
+        oldestCursor?: string | null;
+        messages: readonly import("../client.js").SessionMessage[];
+        terminals: readonly import("../client.js").SessionTerminal[];
+        compactions?: readonly import("../client.js").SessionCompactionMarker[];
+        compactionNotices?: readonly import("../client.js").SessionCompactionNotice[];
+        sandboxFailures?: readonly import("@fungi.computer/mycelium").SandboxFailureEvent[];
+        pending: import("../client.js").SessionPendingPrompts;
+        activity: import("../client.js").SessionActivity;
+        progress: import("../client.js").SessionProgress | null;
+        toolOutput: readonly import("../client.js").SessionToolOutput[];
+        extensions: import("../client.js").SessionExtensionSlots;
+        attention: readonly import("../session-attention.js").SessionAttention[];
+        context?: SessionContext;
+    }>, ShiitakeError, never>;
+    subscribe: (sessionId: string, input: SubscribeOptions) => Stream.Stream<SessionFrame, ShiitakeError, never>;
+    watch: (sessionId: string, input: WatchOptions | undefined) => Effect.Effect<Readonly<{
+        snapshot: SessionSnapshot;
+        changes: Stream.Stream<SessionFrame, ShiitakeError>;
+        close: Effect.Effect<void, ShiitakeError>;
+    }>, ShiitakeError, never>;
+    close: Effect.Effect<void, never, never>;
+}>;