@astrosheep/keiyaku 4.5.28 → 4.6.1

package/build/src/akuma/identity.d.ts

@@ -1,15 +1,17 @@
+import { z } from "zod";
 declare const AKU_ID: unique symbol;
 export type AkuId = string & {
     readonly [AKU_ID]: true;
 };
 export declare function parsePublicHistoryId(value: string): number | null;
-export type AkumaPaths = Readonly<{
-    directory: string;
-    heart: string;
-    leash: string;
-    log: string;
-    requests: string;
-}>;
+export declare const akumaPathsSchema: z.ZodObject<{
+    directory: z.ZodString;
+    heart: z.ZodString;
+    leash: z.ZodString;
+    log: z.ZodString;
+    requests: z.ZodString;
+}, z.core.$strict>;
+export type AkumaPaths = z.infer<typeof akumaPathsSchema>;
 export type AllocatedAkuma = Readonly<{
     id: AkuId;
     archetype: string;
@@ -26,6 +28,7 @@ export declare function parseAkuId(value: string): Readonly<{
     archetype: string;
     suffix: string;
 }>;
+export declare const akumaIdSchema: z.ZodPipe<z.ZodString, z.ZodTransform<AkuId, string>>;
 export declare function akumaRunRoot(worldRoot: string): string;
 export declare function akumaPaths(input: Readonly<{
     runRoot: string;

package/build/src/akuma/identity.js

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { randomBytes } from "node:crypto";
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
@@ -11,6 +12,16 @@ export function parsePublicHistoryId(value) {
     const sequence = Number(match[1]);
     return Number.isSafeInteger(sequence) ? sequence : null;
 }
+const pathText = z.string().refine((value) => value.trim() !== "");
+export const akumaPathsSchema = z
+    .object({
+    directory: pathText,
+    heart: pathText,
+    leash: pathText,
+    log: pathText,
+    requests: pathText,
+})
+    .strict();
 export function archetypeName(value) {
     return validateAkumaName(value);
 }
@@ -36,6 +47,18 @@ export function parseAkuId(value) {
     const suffix = suffixSegment(segments[1]);
     return { id: value, archetype, suffix };
 }
+export const akumaIdSchema = z.string().transform((value, context) => {
+    try {
+        const id = parseAkuId(value).id;
+        if (id !== value)
+            throw new Error("not canonical");
+        return id;
+    }
+    catch {
+        context.addIssue({ code: "custom", message: "expected canonical AkuId" });
+        return z.NEVER;
+    }
+});
 export function akumaRunRoot(worldRoot) {
     return join(worldRoot, ".keiyaku", "akuma", "run");
 }

package/build/src/akuma/index.d.ts

@@ -1,12 +1,14 @@
+export type { WorldRoot } from "../world.js";
+export { AkumaBusyError, AkumaDecodeError, AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";
 export { Akuma } from "./akuma-instance.js";
-export type { AkumaBirthInput, AkumaHistoryOptions, AkumaIdleOptions, AkumaIdleResult, AkumaSignalOptions, AkumaTellOptions, } from "./akuma-instance.js";
-export type { InterruptReceipt, KillEvidence } from "./akuma.js";
-export { Schema } from "./schema.js";
-export type { JsonSchema, JsonSchemaDocument, StandardSchemaV1, SchemaLike } from "./schema.js";
-export type { AkuId } from "./identity.js";
+export type { AkumaAskOptions, AkumaBirthInput, AkumaHistoryOptions, AkumaIdleOptions, AkumaIdleResult, AkumaSignalOptions, AkumaTellOptions, } from "./akuma-instance.js";
+export type { InterruptReceipt } from "./akuma-owner.js";
 export type { AkumaStatus } from "./akuma.js";
-export type { ActivityHistory, ActivityRow } from "./projection.js";
 export { ALLOWED_ACTIONS } from "./allowed.js";
 export type { AllowedAction, AllowedActions } from "./allowed.js";
-export type { WorldRoot } from "../world.js";
-export { AkumaBusyError, AkumaDecodeError, AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";
+export type { KillEvidence } from "./heart/index.js";
+export type { AkuId } from "./identity.js";
+export type { ActivityHistory, ActivityRow } from "./projection.js";
+export { Schema } from "./schema.js";
+export type { JsonSchema, JsonSchemaDocument, SchemaLike, StandardSchemaV1 } from "./schema.js";
+export type { AkumaAskObservation, AkumaAskResult, AkumaTellResult } from "./selection-observation.js";

package/build/src/akuma/index.js

@@ -1,4 +1,4 @@
+export { AkumaBusyError, AkumaDecodeError, AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";
 export { Akuma } from "./akuma-instance.js";
-export { Schema } from "./schema.js";
 export { ALLOWED_ACTIONS } from "./allowed.js";
-export { AkumaBusyError, AkumaDecodeError, AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";
+export { Schema } from "./schema.js";

package/build/src/akuma/nuke.d.ts

@@ -1,2 +1,5 @@
 import type { WorldRoot } from "../world.js";
+export declare class AkumaResetStopError extends Error {
+    constructor(message: string);
+}
 export declare function stopAkuma(world: WorldRoot): Promise<() => Promise<void>>;

package/build/src/akuma/nuke.js

@@ -1,10 +1,16 @@
 import { lstat, readdir, rm, rmdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { nukeAliases } from "../alias/index.js";
-import { classifyHeartSchema, readHeart } from "./heart/index.js";
+import { settleAkumaKill } from "./akuma-owner.js";
 import { acquireLeash } from "./control.js";
-import { settleAkumaKill } from "./akuma-handle.js";
+import { classifyHeartSchema, readHeart } from "./heart/index.js";
 import { akuIdFromDirectoryName, akumaPaths, akumaRunRoot } from "./identity.js";
+export class AkumaResetStopError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "AkumaResetStopError";
+    }
+}
 async function hasAkumaCustody(paths) {
     try {
         const value = await lstat(paths.heart);
@@ -20,13 +26,13 @@ async function stopRunningAkuma(entry) {
     const settled = await settleAkumaKill(entry.paths, undefined, true);
     if (settled.leash !== undefined)
         return settled.leash;
-    throw new Error(`Akuma ${entry.id} could not be stopped: ${settled.evidence}`);
+    throw new AkumaResetStopError(`Akuma ${entry.id} could not be stopped: ${settled.evidence}`);
 }
 async function removeKnownRegularFile(path) {
     try {
         const value = await lstat(path);
         if (!value.isFile() || value.isSymbolicLink())
-            throw new Error(`Akuma custody is not a regular file: ${path}`);
+            throw new AkumaResetStopError(`Akuma custody is not a regular file: ${path}`);
         await rm(path, { force: true });
     }
     catch (error) {
@@ -68,7 +74,7 @@ async function removeKnownRequestChannel(path) {
     try {
         const value = await lstat(path);
         if (!value.isDirectory() || value.isSymbolicLink())
-            throw new Error(`Akuma custody is not a directory: ${path}`);
+            throw new AkumaResetStopError(`Akuma custody is not a directory: ${path}`);
     }
     catch (error) {
         if (error.code === "ENOENT")
@@ -174,14 +180,14 @@ export async function stopAkuma(world) {
                 ? await stopRunningAkuma(entry)
                 : await acquireLeash(entry.paths);
             if (leash === null)
-                throw new Error(`Akuma ${entry.id} could not be verified stopped`);
+                throw new AkumaResetStopError(`Akuma ${entry.id} could not be verified stopped`);
             try {
                 const after = await readHeart(entry.paths);
                 if (after.soul === null || after.latestBody?.end !== undefined) {
                     held.push(leash);
                     continue;
                 }
-                throw new Error(`Akuma ${entry.id} stopped without a durable end`);
+                throw new AkumaResetStopError(`Akuma ${entry.id} stopped without a durable end`);
             }
             catch (error) {
                 leash.release();

package/build/src/akuma/projection-read.js

@@ -105,8 +105,7 @@ function isActiveTool(row) {
     return row.kind === "tool" && row.state === "active";
 }
 function isProtectedCurrentTurnActivity(row) {
-    return (row.kind === "said" ||
-        (row.kind === "tool" && row.call.kind === "fileChange" && row.state !== "active" && row.state !== "unsettled"));
+    return row.kind === "said";
 }
 function isSettledTellDeliveredTo(row, turnSequence) {
     return (row.kind === "tell" &&

package/build/src/akuma/projection.d.ts

@@ -135,7 +135,6 @@ declare const completedToolRowSchema: z.ZodObject<{
     sequence: z.ZodNumber;
     turnSequence: z.ZodNumber;
     at: z.ZodString;
-    completedAt: z.ZodOptional<z.ZodString>;
     durationMs: z.ZodOptional<z.ZodNumber>;
     name: z.ZodString;
     call: z.ZodUnion<readonly [z.ZodObject<{
@@ -352,7 +351,6 @@ declare const openSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z
     sequence: z.ZodNumber;
     turnSequence: z.ZodNumber;
     at: z.ZodString;
-    completedAt: z.ZodOptional<z.ZodString>;
     durationMs: z.ZodOptional<z.ZodNumber>;
     name: z.ZodString;
     call: z.ZodUnion<readonly [z.ZodObject<{
@@ -470,7 +468,6 @@ declare const idleSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z
     sequence: z.ZodNumber;
     turnSequence: z.ZodNumber;
     at: z.ZodString;
-    completedAt: z.ZodOptional<z.ZodString>;
     durationMs: z.ZodOptional<z.ZodNumber>;
     name: z.ZodString;
     call: z.ZodUnion<readonly [z.ZodObject<{
@@ -709,7 +706,6 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [z.ZodObject<{
             sequence: z.ZodNumber;
             turnSequence: z.ZodNumber;
             at: z.ZodString;
-            completedAt: z.ZodOptional<z.ZodString>;
             durationMs: z.ZodOptional<z.ZodNumber>;
             name: z.ZodString;
             call: z.ZodUnion<readonly [z.ZodObject<{
@@ -868,7 +864,6 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [z.ZodObject<{
             sequence: z.ZodNumber;
             turnSequence: z.ZodNumber;
             at: z.ZodString;
-            completedAt: z.ZodOptional<z.ZodString>;
             durationMs: z.ZodOptional<z.ZodNumber>;
             name: z.ZodString;
             call: z.ZodUnion<readonly [z.ZodObject<{

package/build/src/akuma/projection.js

@@ -1,44 +1,25 @@
-import { decodeAgentEvent } from "./provider.js";
+import { toolCallSchema, toolResultSchema, toolInputSchema, fileChangeSchema, diffstatSchema, } from "./heart/activity-schema.js";
 import { projectTell } from "./heart/facts.js";
 import { z } from "zod";
 const nonblankTextSchema = z.string().refine((value) => value.trim() !== "");
 const countSchema = z.number().int().nonnegative();
 const sequenceSchema = z.number().int().positive();
 const timestampSchema = z.string().refine((value) => Number.isFinite(Date.parse(value)), "expected timestamp");
-const diffstatSchema = z.object({ added: countSchema, removed: countSchema }).strict();
-const fileChangeSchema = z
-    .object({
-    op: z.enum(["add", "update", "delete", "unspecified"]),
-    path: z.string(),
-    diffstat: diffstatSchema.optional(),
-})
-    .strict();
-const toolInputSchema = z.object({ json: z.string(), truncated: z.boolean() }).strict();
-const toolCallSchema = z.union([
-    z.object({ kind: z.literal("run"), command: z.string() }).strict(),
-    z
-        .object({
-        kind: z.literal("read"),
-        path: z.string(),
-        offset: countSchema.optional(),
-        limit: countSchema.optional(),
-    })
-        .strict(),
-    z
-        .object({
-        kind: z.literal("search"),
-        query: z.string(),
-        scope: z.enum(["content", "files", "web"]).optional(),
-        path: z.string().optional(),
-        glob: z.string().optional(),
+const strictDiffstatSchema = diffstatSchema.strict();
+const [runCall, readCall, searchCall, changeCall, otherCall] = toolCallSchema.options;
+// Public observation historically admits zero-based read positions, unlike native narration.
+const publicToolCallSchema = z.union([
+    runCall.strict(),
+    readCall.extend({ offset: countSchema.optional(), limit: countSchema.optional() }).strict(),
+    searchCall.strict(),
+    changeCall
+        .extend({
+        changes: z.array(fileChangeSchema.extend({ diffstat: strictDiffstatSchema.optional() }).strict()).readonly(),
     })
         .strict(),
-    z.object({ kind: z.literal("fileChange"), changes: z.array(fileChangeSchema).readonly() }).strict(),
-    z.object({ kind: z.literal("other"), display: z.string(), input: toolInputSchema.optional() }).strict(),
+    otherCall.extend({ input: toolInputSchema.strict().optional() }).strict(),
 ]);
-const toolResultSchema = z
-    .object({ status: z.enum(["ok", "error"]), message: z.string().optional(), exitCode: z.number().int().optional() })
-    .strict();
+const publicToolResultSchema = toolResultSchema.strict();
 const tellDeliverySchema = z
     .object({
     deliveredAt: timestampSchema,
@@ -107,7 +88,7 @@ const activeToolRowSchema = z
     turnSequence: countSchema,
     at: timestampSchema,
     name: nonblankTextSchema,
-    call: toolCallSchema,
+    call: publicToolCallSchema,
     state: z.literal("active"),
     truncated: z.literal(true).optional(),
 })
@@ -118,11 +99,10 @@ const completedToolRowSchema = z
     sequence: countSchema,
     turnSequence: countSchema,
     at: timestampSchema,
-    completedAt: timestampSchema.optional(),
     durationMs: z.number().finite().nonnegative().optional(),
     name: nonblankTextSchema,
-    call: toolCallSchema,
-    state: toolResultSchema,
+    call: publicToolCallSchema,
+    state: publicToolResultSchema,
     truncated: z.literal(true).optional(),
 })
     .strict();
@@ -133,7 +113,7 @@ const unsettledToolRowSchema = z
     turnSequence: countSchema,
     at: timestampSchema,
     name: nonblankTextSchema,
-    call: toolCallSchema,
+    call: publicToolCallSchema,
     state: z.literal("unsettled"),
     truncated: z.literal(true).optional(),
 })
@@ -157,7 +137,7 @@ const reportedFileChangeSchema = z
     at: timestampSchema,
     op: z.enum(["add", "update", "delete", "unspecified"]),
     path: z.string(),
-    diffstat: diffstatSchema.optional(),
+    diffstat: strictDiffstatSchema.optional(),
 })
     .strict();
 const reportedChangeFields = {
@@ -283,10 +263,9 @@ function projectToolEvent(rows, running, fact, event, phase) {
     const durationMs = duration(started.at, fact.at);
     rows[index] = {
         kind: "tool",
-        sequence: started.sequence,
+        sequence: fact.sequence,
         turnSequence: fact.turnSequence,
-        at: started.at,
-        completedAt: fact.at,
+        at: fact.at,
         ...(durationMs === undefined ? {} : { durationMs }),
         name: event.name,
         call: event.call,
@@ -296,7 +275,7 @@ function projectToolEvent(rows, running, fact, event, phase) {
     running.delete(key);
 }
 function projectActivityEvent(state, fact) {
-    const event = decodeAgentEvent(fact.event);
+    const event = fact.event;
     const narration = narrationRow(fact, event);
     if (narration !== null) {
         const turn = state.turnsBySequence.get(fact.turnSequence);
@@ -328,7 +307,7 @@ function foldOutcomeVoice(rows, outcome) {
         : rows;
 }
 function finishTurn(turn) {
-    const rows = foldOutcomeVoice(turn.rows, turn.outcome);
+    const rows = [...foldOutcomeVoice(turn.rows, turn.outcome)].sort((left, right) => left.sequence - right.sequence);
     if (turn.phase === "closed" && turn.outcome !== undefined) {
         return { kind: "closed", turn: turn.turn, rows: rows.map(demoteActive), outcome: turn.outcome };
     }

package/build/src/akuma/provider-recipe.d.ts

@@ -1,27 +1,62 @@
-export type SystemPromptMode = "append" | "replace";
-export type ProviderOptions = Readonly<{
-    model?: string;
-    effort?: string;
-    readonly?: true;
-    network?: "disabled" | "enabled";
-    sandbox?: "full-access";
-    systemPrompt?: string;
-    systemPromptMode?: SystemPromptMode;
-}>;
-export type ReadonlyRestraint = Readonly<{
-    enforcement: "native";
-    diagnostic?: never;
-} | {
-    enforcement: "none";
-    diagnostic: string;
+import { z } from "zod";
+declare const systemPromptModeSchema: z.ZodEnum<{
+    append: "append";
+    replace: "replace";
 }>;
-export type ProviderExecution = Readonly<{
+export type SystemPromptMode = z.infer<typeof systemPromptModeSchema>;
+export declare const providerOptionsSchema: z.ZodPipe<z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    effort: z.ZodOptional<z.ZodString>;
+    network: z.ZodOptional<z.ZodEnum<{
+        disabled: "disabled";
+        enabled: "enabled";
+    }>>;
+    systemPrompt: z.ZodOptional<z.ZodString>;
+    systemPromptMode: z.ZodOptional<z.ZodEnum<{
+        append: "append";
+        replace: "replace";
+    }>>;
+}, z.core.$strip>, z.ZodTransform<Readonly<{
+    systemPromptMode?: "append" | "replace";
+    systemPrompt?: string;
+    network?: "disabled" | "enabled";
+    effort?: string;
+    model?: string;
+}>, {
+    model?: string | undefined;
+    effort?: string | undefined;
+    network?: "disabled" | "enabled" | undefined;
+    systemPrompt?: string | undefined;
+    systemPromptMode?: "append" | "replace" | undefined;
+}>>;
+export type ProviderOptions = z.infer<typeof providerOptionsSchema>;
+export declare const providerRecipeSchema: z.ZodPipe<z.ZodObject<{
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        acp: "acp";
+        "claude-agent-sdk": "claude-agent-sdk";
+        "codex-app-server": "codex-app-server";
+        "grok-build": "grok-build";
+        "opencode-sdk": "opencode-sdk";
+        pi: "pi";
+    }>;
+    executable: z.ZodOptional<z.ZodString>;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>, z.ZodTransform<Readonly<{
+    env?: Readonly<Record<string, string>>;
+    config?: Readonly<Record<string, unknown>>;
+    executable?: string;
     name: string;
     kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "pi";
-    executable?: string;
-    config?: Readonly<Record<string, unknown>>;
-    env?: Readonly<Record<string, string>>;
-}>;
+}>, {
+    name: string;
+    kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "pi";
+    executable?: string | undefined;
+    config?: Record<string, unknown> | undefined;
+    env?: Record<string, string> | undefined;
+}>>;
+export type ProviderExecution = z.infer<typeof providerRecipeSchema>;
 export declare function decodeProviderOptions(value: unknown): ProviderOptions;
-export declare function decodeReadonlyRestraint(value: unknown): ReadonlyRestraint;
-export declare function decodeProviderRecipe(input: unknown): ProviderExecution;
+export declare function decodeProviderRecipe(value: unknown): ProviderExecution;
+export {};

package/build/src/akuma/provider-recipe.js

@@ -1,111 +1,70 @@
-function record(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}
+import { z } from "zod";
+const modelText = z
+    .string({ error: "provider option model must be a nonblank string" })
+    .refine((value) => value.trim() !== "", "provider option model must be a nonblank string");
+const effortText = z
+    .string({ error: "provider option effort must be a nonblank string" })
+    .refine((value) => value.trim() !== "", "provider option effort must be a nonblank string");
+const systemPromptModeSchema = z.enum(["append", "replace"], {
+    error: "provider option systemPromptMode must be append, replace",
+});
+export const providerOptionsSchema = z
+    .object({
+    model: modelText.optional(),
+    effort: effortText.optional(),
+    network: z.enum(["disabled", "enabled"], { error: "provider option network must be disabled, enabled" }).optional(),
+    systemPrompt: z.string({ error: "provider option systemPrompt must be a string" }).optional(),
+    systemPromptMode: systemPromptModeSchema.optional(),
+})
+    .refine((value) => value.systemPromptMode === undefined || value.systemPrompt !== undefined, "provider option systemPromptMode requires systemPrompt")
+    .transform(({ model, effort, network, systemPrompt, systemPromptMode }) => Object.freeze({
+    ...(model === undefined ? {} : { model }),
+    ...(effort === undefined ? {} : { effort }),
+    ...(network === undefined ? {} : { network }),
+    ...(systemPrompt === undefined ? {} : { systemPrompt }),
+    ...(systemPromptMode === undefined ? {} : { systemPromptMode }),
+}));
+// Recipe configuration deliberately stays adapter-owned opaque data, including historical keys.
 function snapshot(value) {
     if (Array.isArray(value))
         return Object.freeze(value.map(snapshot));
-    const object = record(value);
-    if (object === null)
+    if (value === null || typeof value !== "object")
         return value;
-    return Object.freeze(Object.fromEntries(Object.entries(object).map(([key, item]) => [key, snapshot(item)])));
-}
-function optionText(options, field, blank) {
-    const selected = options[field];
-    if (selected === undefined)
-        return undefined;
-    if (typeof selected !== "string" || (blank === "refuse" && selected.trim().length === 0)) {
-        throw new TypeError(`provider option ${field} must be ${blank === "allow" ? "a string" : "a nonblank string"}`);
-    }
-    return selected;
+    return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, snapshot(item)])));
 }
+export const providerRecipeSchema = z
+    .object({
+    name: z.string().refine((value) => value.trim() !== "", "provider execution name must be a nonblank string"),
+    kind: z.enum(["acp", "claude-agent-sdk", "codex-app-server", "grok-build", "opencode-sdk", "pi"], {
+        error: "provider execution has unknown kind",
+    }),
+    executable: z
+        .string()
+        .refine((value) => value.trim() !== "", "provider execution executable must be a nonblank string")
+        .optional(),
+    config: z.record(z.string(), z.unknown()).optional(),
+    env: z.record(z.string(), z.string()).optional(),
+})
+    .transform(({ name, kind, executable, config, env }) => Object.freeze({
+    name,
+    kind,
+    ...(executable === undefined ? {} : { executable }),
+    ...(config === undefined ? {} : { config: snapshot(config) }),
+    ...(env === undefined ? {} : { env: Object.freeze(env) }),
+}));
 export function decodeProviderOptions(value) {
-    const options = record(value);
-    if (options === null)
-        throw new TypeError("provider options must be an object");
-    const model = optionText(options, "model", "refuse");
-    const effort = optionText(options, "effort", "refuse");
-    if (options.readonly !== undefined && options.readonly !== true) {
-        throw new TypeError("provider option readonly must be true");
-    }
-    const network = options.network;
-    if (network !== undefined && network !== "disabled" && network !== "enabled") {
-        throw new TypeError("provider option network must be disabled, enabled");
-    }
-    const sandbox = options.sandbox;
-    if (sandbox !== undefined && sandbox !== "full-access") {
-        throw new TypeError("provider option sandbox must be full-access");
-    }
-    const systemPrompt = optionText(options, "systemPrompt", "allow");
-    const systemPromptMode = options.systemPromptMode;
-    if (systemPromptMode !== undefined) {
-        if (systemPromptMode !== "append" && systemPromptMode !== "replace") {
-            throw new TypeError("provider option systemPromptMode must be append, replace");
-        }
-        if (systemPrompt === undefined) {
-            throw new TypeError("provider option systemPromptMode requires systemPrompt");
-        }
-    }
-    return Object.freeze({
-        ...(model === undefined ? {} : { model }),
-        ...(effort === undefined ? {} : { effort }),
-        ...(options.readonly === undefined ? {} : { readonly: true }),
-        ...(network === undefined ? {} : { network }),
-        ...(sandbox === undefined ? {} : { sandbox }),
-        ...(systemPrompt === undefined ? {} : { systemPrompt }),
-        ...(systemPromptMode === undefined ? {} : { systemPromptMode }),
-    });
-}
-export function decodeReadonlyRestraint(value) {
-    const restraint = record(value);
-    if (restraint === null)
-        throw new TypeError("readonly restraint must be an object");
-    if (restraint.enforcement === "native") {
-        return Object.freeze({ enforcement: "native" });
-    }
-    if (restraint.enforcement === "none" &&
-        typeof restraint.diagnostic === "string" &&
-        restraint.diagnostic.trim().length > 0) {
-        return Object.freeze({ enforcement: "none", diagnostic: restraint.diagnostic });
-    }
-    throw new TypeError("readonly restraint must be native or none with a diagnostic");
-}
-function providerKind(value) {
-    return (value === "acp" ||
-        value === "claude-agent-sdk" ||
-        value === "codex-app-server" ||
-        value === "grok-build" ||
-        value === "opencode-sdk" ||
-        value === "pi");
+    const parsed = providerOptionsSchema.safeParse(value);
+    if (!parsed.success)
+        throw new TypeError(parsed.error.issues[0]?.message ?? "provider options must be an object", {
+            cause: parsed.error,
+        });
+    return parsed.data;
 }
-export function decodeProviderRecipe(input) {
-    const value = record(input);
-    if (value === null)
-        throw new TypeError("provider execution must be an object");
-    if (typeof value.name !== "string" || value.name.trim().length === 0) {
-        throw new TypeError("provider execution name must be a nonblank string");
-    }
-    if (!providerKind(value.kind))
-        throw new TypeError("provider execution has unknown kind");
-    if (value.executable !== undefined &&
-        (typeof value.executable !== "string" || value.executable.trim().length === 0)) {
-        throw new TypeError("provider execution executable must be a nonblank string");
-    }
-    const config = value.config === undefined ? undefined : record(value.config);
-    if (config === null)
-        throw new TypeError("provider execution config must be an object");
-    const env = value.env === undefined ? undefined : record(value.env);
-    if (env === null)
-        throw new TypeError("provider execution env must be an object");
-    if (env !== undefined && Object.values(env).some((item) => typeof item !== "string")) {
-        throw new TypeError("provider execution env must contain only string values");
-    }
-    return Object.freeze({
-        name: value.name,
-        kind: value.kind,
-        ...(value.executable === undefined ? {} : { executable: value.executable }),
-        ...(config === undefined ? {} : { config: snapshot(config) }),
-        ...(env === undefined ? {} : { env: Object.freeze({ ...env }) }),
-    });
+export function decodeProviderRecipe(value) {
+    const parsed = providerRecipeSchema.safeParse(value);
+    if (!parsed.success)
+        throw new TypeError(parsed.error.issues[0]?.message ?? "provider execution must be an object", {
+            cause: parsed.error,
+        });
+    return parsed.data;
 }