@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/agents/harness/projection.js

@@ -1,369 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { FlowError } from "../../flow-error.js";
-import { createEventChannel } from "./event-channel.js";
-import { overflowMarkerFromDropped, prepareAgentEventForPersistence, } from "./execution-handle.js";
-import { classifyFailure, classifySettlementFailure, completeOutcome, createOutcomeState, failFromFailEvent, failWithError, processEvent, recordSessionAdmission, renderOutcomeCapturedText, } from "./outcome.js";
-import { startLiveProjection } from "./router.js";
-import { createAbortError } from "./runtime.js";
-const POLICY_BUDGET_CLEANUP_GRACE_MS = 5_000;
-export function call(terms, options) {
-    return createProjection(terms, undefined, options);
-}
-export function revive(terms, options) {
-    return createProjection(terms, terms, options);
-}
-function createProjection(terms, reviveTerms, options) {
-    return createSteerableProjection(terms, reviveTerms, options);
-}
-function createSteerableProjection(terms, reviveTerms, options) {
-    const shared = createProjectionState(terms, reviveTerms, options);
-    const pendingTells = [];
-    let flushActive = false;
-    const flushPendingTells = async () => {
-        const initialEnqueue = shared.live?.enqueue;
-        if (flushActive || shared.terminal || !initialEnqueue)
-            return;
-        flushActive = true;
-        try {
-            while (!shared.terminal && pendingTells.length > 0) {
-                const enqueue = shared.live?.enqueue;
-                if (!enqueue)
-                    break;
-                const nextTell = pendingTells.shift();
-                if (!nextTell)
-                    break;
-                await enqueue(nextTell);
-            }
-        }
-        finally {
-            flushActive = false;
-            if (!shared.terminal && pendingTells.length > 0 && shared.live?.enqueue) {
-                void flushPendingTells();
-            }
-        }
-    };
-    shared.onLive = (live) => {
-        shared.live = live;
-        void flushPendingTells();
-    };
-    const outcome = settleProjection(shared);
-    return {
-        mode: "steerable",
-        get id() {
-            return shared.id;
-        },
-        get events() {
-            return shared.publicEvents.iterable;
-        },
-        get outcome() {
-            return outcome;
-        },
-        tell(tell) {
-            if (shared.terminal)
-                return;
-            pendingTells.push(tell);
-            void flushPendingTells();
-        },
-        recallTells() {
-            return pendingTells.splice(0, pendingTells.length);
-        },
-        abort(mode) {
-            return abortProjection(shared, mode);
-        },
-        dismiss() {
-            dismissProjection(shared);
-        },
-    };
-}
-function createProjectionState(terms, reviveTerms, options) {
-    const shared = {
-        id: randomUUID(),
-        terms,
-        reviveTerms,
-        publicEvents: createEventChannel({
-            createOverflowMarker: overflowMarkerFromDropped,
-        }),
-        lifecycleAbort: new AbortController(),
-        dismissed: false,
-        externallyAborted: false,
-        explicitlyAborted: false,
-        terminal: false,
-        forceWaiters: new Set(),
-        onLive() { },
-        observer: options?.observer,
-        launchTellIds: options?.launchTellIds,
-    };
-    if (terms.signal) {
-        const listener = () => {
-            shared.externallyAborted = true;
-            requestControlledGracefulAbort(shared, terms.signal?.reason);
-        };
-        terms.signal.addEventListener("abort", listener, { once: true });
-        if (terms.signal.aborted) {
-            listener();
-        }
-    }
-    return shared;
-}
-function dismissProjection(shared) {
-    if (shared.dismissed || shared.terminal)
-        return;
-    shared.dismissed = true;
-    requestControlledGracefulAbort(shared, createAbortError(`${shared.terms.provider} exec dismissed`));
-}
-async function abortProjection(shared, mode = "graceful") {
-    shared.explicitlyAborted = true;
-    if (mode !== "force") {
-        await requestControlledGracefulAbort(shared, createAbortError(`${shared.terms.provider} exec cancelled by client`));
-        return;
-    }
-    if (!shared.lifecycleAbort.signal.aborted) {
-        shared.lifecycleAbort.abort(createAbortError(`${shared.terms.provider} exec cancelled by client`));
-    }
-    shared.forceAbort ??= (async () => {
-        const live = shared.live ?? (shared.terminal ? undefined : await new Promise((resolve) => {
-            shared.forceWaiters.add(resolve);
-        }));
-        await live?.abort("force");
-    })();
-    await shared.forceAbort;
-}
-function resolveForceWaiters(shared, live) {
-    for (const resolve of shared.forceWaiters)
-        resolve(live);
-    shared.forceWaiters.clear();
-}
-function requestControlledGracefulAbort(shared, reason) {
-    if (shared.gracefulAbort)
-        return shared.gracefulAbort;
-    const live = shared.live;
-    if (!live) {
-        if (!shared.lifecycleAbort.signal.aborted)
-            shared.lifecycleAbort.abort(reason);
-        return Promise.resolve();
-    }
-    shared.gracefulAbort = (async () => {
-        try {
-            await live.abort("graceful");
-        }
-        finally {
-            if (!shared.lifecycleAbort.signal.aborted)
-                shared.lifecycleAbort.abort(reason);
-        }
-    })();
-    // Dismiss, timeout, and external cancellation are outcome-driven controls;
-    // keep their rejection observed while explicit abort still receives it.
-    shared.gracefulAbort.catch(() => undefined);
-    return shared.gracefulAbort;
-}
-function requestPolicyBudgetCleanup(shared, reason) {
-    const graceful = requestControlledGracefulAbort(shared, reason);
-    const force = () => {
-        void shared.live?.abort("force").catch(() => undefined);
-    };
-    const cleanupTimeout = setTimeout(force, POLICY_BUDGET_CLEANUP_GRACE_MS);
-    cleanupTimeout.unref?.();
-    void graceful.then(() => clearTimeout(cleanupTimeout), () => {
-        clearTimeout(cleanupTimeout);
-        force();
-    });
-}
-function deliverDriverEvent(shared, state, live, event, refreshIdleTimeout, knownActiveTools, observerEnabled) {
-    if (shared.terminal)
-        return;
-    const prepared = prepareAgentEventForPersistence(event);
-    if (observerEnabled.value && shared.observer) {
-        try {
-            shared.observer.onEvent(prepared);
-        }
-        catch (error) {
-            observerEnabled.value = false;
-            const diagnostic = live.mintEvent({
-                type: "diagnostic",
-                text: `event persistence degraded: ${String(error)}`,
-            });
-            if (diagnostic) {
-                shared.publicEvents.push(diagnostic);
-                processEvent(state, diagnostic);
-            }
-        }
-    }
-    shared.publicEvents.push(event);
-    if (event.type === "activity") {
-        if (event.phase === "started")
-            knownActiveTools.add(event.id);
-        if (event.phase === "completed")
-            knownActiveTools.delete(event.id);
-    }
-    refreshIdleTimeout();
-    processEvent(state, event);
-}
-async function settleProjection(shared) {
-    const state = createOutcomeState(shared.terms.maxCaptureChars, shared.reviveTerms?.session);
-    let idleTimedOut = false;
-    let transportFailure;
-    let policyBudgetExceeded = false;
-    const knownActiveTools = new Set();
-    let abortRequested = false;
-    const observerEnabled = { value: shared.observer !== undefined };
-    let idleTimeout;
-    let executionTimeout;
-    let liveDriver;
-    let probeInFlight;
-    let resolvePolicyBudget;
-    const policyBudget = new Promise((resolve) => {
-        resolvePolicyBudget = resolve;
-    });
-    const refreshIdleTimeout = () => {
-        if (shared.terminal)
-            return;
-        if (idleTimeout)
-            clearTimeout(idleTimeout);
-        idleTimeout = setTimeout(() => {
-            if (knownActiveTools.size > 0) {
-                if (!liveDriver?.probe || probeInFlight)
-                    return;
-                probeInFlight = liveDriver.probe()
-                    .then(() => refreshIdleTimeout())
-                    .catch((error) => {
-                    transportFailure = error;
-                    return requestControlledGracefulAbort(shared, error);
-                })
-                    .finally(() => {
-                    probeInFlight = undefined;
-                });
-                probeInFlight.catch(() => undefined);
-                return;
-            }
-            idleTimedOut = true;
-            requestControlledGracefulAbort(shared, createAbortError(`${shared.terms.provider} exec idle timed out`));
-        }, shared.terms.idleTimeoutMs);
-        idleTimeout.unref?.();
-    };
-    if (shared.terms.executionTimeoutMs > 0) {
-        executionTimeout = setTimeout(() => {
-            policyBudgetExceeded = true;
-            requestPolicyBudgetCleanup(shared, createAbortError(`${shared.terms.provider} execution policy budget expired`));
-            resolvePolicyBudget();
-        }, shared.terms.executionTimeoutMs);
-        executionTimeout.unref?.();
-    }
-    const requestLiveAbort = () => {
-        if (shared.explicitlyAborted)
-            return;
-        if (abortRequested)
-            return;
-        abortRequested = true;
-        requestControlledGracefulAbort(shared, shared.lifecycleAbort.signal.reason);
-    };
-    shared.lifecycleAbort.signal.addEventListener("abort", requestLiveAbort, { once: true });
-    const providerSettlement = (async () => {
-        try {
-            const live = await startLiveProjection(shared.terms, shared.lifecycleAbort.signal, shared.reviveTerms, refreshIdleTimeout, shared.observer, (admission) => {
-                recordSessionAdmission(state, admission.session);
-                refreshIdleTimeout();
-            }, shared.launchTellIds);
-            liveDriver = live;
-            shared.onLive(live);
-            resolveForceWaiters(shared, live);
-            if (shared.lifecycleAbort.signal.aborted) {
-                requestLiveAbort();
-            }
-            try {
-                for await (const event of live.events) {
-                    deliverDriverEvent(shared, state, live, event, refreshIdleTimeout, knownActiveTools, observerEnabled);
-                }
-            }
-            catch (error) {
-                if (error instanceof Error && error.code === "PROJECTION_STATE_ERROR") {
-                    const event = live.mintEvent({
-                        type: "fail",
-                        code: "PROJECTION_STATE_ERROR",
-                        message: error.message,
-                    });
-                    if (event)
-                        deliverDriverEvent(shared, state, live, event, refreshIdleTimeout, knownActiveTools, observerEnabled);
-                }
-                else {
-                    const event = live.mintEvent({
-                        type: "diagnostic",
-                        text: `pump error: ${String(error)}`,
-                    });
-                    if (event)
-                        deliverDriverEvent(shared, state, live, event, refreshIdleTimeout, knownActiveTools, observerEnabled);
-                }
-            }
-            const completionResult = await live.completion.then((value) => ({ ok: true, value }), (error) => ({ ok: false, error }));
-            const completionOutcome = completionResult.ok ? completionResult.value : undefined;
-            // Outcome classification is the terminal publication boundary. A
-            // controlled abort may let the provider run settle before its graceful
-            // cleanup promise does, so prove that shared settlement before publishing
-            // dismissed, failed-for-another-reason, or completed truth.
-            const gracefulResult = shared.gracefulAbort
-                ? await shared.gracefulAbort.then(() => ({ ok: true }), (error) => ({ ok: false, error }))
-                : undefined;
-            if (gracefulResult && !gracefulResult.ok && !transportFailure) {
-                return classifySettlementFailure(shared, state, gracefulResult.error);
-            }
-            if (policyBudgetExceeded || transportFailure) {
-                return classifyFailure(shared, state, completionResult.ok ? undefined : completionResult.error, idleTimedOut, transportFailure, policyBudgetExceeded);
-            }
-            if (state.failEvent) {
-                return failFromFailEvent(shared, state, state.failEvent);
-            }
-            if (!completionResult.ok) {
-                return classifyFailure(shared, state, completionResult.error, idleTimedOut, transportFailure, policyBudgetExceeded);
-            }
-            if (shared.lifecycleAbort.signal.aborted) {
-                return classifyFailure(shared, state, shared.lifecycleAbort.signal.reason, idleTimedOut, transportFailure, policyBudgetExceeded);
-            }
-            if (!state.doneEvent && !completionOutcome) {
-                return failWithError(shared, state, {
-                    code: "SUBAGENT_EXEC_ERROR",
-                    message: `${shared.terms.provider} exec ended before completion`,
-                    timeoutMs: null,
-                    exitCode: null,
-                }, state.finalMessageCandidate);
-            }
-            const finalMessage = state.doneEvent?.finalMessage ??
-                completionOutcome?.finalMessage ??
-                state.finalMessageCandidate ??
-                renderOutcomeCapturedText(state.outputBuffer).trim();
-            if (!state.session) {
-                return failWithError(shared, state, {
-                    code: "SUBAGENT_EXEC_ERROR",
-                    message: `${shared.terms.provider} exec ended without a session handle`,
-                    timeoutMs: null,
-                    exitCode: null,
-                }, finalMessage);
-            }
-            return completeOutcome(state, finalMessage);
-        }
-        catch (error) {
-            if (error instanceof FlowError) {
-                throw error;
-            }
-            return classifyFailure(shared, state, error, idleTimedOut, transportFailure, policyBudgetExceeded);
-        }
-    })();
-    providerSettlement.catch(() => undefined);
-    try {
-        const settled = await Promise.race([
-            providerSettlement.then((outcome) => ({ kind: "provider", outcome })),
-            policyBudget.then(() => ({ kind: "policy-budget" })),
-        ]);
-        return settled.kind === "provider"
-            ? settled.outcome
-            : classifyFailure(shared, state, undefined, idleTimedOut, transportFailure, true);
-    }
-    finally {
-        if (idleTimeout)
-            clearTimeout(idleTimeout);
-        if (executionTimeout)
-            clearTimeout(executionTimeout);
-        shared.lifecycleAbort.signal.removeEventListener("abort", requestLiveAbort);
-        shared.terminal = true;
-        resolveForceWaiters(shared, undefined);
-        shared.publicEvents.close();
-    }
-}

package/build/agents/harness/provider-adapter.js

@@ -1,58 +0,0 @@
-import { SubagentFailure, } from "../types.js";
-/**
- * Typed rejection carrier for failed/aborted adapter settlement.
- * Abort keeps name "AbortError" so existing name checks and CLI exit codes hold.
- */
-export class ProviderTerminalError extends Error {
-    fact;
-    constructor(fact, options) {
-        super(fact.message, options?.cause === undefined ? undefined : { cause: options.cause });
-        this.name = fact.kind === "aborted" ? "AbortError" : "ProviderTerminalError";
-        this.fact = fact;
-    }
-}
-export function isProviderTerminalError(error) {
-    return error instanceof ProviderTerminalError;
-}
-export function createProviderFailure(message, options = {}) {
-    return new ProviderTerminalError({
-        kind: "failed",
-        code: options.code ?? "SUBAGENT_EXEC_ERROR",
-        message,
-        timeoutMs: options.timeoutMs ?? null,
-        exitCode: options.exitCode ?? null,
-        ...(options.diagnostics !== undefined ? { diagnostics: options.diagnostics } : {}),
-        ...(options.output !== undefined ? { output: options.output } : {}),
-        ...(options.publicCause !== undefined ? { publicCause: options.publicCause } : {}),
-    }, options.cause === undefined ? undefined : { cause: options.cause });
-}
-/**
- * Abort-fact constructor. Abort semantics for every live adapter:
- * - abort("graceful") requests provider-native interrupt and keeps local signals
- *   open until native settlement proof (or bounded abort-settlement timeout);
- * - abort("force") must establish zero later provider side effects or reject;
- * - run settlement for a requested abort exits as kind "aborted" (name AbortError).
- */
-export function createAbortError(message, cause) {
-    return new ProviderTerminalError({ kind: "aborted", message }, cause === undefined ? undefined : { cause });
-}
-/** Normalize any thrown value into the typed failure/abort egress fact. */
-export function toProviderTerminalError(error) {
-    if (error instanceof ProviderTerminalError)
-        return error;
-    if (error instanceof SubagentFailure) {
-        return new ProviderTerminalError({
-            kind: "failed",
-            code: error.code,
-            message: error.message,
-            timeoutMs: error.timeoutMs,
-            exitCode: error.exitCode,
-            diagnostics: error.diagnostics,
-            output: error.output,
-        }, { cause: error });
-    }
-    if (error instanceof Error && error.name === "AbortError") {
-        return new ProviderTerminalError({ kind: "aborted", message: error.message }, { cause: error });
-    }
-    return createProviderFailure(error instanceof Error ? error.message : String(error), { cause: error instanceof Error ? error : undefined });
-}

package/build/agents/harness/router.js

@@ -1,30 +0,0 @@
-import { getProviderRegistration } from "../providers/registry.js";
-export async function startLiveProjection(terms, signal, reviveTerms, onIngress, observer, onSessionAdmission, launchTellIds) {
-    const onSyncCheckpoint = observer
-        ? (control, checkpoint) => {
-            observer.onCheckpoint(control, checkpoint);
-        }
-        : "onCheckpoint" in terms
-            ? terms.onCheckpoint
-            : undefined;
-    const onDeliveryOpportunity = observer
-        ? (control) => {
-            observer.onDeliveryOpportunity(control);
-        }
-        : undefined;
-    const registration = getProviderRegistration(terms.provider);
-    if (observer && registration.tellReceiptCapabilities) {
-        await observer.onTellReceiptCapabilities(registration.tellReceiptCapabilities);
-    }
-    return registration.startLive({
-        terms,
-        signal,
-        reviveTerms,
-        onSyncCheckpoint,
-        onDeliveryOpportunity,
-        onSessionAdmission,
-        onIngress,
-        launchTellIds,
-        observer,
-    });
-}

package/build/agents/harness/runtime.js

@@ -1,85 +0,0 @@
-import { createHash } from "node:crypto";
-import { getConfig } from "../../config/env.js";
-import { DISABLE_SUBAGENT_SPAWN_ENV_KEY } from "../../config/env-keys.js";
-export const PROVIDER_ABORT_SETTLEMENT_TIMEOUT_MS = 5_000;
-export function sha256Utf8(value) {
-    const bytes = Buffer.from(value, "utf8");
-    return { sha256: createHash("sha256").update(bytes).digest("hex"), byteLength: bytes.byteLength };
-}
-/**
- * Observer calls are synchronous at the native boundary. Their return values
- * never gate provider progress; rejected thenables are reduced to diagnostics.
- */
-export function emitProviderEvidence(callback, evidence, diagnostic) {
-    if (!callback)
-        return;
-    const reportFailure = () => {
-        try {
-            diagnostic?.("provider evidence callback failed");
-        }
-        catch {
-            // Evidence and its diagnostics are observation-only.
-        }
-    };
-    try {
-        const returned = callback(evidence);
-        if (returned !== null &&
-            (typeof returned === "object" || typeof returned === "function") &&
-            "then" in returned &&
-            typeof returned.then === "function") {
-            void Promise.resolve(returned).catch(reportFailure);
-        }
-    }
-    catch {
-        reportFailure();
-    }
-}
-export { createAbortError } from "./provider-adapter.js";
-export async function awaitProviderAbortSettlement(provider, settlement, operation = "graceful abort could not prove provider terminal settlement") {
-    let timer;
-    const deadline = new Promise((_, reject) => {
-        timer = setTimeout(() => {
-            reject(new Error(`${provider} ${operation} within ${PROVIDER_ABORT_SETTLEMENT_TIMEOUT_MS}ms`));
-        }, PROVIDER_ABORT_SETTLEMENT_TIMEOUT_MS);
-        timer.unref?.();
-    });
-    try {
-        return await Promise.race([settlement, deadline]);
-    }
-    finally {
-        if (timer)
-            clearTimeout(timer);
-    }
-}
-export function coerceString(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
-}
-export function renderTruncationSuffix(truncatedChars) {
-    if (truncatedChars <= 0)
-        return "";
-    return `\n...[truncated ${truncatedChars} chars from start]...`;
-}
-export function renderCapturedText(buffer) {
-    const snapshot = buffer.snapshot();
-    return `${snapshot.text}${renderTruncationSuffix(snapshot.truncatedChars)}`;
-}
-export function linkAbortSignal(signal, controller, onAbort) {
-    if (!signal)
-        return undefined;
-    const handler = () => {
-        onAbort();
-        controller.abort(signal.reason);
-    };
-    signal.addEventListener("abort", handler, { once: true });
-    if (signal.aborted) {
-        handler();
-    }
-    return () => signal.removeEventListener("abort", handler);
-}
-export function buildSubagentEnv(instanceEnv) {
-    return {
-        ...getConfig().runtimeEnv,
-        ...(instanceEnv ?? {}),
-        [DISABLE_SUBAGENT_SPAWN_ENV_KEY]: "1",
-    };
-}

package/build/agents/harness/session.js

@@ -1,15 +0,0 @@
-import { isSubagentProvider } from "../../keiyaku.js";
-import { SUBAGENT_SESSION_VERSION, subagentSessionEnvelopeSchema, } from "../session.js";
-import { getProviderRegistration } from "../providers/registry.js";
-/** Validate a continuation envelope through its owning provider schema. */
-export function isRecoverableSessionEnvelope(provider, value) {
-    if (!isSubagentProvider(provider))
-        return false;
-    const envelope = subagentSessionEnvelopeSchema.safeParse(value);
-    if (!envelope.success)
-        return false;
-    if (envelope.data.provider !== provider || envelope.data.version !== SUBAGENT_SESSION_VERSION) {
-        return false;
-    }
-    return getProviderRegistration(provider).sessionSchema.safeParse(envelope.data.handle).success;
-}

package/build/agents/launch-snapshot/model.js

@@ -1,127 +0,0 @@
-import { FlowError } from "../../flow-error.js";
-import { getProviderRegistration, isSubagentProvider, } from "../providers/registry.js";
-import { exactKeys, objectAt, optionalString, requiredEnum, requiredString, snapshotError, } from "./parse-helpers.js";
-const ACCESS_VALUES = new Set(["read", "write", "auto"]);
-const NETWORK_VALUES = new Set(["disabled", "enabled"]);
-const WEB_SEARCH_VALUES = new Set(["disabled", "cached", "live"]);
-const AKUMA_SOURCES = new Set(["builtin", "user", "project"]);
-const PROVIDER_SOURCES = new Set(["builtin", "global", "project"]);
-function effortOptionsFrom(akuma) {
-    if (!("effortOptions" in akuma))
-        return undefined;
-    if (!Array.isArray(akuma.effortOptions)) {
-        throw snapshotError("akuma.effortOptions", "must be an array");
-    }
-    const options = akuma.effortOptions.map((value, index) => {
-        if (typeof value !== "string" || value.trim().length === 0) {
-            throw snapshotError(`akuma.effortOptions[${index}]`, "must be a nonblank string");
-        }
-        return value;
-    });
-    if (new Set(options).size !== options.length) {
-        throw snapshotError("akuma.effortOptions", "must contain unique strings");
-    }
-    return Object.freeze(options);
-}
-function assertEffortAllowed(effort, options) {
-    if (effort === undefined || options === undefined || options.includes(effort))
-        return;
-    throw new FlowError("INVALID_EFFORT_OVERRIDE", `Effort '${effort}' is not permitted; legal values: ${options.join(", ")}.`);
-}
-/** Effective effort requires an explicit effective model. Model without effort remains legal. */
-function assertEffortRequiresModel(model, effort, kind, akumaName) {
-    if (effort === undefined || model !== undefined)
-        return;
-    if (kind === "profile") {
-        throw new FlowError("INVALID_SETTINGS", `Akuma '${akumaName ?? ""}' sets effort '${effort}' without a model; set model whenever effort is configured.`);
-    }
-    throw new FlowError("INVALID_EFFORT_OVERRIDE", `Effort '${effort}' requires an explicit model.`);
-}
-function providerEffortAndModel(provider) {
-    return getProviderRegistration(provider.kind).providerEffortAndModel(provider);
-}
-function assertSnapshotEffortRequiresModel(snapshot) {
-    const fromAkuma = { model: snapshot.akuma.model, effort: snapshot.akuma.effort };
-    if (fromAkuma.effort !== undefined && fromAkuma.model === undefined) {
-        throw snapshotError("akuma.effort", "requires akuma.model");
-    }
-    const fromProvider = providerEffortAndModel(snapshot.provider);
-    if (fromProvider.effort !== undefined && fromProvider.model === undefined) {
-        const effortField = getProviderRegistration(snapshot.provider.kind).effortField;
-        throw snapshotError(`provider.${effortField}`, "requires an explicit model");
-    }
-}
-function parsePolicy(value) {
-    const policy = objectAt(value, "akuma.policy");
-    exactKeys(policy, ["access", "network", "webSearch"], "akuma.policy");
-    const result = {};
-    if ("access" in policy)
-        result.access = requiredEnum(policy, "access", "akuma.policy", ACCESS_VALUES);
-    if ("network" in policy)
-        result.network = requiredEnum(policy, "network", "akuma.policy", NETWORK_VALUES);
-    if ("webSearch" in policy)
-        result.webSearch = requiredEnum(policy, "webSearch", "akuma.policy", WEB_SEARCH_VALUES);
-    return Object.freeze(result);
-}
-function parseAkuma(value) {
-    const akuma = objectAt(value, "akuma");
-    exactKeys(akuma, ["name", "source", "body", "description", "model", "effort", "effortOptions", "policy"], "akuma");
-    if (!("policy" in akuma))
-        throw snapshotError("akuma.policy", "is required");
-    const effortOptions = effortOptionsFrom(akuma);
-    const effort = optionalString(akuma, "effort", "akuma");
-    if (effort !== undefined && effortOptions !== undefined && !effortOptions.includes(effort)) {
-        throw snapshotError("akuma.effort", "must be a member of akuma.effortOptions");
-    }
-    const result = {
-        name: requiredString(akuma, "name", "akuma"),
-        source: requiredEnum(akuma, "source", "akuma", AKUMA_SOURCES),
-        body: requiredString(akuma, "body", "akuma", true),
-        ...(optionalString(akuma, "description", "akuma") !== undefined ? { description: optionalString(akuma, "description", "akuma") } : {}),
-        ...(optionalString(akuma, "model", "akuma") !== undefined ? { model: optionalString(akuma, "model", "akuma") } : {}),
-        ...(effort !== undefined ? { effort } : {}),
-        ...(effortOptions !== undefined ? { effortOptions } : {}),
-        policy: parsePolicy(akuma.policy),
-    };
-    return Object.freeze(result);
-}
-function parseProviderCommon(provider) {
-    return {
-        name: requiredString(provider, "name", "provider"),
-        source: requiredEnum(provider, "source", "provider", PROVIDER_SOURCES),
-    };
-}
-function parseProvider(value) {
-    const provider = objectAt(value, "provider");
-    const kind = requiredString(provider, "kind", "provider");
-    if (!isSubagentProvider(kind)) {
-        throw snapshotError("provider.kind", `has invalid value '${kind}'`);
-    }
-    const common = parseProviderCommon(provider);
-    return getProviderRegistration(kind).parseLaunchProvider(provider, common);
-}
-export function parseResolvedAkumaLaunchSnapshot(value) {
-    const snapshot = objectAt(value, "resolved Akuma launch snapshot");
-    exactKeys(snapshot, ["version", "akuma", "provider"], "resolved Akuma launch snapshot");
-    if (snapshot.version !== 1)
-        throw snapshotError("version", "must equal 1");
-    if (!("akuma" in snapshot))
-        throw snapshotError("akuma", "is required");
-    if (!("provider" in snapshot))
-        throw snapshotError("provider", "is required");
-    const parsed = Object.freeze({
-        version: 1,
-        akuma: parseAkuma(snapshot.akuma),
-        provider: parseProvider(snapshot.provider),
-    });
-    assertSnapshotEffortRequiresModel(parsed);
-    return parsed;
-}
-export function applySnapshotEffort(snapshot, effort) {
-    assertEffortAllowed(effort, snapshot.akuma.effortOptions);
-    assertEffortRequiresModel(snapshot.akuma.model, effort, "override");
-    const akuma = { ...snapshot.akuma, effort };
-    const provider = getProviderRegistration(snapshot.provider.kind).applyEffort(snapshot.provider, effort);
-    return parseResolvedAkumaLaunchSnapshot({ version: 1, akuma, provider });
-}
-export { assertEffortAllowed, assertEffortRequiresModel };