@astrosheep/keiyaku 1.0.0 → 1.0.2

package/skills/keiyaku-akuma/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: keiyaku-akuma
+description: Use when you need to dispatch an Akuma to do work for you — call a demon, check on it, yell more instructions, or continue from a prior turn.
+allowed-tools: Bash(keiyaku *)
+---
+
+# Keiyaku Akuma
+
+```bash
+keiyaku akuma list
+keiyaku <command> --help
+```
+
+Contract work = `keiyaku` skill. This skill = helpers only.
+
+## Two ids
+
+| Id | Means | Use with |
+| --- | --- | --- |
+| projection id | live who | `wait`, `tell`, `status` |
+| artifact id | saved answer | `revive` |
+
+## Daily path
+
+```bash
+keiyaku call NAME "task..."                   # launch + foreground join (no CLI --timeout)
+keiyaku call NAME --detach "task..."          # return after launch; keep projection id
+keiyaku wait <projection-id>                  # join until terminal; prints activity list
+keiyaku wait <projection-id> --timeout 5m     # bounded join; timeout keeps projection alive
+keiyaku tell <projection-id> "more..."        # mailbox only; does not wait
+keiyaku wait <projection-id> --timeout 10m    # after tell, rejoin to see progress/outcome
+keiyaku status                                # board + compact activity summary; rediscover ids
+keiyaku revive ARTIFACT_ID                    # new life from saved answer
+```
+
+Long prompt: `keiyaku call NAME - < prompt.md`
+
+## Timeouts (do not confuse)
+
+| Surface | Behavior |
+| --- | --- |
+| `call` / `revive` | **No** CLI `--timeout`. Foreground call joins until terminal or signal. |
+| `call --detach` | Returns after launch. Bounded watching is done with `wait --timeout`. |
+| `wait --timeout DURATION` | Only wait command. Forms: `45s`, `5m`, `2h` (max `24h`). Omit = wait until terminal. Timeout exit is a snapshot, not death. |
+| Worker kill (env) | `KEIYAKU_SUBAGENT_EXEC_TIMEOUT_MS` (default 2700000), `KEIYAKU_SUBAGENT_EXEC_IDLE_TIMEOUT_MS` (default 600000). Not CLI flags. |
+| Startup stall | Adoption timeout → wait/status can show `startup timed out` (launch never adopted). |
+
+## Tell vs wait
+
+- `tell` writes mailbox intent and may wake when eligible. It does **not** join.
+- After tell: run `wait` (optionally `--timeout`) for outcome and activity.
+- While pending tells exist, wait header can show `N tells waiting`.
+
+## Activity list
+
+No separate `activity` command.
+
+- **`wait`**: full activity timeline (tools/turns) under the projection header.
+- **`status`**: under `akuma` section, compact per-projection activity summary + tell counts.
+
+Lost the outer handle → `status` to find projection id → `wait` for the list.
+
+## Infrastructure
+
+- `-C` / `--cwd DIR` — effective command directory (all akuma commands)
+
+## Other flags
+
+- `--akuma NAME` — start a session with the named agent (call only)
+- `--incognito` — no response artifact, no later revive (call only)
+- `@addr` / `--contract` — attach commission/arc context when present (call, wait, tell)
+- `--bare` — skip contract attachment only (call only)
+- `--effort LEVEL` — override opaque provider-native effort value (call, revive, tell); must match profile allowlist when set
+
+Profiles: `keiyaku akuma list|show`; user `<KEIYAKU_HOME>/akuma/`, project `.keiyaku/akuma/`.

package/build/agents/effective-policy.js

@@ -1,32 +0,0 @@
-import { FlowError } from "../flow-error.js";
-function deepOverlay(base, extra) {
-    const next = {};
-    for (const key of Object.keys(base))
-        Object.defineProperty(next, key, { value: base[key], enumerable: true, configurable: true, writable: true });
-    for (const key of Object.keys(extra)) {
-        const value = extra[key];
-        const prior = Object.prototype.hasOwnProperty.call(next, key) ? next[key] : undefined;
-        const merged = value && typeof value === "object" && !Array.isArray(value)
-            ? prior && typeof prior === "object" && !Array.isArray(prior)
-                ? deepOverlay(prior, value)
-                : deepOverlay({}, value)
-            : value;
-        Object.defineProperty(next, key, { value: merged, enumerable: true, configurable: true, writable: true });
-    }
-    return next;
-}
-export function resolveEffectiveCodexSdkProfile(profile, cwd, overrides = {}) {
-    if (profile.webSearchPolicy === "cached" || profile.webSearchPolicy === "live")
-        throw new FlowError("UNSUPPORTED_POLICY", `Codex SDK unified webSearchPolicy '${profile.webSearchPolicy}' is unsupported because native web-search capability was not proven with either networkAccessEnabled=false or networkAccessEnabled=true; this restriction can be lifted only by future real native tool-provisioning evidence.`);
-    const unified = {
-        sandboxMode: profile.accessPolicy === "read" ? "read-only" : "workspace-write",
-        networkAccessEnabled: profile.networkPolicy === "enabled",
-        webSearchMode: profile.webSearchPolicy ?? "disabled",
-        ...(profile.model ? { model: profile.model } : {}),
-        ...(profile.effort ? { modelReasoningEffort: profile.effort === "max" ? "xhigh" : profile.effort } : {}),
-    };
-    const native = deepOverlay(unified, profile.threadOptions ?? {});
-    const threadOptions = { ...native, ...(overrides.model ? { model: overrides.model } : {}), ...(overrides.effort ? { modelReasoningEffort: overrides.effort === "max" ? "xhigh" : overrides.effort } : {}), workingDirectory: cwd, skipGitRepoCheck: true };
-    const policy = { ...(threadOptions.sandboxMode === "read-only" ? { accessPolicy: "read" } : threadOptions.sandboxMode === "workspace-write" || threadOptions.sandboxMode === "danger-full-access" ? { accessPolicy: "write" } : {}), ...(typeof threadOptions.networkAccessEnabled === "boolean" ? { networkPolicy: threadOptions.networkAccessEnabled ? "enabled" : "disabled" } : {}), ...(threadOptions.webSearchMode === "disabled" || threadOptions.webSearchMode === "cached" || threadOptions.webSearchMode === "live" ? { webSearchPolicy: threadOptions.webSearchMode } : {}) };
-    return Object.freeze({ provider: "codex-sdk", executable: profile.executable, ...(profile.profile ? { profile: profile.profile } : {}), ...(profile.config ? { config: profile.config } : {}), ...(typeof threadOptions.model === "string" ? { model: threadOptions.model } : {}), threadOptions: Object.freeze(threadOptions), effectivePolicy: Object.freeze(policy) });
-}

package/build/agents/index.js

@@ -1,114 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { EFFORT_LEVELS } from "../keiyaku.js";
-import { resolveEffectiveCodexSdkProfile } from "./effective-policy.js";
-import { getConfig } from "../config/env.js";
-import { selectSubagent } from "./selector.js";
-export { formatAvailableAgentNames } from "./selector.js";
-export function createAbortError(message) {
-    const error = new Error(message);
-    error.name = "AbortError";
-    return error;
-}
-export function coerceString(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
-}
-function codexEffort(config) {
-    const value = config?.model_reasoning_effort;
-    return typeof value === "string" && EFFORT_LEVELS.includes(value) ? value : undefined;
-}
-export async function resolveSubagentConfig(agentName, cwd) {
-    return (await selectSubagent(agentName, cwd)).profile;
-}
-function maxCaptureCharsForProvider(provider) {
-    const config = getConfig();
-    switch (provider) {
-        case "codex-sdk":
-            return config.codex.execMaxCaptureChars;
-        case "codex-app-server":
-            return config.codex.execMaxCaptureChars;
-        case "claude-agent-sdk":
-            return config.claude.execMaxCaptureChars;
-        case "opencode-sdk":
-            return config.opencode.execMaxCaptureChars;
-        case "pi":
-            return config.codex.execMaxCaptureChars;
-    }
-}
-export function buildSummonTerms(config, prompt, cwd, options) {
-    const runtimeConfig = getConfig();
-    const baseTerms = {
-        workdir: cwd,
-        prompt,
-        timeoutMs: options.timeoutMs ?? runtimeConfig.subagent.execTimeoutMs,
-        idleTimeoutMs: options.idleTimeoutMs ?? runtimeConfig.subagent.execIdleTimeoutMs,
-        maxCaptureChars: maxCaptureCharsForProvider(config.provider),
-        signal: options.signal,
-        projectionDir: options.projectionDir,
-        projectionExecutionId: options.projectionExecutionId,
-    };
-    const body = options.akumaBody;
-    const replayPrompt = body ? `[Akuma system prompt]\n${body}\n\n[Operator prompt]\n${prompt}` : prompt;
-    switch (config.provider) {
-        case "codex-sdk":
-            {
-                const effective = "effectivePolicy" in config && config.threadOptions
-                    ? config
-                    : resolveEffectiveCodexSdkProfile(config, cwd, {});
-                return {
-                    ...baseTerms, prompt: replayPrompt,
-                    provider: "codex-sdk",
-                    model: effective.model,
-                    profile: effective.profile,
-                    config: effective.config,
-                    threadOptions: effective.threadOptions,
-                    effectivePolicy: effective.effectivePolicy,
-                    executable: effective.executable,
-                };
-            }
-        case "codex-app-server":
-            return {
-                ...baseTerms,
-                provider: "codex-app-server",
-                model: config.model,
-                effort: codexEffort(config.config),
-                profile: config.profile,
-                config: config.config,
-                executable: config.executable,
-                developerInstructions: body || undefined,
-                onCheckpoint() { },
-            };
-        case "claude-agent-sdk":
-            return {
-                ...baseTerms,
-                provider: "claude-agent-sdk",
-                model: config.model,
-                executable: config.executable,
-                effort: config.effort,
-                permissionMode: config.permissionMode,
-                settingSources: config.settingSources,
-                systemPrompt: body ? { type: "preset", preset: "claude_code", append: body } : undefined,
-                onCheckpoint() { },
-            };
-        case "opencode-sdk":
-            return {
-                ...baseTerms, prompt: replayPrompt,
-                provider: "opencode-sdk",
-                model: config.model,
-                executable: config.executable,
-            };
-        case "pi":
-            return {
-                ...baseTerms,
-                provider: "pi",
-                model: config.model,
-                thinkingLevel: config.thinkingLevel,
-                appendSystemPromptOverride: body ? () => [body] : undefined,
-                onCheckpoint() { },
-            };
-        default:
-            return assertNever(config);
-    }
-}
-function assertNever(_value) {
-    throw new FlowError("INVALID_SETTINGS", "Unsupported subagent provider.");
-}

package/build/agents/selector.js

@@ -1,28 +0,0 @@
-import { getConfig } from "../config/env.js";
-import { assertSettingsKnobUsable, loadKeiyakuSettings, resolveDefaultAgentName, } from "../config/settings.js";
-import { loadAkumaCatalog, normalizeAkumaProfile } from "../config/akuma-loader.js";
-import { FlowError } from "../flow-error.js";
-export function formatAvailableAgentNames(names) {
-    return names.length > 0 ? names.join(", ") : "(none configured)";
-}
-export async function selectSubagent(agentName, cwd) {
-    const loaded = await loadKeiyakuSettings(cwd);
-    assertSettingsKnobUsable(loaded, "agents");
-    const settings = loaded.knobs;
-    const requested = agentName?.trim();
-    if (!requested && !getConfig().subagent.nameOverride) {
-        assertSettingsKnobUsable(loaded, "default");
-    }
-    const selected = requested || getConfig().subagent.nameOverride || resolveDefaultAgentName(settings);
-    const catalog = await loadAkumaCatalog(cwd);
-    const availableNames = Object.keys(catalog.definitions);
-    if (!availableNames.includes(selected)) {
-        throw new FlowError("UNKNOWN_SUBAGENT", `Unknown agent '${selected}'. Expected one of: ${formatAvailableAgentNames(availableNames)}`);
-    }
-    const definition = catalog.definitions[selected];
-    return {
-        name: selected,
-        definition,
-        profile: normalizeAkumaProfile(definition.profile),
-    };
-}

package/build/cli/render/summon.js

@@ -1,17 +0,0 @@
-import { assembleResponse, buildPayload, buildSection, formatMaybe, formatWarnings } from "./format.js";
-import { WARNING_SECTION_TITLE } from "./response-style.js";
-import { CONTENT_SECTION_TITLE, formatSummonPersistenceSummary, INFO_AGENT_MAX_CHARS, SUMMON_RESPONSE_HEADING, } from "./shared.js";
-export function buildSummonResponse(result, input) {
-    const infoLines = [
-        ...formatMaybe("Agent", result.agent ?? input.agent, INFO_AGENT_MAX_CHARS),
-    ];
-    const summarySection = buildSection(CONTENT_SECTION_TITLE, result.summary);
-    const warningSection = buildSection(WARNING_SECTION_TITLE, formatWarnings(result.meta?.warnings ?? []));
-    const persistedSummary = formatSummonPersistenceSummary(input.responsePath);
-    const text = assembleResponse(SUMMON_RESPONSE_HEADING, persistedSummary, [summarySection, warningSection].filter((s) => s !== null), infoLines);
-    const { session: _session, ...responseData } = result;
-    return {
-        text,
-        payload: buildPayload(responseData, input.responsePath),
-    };
-}

package/build/cli/render/tell.js

@@ -1,11 +0,0 @@
-export function renderTellReceipt(id, state) {
-    if (state === "active")
-        return `Tell ${id} delivered to the active generation.\n`;
-    if (state === "woken")
-        return `Tell ${id} accepted; waking the projection.\n`;
-    if (state === "lost")
-        return `Tell ${id} remains durable in the mailbox.\ndelivery: next-generation-replay\nnextAction: Run keiyaku resume --projection ${id}.\n`;
-    if (state === "terminal")
-        return `Tell ${id} remains in the mailbox. Run keiyaku resume --projection ${id}.\n`;
-    return `Tell ${id} accepted in the mailbox.\n`;
-}

package/build/config/akuma-loader.js

@@ -1,268 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { z } from "zod";
-import { parseToAST } from "../core/markdown/parser.js";
-import { BUILTIN_AGENT_PROFILES, CLAUDE_DEFAULT_PERMISSION_MODE, CLAUDE_DEFAULT_SETTING_SOURCES, CLAUDE_EFFORT_LEVELS, CLAUDE_PERMISSION_MODES, CLAUDE_SETTING_SOURCES, } from "../keiyaku.js";
-import { getKeiyakuHome } from "./env.js";
-import { agentNameSchema } from "./settings.js";
-function defaultExecutable(provider) {
-    if (provider === "codex-sdk" || provider === "codex-app-server")
-        return "codex";
-    if (provider === "claude-agent-sdk")
-        return "claude";
-    if (provider === "pi")
-        return "pi";
-    return "opencode";
-}
-export function normalizeAkumaProfile(profile) {
-    const executable = "executable" in profile && profile.executable ? profile.executable : defaultExecutable(profile.provider);
-    if (profile.provider === "codex-sdk" || profile.provider === "codex-app-server") {
-        return Object.freeze({ ...profile, executable, config: profile.config });
-    }
-    if (profile.provider === "claude-agent-sdk") {
-        return Object.freeze({ ...profile, executable, permissionMode: profile.permissionMode ?? CLAUDE_DEFAULT_PERMISSION_MODE, settingSources: Object.freeze([...(profile.settingSources ?? CLAUDE_DEFAULT_SETTING_SOURCES)]) });
-    }
-    return Object.freeze({ ...profile, executable });
-}
-const executableSchema = z.string().superRefine((value, ctx) => {
-    if (/\s/.test(value) || value.includes("\"") || value.includes("'")) {
-        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "must be a single program name token with no spaces or quotes." });
-    }
-});
-const codexFields = {
-    description: z.string().optional(),
-    model: z.string().optional(),
-    profile: z.string().optional(),
-    executable: executableSchema.optional(),
-    config: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).optional(),
-};
-const policyFields = {
-    accessPolicy: z.enum(["read", "write"]).optional(),
-    networkPolicy: z.enum(["disabled", "enabled"]).optional(),
-    webSearchPolicy: z.enum(["disabled", "cached", "live"]).optional(),
-};
-const codexSdkFields = {
-    ...codexFields,
-    ...policyFields,
-    effort: z.enum(CLAUDE_EFFORT_LEVELS).optional(),
-    threadOptions: z.record(z.string(), z.unknown()).optional(),
-};
-const profileSchema = z.discriminatedUnion("provider", [
-    z.object({ provider: z.literal("codex-sdk"), ...codexSdkFields }).strict(),
-    z.object({ provider: z.literal("codex-app-server"), ...codexFields, ...policyFields }).strict(),
-    z.object({ provider: z.literal("claude-agent-sdk"), description: z.string().optional(), model: z.string().optional(), executable: executableSchema.optional(), effort: z.enum(CLAUDE_EFFORT_LEVELS).optional(), permissionMode: z.enum(CLAUDE_PERMISSION_MODES).optional(), settingSources: z.array(z.enum(CLAUDE_SETTING_SOURCES)).optional(), ...policyFields }).strict(),
-    z.object({ provider: z.literal("opencode-sdk"), description: z.string().optional(), model: z.string().optional(), executable: executableSchema.optional(), ...policyFields }).strict(),
-    z.object({ provider: z.literal("pi"), description: z.string().optional(), model: z.string().optional(), ...policyFields }).strict(),
-]);
-function formatIssues(error) {
-    return error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
-}
-function decodeConfigValue(value) {
-    if (value === "true")
-        return true;
-    if (value === "false")
-        return false;
-    if (/^-?\d+$/.test(value))
-        return Number.parseInt(value, 10);
-    if (/^-?\d+\.\d+$/.test(value))
-        return Number.parseFloat(value);
-    return value;
-}
-function stripFrontMatterQuote(rawValue) {
-    const value = rawValue.trim();
-    if (value.length < 2)
-        return value;
-    const quote = value[0];
-    return (quote === "'" || quote === '"') && value.at(-1) === quote ? value.slice(1, -1) : value;
-}
-function splitFrontMatter(content) {
-    const ast = parseToAST(content, { allowSections: false });
-    if (ast.frontmatter === undefined) {
-        throw new Error("missing leading YAML frontmatter");
-    }
-    const lines = content.split(/\r?\n/);
-    let closingIndex = -1;
-    for (let index = 1; index < lines.length; index += 1) {
-        if ((lines[index] ?? "").trim() === "---") {
-            closingIndex = index;
-            break;
-        }
-    }
-    if (closingIndex === -1)
-        throw new Error("frontmatter is not closed");
-    const entries = [];
-    for (const line of lines.slice(1, closingIndex)) {
-        const match = line.trim().match(/^([A-Za-z0-9_.-]+)\s*:\s*(.*)$/);
-        if (match)
-            entries.push([match[1] ?? "", stripFrontMatterQuote(match[2] ?? "")]);
-    }
-    return { entries, body: lines.slice(closingIndex + 1).join("\n") };
-}
-function isNativeObject(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function hasOwn(record, key) {
-    return Object.prototype.hasOwnProperty.call(record, key);
-}
-function defineOwn(record, key, value) {
-    Object.defineProperty(record, key, { value, enumerable: true, configurable: true, writable: true });
-}
-function nativeAssemblyValue(value) {
-    if (!isNativeObject(value))
-        return value;
-    const record = Object.create(null);
-    for (const key of Object.keys(value))
-        defineOwn(record, key, nativeAssemblyValue(value[key]));
-    return record;
-}
-function materializeNativeValue(value) {
-    if (!isNativeObject(value))
-        return value;
-    const record = Object.create(null);
-    for (const key of Object.keys(value))
-        defineOwn(record, key, materializeNativeValue(value[key]));
-    Object.setPrototypeOf(record, Object.prototype);
-    return record;
-}
-function mergeNativeValue(existing, incoming, path) {
-    const existingObject = isNativeObject(existing);
-    const incomingObject = isNativeObject(incoming);
-    if (existingObject !== incomingObject)
-        throw new Error(`${path} has a scalar/object collision`);
-    if (!existingObject || !incomingObject) {
-        if (!Object.is(existing, incoming))
-            throw new Error(`${path} has contradictory scalar values`);
-        return existing;
-    }
-    for (const key of Object.keys(incoming)) {
-        const childPath = `${path}.${key}`;
-        if (hasOwn(existing, key))
-            defineOwn(existing, key, mergeNativeValue(existing[key], incoming[key], childPath));
-        else
-            defineOwn(existing, key, nativeAssemblyValue(incoming[key]));
-    }
-    return existing;
-}
-function decodeNativeValue(value) {
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return value;
-    }
-}
-function insertNativePath(root, segments, decoded) {
-    let target = root;
-    const fullPath = `threadOptions.${segments.join(".")}`;
-    for (const segment of segments.slice(0, -1)) {
-        if (!hasOwn(target, segment))
-            defineOwn(target, segment, Object.create(null));
-        const existing = target[segment];
-        if (!isNativeObject(existing))
-            throw new Error(`${fullPath} has a scalar/object collision`);
-        target = existing;
-    }
-    const leaf = segments.at(-1);
-    const incoming = nativeAssemblyValue(decoded);
-    if (hasOwn(target, leaf))
-        defineOwn(target, leaf, mergeNativeValue(target[leaf], incoming, fullPath));
-    else
-        defineOwn(target, leaf, incoming);
-}
-function decodeProfile(entries) {
-    const raw = {};
-    let nativeThreadOptions;
-    for (const [key, value] of entries) {
-        if (key.startsWith("threadOptions.")) {
-            const segments = key.slice("threadOptions.".length).split(".");
-            if (segments.some((segment) => !segment))
-                throw new Error("threadOptions.* keys must name a path");
-            if (segments[0] === "workingDirectory" || segments[0] === "skipGitRepoCheck")
-                throw new Error(`threadOptions.${segments[0]} is reserved by Keiyaku`);
-            nativeThreadOptions ??= Object.create(null);
-            insertNativePath(nativeThreadOptions, segments, decodeNativeValue(value));
-            continue;
-        }
-        if (key.startsWith("config.")) {
-            const configKey = key.slice("config.".length);
-            if (configKey.length === 0)
-                throw new Error("config.* keys must name a config field");
-            if (/^[\[{]/.test(value.trim()))
-                throw new Error(`config.${configKey} cannot express arrays or nested tables`);
-            const config = (raw.config ??= {});
-            config[configKey] = decodeConfigValue(value);
-            continue;
-        }
-        if (key === "settingSources") {
-            const values = value.split(",").map((token) => token.trim());
-            if (values.some((token) => token.length === 0))
-                throw new Error("settingSources must not contain an empty token");
-            raw[key] = values;
-            continue;
-        }
-        raw[key] = value;
-    }
-    const parsed = profileSchema.safeParse(nativeThreadOptions ? { ...raw, threadOptions: {} } : raw);
-    if (!parsed.success)
-        throw new Error(formatIssues(parsed.error));
-    if (parsed.data.provider === "codex-sdk") {
-        const forbidden = Object.keys(parsed.data.config ?? {}).find((key) => key === "model" || key === "model_reasoning_effort" || key === "sandbox_mode" || key === "sandbox_workspace_write" || key.startsWith("sandbox_workspace_write.") || key === "web_search" || key === "approval_policy");
-        if (forbidden)
-            throw new Error(`config.${forbidden} is forbidden for codex-sdk; use ${forbidden === "model_reasoning_effort" ? "effort" : "native profile fields"} instead`);
-    }
-    return nativeThreadOptions
-        ? { ...parsed.data, threadOptions: materializeNativeValue(nativeThreadOptions) }
-        : parsed.data;
-}
-async function readLayer(directory, source, invalid) {
-    let entries;
-    try {
-        entries = await fs.readdir(directory, { withFileTypes: true });
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return [];
-        invalid.push({ name: `${source}-akuma-directory`, file: directory, reason: `unable to read akuma directory (${error instanceof Error ? error.message : String(error)})` });
-        return [];
-    }
-    const definitions = [];
-    for (const entry of entries.filter((candidate) => candidate.isFile() && candidate.name.endsWith(".md")).sort((a, b) => a.name.localeCompare(b.name))) {
-        const file = path.join(directory, entry.name);
-        const name = path.basename(entry.name, ".md");
-        const nameResult = agentNameSchema.safeParse(name);
-        if (!nameResult.success) {
-            invalid.push({ name, file, reason: `invalid akuma name: ${formatIssues(nameResult.error)}` });
-            continue;
-        }
-        try {
-            const content = await fs.readFile(file, "utf-8");
-            const { entries: frontmatter, body } = splitFrontMatter(content);
-            definitions.push({ name, source, path: file, body, profile: decodeProfile(frontmatter) });
-        }
-        catch (error) {
-            invalid.push({ name, file, reason: error instanceof Error ? error.message : String(error) });
-        }
-    }
-    return definitions;
-}
-export async function loadAkumaCatalog(cwd) {
-    const invalid = [];
-    const definitions = {};
-    const shadows = [];
-    for (const [name, profile] of Object.entries(BUILTIN_AGENT_PROFILES)) {
-        definitions[name] = { name, source: "builtin", path: null, body: "", profile };
-    }
-    for (const definition of await readLayer(path.join(getKeiyakuHome(), "akuma"), "user", invalid)) {
-        const prior = definitions[definition.name];
-        if (prior !== undefined)
-            shadows.push({ name: prior.name, source: prior.source, path: prior.path, shadowedBy: definition.source });
-        definitions[definition.name] = definition;
-    }
-    for (const definition of await readLayer(path.join(cwd, ".keiyaku", "akuma"), "project", invalid)) {
-        const prior = definitions[definition.name];
-        if (prior !== undefined)
-            shadows.push({ name: prior.name, source: prior.source, path: prior.path, shadowedBy: definition.source });
-        definitions[definition.name] = definition;
-    }
-    return { definitions, shadows, invalid };
-}

package/build/core/queue.js

@@ -1,73 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { appendRefLogWithRetry, readRefLog } from "./ref-log.js";
-export const QUEUE_REF = "refs/keiyaku/queue";
-function parseQueueEntry(message) {
-    const body = message.slice(message.indexOf("\n\n") + 2).trim();
-    const parsed = JSON.parse(body);
-    if (parsed.v !== 1 || (parsed.kind !== "enqueue" && parsed.kind !== "dequeue") || !parsed.contract) {
-        throw new FlowError("INTERNAL_STATE", `invalid queue entry for ${QUEUE_REF}`);
-    }
-    return parsed;
-}
-function queueSubject(entry) {
-    return `keiyaku queue: ${entry.kind} ${entry.contract}`;
-}
-export function queuedContracts(entries) {
-    const queued = new Set();
-    const ordered = [];
-    for (const entry of entries) {
-        if (entry.kind === "enqueue") {
-            if (queued.has(entry.contract))
-                continue;
-            queued.add(entry.contract);
-            ordered.push(entry.contract);
-            continue;
-        }
-        if (!queued.delete(entry.contract))
-            continue;
-        const index = ordered.indexOf(entry.contract);
-        if (index >= 0)
-            ordered.splice(index, 1);
-    }
-    return ordered;
-}
-export function queuePositionFromEntries(entries, contractId) {
-    const position = queuedContracts(entries).findIndex((id) => id === contractId);
-    return position < 0 ? null : position + 1;
-}
-export function queuePositionsFromEntries(entries) {
-    return new Map(queuedContracts(entries).map((id, index) => [id, index + 1]));
-}
-export async function readQueue(cwd) {
-    return readRefLog(cwd, QUEUE_REF, parseQueueEntry);
-}
-export async function queuePosition(cwd, contractId) {
-    return queuePositionFromEntries(await readQueue(cwd), contractId);
-}
-export async function enqueueContract(cwd, input) {
-    const result = await appendRefLogWithRetry(cwd, QUEUE_REF, queueSubject, parseQueueEntry, (entries) => {
-        if (queuedContracts(entries).includes(input.contractId))
-            return null;
-        return { v: 1, kind: "enqueue", contract: input.contractId, at: input.at, actor: input.actor };
-    });
-    if (!result.ok) {
-        if (result.reason === "aborted") {
-            return { head: result.currentHead ?? "", position: (await queuePosition(cwd, input.contractId)) ?? 0 };
-        }
-        throw new FlowError("INTERNAL_STATE", `failed to enqueue contract ${input.contractId}: ${result.reason}`);
-    }
-    return { head: result.head, position: (await queuePosition(cwd, input.contractId)) ?? 0 };
-}
-export async function dequeueContract(cwd, input) {
-    const result = await appendRefLogWithRetry(cwd, QUEUE_REF, queueSubject, parseQueueEntry, (entries) => {
-        if (!queuedContracts(entries).includes(input.contractId))
-            return null;
-        return { v: 1, kind: "dequeue", contract: input.contractId, at: input.at, actor: input.actor };
-    });
-    if (!result.ok) {
-        if (result.reason === "aborted")
-            return { head: result.currentHead };
-        throw new FlowError("INTERNAL_STATE", `failed to dequeue contract ${input.contractId}: ${result.reason}`);
-    }
-    return { head: result.head };
-}