@astrosheep/keiyaku 2.8.5 → 2.9.0

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

@@ -0,0 +1,269 @@
+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 { 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(),
+});
+/** Exact model shape: `<provider>/<id>` (single slash separating non-empty sides). */
+const PI_MODEL_PATTERN = /^[^/]+\/[^/]+$/;
+const importPiSdk = new Function("specifier", "return import(specifier)");
+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)) {
+        throw new FlowError("INVALID_SETTINGS", `Invalid pi model '${model}'. Expected exact shape '<provider>/<id>'.`);
+    }
+    const slash = trimmed.indexOf("/");
+    return {
+        provider: trimmed.slice(0, slash),
+        id: trimmed.slice(slash + 1),
+    };
+}
+export async function startPi(prompt, cwd, options = {}) {
+    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);
+    const sessionManagerApi = readSessionManager(sdk);
+    const sessionManager = resumeSessionFile
+        ? sessionManagerApi.open(resumeSessionFile)
+        : sessionManagerApi.create(cwd);
+    let model;
+    let authStorage;
+    let modelRegistry;
+    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);
+        if (!model) {
+            throw new SubagentFailure("SUBAGENT_PROVIDER_UNAVAILABLE", `${PI_PROVIDER} model '${original}' is not available`);
+        }
+    }
+    // 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`);
+    }
+    let emittedAppendEvidence = false;
+    let pendingEvidenceDiagnostics = 0;
+    let reportEvidenceDiagnostic = () => {
+        pendingEvidenceDiagnostics += 1;
+        appendDebugLog("provider evidence callback failed before Pi driver start", { cwd, section: PI_PROVIDER });
+    };
+    const observedAppendOverride = options.appendSystemPromptOverride && options.onEvidence
+        ? () => {
+            const body = options.appendSystemPromptOverride();
+            if (!emittedAppendEvidence) {
+                emittedAppendEvidence = true;
+                emitProviderEvidence(options.onEvidence, { type: "outbound", provider: PI_PROVIDER, direction: "input", kind: "system-prompt", ...sha256Utf8(body.join("\n")) }, reportEvidenceDiagnostic);
+            }
+            return body;
+        }
+        : options.appendSystemPromptOverride;
+    const resourceLoader = observedAppendOverride
+        ? new sdk.DefaultResourceLoader({
+            cwd,
+            agentDir: sdk.getAgentDir(),
+            appendSystemPromptOverride: observedAppendOverride,
+        })
+        : undefined;
+    await resourceLoader?.reload();
+    // 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 } : {}),
+        ...(resourceLoader ? { resourceLoader } : {}),
+    });
+    const session = created.session;
+    if (options.onEvidence)
+        emitProviderEvidence(options.onEvidence, { type: "session", provider: PI_PROVIDER, sessionId: session.sessionId, ...(session.sessionFile ? { sessionFile: session.sessionFile } : {}) }, reportEvidenceDiagnostic);
+    session.setSteeringMode("one-at-a-time");
+    const checkpointController = createPiCheckpointController(session, {
+        onEvidence: options.onEvidence,
+        diagnostic: () => reportEvidenceDiagnostic,
+        onSyncCheckpoint: options.onSyncCheckpoint,
+    });
+    let disposed = false;
+    let unsub;
+    const disposeSession = (propagate = false) => {
+        if (disposed)
+            return;
+        disposed = true;
+        unsub?.();
+        try {
+            session.dispose();
+        }
+        catch (error) {
+            if (propagate)
+                throw error;
+        }
+    };
+    let resolveRunSettled;
+    const runSettled = new Promise((resolve) => {
+        resolveRunSettled = resolve;
+    });
+    let activePrompt;
+    let abortRequested;
+    const requestAbort = async (state) => {
+        state.abortIntent = true;
+        if (abortRequested) {
+            await abortRequested;
+            return;
+        }
+        abortRequested = (async () => {
+            // Publish abortRequested before clearQueue can synchronously emit queue_update.
+            await Promise.resolve();
+            try {
+                session.clearQueue();
+                await session.abort();
+            }
+            finally {
+                if (state.settled) {
+                    disposeSession();
+                }
+            }
+        })();
+        await abortRequested;
+    };
+    return createProjectionDriver({
+        steerMode: "mid-execution",
+        initialTurn: options.initialTurn,
+        enqueue: checkpointController.enqueue,
+        onIngress: options.onIngress,
+        async abort(mode) {
+            if (mode !== "force") {
+                await requestAbort({ abortIntent: true, settled: false });
+                return;
+            }
+            let failure;
+            try {
+                await requestAbort({ abortIntent: true, settled: false });
+            }
+            catch (error) {
+                failure = error;
+            }
+            try {
+                disposeSession(true);
+            }
+            catch (error) {
+                failure ??= error;
+            }
+            await activePrompt;
+            await runSettled;
+            if (failure !== undefined)
+                throw failure;
+        },
+        async run(builder) {
+            reportEvidenceDiagnostic = () => builder.emit({ type: "diagnostic", text: "provider evidence callback failed" });
+            checkpointController.setTurnStartedEmitter(() => builder.emit({ type: "turn", phase: "started" }));
+            while (pendingEvidenceDiagnostics > 0) {
+                pendingEvidenceDiagnostics -= 1;
+                reportEvidenceDiagnostic();
+            }
+            const state = {
+                abortIntent: false,
+                lastAssistantMessage: "",
+                settled: false,
+                thoughtTurnOrdinal: 0,
+                assistantMessageOrdinal: -1,
+                activityCalls: new Map(),
+            };
+            let settleOutcome;
+            const outcome = new Promise((resolve, reject) => {
+                settleOutcome = {
+                    resolve(value) {
+                        if (state.settled)
+                            return;
+                        state.settled = true;
+                        resolve(value);
+                    },
+                    reject(error) {
+                        if (state.settled)
+                            return;
+                        state.settled = true;
+                        reject(error);
+                    },
+                };
+                unsub = bindPiSessionEvents(session, builder, checkpointController, state, settleOutcome);
+            });
+            outcome.catch(() => undefined);
+            const onAbort = () => {
+                void requestAbort(state)
+                    .catch((error) => {
+                    settleOutcome.reject(error);
+                })
+                    .finally(() => {
+                    if (!state.settled) {
+                        settleOutcome.reject(createAbortError(`${PI_PROVIDER} exec cancelled by client`));
+                    }
+                });
+            };
+            builder.signal.addEventListener("abort", onAbort, { once: true });
+            options.signal?.addEventListener("abort", onAbort, { once: true });
+            try {
+                if (builder.signal.aborted || options.signal?.aborted) {
+                    await requestAbort(state);
+                    throw createAbortError(`${PI_PROVIDER} exec cancelled by client`);
+                }
+                activePrompt = session.prompt(prompt).catch((error) => {
+                    if (state.settled) {
+                        return;
+                    }
+                    settleOutcome.reject(state.abortIntent ? createAbortError(`${PI_PROVIDER} exec cancelled by client`) : error);
+                });
+                const result = await outcome;
+                await activePrompt;
+                return result;
+            }
+            catch (error) {
+                if (state.abortIntent) {
+                    throw createAbortError(`${PI_PROVIDER} exec cancelled by client`);
+                }
+                throw error;
+            }
+            finally {
+                builder.signal.removeEventListener("abort", onAbort);
+                options.signal?.removeEventListener("abort", onAbort);
+                await abortRequested?.catch(() => undefined);
+                try {
+                    disposeSession();
+                }
+                finally {
+                    resolveRunSettled();
+                }
+            }
+        },
+    });
+}
+function readSessionManager(sdk) {
+    const store = sdk[`Session${"Man"}${"ager"}`];
+    return store;
+}

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

@@ -0,0 +1,41 @@
+import { emitProviderEvidence, sha256Utf8 } from "../../harness/runtime.js";
+export const PI_PROVIDER = "pi";
+export function toPiSdkThinkingLevel(effort) {
+    return effort; // opacity boundary
+}
+export function normalizeClearQueue(result) {
+    if (Array.isArray(result))
+        return result;
+    return [...(result.steering ?? []), ...(result.followUp ?? [])];
+}
+export function createPiCheckpointController(session, options) {
+    let submittedTurnOrdinal = 0;
+    let emitTurnStarted;
+    const enqueue = async (tell) => {
+        if (options.onEvidence)
+            emitProviderEvidence(options.onEvidence, { type: "outbound", provider: PI_PROVIDER, direction: "input", kind: "steer", ...sha256Utf8(tell.text) }, options.diagnostic());
+        if (tell.effort) {
+            if (!session.setThinkingLevel)
+                throw new Error(`${PI_PROVIDER} session does not support thinking level control`);
+            session.setThinkingLevel(toPiSdkThinkingLevel(tell.effort));
+        }
+        await session.steer(tell.text);
+        emitTurnStarted?.();
+        if (options.onEvidence)
+            emitProviderEvidence(options.onEvidence, { type: "ack", provider: PI_PROVIDER, fence: { kind: "ordinal", ordinal: submittedTurnOrdinal }, outbound: "steer" }, options.diagnostic());
+        return { fence: { kind: "ordinal", ordinal: submittedTurnOrdinal } };
+    };
+    const control = { enqueue };
+    return {
+        enqueue,
+        control,
+        setTurnStartedEmitter(emitter) { emitTurnStarted = emitter; },
+        completeTurn() {
+            submittedTurnOrdinal += 1;
+            const checkpoint = { fence: { kind: "ordinal", ordinal: submittedTurnOrdinal }, consumptionEvidence: true };
+            if (options.onEvidence)
+                emitProviderEvidence(options.onEvidence, { type: "checkpoint", provider: PI_PROVIDER, fence: checkpoint.fence, source: "notification" }, options.diagnostic());
+            options.onSyncCheckpoint?.(control, checkpoint);
+        },
+    };
+}

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

@@ -0,0 +1,282 @@
+import { SUBAGENT_SESSION_VERSION } from "../../session.js";
+import { activityCallFromNamedTool, boundActivityExcerpt, diffstatFromUnifiedPatch } from "../../harness/activity-values.js";
+import { AGENT_THOUGHT_TEXT_MAX_CHARS } from "../../harness/events.js";
+import { createAbortError } from "../../harness/runtime.js";
+import { SubagentFailure } from "../../types.js";
+import { PI_PROVIDER } from "./checkpoint.js";
+const PI_ACKNOWLEDGED_UNPERSISTED = new Set(["message_update", "queue_update"]);
+const PI_MAPPED = new Set(["agent_start", "agent_end", "turn_start", "turn_end", "message_start", "message_end", "tool_execution_start", "tool_execution_update", "tool_execution_end", "compaction_start", "compaction_end", "session_info_changed", "thinking_level_changed", "auto_retry_start", "auto_retry_end"]);
+function piIngressDisposition(type) {
+    if (PI_ACKNOWLEDGED_UNPERSISTED.has(type))
+        return "acknowledged-unpersisted";
+    if (PI_MAPPED.has(type))
+        return "mapped";
+    return "unknown";
+}
+function extractAssistantText(event) {
+    if (event.type === "message_end") {
+        const message = event.message;
+        if (message?.role !== "assistant")
+            return undefined;
+        return extractContentText(message.content);
+    }
+    return undefined;
+}
+function extractContentText(content) {
+    if (typeof content === "string") {
+        const trimmed = content.trim();
+        return trimmed || undefined;
+    }
+    if (!Array.isArray(content))
+        return undefined;
+    const text = content
+        .map((block) => {
+        if (typeof block === "string")
+            return block;
+        if (block &&
+            typeof block === "object" &&
+            block.type === "text") {
+            const candidate = block.text;
+            return typeof candidate === "string" ? candidate : "";
+        }
+        return "";
+    })
+        .join("")
+        .trim();
+    return text || undefined;
+}
+function emitPiThoughts(builder, event, turnOrdinal, messageOrdinal) {
+    if (event.type !== "message_end")
+        return;
+    const message = event.message;
+    if (message?.role !== "assistant" || !Array.isArray(message.content))
+        return;
+    message.content.forEach((block, blockIndex) => {
+        if (!block || typeof block !== "object")
+            return;
+        const record = block;
+        if (record.type !== "thinking" || record.redacted === true)
+            return;
+        if (typeof record.thinking !== "string" || record.thinking.trim().length === 0)
+            return;
+        const truncated = record.thinking.length > AGENT_THOUGHT_TEXT_MAX_CHARS;
+        builder.emit({
+            type: "thought",
+            id: `t${turnOrdinal}:m${messageOrdinal}:b${blockIndex}`,
+            text: record.thinking.slice(0, AGENT_THOUGHT_TEXT_MAX_CHARS),
+            final: true,
+            ...(truncated ? { truncated: true } : {}),
+        });
+    });
+}
+function piRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function piCallFacts(args) {
+    const value = piRecord(args);
+    if (!value)
+        return {};
+    return {
+        ...(typeof value.command === "string" ? { command: value.command } : {}),
+        ...(typeof value.description === "string" ? { description: value.description } : {}),
+        ...(typeof value.path === "string" ? { path: value.path } : {}),
+        ...(typeof value.offset === "number" && Number.isFinite(value.offset) ? { offset: value.offset } : {}),
+        ...(typeof value.limit === "number" && Number.isFinite(value.limit) ? { limit: value.limit } : {}),
+        ...(typeof value.query === "string" ? { query: value.query } : {}),
+    };
+}
+function piResult(value, isError) {
+    const payload = piRecord(value);
+    const content = Array.isArray(payload?.content)
+        ? payload.content.flatMap((entry) => {
+            const block = piRecord(entry);
+            return block?.type === "text" && typeof block.text === "string" ? [block.text] : [];
+        }).join("\n")
+        : undefined;
+    const details = piRecord(payload?.details);
+    const diffstat = typeof details?.patch === "string" ? diffstatFromUnifiedPatch(details.patch) : undefined;
+    return {
+        status: isError ? "error" : "ok",
+        ...(content ? { message: boundActivityExcerpt(content) } : {}),
+        ...(diffstat ? { diffstat } : {}),
+    };
+}
+function piActivityBody(event, calls) {
+    if (event.type !== "tool_execution_start" &&
+        event.type !== "tool_execution_update" &&
+        event.type !== "tool_execution_end") {
+        return undefined;
+    }
+    if (typeof event.toolCallId !== "string" || typeof event.toolName !== "string")
+        return undefined;
+    const phase = event.type === "tool_execution_start"
+        ? "started"
+        : event.type === "tool_execution_update"
+            ? "updated"
+            : "completed";
+    if (event.type === "tool_execution_start") {
+        calls.set(event.toolCallId, activityCallFromNamedTool(event.toolName, piCallFacts(event.args)));
+    }
+    const call = calls.get(event.toolCallId) ?? (event.type === "tool_execution_end"
+        ? { kind: "other", display: event.toolName }
+        : activityCallFromNamedTool(event.toolName, piCallFacts(event.args)));
+    if (event.type === "tool_execution_end")
+        calls.delete(event.toolCallId);
+    return {
+        type: "activity",
+        phase,
+        id: event.toolCallId,
+        tool: event.toolName,
+        call,
+        ...(event.type === "tool_execution_start"
+            ? {}
+            : { result: piResult(event.type === "tool_execution_update" ? event.partialResult : event.result, event.type === "tool_execution_end" && event.isError) }),
+    };
+}
+function piUsageBody(event) {
+    if (event.type !== "message_end")
+        return undefined;
+    const message = event.message;
+    if (message?.role !== "assistant")
+        return undefined;
+    const usage = message.usage;
+    if (!usage || typeof usage.input !== "number" || typeof usage.output !== "number")
+        return undefined;
+    return {
+        type: "usage",
+        inputTokens: usage.input,
+        outputTokens: usage.output,
+        ...(typeof usage.cacheRead === "number" ? { cachedInputTokens: usage.cacheRead } : {}),
+        ...(typeof usage.cost?.total === "number" ? { costUsd: usage.cost.total } : {}),
+        ...(typeof message.responseModel === "string"
+            ? { model: message.responseModel }
+            : typeof message.model === "string"
+                ? { model: message.model }
+                : {}),
+    };
+}
+/** True when native messages prove the run stopped via abort (stopReason aborted). */
+function agentEndLooksAborted(event) {
+    if (event.type !== "agent_end")
+        return false;
+    const messages = event.messages;
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const message = messages[i];
+        if (!message || message.role !== "assistant")
+            continue;
+        if (message.stopReason === "aborted")
+            return true;
+        // Last assistant message is the terminal one for this run.
+        break;
+    }
+    return false;
+}
+/** Returns the terminal Pi provider error, if the final assistant message ended in error. */
+function agentEndProviderError(event) {
+    if (event.type !== "agent_end")
+        return undefined;
+    const messages = event.messages;
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const message = messages[i];
+        if (!message || message.role !== "assistant")
+            continue;
+        if (message.stopReason !== "error")
+            return undefined;
+        if (typeof message.errorMessage === "string" && message.errorMessage.trim()) {
+            return message.errorMessage;
+        }
+        return `${PI_PROVIDER} provider error (stopReason error)`;
+    }
+    return undefined;
+}
+function buildPiSessionOutcome(session, finalMessage) {
+    const sessionFile = session.sessionFile;
+    if (!sessionFile) {
+        return new SubagentFailure("SUBAGENT_EXEC_ERROR", `${PI_PROVIDER} exec ended without a session file`);
+    }
+    return {
+        finalMessage,
+        session: {
+            provider: "pi",
+            version: SUBAGENT_SESSION_VERSION,
+            handle: {
+                sessionFile,
+                sessionId: session.sessionId,
+            },
+        },
+    };
+}
+export function bindPiSessionEvents(session, builder, controller, state, settle) {
+    return session.subscribe((event) => {
+        builder.ingress(PI_PROVIDER, event.type, event, piIngressDisposition(event.type), () => {
+            if (event.type === "agent_start") {
+                builder.emit({ type: "turn", phase: "started" });
+            }
+            if (event.type === "turn_start") {
+                state.thoughtTurnOrdinal += 1;
+                state.assistantMessageOrdinal = -1;
+                state.activeAssistantMessageOrdinal = undefined;
+            }
+            if (event.type === "message_start") {
+                const message = event.message;
+                if (message?.role === "assistant") {
+                    state.assistantMessageOrdinal += 1;
+                    state.activeAssistantMessageOrdinal = state.assistantMessageOrdinal;
+                }
+            }
+            const activity = piActivityBody(event, state.activityCalls);
+            if (activity)
+                builder.emit(activity);
+            if (event.type === "message_end") {
+                const message = event.message;
+                if (message?.role === "assistant") {
+                    if (state.activeAssistantMessageOrdinal === undefined) {
+                        state.assistantMessageOrdinal += 1;
+                        state.activeAssistantMessageOrdinal = state.assistantMessageOrdinal;
+                    }
+                    const messageId = `pi-assistant-${state.activeAssistantMessageOrdinal}`;
+                    emitPiThoughts(builder, event, state.thoughtTurnOrdinal, state.activeAssistantMessageOrdinal);
+                    const assistantText = extractAssistantText(event);
+                    if (assistantText) {
+                        state.lastAssistantMessage = assistantText;
+                        builder.emit({ type: "message", id: messageId, text: assistantText });
+                    }
+                    state.activeAssistantMessageOrdinal = undefined;
+                }
+            }
+            const usage = piUsageBody(event);
+            if (usage)
+                builder.emit(usage);
+            if (event.type === "turn_end" && !state.abortIntent)
+                controller.completeTurn();
+            if (event.type !== "agent_end" || state.settled) {
+                return;
+            }
+            if (state.abortIntent || agentEndLooksAborted(event)) {
+                settle.reject(createAbortError(`${PI_PROVIDER} exec cancelled by client`));
+                return;
+            }
+            if (event.willRetry) {
+                return;
+            }
+            const providerError = agentEndProviderError(event);
+            if (providerError) {
+                const failure = new SubagentFailure("SUBAGENT_EXEC_ERROR", providerError);
+                builder.emit({ type: "fail", message: failure.message });
+                settle.reject(failure);
+                return;
+            }
+            const outcome = buildPiSessionOutcome(session, state.lastAssistantMessage);
+            if (outcome instanceof SubagentFailure) {
+                builder.emit({ type: "fail", message: outcome.message });
+                settle.reject(outcome);
+                return;
+            }
+            builder.emit({ type: "turn", phase: "completed" });
+            builder.emit({ type: "done", finalMessage: outcome.finalMessage, session: outcome.session });
+            settle.resolve(outcome);
+        });
+    });
+}

package/build/agents/{selector_v2.js → selector.js}

@@ -1,6 +1,8 @@
 import { getConfig } from "../config/env.js";
-import { loadAkumaCatalogV2, } from "../config/akuma-loader_v2.js";
-import { assertSettingsKnobUsable, loadKeiyakuSettings, resolveDefaultAgentName, } from "../config/settings.js";
+import { loadAkumaCatalog, } from "../config/akuma-loader.js";
+import { assertSettingsKnobUsable } from "../config/settings/disease.js";
+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"];
@@ -32,7 +34,7 @@ const SUPPORTED_EXPLICIT = {
         webSearch: new Set(),
     },
 };
-export function formatAvailableAgentNamesV2(names) {
+export function formatAvailableAgentNames(names) {
     if (names.length === 0)
         return "(none configured)";
     return [...names].sort().join(", ");
@@ -78,7 +80,7 @@ function freezeResolvedProfile(profile) {
         effortOptions: Object.freeze([...profile.effortOptions]),
     });
 }
-export async function selectSubagentV2(agentName, cwd) {
+export async function selectSubagent(agentName, cwd) {
     const loaded = await loadKeiyakuSettings(cwd);
     assertSettingsKnobUsable(loaded, "agents");
     const settings = loaded.knobs;
@@ -87,11 +89,11 @@ export async function selectSubagentV2(agentName, cwd) {
         assertSettingsKnobUsable(loaded, "default");
     }
     const selected = requested || getConfig().subagent.nameOverride || resolveDefaultAgentName(settings);
-    const catalog = await loadAkumaCatalogV2(cwd);
+    const catalog = await loadAkumaCatalog(cwd);
     const availableNames = Object.keys(catalog.selected);
     const candidate = catalog.selected[selected];
     if (candidate === undefined) {
-        throw new FlowError("UNKNOWN_SUBAGENT", `Unknown agent '${selected}'. Expected one of: ${formatAvailableAgentNamesV2(availableNames)}`);
+        throw new FlowError("UNKNOWN_SUBAGENT", `Unknown agent '${selected}'. Expected one of: ${formatAvailableAgentNames(availableNames)}`);
     }
     if (!isValidAkumaCandidate(candidate)) {
         throw new FlowError("INVALID_SETTINGS", `Akuma '${selected}' is invalid: ${candidate.reason}`);

package/build/cli/commands/akuma/akuma/handler.js

@@ -0,0 +1,4 @@
+import { missingSubcommandError } from "../../../help.js";
+export const handler = async () => {
+    throw missingSubcommandError("akuma", ["ls", "view"]);
+};

package/build/cli/commands/akuma/akuma/meta.js

@@ -0,0 +1,16 @@
+export const meta = {
+    command: "akuma",
+    summary: "Inspect Akuma profiles",
+    usage: ["keiyaku akuma ls|view"],
+    stdin: "none",
+    flags: [],
+    purpose: "Inspect configured helper profiles.",
+    subcommands: ["ls", "view"],
+    notes: [
+        "Define user profiles in <KEIYAKU_HOME>/akuma/<name>.md.",
+        "Define project profiles in .keiyaku/akuma/<name>.md.",
+        "See README Configuration for the Markdown frontmatter format.",
+    ],
+    examples: ["keiyaku akuma ls", "keiyaku akuma view akuma-codex"],
+    completionRank: 6,
+};

package/build/cli/commands/akuma/catalog.js

@@ -0,0 +1,8 @@
+import { meta as akumaMeta } from "./akuma/meta.js";
+import { meta as lsMeta } from "./list/meta-ls.js";
+import { meta as viewMeta } from "./view/meta.js";
+export const akumaCatalog = [
+    { meta: akumaMeta, load: () => import("./akuma/handler.js") },
+    { meta: lsMeta, load: () => import("./list/handler.js") },
+    { meta: viewMeta, load: () => import("./view/handler.js") },
+];