@fungi.computer/shiitake 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,27 @@
+import type { FileTool } from "@fungi.computer/knapsack";
+import type { ModuleRegistration } from "@fungi.computer/mycelium";
+import * as Effect from "effect/Effect";
+import { ShiitakeError } from "../errors.js";
+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";
+declare const toolSetupMessages: {
+    readonly missing: "Instruction capabilities have no tool runtime";
+    readonly runtime: "Tool runtime failed";
+    readonly lease: "Tool lease failed";
+};
+/** Closed setup phases owned here; foreign error messages never define them. */
+export declare class ToolSetupError extends ShiitakeError {
+    private readonly phase;
+    constructor(phase: keyof typeof toolSetupMessages);
+    get diagnostic(): string;
+}
+/** Run one accepted command with Pi compaction explicitly composed around Mule. */
+export declare function runAcceptedCommand(options: ShiitakeEffectOptions, prepared: PreparedSessionRun, executionContract: RunContract, extensionModules: readonly ModuleRegistration[], extensionFileTools: readonly FileTool[], compactionHandoff: CompactionHandoffV0 | undefined, promptSections?: () => Effect.Effect<readonly PromptSectionV0[], ShiitakeError>): Effect.Effect<import("@fungi.computer/mule/effect").MuleRunOutcome, ShiitakeError, never>;
+/**
+ * Run one accepted compaction request: the run's model acquisition and the
+ * Session's one compaction commit, with no model turn and no tools.
+ */
+export declare function runAcceptedCompaction(options: ShiitakeEffectOptions, prepared: PreparedSessionRun, compactionHandoff: CompactionHandoffV0 | undefined): Effect.Effect<ManualCompactionOutcome, ShiitakeError>;
+export {};

package/dist/internal/run-scope.js

@@ -0,0 +1,214 @@
+import { muleEffect, piCodingAgentRetryDefaults, piHttpIdleTimeoutMs, } from "@fungi.computer/mule/effect";
+import { make as makeMycelium } from "@fungi.computer/mycelium/effect";
+import * as Effect from "effect/Effect";
+import { ShiitakeError } from "../errors.js";
+import { compactSession, runWithCompaction, } from "./compaction/session-compaction.js";
+import { openCompactionSettings } from "./compaction/settings.js";
+import { acquireOwnedModel } from "./model-acquisition.js";
+import { isCompactCommand, openMuleRecorder, readSessionGrants, recordLiveRetryEvent, recordSandboxFailure, takeSessionControls, } from "./woodstock/index.js";
+function runtimeFailure(message) {
+    return new ShiitakeError("runtime", "rejected", message);
+}
+const toolSetupMessages = {
+    missing: "Instruction capabilities have no tool runtime",
+    runtime: "Tool runtime failed",
+    lease: "Tool lease failed",
+};
+/** Closed setup phases owned here; foreign error messages never define them. */
+export class ToolSetupError extends ShiitakeError {
+    phase;
+    constructor(phase) {
+        super("runtime", "rejected", toolSetupMessages[phase]);
+        this.phase = phase;
+    }
+    get diagnostic() {
+        return toolSetupMessages[this.phase];
+    }
+}
+/**
+ * Map Mule's retry transitions onto Woodstock's retained `live_retry` facts.
+ * A started attempt ends the backoff countdown before streaming resumes.
+ */
+function toLiveRetryEvent(event) {
+    if (event.type === "retry_attempt_started")
+        return {
+            type: "auto_retry_attempt",
+            run: event.run,
+            attempt: event.attempt,
+        };
+    return event.type === "retry_scheduled"
+        ? {
+            type: "auto_retry_start",
+            run: event.run,
+            attempt: event.attempt,
+            maxAttempts: event.maxAttempts,
+            delayMs: event.delayMs,
+            errorMessage: event.errorMessage,
+        }
+        : event.finalError === undefined
+            ? {
+                type: "auto_retry_end",
+                run: event.run,
+                attempt: event.attempt,
+                success: event.success,
+            }
+            : {
+                type: "auto_retry_end",
+                run: event.run,
+                attempt: event.attempt,
+                success: event.success,
+                finalError: event.finalError,
+            };
+}
+/** Acquire the run's tools for exactly one Session, so hosts can project per Session. */
+function acquiredTools(options, sessionId, workId, meta, instructions, extensionModules, extensionFileTools) {
+    const toolSource = options.tools;
+    const instructionModules = instructions.modules ?? [];
+    const modules = [...instructionModules, ...extensionModules];
+    if (toolSource === undefined) {
+        if (instructionModules.length > 0 || extensionFileTools.length > 0)
+            return Effect.fail(new ToolSetupError("missing"));
+        return Effect.succeed([]);
+    }
+    return Effect.gen(function* () {
+        let session = { sessionId, commandId: workId };
+        if (meta !== undefined)
+            session = { ...session, meta };
+        const runtimeOptions = {
+            sources: toolSource.sources,
+            session,
+            sandbox: toolSource.sandbox,
+            onSandboxFailure: (event) => recordSandboxFailure(options.store, { sessionId, commandId: workId }, event).pipe(Effect.orDie),
+            modules: [...toolSource.modules, ...modules],
+            tools: extensionFileTools,
+            access: {
+                ...toolSource.access,
+                // Mycelium reads the stored grants at every call, so a grant the
+                // host changes mid-run applies to the very next call.
+                sessionGrants: () => readSessionGrants(options.store, sessionId)?.grants ?? {},
+            },
+        };
+        const runtime = yield* makeMycelium(toolSource.execution === undefined
+            ? runtimeOptions
+            : { ...runtimeOptions, execution: toolSource.execution }).pipe(Effect.mapError(() => new ToolSetupError("runtime")));
+        const lease = yield* runtime
+            .acquire()
+            .pipe(Effect.mapError(() => new ToolSetupError("lease")));
+        return [lease.executeTool, ...lease.tools];
+    });
+}
+/** Run one accepted command with Pi compaction explicitly composed around Mule. */
+export function runAcceptedCommand(options, prepared, executionContract, extensionModules, extensionFileTools, compactionHandoff, promptSections) {
+    return Effect.scoped(Effect.gen(function* () {
+        const instructions = yield* options.instructions.load({
+            sessionId: prepared.command.sessionId,
+            commandId: prepared.command.entry.workId,
+        });
+        const releaseInstructions = instructions.release;
+        if (releaseInstructions !== undefined)
+            yield* Effect.addFinalizer(() => Effect.sync(releaseInstructions));
+        const acquired = yield* acquireOwnedModel(options.model.acquire({
+            sessionId: prepared.command.sessionId,
+            preference: prepared.modelPreference,
+        }));
+        const tools = yield* acquiredTools(options, prepared.command.sessionId, prepared.command.entry.workId, prepared.command.entry.meta, instructions, extensionModules, extensionFileTools);
+        const accepted = Object.freeze({
+            sessionId: prepared.command.sessionId,
+            requestId: prepared.command.entry.requestId,
+            commandId: prepared.command.entry.workId,
+        });
+        const recorder = yield* openMuleRecorder(options.store, accepted, executionContract);
+        const controlMessages = (delivery) => takeSessionControls(options.store, {
+            sessionId: accepted.sessionId,
+            workId: accepted.commandId,
+            delivery,
+        }).pipe(Effect.map((controls) => controls.map(({ message }) => message)), Effect.mapError((error) => ({
+            _tag: "MuleError",
+            // Control failures are terminal-worthy; listener failures
+            // suppress the terminal notification because the listener
+            // cannot store it.
+            phase: "control",
+            message: error instanceof ShiitakeError
+                ? error.message
+                : "Session control delivery failed",
+        })));
+        let resume = prepared.resume;
+        const settings = openCompactionSettings(options.compaction)(acquired.model);
+        return yield* runWithCompaction({
+            store: options.store,
+            sessionId: prepared.command.sessionId,
+            workId: prepared.command.entry.workId,
+            model: acquired.model,
+            stream: acquired.stream,
+            handoff: compactionHandoff,
+            settings,
+            path: prepared.path,
+            messages: prepared.messages,
+            resuming: resume !== undefined,
+            run: (workingMessages, betweenTurns) => {
+                const continuation = resume;
+                resume = undefined;
+                const listener = (event) => recorder(event);
+                const input = {
+                    model: acquired.model,
+                    modelStreamIdleTimeoutMs: options.modelStreamIdleTimeoutMs ?? piHttpIdleTimeoutMs,
+                    retry: options.retry ?? piCodingAgentRetryDefaults,
+                    retryAfterMs: acquired.retryAfterMs,
+                    systemPrompt: instructions.text,
+                    prepareSystemPrompt: () => (promptSections === undefined
+                        ? Effect.succeed([])
+                        : promptSections()).pipe(Effect.map((sections) => instructions.text +
+                        sections
+                            .map(({ name, text }) => `\n\n[extension:${name}]\n${text}`)
+                            .join("")), Effect.mapError((cause) => ({
+                        _tag: "MuleError",
+                        phase: "model",
+                        message: "Extension prompt is unavailable",
+                        cause,
+                    }))),
+                    messages: workingMessages,
+                    resume: continuation,
+                    tools,
+                    getSteeringMessages: () => controlMessages("steer"),
+                    prepareNextTurn: (turn) => betweenTurns(turn.context, turn.newMessages.length).pipe(Effect.mapError((error) => ({
+                        _tag: "MuleError",
+                        phase: "control",
+                        message: error.message,
+                    }))),
+                    onRetry: (event) => recordLiveRetryEvent(options.store, accepted, toLiveRetryEvent(event), event.turn),
+                };
+                return muleEffect
+                    .run(acquired.stream === undefined
+                    ? input
+                    : { ...input, stream: acquired.stream }, listener)
+                    .pipe(Effect.mapError((error) => runtimeFailure(error.phase === "model"
+                    ? error.message
+                    : "Mule rejected the durable command run")));
+            },
+        });
+    }));
+}
+/**
+ * Run one accepted compaction request: the run's model acquisition and the
+ * Session's one compaction commit, with no model turn and no tools.
+ */
+export function runAcceptedCompaction(options, prepared, compactionHandoff) {
+    return Effect.scoped(Effect.gen(function* () {
+        const acquired = yield* acquireOwnedModel(options.model.acquire({
+            sessionId: prepared.command.sessionId,
+            preference: prepared.modelPreference,
+        }));
+        const entry = prepared.command.entry;
+        return yield* compactSession({
+            store: options.store,
+            sessionId: prepared.command.sessionId,
+            workId: entry.workId,
+            model: acquired.model,
+            stream: acquired.stream,
+            handoff: compactionHandoff,
+            settings: openCompactionSettings(options.compaction)(acquired.model),
+            path: prepared.path,
+            instructions: isCompactCommand(entry) ? entry.instructions : undefined,
+        });
+    }));
+}

package/dist/internal/runtime-coordinator.d.ts

@@ -0,0 +1,34 @@
+import { type BirdDogEffect } from "@fungi.computer/bird-dog/effect";
+import { type WatchdogQueueHead } from "@fungi.computer/watchdog/effect";
+import * as Effect from "effect/Effect";
+import type { AgentRunningWork } from "../client.js";
+import { ShiitakeError } from "../errors.js";
+import { type AdmissionDoor } from "./admission-door.js";
+import type { ShiitakeEffectOptions } from "./effect-contracts.js";
+import type { AdmittedExtensionV0 } from "./extension-roster.js";
+import { type ExtensionRuntime } from "./extension-runtime.js";
+import { type RecordAcceptedCancellation, type StorageAdmission } from "./woodstock/index.js";
+/** Bound lifecycle and owner-transaction doors used by the public coordinator. */
+export type RuntimeCoordinator = Readonly<{
+    activeSessions: Effect.Effect<readonly string[]>;
+    runningWork: (jobId: string) => Effect.Effect<AgentRunningWork | null, ShiitakeError>;
+    assertOpen: Effect.Effect<void, ShiitakeError>;
+    /** Rostered v1 extensions bound to core's doors and tables. */
+    extensions: ExtensionRuntime;
+    beginClose: Effect.Effect<void>;
+    /** The one accepted-command door every prompt producer admits through. */
+    door: AdmissionDoor;
+    /** Storage-pressure check for new Sessions and new prompts. */
+    storage: StorageAdmission;
+    recordAcceptedCancellation: RecordAcceptedCancellation;
+    assertIdleSession: (queue: string) => void;
+    signalCancellation: (jobId: string, cancellationId: string) => Effect.Effect<void, ShiitakeError>;
+    commit: <A>(mutation: Effect.Effect<A, ShiitakeError>) => Effect.Effect<A, ShiitakeError>;
+    requestWake: Effect.Effect<void, ShiitakeError>;
+    readQueueHead: (queue: string) => Effect.Effect<WatchdogQueueHead, ShiitakeError>;
+    /** Transactional queue-head projection used by owner-atomic cancellation. */
+    readQueueHeadTransactional: (queue: string) => WatchdogQueueHead;
+    close: Effect.Effect<void, ShiitakeError>;
+}>;
+/** Construct Watchdog once and bind its deep tick to the host wake door. */
+export declare function openRuntimeCoordinator(options: ShiitakeEffectOptions, coreDigest: string, admitted: readonly AdmittedExtensionV0[], mailRoom?: BirdDogEffect): Effect.Effect<RuntimeCoordinator, ShiitakeError>;

package/dist/internal/runtime-coordinator.js

@@ -0,0 +1,233 @@
+import { agentJobFromInput, } from "@fungi.computer/bird-dog/effect";
+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 { publishOwnerObservation } from "./observation-kernel.js";
+import { ShiitakeError } from "../errors.js";
+import { agentTurnRecovery, executeAcceptedRun, } from "./accepted-run-executor.js";
+import { openAdmissionDoor } from "./admission-door.js";
+import { openCompactionSettings } from "./compaction/settings.js";
+import { coreConsumer, openExtensionRuntime, } from "./extension-runtime.js";
+import { reconcileRuntime } from "./runtime-reconciliation.js";
+import { advanceCursor, prepareExtensionStore, projectSessionRun, openStorageAdmission, readCursor, } from "./woodstock/index.js";
+function runtimeFailure(message) {
+    return new ShiitakeError("runtime", "rejected", message);
+}
+/** Construct Watchdog once and bind its deep tick to the host wake door. */
+export function openRuntimeCoordinator(options, coreDigest, admitted, mailRoom) {
+    return Effect.gen(function* () {
+        if (options.hostJobs?.lane === "default")
+            return yield* Effect.fail(runtimeFailure("Host lane conflicts with Agent work"));
+        let lifecycleState = "open";
+        let retainedFailure;
+        let retainedBeforeClose;
+        const closing = Latch.makeUnsafe(false);
+        const retainFailure = (failure) => Effect.sync(() => {
+            if (lifecycleState === "open")
+                retainedFailure ??= failure;
+        });
+        const beginClose = Effect.suspend(() => {
+            if (lifecycleState !== "open")
+                return Effect.void;
+            lifecycleState = "closing";
+            retainedBeforeClose = retainedFailure;
+            return closing.open;
+        }).pipe(Effect.uninterruptible);
+        const boundRuntime = {};
+        const extensionsRef = { current: undefined };
+        const requestBoundWake = Effect.suspend(() => boundRuntime.requestWake ??
+            Effect.fail(runtimeFailure("Runtime host is unavailable")));
+        const hostExecutor = { current: undefined };
+        const activeSessions = new Set();
+        const runningSlots = new Map();
+        const watchdogOptions = {
+            owner: options.store,
+            // Each Watchdog slot serializes ticks and inspects only its partition. A claim
+            // found on a new owner has no surviving execution (including DO eviction).
+            // Hosts must keep one runtime per SQLite owner, never two live coordinators.
+            isAlive: () => Effect.succeed(false),
+            executor: {
+                execute: (job) => Effect.acquireUseRelease(Effect.sync(() => {
+                    const runningWork = job.lane === options.hostJobs?.lane
+                        ? { kind: "host", lane: job.lane, jobId: job.jobId }
+                        : {
+                            kind: "session",
+                            sessionId: job.queue,
+                            commandId: job.jobId,
+                        };
+                    runningSlots.set(runningWork.kind === "host" ? "host" : "serial", runningWork);
+                    if (runningWork.kind === "session")
+                        activeSessions.add(job.queue);
+                    // A different Session's wait changes when this executor changes.
+                    publishOwnerObservation(options.store, null);
+                }), () => job.lane === options.hostJobs?.lane
+                    ? (hostExecutor.current?.execute(job) ??
+                        Effect.fail(new WatchdogError("execution_failed")))
+                    : executeAcceptedRun(options, coreDigest, job, extensionsRef.current), () => Effect.sync(() => {
+                    if (job.lane !== options.hostJobs?.lane)
+                        activeSessions.delete(job.queue);
+                    runningSlots.delete(job.lane === options.hostJobs?.lane ? "host" : "serial");
+                    publishOwnerObservation(options.store, null);
+                })),
+            },
+            wake: {
+                recompute: () => requestBoundWake.pipe(Effect.mapError(() => new WatchdogError("wake_unavailable"))),
+            },
+            // Inbox rows change in the same transaction as the queue they project.
+            project: (transition) => {
+                projectSessionRun(options.store, transition, Date.now());
+            },
+        };
+        const openWatchdog = options.hostJobs === undefined
+            ? makeWatchdogRuntime(watchdogOptions)
+            : makeWatchdogRuntime({
+                ...watchdogOptions,
+                concurrentLane: options.hostJobs.lane,
+            }).pipe(Effect.tap((runtime) => Effect.sync(() => {
+                hostExecutor.current = options.hostJobs?.open(runtime);
+            })));
+        const watchdog = yield* openWatchdog.pipe(Effect.mapError(() => runtimeFailure("Watchdog is unavailable")));
+        const contract = () => ({
+            core: coreDigest,
+            extensions: [...(extensionsRef.current?.runParticipants() ?? [])],
+        });
+        // Refuse invalid compaction budgets when the owner opens, not mid-run.
+        yield* Effect.try({
+            try: () => openCompactionSettings(options.compaction),
+            catch: (error) => error instanceof ShiitakeError
+                ? error
+                : runtimeFailure("Compaction settings are unavailable"),
+        });
+        const storage = yield* Effect.try({
+            try: () => openStorageAdmission(options.storageBudget),
+            catch: (error) => error instanceof ShiitakeError
+                ? error
+                : runtimeFailure("Storage budget is unavailable"),
+        });
+        const door = openAdmissionDoor({
+            owner: options.store,
+            admitNew: storage.admitNew,
+            hostMeta: options.meta,
+            contract,
+            enqueue: (work, mail) => {
+                const input = { work: { ...work, recovery: agentTurnRecovery } };
+                watchdog.transactional.enqueueAcceptedJob(agentJobFromInput(mail === undefined ? input : { ...input, mail }));
+            },
+            readQueueHead: (queue) => watchdog.transactional.readQueueHead(queue),
+            commit: (mutation) => Effect.suspend(() => boundRuntime.commit === undefined
+                ? Effect.fail(runtimeFailure("Runtime host is unavailable"))
+                : boundRuntime.commit(mutation)),
+            requestWake: requestBoundWake,
+        });
+        yield* Effect.try({
+            try: () => {
+                prepareExtensionStore(options.store);
+                if (readCursor(options.store, coreConsumer) === undefined)
+                    options.store.transactionSync(() => {
+                        advanceCursor(options.store, coreConsumer, 0);
+                    });
+            },
+            catch: () => new ShiitakeError("store", "unavailable", "Extension store is unavailable"),
+        });
+        const extensions = yield* openExtensionRuntime({
+            owner: options.store,
+            readQueueHead: (sessionId) => watchdog.transactional.readQueueHead(sessionId),
+            door,
+            admitted,
+            requestWake: requestBoundWake,
+        });
+        extensionsRef.current = extensions;
+        const reconcile = reconcileRuntime({
+            watchdog,
+            store: options.store,
+            extensions,
+            requestWake: requestBoundWake,
+            mailRoom,
+        }).pipe(Effect.tapError(retainFailure));
+        const pendingWork = Effect.gen(function* () {
+            const watchdogPending = yield* watchdog.hasPendingWork;
+            const now = Date.now();
+            const cursors = yield* Effect.try({
+                try: () => [
+                    readCursor(options.store, coreConsumer) ?? 0,
+                    ...extensions.settledConsumers().map(({ cursor }) => cursor),
+                ],
+                catch: () => runtimeFailure("Settled cursor is unavailable"),
+            });
+            const settledLag = (yield* watchdog.readSettled(1, Math.min(...cursors))).length > 0;
+            const timers = yield* Effect.try({
+                try: () => extensions.timerWake(now),
+                catch: () => runtimeFailure("Extension timers are unavailable"),
+            });
+            return {
+                pending: watchdogPending || settledLag || timers.due,
+                nextWakeAt: timers.nextWakeAt,
+            };
+        });
+        const bound = yield* options.runtime
+            .bind({
+            reconcile,
+            pendingWork: pendingWork.pipe(Effect.mapError(() => runtimeFailure("Pending work is unavailable"))),
+        })
+            .pipe(Effect.onError(() => extensions.close.pipe(Effect.orDie)));
+        const requestWake = Effect.suspend(() => lifecycleState === "open"
+            ? Effect.raceFirst(bound.requestWake.pipe(Effect.catch(retainFailure)), closing.await)
+            : Effect.void);
+        boundRuntime.requestWake = requestWake;
+        boundRuntime.commit = bound.commit;
+        // Every host must get one post-bind tick to recover durable work after a cold reopen.
+        yield* bound.requestWake.pipe(Effect.onError(() => Effect.all([bound.close, extensions.close]).pipe(Effect.orDie)));
+        return Object.freeze({
+            activeSessions: Effect.sync(() => [...activeSessions]),
+            runningWork: (jobId) => watchdog.read(jobId).pipe(Effect.map((result) => result.status === "found"
+                ? (runningSlots.get(result.job.lane === options.hostJobs?.lane
+                    ? "host"
+                    : "serial") ?? null)
+                : null), Effect.mapError((cause) => new ShiitakeError("runtime", "rejected", "Running work is unavailable", undefined, cause))),
+            extensions,
+            commit: bound.commit,
+            assertOpen: Effect.suspend(() => lifecycleState === "open"
+                ? Effect.void
+                : Effect.fail(new ShiitakeError("runtime", "closed", "Shiitake is closed"))),
+            beginClose,
+            door,
+            storage,
+            recordAcceptedCancellation: ({ jobId, cancellationId, onlyIfPending }) => watchdog.transactional.recordCancellationIntent({
+                jobId,
+                cancellationId,
+                onlyIfQueued: onlyIfPending,
+            }),
+            assertIdleSession: (queue) => {
+                try {
+                    const head = watchdog.transactional.readQueueHead(queue);
+                    if (head.state !== "idle")
+                        throw new ShiitakeError("runtime", "conflict", "Session branch or fork requires an idle Session");
+                }
+                catch (error) {
+                    if (error instanceof ShiitakeError)
+                        throw error;
+                    throw runtimeFailure("Session status is unavailable");
+                }
+            },
+            signalCancellation: (jobId, cancellationId) => watchdog.cancel({ jobId, cancellationId }).pipe(Effect.flatMap((result) => result.status === "recorded" || result.status === "replayed"
+                ? Effect.void
+                : Effect.fail(runtimeFailure("Cancellation is unavailable"))), Effect.mapError(() => runtimeFailure("Cancellation is unavailable"))),
+            readQueueHead: (queue) => watchdog
+                .readQueueHead(queue)
+                .pipe(Effect.mapError(() => runtimeFailure("Session status is unavailable"))),
+            readQueueHeadTransactional: (queue) => watchdog.transactional.readQueueHead(queue),
+            requestWake,
+            close: beginClose.pipe(Effect.andThen(Effect.matchCauseEffect(bound.close, {
+                onFailure: (cause) => extensions.close.pipe(Effect.andThen(retainedBeforeClose === undefined
+                    ? Effect.failCause(cause)
+                    : Effect.fail(retainedBeforeClose))),
+                onSuccess: () => extensions.close.pipe(Effect.andThen(retainedBeforeClose === undefined
+                    ? Effect.void
+                    : Effect.fail(retainedBeforeClose))),
+            })), Effect.ensuring(Effect.sync(() => {
+                lifecycleState = "closed";
+            }))),
+        });
+    });
+}

package/dist/internal/runtime-core.d.ts

@@ -0,0 +1,19 @@
+import type { CommandSettlement } from "./contracts.js";
+import type { Json } from "../extensions.js";
+import type { BirdDogMail } from "@fungi.computer/bird-dog";
+import type { VerifiedAgentReply } from "./woodstock/index.js";
+import type { BirdDogEffect } from "@fungi.computer/bird-dog/effect";
+import * as Effect from "effect/Effect";
+import type { Accepted } from "../client.js";
+import { ShiitakeError } from "../errors.js";
+import type { ShiitakeEffectOptions, ShiitakeEffectOwner } from "./effect-contracts.js";
+/** Private host composition with the addressed-mail ingress kept off Session. */
+export type RuntimeCore = Readonly<{
+    agent: ShiitakeEffectOwner;
+    readSettlement: (sessionId: string, commandId: string) => Effect.Effect<CommandSettlement | undefined, ShiitakeError>;
+    /** Owner-local execution projection; never served by the remote client. */
+    activeSessions: Effect.Effect<readonly string[]>;
+    acceptMail: (mail: BirdDogMail, meta?: Json, reply?: VerifiedAgentReply) => Effect.Effect<Accepted, ShiitakeError>;
+}>;
+/** Open Runtime Core, optionally joining its owner-local BirdDog mail room. */
+export declare function openRuntimeCore(options: ShiitakeEffectOptions, mailRoom?: BirdDogEffect): Effect.Effect<RuntimeCore, ShiitakeError>;

package/dist/internal/runtime-core.js

@@ -0,0 +1,39 @@
+import * as Effect from "effect/Effect";
+import { ShiitakeError } from "../errors.js";
+import { composeAgentClose } from "./agent-close.js";
+import { acceptAddressedMail, openCoordinator } from "./coordinator.js";
+import { admitExtensionRosterV0, coreProtocolDigest, } from "./extension-roster.js";
+import { openRuntimeCoordinator } from "./runtime-coordinator.js";
+import { readCommandSettlement, prepareWoodstockSchema, } from "./woodstock/index.js";
+/** Open Runtime Core, optionally joining its owner-local BirdDog mail room. */
+export function openRuntimeCore(options, mailRoom) {
+    return Effect.gen(function* () {
+        const admitted = yield* admitExtensionRosterV0(options.extensions);
+        const coreDigest = yield* coreProtocolDigest([]);
+        yield* prepareWoodstockSchema(options.store);
+        const runtime = yield* openRuntimeCoordinator(options, coreDigest, admitted, mailRoom);
+        const coordinator = openCoordinator(options, runtime);
+        const agent = Object.freeze({
+            session: coordinator.session,
+            createSession: coordinator.createSession,
+            deleteSession: coordinator.deleteSession,
+            listSessions: coordinator.listSessions,
+            extensions: coordinator.extensions,
+            close: composeAgentClose(coordinator.close, runtime.close),
+        });
+        const owner = Object.freeze({
+            ...agent,
+            grants: coordinator.grants,
+            withMeta: (meta) => Object.freeze({
+                ...agent,
+                session: coordinator.withMeta(meta).session,
+            }),
+        });
+        return Object.freeze({
+            agent: owner,
+            readSettlement: (sessionId, commandId) => runtime.assertOpen.pipe(Effect.andThen(readCommandSettlement(options.store, sessionId, commandId))),
+            activeSessions: runtime.activeSessions,
+            acceptMail: (mail, meta, reply) => acceptAddressedMail(runtime, mail, meta, reply),
+        });
+    });
+}

package/dist/internal/runtime-reconciliation.d.ts

@@ -0,0 +1,18 @@
+import { type BirdDogEffect } from "@fungi.computer/bird-dog/effect";
+import type { WatchdogRuntimeEffect } from "@fungi.computer/watchdog/effect";
+import * as Effect from "effect/Effect";
+import { ShiitakeError } from "../errors.js";
+import type { SqliteOwner } from "./contracts.js";
+import { type ExtensionRuntime } from "./extension-runtime.js";
+/**
+ * One reconcile tick. Each step is its own Exit boundary: a failed extension
+ * stops only itself, and mail always drains. Only a core failure fails the
+ * tick, so the host backs off only for core.
+ */
+export declare function reconcileRuntime(input: Readonly<{
+    watchdog: WatchdogRuntimeEffect;
+    store: SqliteOwner;
+    mailRoom: BirdDogEffect | undefined;
+    extensions: ExtensionRuntime;
+    requestWake: Effect.Effect<void, ShiitakeError>;
+}>): Effect.Effect<void, ShiitakeError>;