@fungi.computer/shiitake 0.0.0-stage → 0.1.0

package/dist/internal/failure.d.ts

@@ -0,0 +1,2 @@
+/** Retain the original failure without printing Session or provider data. */
+export declare function reportCatchFailure(operation: string, cause: unknown): void;

package/dist/internal/failure.js

@@ -0,0 +1,9 @@
+import * as Effect from "effect/Effect";
+import * as Redacted from "effect/Redacted";
+/** Retain the original failure without printing Session or provider data. */
+export function reportCatchFailure(operation, cause) {
+    Effect.runFork(Effect.logError("shiitake_operation_failed", Redacted.make(cause)).pipe(Effect.annotateLogs({
+        operation,
+        errorKind: cause instanceof Error ? "error" : "non-error",
+    })));
+}

package/dist/internal/host-meta.d.ts

@@ -0,0 +1,41 @@
+import * as Schema from "effect/Schema";
+import type { Json } from "../extensions.js";
+/**
+ * Host metadata as stored: any finite JSON value within the byte cap.
+ * Shiitake stores and returns it and never branches on it.
+ */
+export declare const HostMetaSchema: Schema.Codec<Json>;
+/**
+ * Any Standard Schema, such as a Zod 4 schema, whose `validate` settles
+ * synchronously. Shiitake only asks whether a value is accepted.
+ */
+export type StandardHostMetaSchema = Readonly<{
+    "~standard": Readonly<{
+        /** Accept or refuse one value; must settle synchronously for Shiitake. */
+        validate: (value: Json) => StandardHostMetaResult | PromiseLike<StandardHostMetaResult>;
+    }>;
+}>;
+/** One Standard Schema validation outcome; only acceptance matters here. */
+export type StandardHostMetaResult = Readonly<{
+    issues?: undefined;
+}> | Readonly<{
+    issues: readonly Readonly<{
+        message: string;
+    }>[];
+}>;
+/**
+ * The one schema a host supplies at Agent creation for the metadata it
+ * attaches to prompts and operator lines: an Effect schema whose encoded side
+ * is JSON, or a synchronous Standard Schema. Shiitake checks each value
+ * against it before writing; it never reads the decoded form.
+ */
+export type HostMetaOptions = Readonly<{
+    schema: Schema.Codec<unknown, Json> | StandardHostMetaSchema;
+}>;
+/**
+ * Check one host-attached value: finite JSON within the cap, and accepted by
+ * the host's schema when it supplied one. Fails as an invalid contract.
+ */
+export declare function checkHostMeta(options: HostMetaOptions | undefined, meta: Json): Json;
+/** Whether two stored metadata values are the same canonical JSON. */
+export declare function sameHostMeta(left: Json | undefined, right: Json | undefined): boolean;

package/dist/internal/host-meta.js

@@ -0,0 +1,39 @@
+import * as Predicate from "effect/Predicate";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { ShiitakeError } from "../errors.js";
+import { JsonValueSchema } from "./json-value.js";
+/** The most encoded JSON one message's host metadata may occupy. */
+const MAX_HOST_META_BYTES = 4096;
+const encoder = new TextEncoder();
+/**
+ * Host metadata as stored: any finite JSON value within the byte cap.
+ * Shiitake stores and returns it and never branches on it.
+ */
+export const HostMetaSchema = JsonValueSchema.check(Schema.makeFilter((value) => encoder.encode(JSON.stringify(value)).byteLength <= MAX_HOST_META_BYTES));
+const decodeStoredMeta = Schema.decodeUnknownResult(HostMetaSchema);
+/** Whether the host's schema accepts one stored value. */
+function hostAccepts(schema, meta) {
+    if (Schema.isSchema(schema))
+        return Result.isSuccess(Schema.decodeUnknownResult(schema)(meta));
+    const result = schema["~standard"].validate(meta);
+    if (Predicate.hasProperty(result, "then"))
+        throw new ShiitakeError("contract", "invalid", "Host metadata schema must validate synchronously");
+    return result.issues === undefined;
+}
+/**
+ * Check one host-attached value: finite JSON within the cap, and accepted by
+ * the host's schema when it supplied one. Fails as an invalid contract.
+ */
+export function checkHostMeta(options, meta) {
+    const stored = decodeStoredMeta(meta);
+    if (Result.isFailure(stored))
+        throw new ShiitakeError("contract", "invalid", "Host metadata is not JSON within 4096 bytes");
+    if (options !== undefined && !hostAccepts(options.schema, stored.success))
+        throw new ShiitakeError("contract", "invalid", "Host metadata does not match the host's schema");
+    return stored.success;
+}
+/** Whether two stored metadata values are the same canonical JSON. */
+export function sameHostMeta(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}

package/dist/internal/json-value.d.ts

@@ -0,0 +1,4 @@
+import * as Schema from "effect/Schema";
+import type { Json } from "../extensions.js";
+/** Any finite JSON value; an extension's own schema decodes it further. */
+export declare const JsonValueSchema: Schema.Codec<Json>;

package/dist/internal/json-value.js

@@ -0,0 +1,3 @@
+import * as Schema from "effect/Schema";
+/** Any finite JSON value; an extension's own schema decodes it further. */
+export const JsonValueSchema = Schema.Json;

package/dist/internal/model-acquisition.d.ts

@@ -0,0 +1,21 @@
+import * as Effect from "effect/Effect";
+import type * as Scope from "effect/Scope";
+import type { ModelAcquisition, ModelSource } from "./contracts.js";
+import type { ModelAcquisitionEffect, ModelSourceEffect } from "./effect-contracts.js";
+/**
+ * Adapt a host Promise while keeping an interrupted late result owned.
+ *
+ * Effect's interruptible acquisition can stop waiting before a foreign
+ * Promise settles. The returned async cleanup therefore waits for that
+ * Promise and releases a result which was never transferred to the run
+ * scope. A successful result resumes the Effect only after the signal check,
+ * so the run scope's finalizer owns it exactly once.
+ */
+export declare function acquireModelPromise(acquire: (signal: AbortSignal) => Promise<ModelAcquisition>): ReturnType<ModelSourceEffect["acquire"]>;
+/**
+ * Transfer one interruptible acquisition into its run scope without an
+ * interruption gap between success and ownership registration.
+ */
+export declare function acquireOwnedModel<E, R>(acquire: Effect.Effect<ModelAcquisitionEffect, E, R>): Effect.Effect<ModelAcquisitionEffect, E, R | Scope.Scope>;
+/** Lift one host model source into the Effect runtime boundary. */
+export declare function adaptModelSource(source: ModelSource): ModelSourceEffect;

package/dist/internal/model-acquisition.js

@@ -0,0 +1,98 @@
+import * as Effect from "effect/Effect";
+import { ShiitakeError } from "../errors.js";
+import { reportCatchFailure } from "./failure.js";
+function acquisitionFailure(cause) {
+    if (cause instanceof ShiitakeError)
+        return cause;
+    return new ShiitakeError("model", "rejected", "Model acquisition failed", undefined, cause);
+}
+function releaseFailure(cause) {
+    return new ShiitakeError("model", "rejected", "Model release failed", undefined, cause);
+}
+function asEffectAcquisition(acquisition) {
+    const release = Effect.tryPromise({
+        try: () => acquisition.release(),
+        catch: releaseFailure,
+    });
+    const shared = { model: acquisition.model, release };
+    if (acquisition.stream === undefined)
+        return acquisition.retryAfterMs === undefined
+            ? Object.freeze(shared)
+            : Object.freeze({ ...shared, retryAfterMs: acquisition.retryAfterMs });
+    return acquisition.retryAfterMs === undefined
+        ? Object.freeze({ ...shared, stream: acquisition.stream })
+        : Object.freeze({
+            ...shared,
+            stream: acquisition.stream,
+            retryAfterMs: acquisition.retryAfterMs,
+        });
+}
+/**
+ * Adapt a host Promise while keeping an interrupted late result owned.
+ *
+ * Effect's interruptible acquisition can stop waiting before a foreign
+ * Promise settles. The returned async cleanup therefore waits for that
+ * Promise and releases a result which was never transferred to the run
+ * scope. A successful result resumes the Effect only after the signal check,
+ * so the run scope's finalizer owns it exactly once.
+ */
+export function acquireModelPromise(acquire) {
+    return Effect.callback((resume, signal) => {
+        if (signal.aborted)
+            return;
+        let acquisition;
+        try {
+            acquisition = Promise.resolve(acquire(signal));
+        }
+        catch (cause) {
+            resume(Effect.fail(acquisitionFailure(cause)));
+            return;
+        }
+        const settled = acquisition.then((resource) => {
+            if (signal.aborted) {
+                // An interrupted foreign Promise may still produce a resource. Keep
+                // cancellation pending until that resource has been released.
+                return Promise.resolve(resource.release()).then(() => undefined);
+            }
+            resume(Effect.succeed(asEffectAcquisition(resource)));
+            return undefined;
+        }, (cause) => {
+            if (!signal.aborted)
+                resume(Effect.fail(acquisitionFailure(cause)));
+            else
+                reportCatchFailure("late-model-acquisition", cause);
+        });
+        // Effect runs this cleanup when its interruptible async wait is stopped.
+        // `settled` also observes late rejection, preventing an unhandled Promise.
+        return Effect.tryPromise({
+            try: () => settled,
+            catch: releaseFailure,
+        }).pipe(Effect.orDie);
+    });
+}
+/**
+ * Transfer one interruptible acquisition into its run scope without an
+ * interruption gap between success and ownership registration.
+ */
+export function acquireOwnedModel(acquire) {
+    let owned;
+    const transfer = Effect.uninterruptibleMask((restore) => Effect.flatMap(restore(acquire), (acquisition) => Effect.sync(() => {
+        owned = acquisition;
+        return acquisition;
+    })));
+    return Effect.acquireRelease(transfer, () => owned === undefined ? Effect.void : owned.release.pipe(Effect.orDie), { interruptible: true });
+}
+/** Lift one host model source into the Effect runtime boundary. */
+export function adaptModelSource(source) {
+    const acquire = ({ sessionId, preference }) => acquireModelPromise((signal) => source.acquire({ sessionId, preference, signal }));
+    const describe = source.describe;
+    return Object.freeze(describe === undefined
+        ? { acquire }
+        : {
+            acquire,
+            describe: ({ sessionId, preference, }) => Effect.tryPromise({
+                try: (signal) => describe({ sessionId, preference, signal }),
+                catch: acquisitionFailure,
+            }),
+        });
+}

package/dist/internal/model-preference.d.ts

@@ -0,0 +1,21 @@
+import * as Schema from "effect/Schema";
+/** Secret-free request to the host's maintained model catalogue. */
+export declare const ModelPreferenceSchema: Schema.Struct<{
+    readonly providerId: Schema.String;
+    readonly modelId: Schema.String;
+    readonly reasoning: Schema.optional<Schema.Literals<readonly ["minimal", "low", "medium", "high", "xhigh", "max"]>>;
+}>;
+/** Null at the Session boundary means inherit the Agent default. */
+export type ModelPreference = Schema.Schema.Type<typeof ModelPreferenceSchema>;
+/** Decode the bounded client preference; availability remains model-owner policy. */
+export declare const parseModelPreference: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => {
+    readonly providerId: string;
+    readonly modelId: string;
+    readonly reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+} | null;
+/** Decode the serialized preference with the same maintained schema. */
+export declare const parseModelPreferenceJson: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => {
+    readonly providerId: string;
+    readonly modelId: string;
+    readonly reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+} | null;

package/dist/internal/model-preference.js

@@ -0,0 +1,20 @@
+import * as Schema from "effect/Schema";
+const identifier = Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.isMaxLength(256)));
+const reasoningLevels = [
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+];
+/** Secret-free request to the host's maintained model catalogue. */
+export const ModelPreferenceSchema = Schema.Struct({
+    providerId: identifier,
+    modelId: identifier,
+    reasoning: Schema.optional(Schema.Literals(reasoningLevels)),
+});
+/** Decode the bounded client preference; availability remains model-owner policy. */
+export const parseModelPreference = Schema.decodeUnknownSync(Schema.NullOr(ModelPreferenceSchema));
+/** Decode the serialized preference with the same maintained schema. */
+export const parseModelPreferenceJson = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.NullOr(ModelPreferenceSchema)));

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

@@ -0,0 +1,28 @@
+import * as Effect from "effect/Effect";
+import { ShiitakeError } from "../errors.js";
+import type { SqliteOwner } from "./contracts.js";
+/** Finite process-local signal; durable owner state remains authoritative. */
+export type ObservationSignal = "closed" | "reset" | "durable" | "progress";
+export type ObservationReason = "durable" | "progress";
+/** One scoped process-local observation registration. */
+export type ObservationRegistration = Readonly<{
+    /** Inspect and consume one pending finite signal without waiting. */
+    pollSignal: Effect.Effect<ObservationSignal | undefined>;
+    /** Await and consume one finite observation signal. */
+    awaitSignal: Effect.Effect<ObservationSignal>;
+    /** Release this registration without affecting durable work. */
+    close: () => void;
+}>;
+/** Process-local wake coordination; durable facts remain authoritative. */
+export type ObservationKernel = Readonly<{
+    /** Register before the caller's first durable read. */
+    register: (sessionId: string) => Effect.Effect<ObservationRegistration, ShiitakeError>;
+    /** Close every registration and release this agent's owner publisher. */
+    close: Effect.Effect<void>;
+}>;
+/** Combine coalesced reasons without allowing a progress hint to hide a commit. */
+export declare function mergeObservationSignals(first: ObservationSignal, second: ObservationSignal): ObservationSignal;
+/** Notify owner observers; null identifies an Agent-wide execution change. */
+export declare function publishOwnerObservation(store: SqliteOwner, sessionId: string | null, reason?: ObservationReason): void;
+/** Open one coalescing process-local observation kernel per agent. */
+export declare function openObservationKernel(store: SqliteOwner): ObservationKernel;

package/dist/internal/observation-kernel.js

@@ -0,0 +1,169 @@
+import * as Effect from "effect/Effect";
+import { ShiitakeError } from "../errors.js";
+import { reportCatchFailure } from "./failure.js";
+const MAX_OBSERVATIONS = 64;
+const MAX_PENDING_HINTS = 256;
+const ownerPublishers = new WeakMap();
+/** Combine coalesced reasons without allowing a progress hint to hide a commit. */
+export function mergeObservationSignals(first, second) {
+    if (first === "closed" || second === "closed")
+        return "closed";
+    if (first === "reset" || second === "reset")
+        return "reset";
+    if (first === "durable" || second === "durable")
+        return "durable";
+    return "progress";
+}
+function queueObservation(listener, reason) {
+    if (listener.pendingCount >= MAX_PENDING_HINTS) {
+        listener.pendingCount = 0;
+        listener.pendingReason = undefined;
+        listener.reset = true;
+        return;
+    }
+    listener.pendingCount += 1;
+    listener.pendingReason =
+        listener.pendingReason === "durable" || reason === "durable"
+            ? "durable"
+            : "progress";
+}
+function deliverObservation(listener, reason) {
+    if (listener.closed || listener.reset)
+        return;
+    const wake = listener.wake;
+    if (wake === undefined) {
+        queueObservation(listener, reason);
+        return;
+    }
+    listener.wake = undefined;
+    try {
+        wake(reason);
+    }
+    catch (cause) {
+        reportCatchFailure("observation-delivery", cause);
+        listener.pendingCount = 0;
+        listener.pendingReason = undefined;
+        listener.reset = true;
+    }
+}
+/** Notify owner observers; null identifies an Agent-wide execution change. */
+export function publishOwnerObservation(store, sessionId, reason = "durable") {
+    const publishers = ownerPublishers.get(store);
+    if (publishers === undefined)
+        return;
+    for (const publish of publishers) {
+        try {
+            publish(sessionId, reason);
+        }
+        catch (cause) {
+            reportCatchFailure("owner-observation-publish", cause);
+            continue;
+        }
+    }
+}
+/** Open one coalescing process-local observation kernel per agent. */
+export function openObservationKernel(store) {
+    const sessions = new Map();
+    const active = new Set();
+    const publishers = ownerPublishers.get(store) ?? new Set();
+    let released = false;
+    const takeSignal = (listener) => {
+        if (listener.closed)
+            return "closed";
+        if (listener.reset) {
+            listener.reset = false;
+            return "reset";
+        }
+        if (listener.pendingCount === 0)
+            return undefined;
+        listener.pendingCount = 0;
+        const reason = listener.pendingReason;
+        listener.pendingReason = undefined;
+        return reason === "durable" ? "durable" : "progress";
+    };
+    const closeListener = (listener) => {
+        if (listener.closed)
+            return;
+        listener.closed = true;
+        listener.pendingCount = 0;
+        listener.pendingReason = undefined;
+        listener.reset = false;
+        const wake = listener.wake;
+        listener.wake = undefined;
+        active.delete(listener);
+        const listeners = sessions.get(listener.sessionId);
+        listeners?.delete(listener);
+        if (listeners?.size === 0)
+            sessions.delete(listener.sessionId);
+        if (wake !== undefined) {
+            try {
+                wake("closed");
+            }
+            catch (cause) {
+                reportCatchFailure("observation-listener-close", cause);
+            }
+        }
+    };
+    const publish = (sessionId, reason) => {
+        const listeners = sessionId === null ? active : sessions.get(sessionId);
+        if (listeners === undefined)
+            return;
+        for (const listener of listeners)
+            deliverObservation(listener, reason);
+    };
+    publishers.add(publish);
+    ownerPublishers.set(store, publishers);
+    return Object.freeze({
+        register: (sessionId) => Effect.suspend(() => {
+            if (released)
+                return Effect.fail(new ShiitakeError("runtime", "closed", "Shiitake is closed"));
+            if (active.size >= MAX_OBSERVATIONS)
+                return Effect.fail(new ShiitakeError("runtime", "rejected", "Observation capacity is exhausted"));
+            const listener = {
+                sessionId,
+                closed: false,
+                pendingCount: 0,
+                pendingReason: undefined,
+                reset: false,
+                wake: undefined,
+            };
+            const listeners = sessions.get(sessionId) ?? new Set();
+            listeners.add(listener);
+            sessions.set(sessionId, listeners);
+            active.add(listener);
+            const pollSignal = Effect.sync(() => takeSignal(listener));
+            const awaitSignal = Effect.callback((resume) => {
+                const signal = takeSignal(listener);
+                if (signal !== undefined) {
+                    resume(Effect.succeed(signal));
+                    return;
+                }
+                const wake = (next) => {
+                    resume(Effect.succeed(next));
+                };
+                listener.wake = wake;
+                return Effect.sync(() => {
+                    if (listener.wake === wake)
+                        listener.wake = undefined;
+                });
+            });
+            return Effect.succeed(Object.freeze({
+                pollSignal,
+                awaitSignal,
+                close: () => {
+                    closeListener(listener);
+                },
+            }));
+        }),
+        close: Effect.sync(() => {
+            if (released)
+                return;
+            released = true;
+            publishers.delete(publish);
+            if (publishers.size === 0)
+                ownerPublishers.delete(store);
+            for (const listener of active)
+                closeListener(listener);
+        }),
+    });
+}

package/dist/internal/promise-facade.d.ts

@@ -0,0 +1,18 @@
+import type { Json } from "../extensions.js";
+import * as Effect from "effect/Effect";
+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 type { Accepted } from "../client.js";
+import type { ShiitakeEffectHost } from "../effect.js";
+import { ShiitakeError } from "../errors.js";
+import type { CommandSettlement, ShiitakeOptions, ShiitakeOwnerAgent } from "./contracts.js";
+import type { ShiitakeEffectOwner, ShiitakeEffectOptions } from "./effect-contracts.js";
+/** Open the single Promise adaptation over the canonical Effect agent. */
+export declare function openPromiseAgent(options: ShiitakeOptions, make: (options: ShiitakeEffectOptions) => Effect.Effect<ShiitakeEffectOwner, ShiitakeError>): Promise<ShiitakeOwnerAgent>;
+/** Open the Promise-facing host over the canonical Effect host composition. */
+export declare function openPromiseHost(options: ShiitakeOptions, mailRoom: BirdDogEffect, openHost: (options: ShiitakeEffectOptions, mailRoom: BirdDogEffect) => Effect.Effect<ShiitakeEffectHost, ShiitakeError>): Promise<Readonly<{
+    agent: ShiitakeOwnerAgent;
+    readSettlement: (sessionId: string, commandId: string) => Promise<CommandSettlement | undefined>;
+    acceptMail: (mail: BirdDogMail, meta?: Json, reply?: VerifiedAgentReply) => Promise<Accepted>;
+}>>;

package/dist/internal/promise-facade.js

@@ -0,0 +1,172 @@
+import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import { fromTypedSandbox } from "@fungi.computer/mycelium/effect";
+import { ShiitakeError } from "../errors.js";
+import { runShiitakePromise, toPromiseOwner } from "./effect-client.js";
+import { adaptModelSource } from "./model-acquisition.js";
+function boundary(boundaryName, message) {
+    return new ShiitakeError(boundaryName, "rejected", message);
+}
+const identifier = Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.isMaxLength(256)));
+const instructionText = Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.makeFilter((value) => new TextEncoder().encode(value).byteLength <= 32_000)));
+const instructionSchema = Schema.Struct({
+    revision: identifier,
+    text: instructionText,
+    // The facade preserves opaque registration handles; Mycelium's compiler
+    // validates their WeakMap identity when the run scope installs them.
+    modules: Schema.optionalKey(Schema.declare((input) => Array.isArray(input) && input.every(Predicate.isObject))),
+});
+const runtimeBindSchema = Schema.declare((input) => Predicate.isFunction(input));
+const runtimeMethodSchema = Schema.declare((input) => Predicate.isFunction(input));
+const runtimeHostSchema = Schema.Struct({ bind: runtimeBindSchema });
+const runtimeCommitSchema = Schema.declare((input) => Predicate.isFunction(input));
+const runtimeHandleSchema = Schema.Struct({
+    commit: runtimeCommitSchema,
+    requestWake: runtimeMethodSchema,
+    close: runtimeMethodSchema,
+});
+const runtimeCloseSchema = Schema.Struct({ close: runtimeMethodSchema });
+const decodeInstructions = Schema.decodeUnknownResult(instructionSchema);
+const decodeRuntimeHost = Schema.decodeUnknownResult(runtimeHostSchema);
+const decodeRuntimeHandle = Schema.decodeUnknownResult(runtimeHandleSchema);
+const decodeRuntimeClose = Schema.decodeUnknownResult(runtimeCloseSchema);
+function runtimeInvalid(cause) {
+    return new ShiitakeError("runtime", "invalid", "Runtime host is invalid", undefined, cause);
+}
+function runtimeUnavailable() {
+    return new ShiitakeError("runtime", "unavailable", "Runtime host is unavailable");
+}
+function liftRuntimeMethod(receiver, method) {
+    return Effect.try({
+        try: () => method.call(receiver),
+        catch: runtimeUnavailable,
+    }).pipe(Effect.flatMap((result) => Effect.tryPromise({
+        try: () => Promise.resolve(result),
+        catch: runtimeUnavailable,
+    })), Effect.flatMap((result) => result === undefined ? Effect.void : Effect.fail(runtimeInvalid())));
+}
+function failInvalidAfterCleanup(receiver, close, cause) {
+    const decoded = decodeRuntimeClose({ close });
+    if (decoded._tag === "Failure")
+        return Effect.fail(runtimeInvalid(cause));
+    return Effect.uninterruptible(liftRuntimeMethod(receiver, decoded.success.close)).pipe(Effect.matchCauseEffect({
+        onFailure: (cleanup) => Effect.fail(runtimeInvalid({ cause, cleanup })),
+        onSuccess: () => Effect.fail(runtimeInvalid(cause)),
+    }));
+}
+function liftRuntimeHandle(value) {
+    return Effect.suspend(() => {
+        if (!Predicate.isObject(value))
+            return Effect.fail(runtimeInvalid());
+        const receiver = value;
+        let close;
+        try {
+            close = receiver.close;
+        }
+        catch (cause) {
+            return Effect.fail(runtimeInvalid(cause));
+        }
+        let requestWake;
+        try {
+            requestWake = receiver.requestWake;
+        }
+        catch (cause) {
+            return failInvalidAfterCleanup(receiver, close, cause);
+        }
+        const decoded = decodeRuntimeHandle({
+            commit: receiver.commit,
+            requestWake,
+            close,
+        });
+        if (decoded._tag === "Failure")
+            return failInvalidAfterCleanup(receiver, close);
+        return Effect.succeed(Object.freeze({
+            commit: (mutation) => Effect.tryPromise({
+                try: () => receiver.commit(() => runShiitakePromise(mutation)),
+                catch: (error) => error instanceof ShiitakeError ? error : runtimeUnavailable(),
+            }),
+            requestWake: liftRuntimeMethod(receiver, decoded.success.requestWake),
+            close: liftRuntimeMethod(receiver, decoded.success.close),
+        }));
+    });
+}
+function liftRuntime(options) {
+    return Effect.try({
+        try: () => {
+            const runtime = options.runtime;
+            if (!Predicate.isObject(runtime))
+                throw runtimeInvalid();
+            const decoded = decodeRuntimeHost(runtime);
+            if (decoded._tag === "Failure")
+                throw runtimeInvalid();
+            return { receiver: runtime, bind: decoded.success.bind };
+        },
+        catch: runtimeInvalid,
+    }).pipe(Effect.map(({ receiver, bind }) => Object.freeze({
+        bind: ({ reconcile, pendingWork }) => Effect.try({
+            try: () => bind.call(receiver, {
+                reconcile: () => runShiitakePromise(reconcile),
+                pendingWork: () => runShiitakePromise(pendingWork),
+            }),
+            catch: runtimeUnavailable,
+        }).pipe(Effect.flatMap((result) => Effect.tryPromise({
+            try: () => Promise.resolve(result),
+            catch: runtimeUnavailable,
+        })), Effect.flatMap(liftRuntimeHandle)),
+    })));
+}
+function liftOptions(options, runtime) {
+    const base = {
+        // Native SQL and transactionSync are synchronous owner capabilities; do
+        // not unwrap them into a second Promise/CAS storage abstraction.
+        store: options.store,
+        runtime,
+        extensions: options.extensions,
+        instructions: {
+            load: ({ sessionId, commandId }) => Effect.tryPromise({
+                try: (signal) => options.instructions.load({ sessionId, commandId, signal }),
+                catch: () => boundary("instructions", "Instruction acquisition failed"),
+            }).pipe(Effect.flatMap((value) => {
+                const decoded = decodeInstructions(value);
+                return decoded._tag === "Success"
+                    ? Effect.succeed(decoded.success)
+                    : Effect.fail(new ShiitakeError("contract", "invalid", "Instruction revision is invalid"));
+            })),
+        },
+        model: adaptModelSource(options.model),
+    };
+    if (options.meta !== undefined)
+        Object.assign(base, { meta: options.meta });
+    if (options.storageBudget !== undefined)
+        Object.assign(base, { storageBudget: options.storageBudget });
+    if (options.compaction !== undefined)
+        Object.assign(base, { compaction: options.compaction });
+    const toolSource = options.tools;
+    if (toolSource === undefined)
+        return base;
+    const tools = {
+        modules: toolSource.modules ?? [],
+        sources: toolSource.sources ?? [],
+        sandbox: fromTypedSandbox(toolSource.sandbox),
+        access: toolSource.access ?? {},
+    };
+    return {
+        ...base,
+        tools: toolSource.execution === undefined
+            ? tools
+            : { ...tools, execution: toolSource.execution },
+    };
+}
+/** Open the single Promise adaptation over the canonical Effect agent. */
+export function openPromiseAgent(options, make) {
+    return runShiitakePromise(liftRuntime(options).pipe(Effect.flatMap((runtime) => make(liftOptions(options, runtime))))).then(toPromiseOwner);
+}
+/** Open the Promise-facing host over the canonical Effect host composition. */
+export function openPromiseHost(options, mailRoom, openHost) {
+    return runShiitakePromise(liftRuntime(options).pipe(Effect.flatMap((runtime) => openHost(liftOptions(options, runtime), mailRoom)))).then(({ agent, acceptMail, readSettlement }) => Object.freeze({
+        agent: toPromiseOwner(agent),
+        readSettlement: (sessionId, commandId) => runShiitakePromise(readSettlement(sessionId, commandId)),
+        acceptMail: (mail, meta, reply) => runShiitakePromise(acceptMail(mail, meta, reply)),
+    }));
+}