@astrosheep/keiyaku 2.8.4 → 2.9.0

package/build/cli/render/status.js

@@ -1,15 +1,50 @@
-import { formatSettingsDiseases } from "../../config/settings.js";
-import { formatAgeMs, projectionGlyph, renderKanshiBoard, shortCommitHash } from "../../core/render.js";
+import { formatSettingsDiseases } from "../../config/settings/disease.js";
+import { shortCommitHash } from "../../git/commits.js";
+import { formatAgeMs } from "./format.js";
+import { renderKanshiBoard } from "./kanshi.js";
 import { renderProjectionActivitySummary, } from "./projection-activity.js";
 export const STATUS_DISEASES_SECTION_TITLE = "Diseases";
 export const STATUS_PROJECTION_SECTION_TITLE = "akuma";
 export const STATUS_CLAIM_RECEIPTS_SECTION_TITLE = "claim receipts";
-export function renderSettingsDiseasesSection(diseases) {
-    if (diseases.length === 0)
+function projectionGlyph(state) {
+    switch (state) {
+        case "out":
+            return "●";
+        case "lost":
+            return "○";
+        case "done":
+            return "◎";
+        case "dismissed":
+            return "×";
+        case "dead":
+            return "✕";
+        case "minting":
+            return "…";
+        case "startup-timeout":
+            return "!";
+        case "unknown":
+            return "?";
+    }
+}
+export function renderSettingsDiseasesSection(diseases, taskDiseases = []) {
+    if (diseases.length === 0 && taskDiseases.length === 0)
         return "";
     const lines = formatSettingsDiseases(diseases).map((line) => `- ${line}`);
+    lines.push(...taskDiseases.map((line) => `- ${line}`));
     return `${STATUS_DISEASES_SECTION_TITLE}\n${lines.join("\n")}\n`;
 }
+function renderTaskStatusSection(tasks) {
+    if (!tasks || tasks.inProgress + tasks.ready + tasks.blocked === 0)
+        return "";
+    const segments = [
+        tasks.inProgress > 0 ? `${tasks.inProgress} in_progress` : undefined,
+        tasks.ready > 0 ? `${tasks.ready} ready` : undefined,
+        tasks.blocked > 0 ? `${tasks.blocked} blocked` : undefined,
+    ].filter((segment) => segment !== undefined);
+    const lines = [`tasks · ${segments.join(" / ")}`];
+    lines.push(...tasks.topTasks.map((task) => `  ${task.id.slice(0, 9)} · P${task.pri} · ${task.state === "in_progress" ? "in_progress" : "ready"} · ${task.title}`));
+    return `${lines.join("\n")}\n`;
+}
 function renderProjectionDiagnostics(row) {
     if (row.diagnostics.length === 0)
         return "";
@@ -18,7 +53,7 @@ function renderProjectionDiagnostics(row) {
 function renderProjectionOmission(board) {
     if (!board.omitted)
         return undefined;
-    const counts = ["failed", "dead", "done", "dismissed"]
+    const counts = ["failed", "dead", "done", "killed", "dismissed"]
         .flatMap((state) => {
         const count = board.omitted?.byState[state] ?? 0;
         return count > 0 ? [`${count} ${state}`] : [];
@@ -28,6 +63,8 @@ function renderProjectionOmission(board) {
 function renderProjectionAge(row) {
     if (row.state === "done")
         return "done";
+    if (row.state === "killed")
+        return "killed";
     if (row.state === "dismissed")
         return "dismissed";
     if (row.state === "failed")
@@ -50,6 +87,7 @@ function projectionActivityState(row) {
         case "failed":
         case "dead": return "dead";
         case "lost": return "lost";
+        case "killed":
         case "dismissed": return "dismissed";
         case "minting":
         case "out": return "running";
@@ -68,11 +106,13 @@ function renderProjectionActivityLine(row) {
     });
 }
 function renderProjectionRow(row) {
-    const glyph = projectionGlyph(row.state === "failed"
-        ? "lost"
-        : row.state === "startup-timeout"
-            ? "minting"
-            : row.state);
+    const glyph = row.state === "killed"
+        ? "×"
+        : projectionGlyph(row.state === "failed"
+            ? "lost"
+            : row.state === "startup-timeout"
+                ? "minting"
+                : row.state);
     const identity = row.alias ? `${row.id} (${row.alias})` : row.id;
     let heading;
     if (row.state === "startup-timeout" || row.state === "unknown") {
@@ -90,6 +130,25 @@ function renderProjectionRow(row) {
     const activity = renderProjectionActivityLine(row);
     return activity ? [heading, activity] : [heading];
 }
+function isTerminalProjectionStatus(row) {
+    return row.state === "done"
+        || row.state === "killed"
+        || row.state === "dismissed"
+        || row.state === "failed"
+        || row.state === "dead";
+}
+export function renderProjectionFilteredStatus(board, projectionId) {
+    const head = board.defaultHead ? shortCommitHash(board.defaultHead) : "(no HEAD)";
+    const heading = `現世 ${head} · projection ${projectionId}`;
+    const row = board.projections?.rows.find((candidate) => candidate.id === projectionId);
+    if (!row)
+        return `${heading}\nno projections on projection ${projectionId}\n`;
+    const lines = [heading, "", ...renderProjectionRow(row), ""];
+    if (!isTerminalProjectionStatus(row))
+        lines.push(`» keiyaku tell ${projectionId} "..."`);
+    lines.push(`» keiyaku wait ${projectionId}`);
+    return `${lines.join("\n")}\n`;
+}
 export function renderProjectionStatusSection(board) {
     if (!board || board.rows.length === 0)
         return "";
@@ -116,17 +175,24 @@ export function renderStatusBoard(board) {
     const boardText = renderKanshiBoard(board);
     const projectionText = renderProjectionStatusSection(board.projections);
     const receiptsText = renderClaimReconciliationSection(board.claimReconciliation);
-    const diseasesText = renderSettingsDiseasesSection(board.diseases);
-    if (!projectionText && !receiptsText && board.diseases.length === 0)
+    const taskText = renderTaskStatusSection(board.tasks);
+    const taskDiseaseText = [
+        ...(board.tasks?.diseases ?? []).map((disease) => disease.message),
+        ...(board.tasks?.diagnostic ? [board.tasks.diagnostic] : []),
+    ];
+    const diseasesText = renderSettingsDiseasesSection(board.diseases, taskDiseaseText);
+    if (!projectionText && !receiptsText && !taskText && diseasesText === "")
         return boardText;
     const sections = [boardText.trimEnd()];
-    if (board.targetFilter !== null) {
+    if (board.targetFilter !== null && (projectionText || receiptsText || diseasesText)) {
         sections.push("repository-wide — not filtered by target");
     }
     if (projectionText)
         sections.push(projectionText.trimEnd());
     if (receiptsText)
         sections.push(receiptsText.trimEnd());
+    if (taskText)
+        sections.push(taskText.trimEnd());
     if (diseasesText)
         sections.push(diseasesText.trimEnd());
     return `${sections.join("\n\n")}\n`;

package/build/cli/render/task.js

@@ -0,0 +1,113 @@
+export function shortTaskId(id) {
+    return id.slice(0, 9);
+}
+export function shortContractId(contractId) {
+    const separator = contractId.indexOf(".");
+    return separator > 0 ? contractId.slice(0, separator) : contractId;
+}
+export function deriveTaskDisplay(task) {
+    if (task.state === "done")
+        return "done";
+    if (task.state === "drop")
+        return "dropped";
+    if (task.contractId !== undefined)
+        return `bound(${shortContractId(task.contractId)})`;
+    if (task.state === "in_progress")
+        return "in_progress";
+    return task.blocked ? "blocked" : "ready";
+}
+function renderTaskRowWithId(task, id) {
+    return `${id} · P${task.pri} · ${deriveTaskDisplay(task)} · ${task.title}`;
+}
+export function renderTaskListRow(task) {
+    return renderTaskRowWithId(task, shortTaskId(task.id));
+}
+export function renderTaskMutationRow(task) {
+    return renderTaskRowWithId(task, task.id);
+}
+export function renderTaskRow(task, completeId = false) {
+    return completeId ? renderTaskMutationRow(task) : renderTaskListRow(task);
+}
+function displayOrder(display) {
+    if (display === "in_progress")
+        return 0;
+    if (display === "ready")
+        return 1;
+    if (display === "blocked")
+        return 2;
+    if (display.startsWith("bound("))
+        return 3;
+    return display === "done" ? 4 : 5;
+}
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function compareTasks(left, right) {
+    const displayDifference = displayOrder(deriveTaskDisplay(left)) - displayOrder(deriveTaskDisplay(right));
+    if (displayDifference !== 0)
+        return displayDifference;
+    if (left.pri !== right.pri)
+        return left.pri - right.pri;
+    const createdDifference = compareText(left.createdAt, right.createdAt);
+    return createdDifference || compareText(left.id, right.id);
+}
+function selected(task, selection) {
+    const display = deriveTaskDisplay(task);
+    const terminal = display === "done" || display === "dropped";
+    if (selection === "done")
+        return terminal;
+    if (selection === "default")
+        return !terminal;
+    return true;
+}
+export function groupAndSortTasks(tasks, selection = "default") {
+    return tasks.filter((task) => selected(task, selection)).sort(compareTasks);
+}
+export function renderTaskList(tasks, options = {}) {
+    return groupAndSortTasks(tasks, options.selection).map(renderTaskListRow).join("\n");
+}
+function renderIds(ids) {
+    return ids.length === 0 ? "(none)" : ids.map(shortTaskId).join(", ");
+}
+export function renderTaskShow(task) {
+    const released = new Set(task.releasedNeeds);
+    const needs = task.needs.length === 0
+        ? "(none)"
+        : task.needs
+            .map((id) => `${shortTaskId(id)}${released.has(id) ? " (dropped)" : ""}`)
+            .join(", ");
+    return [
+        `${shortTaskId(task.id)} · ${task.title}`,
+        `state: ${deriveTaskDisplay(task)}`,
+        `priority: ${task.pri}`,
+        `needs: ${needs}`,
+        `blocks: ${renderIds(task.blocks)}`,
+        `parent: ${task.parent === null ? "(none)" : shortTaskId(task.parent)}`,
+        `from: ${renderIds(task.from)}`,
+        `created: ${task.createdAt} by ${task.creator}`,
+        "",
+        task.body,
+    ].join("\n");
+}
+export function taskJson(task) {
+    return {
+        id: task.id,
+        title: task.title,
+        state: task.state,
+        display: deriveTaskDisplay(task),
+        priority: task.pri,
+        needs: [...task.needs],
+        blocks: [...task.blocks],
+        parent: task.parent,
+        from: [...task.from],
+        contractId: task.contractId ?? null,
+        createdAt: task.createdAt,
+        creator: task.creator,
+    };
+}
+export function renderTaskShowJson(task) {
+    return `${JSON.stringify({ ...taskJson(task), body: task.body })}\n`;
+}
+export function renderTaskListJson(tasks, selection = "default") {
+    return `${JSON.stringify(groupAndSortTasks(tasks, selection).map(taskJson))}\n`;
+}

package/build/cli/render/wait.js

@@ -10,6 +10,7 @@ function phaseState(phase) {
         case "done": return "returned";
         case "failed": return "dead";
         case "lost": return "lost";
+        case "killed":
         case "dismissed": return "dismissed";
         case "startup-timeout": return "stalled";
         case "unknown": return "unknown";
@@ -35,6 +36,8 @@ function waitStateText(snapshot) {
             return `returned · lived ${formatTimelineDuration(snapshot.durationMs)}`;
         case "failed":
             return `dead · lived ${formatTimelineDuration(snapshot.durationMs)}`;
+        case "killed":
+            return "killed";
         case "dismissed":
             return "dismissed";
         case "lost":
@@ -68,7 +71,7 @@ function terminalDiagnostic(result) {
 }
 function ledgerHint(projectionId, snapshot) {
     const file = snapshot.eventLedgerFile ?? "events.jsonl";
-    return `⟶ ledger: .keiyaku/projection/${projectionId}/${file}`;
+    return `· ledger: .keiyaku/projection/${projectionId}/${file}`;
 }
 function recordReviveLines(artifactId) {
     return [
@@ -98,6 +101,17 @@ function nextActionLines(projectionId, result, state) {
             : ["The akuma dropped dead mid-turn.", "no record survived — there is nothing to revive."];
     }
     if (result.state === "terminal" && result.verdict.state === "failed") {
+        if (snapshot.failureCode === "SUBAGENT_PROVIDER_UNAVAILABLE") {
+            return snapshot.sourceArtifactId
+                ? [
+                    "× provider unavailable — no turn accepted",
+                    `» nothing was consumed · retry from the same artifact: keiyaku revive ${snapshot.sourceArtifactId}`,
+                ]
+                : [
+                    "× provider unavailable — no turn accepted",
+                    "» nothing was consumed · safe to call again",
+                ];
+        }
         return [
             "The akuma failed and stopped.",
             ...(snapshot.artifactId ? [`record: ${snapshot.artifactId}`] : []),
@@ -117,7 +131,7 @@ function nextActionLines(projectionId, result, state) {
             ];
     }
     if (state === "stalled" || state === "unknown") {
-        return [ledgerHint(projectionId, snapshot), "⟶ keiyaku status"];
+        return [ledgerHint(projectionId, snapshot), "» keiyaku status"];
     }
     return [];
 }
@@ -186,6 +200,12 @@ export function buildWaitResponse(projectionId, result, options = {}) {
     }
     const snapshot = result.snapshot;
     const maxColumns = options.maxColumns ?? resolveLineColumns();
+    if (result.state === "terminal" && result.verdict.state === "killed") {
+        return {
+            ...textResponse(`× killed ${projectionId}`),
+            exitCode: 1,
+        };
+    }
     if (snapshot.phase === "startup-timeout") {
         return startupTimeoutResponse(projectionId, result.pact.akuma);
     }
@@ -216,7 +236,7 @@ export function buildWaitResponse(projectionId, result, options = {}) {
         lines.push("   not a word out of it yet — pulse is steady");
     }
     const nextActions = nextActionLines(options.alias ?? projectionId, result, state);
-    if (rendered.hasMutationFiles && nextActions.length > 0)
+    if (nextActions.length > 0)
         lines.push("");
     lines.push(...nextActions);
     const response = textResponse(lines.join("\n"));

package/build/cli/types.js

@@ -1 +1 @@
-export {};
+export const TASK_SUBCOMMANDS = ["add", "view", "ls", "start", "stop", "done", "drop", "update", "doctor"];

package/build/config/{akuma-loader_v2.js → akuma-loader.js}

@@ -5,7 +5,7 @@ import { parseToAST } from "../core/markdown/parser.js";
 import { isGitRepo } from "../git/branches.js";
 import { BUILTIN_AGENT_PROFILES } from "../keiyaku.js";
 import { getKeiyakuHome } from "./env.js";
-import { agentNameSchema, providerInstanceNameSchema } from "./settings.js";
+import { agentNameSchema, providerInstanceNameSchema } from "./settings/schema.js";
 const nonblankString = z.string().refine((value) => value.trim().length > 0, { message: "must not be blank" });
 const effortOptionsSchema = z.array(nonblankString).superRefine((values, ctx) => {
     if (new Set(values).size !== values.length) {
@@ -187,7 +187,7 @@ function foldLayer(selected, shadows, allCandidates, source, layer) {
         selected[candidate.name] = candidate;
     }
 }
-export async function loadAkumaCatalogV2(cwd) {
+export async function loadAkumaCatalog(cwd) {
     const candidates = [];
     const selected = {};
     const shadows = [];

package/build/config/env.js

@@ -4,12 +4,14 @@ import * as path from "node:path";
 import { z } from "zod";
 import { isErrnoException } from "../errno.js";
 import { ENV_KEYS, getEnvDefaultValue } from "./env-keys.js";
-function readEnvHome() {
-    const value = process.env.KEIYAKU_HOME?.trim();
+import { configureResponseArtifactCatalog } from "../core/response-artifact-catalog.js";
+import { createSqliteResponseArtifactCatalog } from "../core/response-artifact-catalog-sqlite.js";
+function readEnvHome(env = process.env) {
+    const value = env.KEIYAKU_HOME?.trim();
     return value && value.length > 0 ? value : undefined;
 }
-export function getKeiyakuHome() {
-    return readEnvHome() ?? path.join(os.homedir(), ".keiyaku");
+export function getKeiyakuHome(env = process.env) {
+    return readEnvHome(env) ?? path.join(os.homedir(), ".keiyaku");
 }
 const DOTENV_FILE = ".env";
 function decodeQuotedValue(raw) {
@@ -260,6 +262,8 @@ export function initializeConfig(env = process.env, cwd = process.cwd()) {
         runtimeEnv: snapshotEnv({ ...dotenvEnv, ...env }),
     });
     activeConfig = runtimeConfig;
+    const homeEnv = { ...process.env, ...env };
+    configureResponseArtifactCatalog(createSqliteResponseArtifactCatalog({ keiyakuHome: getKeiyakuHome(homeEnv) }));
     return runtimeConfig;
 }
 export function getConfig() {
@@ -270,4 +274,5 @@ export function getConfig() {
 }
 export function resetConfigForTests() {
     activeConfig = undefined;
+    configureResponseArtifactCatalog(undefined);
 }

package/build/config/settings/disease.js

@@ -0,0 +1,26 @@
+import { FlowError } from "../../flow-error.js";
+import { SETTINGS_FILE } from "../../keiyaku.js";
+export function findSettingsDiseasesForKnob(diseases, knob) {
+    return diseases.filter((disease) => disease.knob === knob);
+}
+export function formatSettingsDiseases(diseases) {
+    return diseases.map((disease) => {
+        const where = disease.knob ? `${disease.source}:${disease.knob}` : `${disease.source}:(root)`;
+        return `${where}: ${disease.reason}`;
+    });
+}
+/**
+ * Reject when a named knob is diseased and was not admitted into knobs.
+ * A healthy value from another source still wins; only failed-and-unset knobs reject.
+ */
+export function assertSettingsKnobUsable(loaded, knob) {
+    const knobs = loaded.knobs;
+    if (knobs !== null && knobs[knob] !== undefined)
+        return;
+    const hits = findSettingsDiseasesForKnob(loaded.diseases, knob);
+    if (hits.length === 0)
+        return;
+    throw new FlowError("INVALID_SETTINGS", `Invalid settings in ${SETTINGS_FILE} (diseased knob '${knob}').`, {
+        hints: formatSettingsDiseases(hits),
+    });
+}

package/build/config/settings/knobs.js

@@ -0,0 +1,8 @@
+export const KNOWN_SETTINGS_KNOBS = ["default", "reviewer", "gate", "defaultBranch", "worktreeBootstrap"];
+export const KNOWN_SETTINGS_ROOT_KEYS = [...KNOWN_SETTINGS_KNOBS, "providers"];
+export function resolveDefaultAgentName(settings) {
+    return settings?.default ?? "akuma-codex";
+}
+export function resolveReviewerAgentName(settings) {
+    return settings?.reviewer ?? resolveDefaultAgentName(settings);
+}

package/build/config/settings/loader.js

@@ -0,0 +1,244 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { isErrnoException } from "../../errno.js";
+import { SETTINGS_FILE } from "../../keiyaku.js";
+import { getKeiyakuHome } from "../env.js";
+import { KNOWN_SETTINGS_KNOBS, KNOWN_SETTINGS_ROOT_KEYS } from "./knobs.js";
+import { BUILTIN_PROVIDER_INSTANCE_CANDIDATES, knobSchemas, providerInstanceNameSchema, providerInstanceSchema, } from "./schema.js";
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMerge(base, override) {
+    if (!isPlainObject(base) || !isPlainObject(override)) {
+        return override;
+    }
+    const merged = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        merged[key] = key in merged ? deepMerge(merged[key], value) : value;
+    }
+    return merged;
+}
+function formatZodIssues(error) {
+    return error.issues
+        .map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`)
+        .join("; ");
+}
+async function readSettingsSource(filePath) {
+    try {
+        const text = await fs.readFile(filePath, "utf-8");
+        try {
+            return { found: true, raw: JSON.parse(text) };
+        }
+        catch (error) {
+            const reason = error instanceof SyntaxError
+                ? `invalid JSON: ${error.message}`
+                : error instanceof Error
+                    ? error.message
+                    : String(error);
+            return { found: true, raw: undefined, parseError: reason };
+        }
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === "ENOENT") {
+            return { found: false };
+        }
+        const reason = error instanceof Error ? error.message : String(error);
+        return { found: true, raw: undefined, parseError: reason };
+    }
+}
+function builtinProviderInstanceCatalog() {
+    return { selected: { ...BUILTIN_PROVIDER_INSTANCE_CANDIDATES }, shadows: [] };
+}
+function formatProviderInstanceIssues(name, error) {
+    return error.issues
+        .map((issue) => {
+        const suffix = issue.path.length === 0 ? "" : `.${issue.path.join(".")}`;
+        return `providers.${name}${suffix}: ${issue.message}`;
+    })
+        .join("; ");
+}
+function collectProviderCandidates(source, rawProviders) {
+    if (!isPlainObject(rawProviders)) {
+        return {
+            candidates: [],
+            disease: { source: source === "project" ? "local" : "global", knob: "providers", reason: "providers: must be a JSON object" },
+        };
+    }
+    const candidates = [];
+    for (const [name, rawInstance] of Object.entries(rawProviders)) {
+        const nameResult = providerInstanceNameSchema.safeParse(name);
+        if (!nameResult.success) {
+            candidates.push({
+                name,
+                source,
+                reason: formatProviderInstanceIssues(name, nameResult.error),
+            });
+            continue;
+        }
+        const instanceResult = providerInstanceSchema.safeParse(rawInstance);
+        if (!instanceResult.success) {
+            candidates.push({
+                name,
+                source,
+                reason: formatProviderInstanceIssues(name, instanceResult.error),
+            });
+            continue;
+        }
+        const instance = instanceResult.data;
+        if (instance.kind === "codex-app-server" && instance.writableRoots !== undefined && source === "global") {
+            let relativeIndex;
+            for (let i = 0; i < instance.writableRoots.length; i++) {
+                if (!path.posix.isAbsolute(instance.writableRoots[i])) {
+                    relativeIndex = i;
+                    break;
+                }
+            }
+            if (relativeIndex !== undefined) {
+                candidates.push({
+                    name,
+                    source,
+                    reason: `providers.${name}.writableRoots.${relativeIndex}: writableRoots item must be an absolute path for global provider instances`,
+                });
+                continue;
+            }
+        }
+        candidates.push({ name, source, instance: instanceResult.data });
+    }
+    return { candidates };
+}
+function mergeProviderCandidates(catalog, candidates) {
+    const selected = { ...catalog.selected };
+    const shadows = [...catalog.shadows];
+    for (const candidate of candidates) {
+        const prior = selected[candidate.name];
+        if (prior !== undefined) {
+            shadows.push({ name: candidate.name, source: prior.source, shadowedBy: candidate.source });
+        }
+        selected[candidate.name] = candidate;
+    }
+    return { selected, shadows };
+}
+function collectSourceDiseases(source, providerSource, read) {
+    if (!read.found) {
+        return { partial: {}, diseases: [], providerCandidates: [] };
+    }
+    if (read.parseError !== undefined) {
+        return {
+            partial: {},
+            diseases: [{ source, reason: `settings root is unreadable (${read.parseError})` }],
+            providerCandidates: [],
+        };
+    }
+    if (!isPlainObject(read.raw)) {
+        return {
+            partial: {},
+            diseases: [{ source, reason: "settings root must be a JSON object" }],
+            providerCandidates: [],
+        };
+    }
+    const diseases = [];
+    const partial = {};
+    let providerCandidates = [];
+    const raw = read.raw;
+    for (const key of Object.keys(raw)) {
+        if (!KNOWN_SETTINGS_ROOT_KEYS.includes(key)) {
+            diseases.push({
+                source,
+                knob: key,
+                reason: key === "agents"
+                    ? 'settings key "agents" has been removed; define profiles in .keiyaku/akuma/<name>.md'
+                    : `unknown settings key "${key}"`,
+            });
+        }
+    }
+    if ("providers" in raw) {
+        const collectedProviders = collectProviderCandidates(providerSource, raw.providers);
+        providerCandidates = collectedProviders.candidates;
+        if (collectedProviders.disease !== undefined)
+            diseases.push(collectedProviders.disease);
+    }
+    for (const knob of KNOWN_SETTINGS_KNOBS) {
+        if (!(knob in raw))
+            continue;
+        // worktreeBootstrap is project-layer only. Global/user presence is a named
+        // disease and never contributes execution authority.
+        if (knob === "worktreeBootstrap" && source === "global") {
+            diseases.push({
+                source,
+                knob,
+                reason: "worktreeBootstrap is project-only and never supplies a value from global settings",
+            });
+            continue;
+        }
+        const schema = knobSchemas[knob];
+        const result = schema.safeParse(raw[knob]);
+        if (!result.success) {
+            diseases.push({
+                source,
+                knob,
+                reason: formatZodIssues(result.error),
+            });
+            continue;
+        }
+        if (result.data === undefined)
+            continue;
+        partial[knob] = result.data;
+    }
+    return { partial, diseases, providerCandidates };
+}
+function mergeSettingsKnobs(base, override) {
+    // worktreeBootstrap is whole-value project authority; never field-merge it.
+    const { worktreeBootstrap: baseBootstrap, ...baseRest } = base;
+    const { worktreeBootstrap: overrideBootstrap, ...overrideRest } = override;
+    const mergedRaw = deepMerge(baseRest, overrideRest);
+    if (!isPlainObject(mergedRaw)) {
+        return overrideBootstrap !== undefined
+            ? { ...override, worktreeBootstrap: overrideBootstrap }
+            : { ...override };
+    }
+    const merged = {};
+    for (const knob of KNOWN_SETTINGS_KNOBS) {
+        if (knob === "worktreeBootstrap")
+            continue;
+        if (knob in mergedRaw) {
+            merged[knob] = mergedRaw[knob];
+        }
+    }
+    const bootstrap = overrideBootstrap ?? baseBootstrap;
+    if (bootstrap !== undefined)
+        merged.worktreeBootstrap = bootstrap;
+    return merged;
+}
+export async function loadKeiyakuSettings(cwd) {
+    const localSettingsPath = path.join(cwd, SETTINGS_FILE);
+    const globalSettingsPath = path.join(getKeiyakuHome(), path.basename(SETTINGS_FILE));
+    let globalRead;
+    let localRead;
+    try {
+        [globalRead, localRead] = await Promise.all([
+            readSettingsSource(globalSettingsPath),
+            readSettingsSource(localSettingsPath),
+        ]);
+    }
+    catch (error) {
+        // loadKeiyakuSettings never throws; unexpected I/O becomes a local root disease.
+        const reason = error instanceof Error ? error.message : String(error);
+        return {
+            knobs: null,
+            diseases: [{ source: "local", reason: `settings root is unreadable (${reason})` }],
+            providerInstances: builtinProviderInstanceCatalog(),
+        };
+    }
+    const globalCollected = collectSourceDiseases("global", "global", globalRead);
+    const localCollected = collectSourceDiseases("local", "project", localRead);
+    const diseases = [...globalCollected.diseases, ...localCollected.diseases];
+    let providerInstances = builtinProviderInstanceCatalog();
+    providerInstances = mergeProviderCandidates(providerInstances, globalCollected.providerCandidates);
+    providerInstances = mergeProviderCandidates(providerInstances, localCollected.providerCandidates);
+    let knobs = null;
+    if (globalRead.found || localRead.found) {
+        knobs = mergeSettingsKnobs(globalCollected.partial, localCollected.partial);
+    }
+    // Empty object still means "settings files were present"; callers treat null as absent files.
+    return { knobs, diseases, providerInstances };
+}