@astrosheep/keiyaku 2.8.5 → 2.9.1

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}

@@ -2,10 +2,10 @@ 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 { isGitRepo } from "../git/branches.js";
+import { observeGitRepository } 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 = [];
@@ -211,7 +211,10 @@ export async function loadAkumaCatalogV2(cwd) {
         selected[name] = candidate;
     }
     foldLayer(selected, shadows, candidates, "user", await readLayer(path.join(getKeiyakuHome(), "akuma"), "user"));
-    if (await isGitRepo(cwd)) {
+    const repository = await observeGitRepository(cwd);
+    if (repository.capability === "unknown")
+        throw repository.error;
+    if (repository.capability === "available" && repository.coordinate === "repository") {
         foldLayer(selected, shadows, candidates, "project", await readLayer(path.join(cwd, ".keiyaku", "akuma"), "project"));
     }
     return Object.freeze({

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);
+}