@astrosheep/keiyaku 2.9.2 → 2.9.4

package/build/agents/providers/opencode-sdk/registration.js

@@ -0,0 +1,135 @@
+import { z } from "zod";
+import { executableSchema, providerCommonFields, providerEnvSchema, } from "../../../config/settings/provider-instance-fields.js";
+import { FlowError } from "../../../flow-error.js";
+import { exactKeys, optionalString, optionalStringRecord, } from "../../launch-snapshot/parse-helpers.js";
+import { SUBAGENT_SESSION_VERSION, subagentSessionEnvelopeSchema, } from "../../session.js";
+import { OPENCODE_SDK_PROVIDER } from "./session.js";
+import { opencodeSessionSchema } from "./session-schema.js";
+const startOpencode = async (prompt, cwd, options) => {
+    const { startOpencode: start } = await import("./adapter.js");
+    return start(prompt, cwd, options);
+};
+function admitResumeShape(schema, session, resumePath) {
+    const envelopeResult = subagentSessionEnvelopeSchema.safeParse(session);
+    if (!envelopeResult.success) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' includes an invalid session envelope.`);
+    }
+    if (session.provider !== OPENCODE_SDK_PROVIDER) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' was created with provider '${session.provider}', but the selected subagent resolves to '${OPENCODE_SDK_PROVIDER}'. Cross-provider resume is not supported.`);
+    }
+    if (session.version !== SUBAGENT_SESSION_VERSION) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' uses unsupported session version '${session.version}' for provider '${session.provider}'.`);
+    }
+    const shapeResult = schema.safeParse(session.handle);
+    if (!shapeResult.success) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' includes an invalid session handle for provider '${session.provider}'.`);
+    }
+    return shapeResult.data;
+}
+export const opencodeSdkRegistration = {
+    name: OPENCODE_SDK_PROVIDER,
+    start: startOpencode,
+    sessionSchema: opencodeSessionSchema,
+    effortField: "effort",
+    instanceSchema: z
+        .object({
+        kind: z.literal(OPENCODE_SDK_PROVIDER),
+        ...providerCommonFields,
+        executable: executableSchema.optional(),
+        env: providerEnvSchema,
+    })
+        .strict(),
+    builtinInstance: {
+        name: OPENCODE_SDK_PROVIDER,
+        source: "builtin",
+        instance: { kind: OPENCODE_SDK_PROVIDER, executable: "opencode" },
+    },
+    portablePolicy: {
+        access: new Set(),
+        network: new Set(),
+        webSearch: new Set(),
+    },
+    maxCaptureChars: (config) => config.opencode.execMaxCaptureChars,
+    sessionContinuationPromptPrefix: (body) => `[Akuma system prompt]\n${body}\n\n[Operator prompt]\n`,
+    buildCallTerms: ({ snapshot, baseTerms, replayPrompt }) => {
+        const provider = snapshot.provider;
+        return {
+            ...baseTerms,
+            prompt: replayPrompt,
+            provider: OPENCODE_SDK_PROVIDER,
+            ...(provider.model !== undefined ? { model: provider.model } : {}),
+            ...(provider.effort !== undefined ? { effort: provider.effort } : {}),
+            ...(provider.executable !== undefined ? { executable: provider.executable } : {}),
+            ...(provider.env !== undefined ? { env: provider.env } : {}),
+        };
+    },
+    resolveLaunchProvider: ({ common, instance, model, effort }) => {
+        if (instance.kind !== OPENCODE_SDK_PROVIDER) {
+            throw new Error(`resolveLaunchProvider expected ${OPENCODE_SDK_PROVIDER}`);
+        }
+        const opencodeInstance = instance;
+        return Object.freeze({
+            ...common,
+            kind: OPENCODE_SDK_PROVIDER,
+            ...(opencodeInstance.executable !== undefined ? { executable: opencodeInstance.executable } : {}),
+            ...(model !== undefined ? { model } : {}),
+            ...(effort !== undefined ? { effort } : {}),
+            ...(opencodeInstance.env !== undefined ? { env: opencodeInstance.env } : {}),
+        });
+    },
+    parseLaunchProvider: (provider, common) => {
+        exactKeys(provider, ["name", "source", "kind", "executable", "model", "effort", "env"], "provider");
+        const executable = optionalString(provider, "executable", "provider");
+        const model = optionalString(provider, "model", "provider");
+        const effort = optionalString(provider, "effort", "provider");
+        const env = optionalStringRecord(provider, "env");
+        return Object.freeze({
+            ...common,
+            kind: OPENCODE_SDK_PROVIDER,
+            ...(executable !== undefined ? { executable } : {}),
+            ...(model !== undefined ? { model } : {}),
+            ...(effort !== undefined ? { effort } : {}),
+            ...(env !== undefined ? { env } : {}),
+        });
+    },
+    applyEffort: (provider, effort) => Object.freeze({ ...provider, effort }),
+    providerEffortAndModel: (provider) => {
+        const resolved = provider;
+        return { model: resolved.model, effort: resolved.effort };
+    },
+    attachLoader: (terms, ports) => {
+        if (terms.provider !== OPENCODE_SDK_PROVIDER)
+            return terms;
+        const loader = ports.opencodeSdk;
+        return loader ? { ...terms, loader } : terms;
+    },
+    nativePolicyOwnership: () => null,
+    startLive: async ({ terms, signal, reviveTerms, onSyncCheckpoint, onDeliveryOpportunity, onIngress, }) => {
+        if (terms.provider !== OPENCODE_SDK_PROVIDER) {
+            throw new Error(`startLive expected ${OPENCODE_SDK_PROVIDER}`);
+        }
+        const opencodeTerms = terms;
+        const options = {
+            model: opencodeTerms.model,
+            effort: opencodeTerms.effort,
+            executable: opencodeTerms.executable,
+            env: opencodeTerms.env,
+            signal,
+            onSyncCheckpoint,
+            onDeliveryOpportunity,
+            onEvidence: opencodeTerms.onEvidence,
+            onIngress,
+            initialTurn: opencodeTerms.initialTurn,
+            loader: opencodeTerms.loader,
+        };
+        const { startOpencode: start } = await import("./adapter.js");
+        if (reviveTerms) {
+            const session = admitResumeShape(opencodeSessionSchema, reviveTerms.session, reviveTerms.resumePath);
+            return start(opencodeTerms.prompt, opencodeTerms.workdir, {
+                ...options,
+                sessionId: session.sessionId,
+            });
+        }
+        return start(opencodeTerms.prompt, opencodeTerms.workdir, options);
+    },
+};

package/build/agents/providers/opencode-sdk/session-schema.js

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export const opencodeSessionSchema = z.object({ sessionId: z.string().trim().min(1) });

package/build/agents/providers/opencode-sdk/session.js

@@ -18,6 +18,8 @@ export class OpencodeIdleMonitor {
     settledIngressEpoch = 0;
     observedIngressEpoch = 0;
     fallbackDelayMs = OPENCODE_SILENT_FALLBACK_INITIAL_MS;
+    observedActive = false;
+    terminalObserved = false;
     disposed = false;
     constructor(session, sessionId, signal) {
         this.session = session;
@@ -47,6 +49,9 @@ export class OpencodeIdleMonitor {
         if (!this.queryRunning)
             this.scheduleTrailingQuery();
     }
+    terminal() {
+        this.terminalObserved = true;
+    }
     dispose() {
         if (this.disposed)
             return;
@@ -85,6 +90,8 @@ export class OpencodeIdleMonitor {
         this.rejectCycle = undefined;
         this.settledIngressEpoch = this.ingressEpoch;
         this.fallbackDelayMs = OPENCODE_SILENT_FALLBACK_INITIAL_MS;
+        this.observedActive = false;
+        this.terminalObserved = false;
         resolve?.();
     }
     fail(error) {
@@ -111,13 +118,20 @@ export class OpencodeIdleMonitor {
                 this.scheduleTrailingQuery();
                 return;
             }
-            if (!Object.prototype.hasOwnProperty.call(active, this.sessionId)) {
-                this.finish();
-                return;
-            }
             if (hadUnobservedIngress) {
                 this.scheduleTrailingQuery();
             }
+            else if (Object.prototype.hasOwnProperty.call(active, this.sessionId)) {
+                this.observedActive = true;
+                const delayMs = this.fallbackDelayMs;
+                this.fallbackDelayMs = Math.min(delayMs * 2, OPENCODE_SILENT_FALLBACK_MAX_MS);
+                this.schedule(delayMs);
+            }
+            else if (this.observedActive ||
+                this.terminalObserved ||
+                this.ingressEpoch === this.settledIngressEpoch) {
+                this.finish();
+            }
             else {
                 const delayMs = this.fallbackDelayMs;
                 this.fallbackDelayMs = Math.min(delayMs * 2, OPENCODE_SILENT_FALLBACK_MAX_MS);
@@ -135,7 +149,6 @@ export class OpencodeIdleMonitor {
         }
     }
 }
-let opencodeSdkLoader;
 export function sessionIdFrom(info, fallback) {
     return coerceString(info.id) ?? fallback;
 }
@@ -158,9 +171,9 @@ export async function withAbort(promise, signal, message) {
         });
     });
 }
-export async function loadOpencodeSdk(executable, cwd, env, signal) {
-    if (opencodeSdkLoader)
-        return opencodeSdkLoader(cwd);
+export async function loadOpencodeSdk(executable, cwd, env, signal, loader) {
+    if (loader)
+        return loader(cwd);
     const sdk = await createOpencode({
         executable,
         directory: cwd,
@@ -172,9 +185,3 @@ export async function loadOpencodeSdk(executable, cwd, env, signal) {
         close: sdk.server?.close,
     };
 }
-export function setOpencodeSdkLoaderForTests(loader) {
-    opencodeSdkLoader = loader;
-}
-export function resetOpencodeSdkLoaderForTests() {
-    opencodeSdkLoader = undefined;
-}

package/build/agents/providers/opencode-sdk/terms.js

@@ -0,0 +1 @@
+export {};

package/build/agents/providers/pi/adapter.js

@@ -1,16 +1,11 @@
-import { z } from "zod";
 import { FlowError } from "../../../flow-error.js";
 import { appendDebugLog } from "../../../telemetry/debug-log.js";
 import { createProjectionDriver } from "../../harness/execution-handle.js";
+import { createProviderFailure, toProviderTerminalError, } from "../../harness/provider-adapter.js";
 import { createAbortError, emitProviderEvidence, sha256Utf8 } from "../../harness/runtime.js";
-import { SubagentFailure } from "../../types.js";
 import { createPiCheckpointController, PI_PROVIDER, toPiSdkThinkingLevel, } from "./checkpoint.js";
 import { bindPiSessionEvents } from "./events.js";
-/** Opaque Pi resume handle: exact session file path (UUID alone is ambiguous). */
-export const piSessionSchema = z.object({
-    sessionFile: z.string().trim().min(1),
-    sessionId: z.string().trim().min(1).optional(),
-});
+export { piSessionSchema } from "./session-schema.js";
 /** Exact model shape: `<provider>/<id>` (single slash separating non-empty sides). */
 const PI_MODEL_PATTERN = /^[^/]+\/[^/]+$/;
 const importPiSdk = new Function("specifier", "return import(specifier)");
@@ -18,21 +13,8 @@ async function loadPiSdk(loader) {
     if (loader) {
         return loader();
     }
-    if (_piSdkLoader) {
-        return _piSdkLoader();
-    }
     return (await importPiSdk("@earendil-works/pi-coding-agent"));
 }
-/** @deprecated Use PiOptions.loader instead. Kept for pipeline-based tests pending loader channel. */
-let _piSdkLoader;
-/** @deprecated Use PiOptions.loader instead. */
-export function setPiSdkLoaderForTests(loader) {
-    _piSdkLoader = loader;
-}
-/** @deprecated Use PiOptions.loader instead. */
-export function resetPiSdkLoaderForTests() {
-    _piSdkLoader = undefined;
-}
 export function parsePiModelRef(model) {
     const trimmed = model.trim();
     if (!PI_MODEL_PATTERN.test(trimmed)) {
@@ -45,6 +27,23 @@ export function parsePiModelRef(model) {
     };
 }
 export async function startPi(prompt, cwd, options = {}) {
+    // Pre-driver awaits (sdk/session/model/resource/createAgentSession) sit outside
+    // createProjectionDriver's run gate; map every startup throw to the typed
+    // terminal boundary here. FlowError (settings shape) remains unnormalized.
+    try {
+        return await openPiProjectionDriver(prompt, cwd, options);
+    }
+    catch (error) {
+        if (error instanceof FlowError)
+            throw error;
+        throw toProviderTerminalError(error);
+    }
+}
+async function openPiProjectionDriver(prompt, cwd, options) {
+    // Pre-driver cancellation is immediately signal-cancellable — check before any SDK work.
+    if (options.signal?.aborted) {
+        throw createAbortError(`${PI_PROVIDER} exec cancelled by client`, options.signal.reason);
+    }
     const resumeSessionFile = options.sessionFile?.trim();
     appendDebugLog(`startPi: mode=${resumeSessionFile ? "resume" : "fresh"} model=${options.model ?? "default"}`, { cwd, section: PI_PROVIDER });
     const sdk = await loadPiSdk(options.loader);
@@ -53,22 +52,20 @@ export async function startPi(prompt, cwd, options = {}) {
         ? sessionManagerApi.open(resumeSessionFile)
         : sessionManagerApi.create(cwd);
     let model;
-    let authStorage;
-    let modelRegistry;
+    let modelRuntime;
     if (options.model !== undefined && options.model.trim().length > 0) {
         const original = options.model.trim();
         const ref = parsePiModelRef(original);
-        authStorage = sdk.AuthStorage.create();
-        modelRegistry = sdk.ModelRegistry.create(authStorage);
-        model = modelRegistry.find(ref.provider, ref.id);
+        modelRuntime = await sdk.ModelRuntime.create();
+        model = modelRuntime.getModel(ref.provider, ref.id);
         if (!model) {
-            throw new SubagentFailure("SUBAGENT_PROVIDER_UNAVAILABLE", `${PI_PROVIDER} model '${original}' is not available`);
+            throw createProviderFailure(`${PI_PROVIDER} model '${original}' is not available`, { code: "SUBAGENT_PROVIDER_UNAVAILABLE" });
         }
     }
     // With an Akuma body, retain the default loader's discovery and override only its append list.
     // The override deliberately suppresses discovered APPEND_SYSTEM.md content.
     if (options.appendSystemPromptOverride && (!sdk.DefaultResourceLoader || !sdk.getAgentDir)) {
-        throw new Error(`${PI_PROVIDER} SDK does not expose DefaultResourceLoader and getAgentDir`);
+        throw createProviderFailure(`${PI_PROVIDER} SDK does not expose DefaultResourceLoader and getAgentDir`);
     }
     let emittedAppendEvidence = false;
     let pendingEvidenceDiagnostics = 0;
@@ -94,12 +91,15 @@ export async function startPi(prompt, cwd, options = {}) {
         })
         : undefined;
     await resourceLoader?.reload();
+    if (options.signal?.aborted) {
+        throw createAbortError(`${PI_PROVIDER} exec cancelled by client`, options.signal.reason);
+    }
     // Empty bodies retain the SDK's default ResourceLoader path unchanged.
     const created = await sdk.createAgentSession({
         cwd,
         sessionManager,
         ...(options.thinkingLevel ? { thinkingLevel: toPiSdkThinkingLevel(options.thinkingLevel) } : {}),
-        ...(model ? { model, authStorage, modelRegistry } : {}),
+        ...(model ? { model, modelRuntime } : {}),
         ...(resourceLoader ? { resourceLoader } : {}),
     });
     const session = created.session;
@@ -131,6 +131,7 @@ export async function startPi(prompt, cwd, options = {}) {
         resolveRunSettled = resolve;
     });
     let activePrompt;
+    let activeState;
     let abortRequested;
     const requestAbort = async (state) => {
         state.abortIntent = true;
@@ -159,13 +160,14 @@ export async function startPi(prompt, cwd, options = {}) {
         enqueue: checkpointController.enqueue,
         onIngress: options.onIngress,
         async abort(mode) {
+            const state = activeState ?? { abortIntent: true, settled: false };
             if (mode !== "force") {
-                await requestAbort({ abortIntent: true, settled: false });
+                await requestAbort(state);
                 return;
             }
             let failure;
             try {
-                await requestAbort({ abortIntent: true, settled: false });
+                await requestAbort(state);
             }
             catch (error) {
                 failure = error;
@@ -196,6 +198,7 @@ export async function startPi(prompt, cwd, options = {}) {
                 assistantMessageOrdinal: -1,
                 activityCalls: new Map(),
             };
+            activeState = state;
             let settleOutcome;
             const outcome = new Promise((resolve, reject) => {
                 settleOutcome = {
@@ -250,6 +253,7 @@ export async function startPi(prompt, cwd, options = {}) {
                 throw error;
             }
             finally {
+                activeState = undefined;
                 builder.signal.removeEventListener("abort", onAbort);
                 options.signal?.removeEventListener("abort", onAbort);
                 await abortRequested?.catch(() => undefined);
@@ -263,6 +267,8 @@ export async function startPi(prompt, cwd, options = {}) {
         },
     });
 }
+// Compiler-level binding to the named ProviderAdapter function contract.
+startPi;
 function readSessionManager(sdk) {
     const store = sdk[`Session${"Man"}${"ager"}`];
     return store;

package/build/agents/providers/pi/registration.js

@@ -0,0 +1,145 @@
+import { z } from "zod";
+import { providerCommonFields, providerEnvSchema, } from "../../../config/settings/provider-instance-fields.js";
+import { FlowError } from "../../../flow-error.js";
+import { exactKeys, optionalString, optionalStringRecord, } from "../../launch-snapshot/parse-helpers.js";
+import { SUBAGENT_SESSION_VERSION, subagentSessionEnvelopeSchema, } from "../../session.js";
+import { PI_PROVIDER } from "./checkpoint.js";
+import { piSessionSchema } from "./session-schema.js";
+const startPi = async (prompt, cwd, options) => {
+    const { startPi: start } = await import("./adapter.js");
+    return start(prompt, cwd, options);
+};
+function admitResumeShape(schema, session, resumePath) {
+    const envelopeResult = subagentSessionEnvelopeSchema.safeParse(session);
+    if (!envelopeResult.success) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' includes an invalid session envelope.`);
+    }
+    if (session.provider !== PI_PROVIDER) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' was created with provider '${session.provider}', but the selected subagent resolves to '${PI_PROVIDER}'. Cross-provider resume is not supported.`);
+    }
+    if (session.version !== SUBAGENT_SESSION_VERSION) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' uses unsupported session version '${session.version}' for provider '${session.provider}'.`);
+    }
+    const shapeResult = schema.safeParse(session.handle);
+    if (!shapeResult.success) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' includes an invalid session handle for provider '${session.provider}'.`);
+    }
+    return shapeResult.data;
+}
+export const piRegistration = {
+    name: PI_PROVIDER,
+    start: startPi,
+    sessionSchema: piSessionSchema,
+    effortField: "thinkingLevel",
+    instanceSchema: z
+        .object({
+        kind: z.literal(PI_PROVIDER),
+        ...providerCommonFields,
+        env: providerEnvSchema,
+    })
+        .strict()
+        .superRefine((data, ctx) => {
+        if (data.env === undefined)
+            return;
+        if (Object.keys(data.env).length === 0)
+            return;
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["env"],
+            message: `env injection not supported for provider ${PI_PROVIDER}`,
+        });
+    }),
+    builtinInstance: {
+        name: PI_PROVIDER,
+        source: "builtin",
+        instance: { kind: PI_PROVIDER },
+    },
+    portablePolicy: {
+        access: new Set(),
+        network: new Set(),
+        webSearch: new Set(),
+    },
+    maxCaptureChars: (config) => config.codex.execMaxCaptureChars,
+    buildCallTerms: ({ snapshot, baseTerms, body }) => {
+        const provider = snapshot.provider;
+        return {
+            ...baseTerms,
+            provider: PI_PROVIDER,
+            ...(provider.model !== undefined ? { model: provider.model } : {}),
+            ...(provider.thinkingLevel !== undefined ? { thinkingLevel: provider.thinkingLevel } : {}),
+            appendSystemPromptOverride: body ? () => [body] : undefined,
+            onCheckpoint() { },
+        };
+    },
+    resolveLaunchProvider: ({ common, instance, model, effort }) => {
+        if (instance.kind !== PI_PROVIDER) {
+            throw new Error(`resolveLaunchProvider expected ${PI_PROVIDER}`);
+        }
+        const piInstance = instance;
+        return Object.freeze({
+            ...common,
+            kind: PI_PROVIDER,
+            ...(model !== undefined ? { model } : {}),
+            ...(effort !== undefined ? { thinkingLevel: effort } : {}),
+            ...(piInstance.env !== undefined ? { env: piInstance.env } : {}),
+        });
+    },
+    parseLaunchProvider: (provider, common) => {
+        exactKeys(provider, ["name", "source", "kind", "model", "thinkingLevel", "env"], "provider");
+        const model = optionalString(provider, "model", "provider");
+        const thinkingLevel = optionalString(provider, "thinkingLevel", "provider");
+        const env = optionalStringRecord(provider, "env");
+        return Object.freeze({
+            ...common,
+            kind: PI_PROVIDER,
+            ...(model !== undefined ? { model } : {}),
+            ...(thinkingLevel !== undefined ? { thinkingLevel } : {}),
+            ...(env !== undefined ? { env } : {}),
+        });
+    },
+    applyEffort: (provider, effort) => Object.freeze({ ...provider, thinkingLevel: effort }),
+    providerEffortAndModel: (provider) => {
+        const resolved = provider;
+        return { model: resolved.model, effort: resolved.thinkingLevel };
+    },
+    attachLoader: (terms, ports) => {
+        if (terms.provider !== PI_PROVIDER)
+            return terms;
+        const loader = ports.pi;
+        return loader ? { ...terms, loader } : terms;
+    },
+    nativePolicyOwnership: () => null,
+    startLive: async ({ terms, signal, reviveTerms, onSyncCheckpoint, onIngress }) => {
+        if (terms.provider !== PI_PROVIDER) {
+            throw new Error(`startLive expected ${PI_PROVIDER}`);
+        }
+        const piTerms = terms;
+        const { startPi: start } = await import("./adapter.js");
+        if (reviveTerms) {
+            const session = admitResumeShape(piSessionSchema, reviveTerms.session, reviveTerms.resumePath);
+            return start(piTerms.prompt, piTerms.workdir, {
+                model: piTerms.model,
+                thinkingLevel: piTerms.thinkingLevel,
+                signal,
+                sessionFile: session.sessionFile,
+                appendSystemPromptOverride: piTerms.appendSystemPromptOverride,
+                onSyncCheckpoint,
+                onEvidence: piTerms.onEvidence,
+                onIngress,
+                initialTurn: piTerms.initialTurn,
+                loader: piTerms.loader,
+            });
+        }
+        return start(piTerms.prompt, piTerms.workdir, {
+            model: piTerms.model,
+            thinkingLevel: piTerms.thinkingLevel,
+            signal,
+            appendSystemPromptOverride: piTerms.appendSystemPromptOverride,
+            onSyncCheckpoint,
+            onEvidence: piTerms.onEvidence,
+            onIngress,
+            initialTurn: piTerms.initialTurn,
+            loader: piTerms.loader,
+        });
+    },
+};

package/build/agents/providers/pi/session-schema.js

@@ -0,0 +1,6 @@
+import { z } from "zod";
+/** Opaque Pi resume handle: exact session file path (UUID alone is ambiguous). */
+export const piSessionSchema = z.object({
+    sessionFile: z.string().trim().min(1),
+    sessionId: z.string().trim().min(1).optional(),
+});

package/build/agents/providers/pi/terms.js

@@ -0,0 +1 @@
+export {};

package/build/agents/providers/registration.js

@@ -0,0 +1,7 @@
+/**
+ * Identity helper that locks `Name` across name / instanceSchema / builtinInstance.
+ * `const Name` keeps the literal; a schema whose kind is not exactly that literal fails here.
+ */
+export function defineProviderRegistration(registration) {
+    return registration;
+}

package/build/agents/providers/registry.js

@@ -0,0 +1,76 @@
+import { z } from "zod";
+import { claudeAgentSdkRegistration } from "./claude-agent-sdk/registration.js";
+import { codexAppServerRegistration } from "./codex-app-server/registration.js";
+import { opencodeSdkRegistration } from "./opencode-sdk/registration.js";
+import { piRegistration } from "./pi/registration.js";
+/**
+ * Sole provider-vocabulary registration surface.
+ * Add/remove a live provider by editing that provider's directory and this list.
+ * Runtime tables, schemas, and builtin Akuma profiles are derived from the list.
+ */
+export const PROVIDER_REGISTRATIONS = [
+    codexAppServerRegistration,
+    claudeAgentSdkRegistration,
+    opencodeSdkRegistration,
+    piRegistration,
+];
+function nonEmptyProviderNames(registrations) {
+    if (registrations.length === 0) {
+        throw new Error("PROVIDER_REGISTRATIONS must not be empty");
+    }
+    return registrations.map((registration) => registration.name);
+}
+export const SUBAGENT_PROVIDERS = nonEmptyProviderNames(PROVIDER_REGISTRATIONS);
+const providerNameSet = new Set(SUBAGENT_PROVIDERS);
+export function isSubagentProvider(value) {
+    return providerNameSet.has(value);
+}
+function indexByProviderName(pick) {
+    const out = {};
+    for (const registration of PROVIDER_REGISTRATIONS) {
+        out[registration.name] = pick(registration);
+    }
+    return Object.freeze(out);
+}
+const registrationByName = new Map(PROVIDER_REGISTRATIONS.map((registration) => [registration.name, registration]));
+export function getProviderRegistration(name) {
+    const registration = registrationByName.get(name);
+    if (!registration) {
+        throw new Error(`Unknown provider '${name}'`);
+    }
+    return registration;
+}
+export const PROVIDER_REGISTRATION_BY_NAME = indexByProviderName((registration) => registration);
+export const BUILTIN_PROVIDER_INSTANCE_CANDIDATES = indexByProviderName((registration) => ({
+    name: registration.name,
+    source: "builtin",
+    instance: registration.builtinInstance.instance,
+}));
+export const PROVIDER_PORTABLE_POLICY = indexByProviderName((registration) => registration.portablePolicy);
+/**
+ * Closed provider-instance schema derived solely from PROVIDER_REGISTRATIONS.
+ * Each contribution's instanceSchema is a kind-literal object schema (possibly
+ * refined); Zod's discriminable marker is erased by ProviderInstanceSchema, so
+ * the non-empty tuple assertion restores only that structural requirement.
+ */
+export const providerInstanceSchema = z.discriminatedUnion("kind", (() => {
+    const schemas = PROVIDER_REGISTRATIONS.map((registration) => registration.instanceSchema);
+    if (schemas.length === 0) {
+        throw new Error("PROVIDER_REGISTRATIONS must not be empty");
+    }
+    return schemas;
+})());
+/** Product builtin Akuma profiles contributed by registrations. */
+export const BUILTIN_AGENT_PROFILES = Object.freeze(Object.fromEntries(PROVIDER_REGISTRATIONS.flatMap((registration) => {
+    const open = registration;
+    const profiles = open.builtinAkumaProfiles ?? [];
+    return profiles.map((profile) => [
+        profile.name,
+        Object.freeze({
+            provider: registration.name,
+            description: profile.description,
+        }),
+    ]);
+})));
+export const BUILTIN_AGENT_NAMES = Object.freeze(Object.keys(BUILTIN_AGENT_PROFILES));
+export { defineProviderRegistration } from "./registration.js";

package/build/agents/selector.js

@@ -5,35 +5,8 @@ import { resolveDefaultAgentName } from "../config/settings/knobs.js";
 import { loadKeiyakuSettings } from "../config/settings/loader.js";
 import { nativePolicyOwnership } from "../config/provider-policy-ownership.js";
 import { FlowError } from "../flow-error.js";
-const ACCESS_VALUES = ["read", "write", "auto"];
-const NETWORK_VALUES = ["disabled", "enabled"];
-const SUPPORTED_EXPLICIT = {
-    "codex-sdk": {
-        access: new Set(ACCESS_VALUES),
-        network: new Set(NETWORK_VALUES),
-        webSearch: new Set(["disabled", "cached", "live"]),
-    },
-    "codex-app-server": {
-        access: new Set(["write"]),
-        network: new Set(NETWORK_VALUES),
-        webSearch: new Set(),
-    },
-    "claude-agent-sdk": {
-        access: new Set(ACCESS_VALUES),
-        network: new Set(),
-        webSearch: new Set(["disabled"]),
-    },
-    "opencode-sdk": {
-        access: new Set(),
-        network: new Set(),
-        webSearch: new Set(),
-    },
-    pi: {
-        access: new Set(),
-        network: new Set(),
-        webSearch: new Set(),
-    },
-};
+import { PROVIDER_PORTABLE_POLICY } from "./providers/registry.js";
+const SUPPORTED_EXPLICIT = PROVIDER_PORTABLE_POLICY;
 export function formatAvailableAgentNames(names) {
     if (names.length === 0)
         return "(none configured)";

package/build/agents/types.js

@@ -1,3 +1,11 @@
+export const SUBAGENT_FAILURE_CODES = [
+    "SUBAGENT_TIMEOUT",
+    "SUBAGENT_NON_ZERO_EXIT",
+    "SUBAGENT_SPAWN_ERROR",
+    "SUBAGENT_EXEC_ERROR",
+    "SUBAGENT_PROVIDER_UNAVAILABLE",
+];
+export const OUTCOME_ERROR_VERSION = 1;
 export class SubagentFailure extends Error {
     code;
     timeoutMs;