@astrosheep/keiyaku 2.9.3 → 2.9.5

package/build/core/settlement/settlement.js

@@ -0,0 +1,288 @@
+import { FlowError } from "../../flow-error.js";
+import { readCurrentContractContext } from "../context.js";
+import { readLedger } from "../ledger.js";
+import { commissionTarget } from "../status/drift.js";
+import { deriveContractState } from "../status/lifecycle.js";
+import { getCurrentBranch, requireGitRepository } from "../../git/branches.js";
+import { readContractLog } from "../log.js";
+import { listRefLogCommits } from "../ref-log.js";
+import { effectiveScope } from "../seal.js";
+import { scopePathEvidence } from "../scope.js";
+import { nextReviewResponseNumber } from "../transcripts.js";
+import { claimContract } from "./claim.js";
+import { buildClaimGatePipeline, } from "./petition-claim-gates.js";
+import { resolveVerificationCommands } from "./verification.js";
+import { forfeitKeiyaku } from "./petition-forfeit.js";
+import { assertHeadUnchanged } from "./petition-head-guard.js";
+import { petitionContract } from "./petition.js";
+import { verdictContract } from "./verdict.js";
+const VERDICT_DENIED_CODE = "VERDICT_DENIED";
+async function resolveClaimGateConfig(cwd) {
+    const merged = {
+        verificationCommands: [],
+    };
+    try {
+        merged.verificationCommands = await resolveVerificationCommands(cwd);
+        return merged;
+    }
+    catch (error) {
+        if (error instanceof FlowError && error.code === "INVALID_SETTINGS") {
+            throw new FlowError(VERDICT_DENIED_CODE, `Configuration Error: ${error.message}`, {
+                cause: error,
+                facts: error.facts,
+            });
+        }
+        throw error;
+    }
+}
+async function loadCloseContext(cwd, requestedContractId) {
+    await requireGitRepository(cwd, "petition");
+    if (requestedContractId) {
+        const ledger = await readLedger(cwd, requestedContractId);
+        if (!ledger) {
+            throw new FlowError("INTERNAL_STATE", `contract ${requestedContractId} not found or not active`);
+        }
+        const target = commissionTarget(ledger.entries);
+        if (!target) {
+            throw new FlowError("INTERNAL_STATE", `contract ${requestedContractId} active ledger is missing commission target`);
+        }
+        return {
+            cwd,
+            keiyakuBranch: `keiyaku/${requestedContractId}`,
+            baseBranch: target.branch,
+            contractId: requestedContractId,
+        };
+    }
+    let contractContext;
+    try {
+        contractContext = await readCurrentContractContext(cwd);
+    }
+    catch (error) {
+        if (!(error instanceof FlowError) || error.code !== "EMPTY_PARAM") {
+            throw error;
+        }
+        throw new FlowError("NOT_ACTIVE_KEIYAKU_BRANCH", "Current workspace is not addressing an active Keiyaku contract.");
+    }
+    const keiyakuBranch = await getCurrentBranch(cwd);
+    return {
+        cwd,
+        keiyakuBranch,
+        baseBranch: contractContext.baseBranch,
+        contractId: contractContext.contractId,
+    };
+}
+async function throwClaimGateFailure(failure, _input, context, _dependencies) {
+    void _input;
+    void _dependencies;
+    void context.contractId;
+    if (failure.reviewHeadBeforeWrite) {
+        await assertHeadUnchanged(context.cwd, failure.reviewHeadBeforeWrite, "claim review");
+    }
+    throw new FlowError(failure.code, failure.message, {
+        review: failure.review,
+        facts: failure.facts,
+    });
+}
+async function runClaimGatePipelineOrThrow(input, context, dependencies) {
+    const { verificationCommands } = await dependencies.resolveClaimGateConfig(context.cwd);
+    let review;
+    let reviewHeadBeforeWrite;
+    let reviewerActor;
+    for (const gate of buildClaimGatePipeline()) {
+        const result = await gate.evaluate({
+            cwd: context.cwd,
+            contractId: context.contractId,
+            input,
+            verificationCommands,
+            baseBranch: dependencies.baseBranch,
+            reviewNumber: dependencies.reviewNumber,
+        });
+        if (result.review) {
+            review = result.review;
+            reviewHeadBeforeWrite = result.reviewHeadBeforeWrite;
+        }
+        if (result.reviewerActor)
+            reviewerActor = result.reviewerActor;
+        if (!result.pass) {
+            await throwClaimGateFailure(result, input, context, dependencies);
+        }
+    }
+    return { review, reviewHeadBeforeWrite, reviewerActor };
+}
+function maxArc(entries) {
+    return entries.filter((entry) => entry.kind === "arc").length;
+}
+function cleanupWarnings(cleanup) {
+    return [
+        ...(cleanup.worktreeRemoveFailure
+            ? [`Could not remove contract worktree ${cleanup.worktreeRemoveFailure.path}: ${cleanup.worktreeRemoveFailure.reason}`]
+            : []),
+        ...(cleanup.branchDeleteFailure
+            ? [`Could not delete contract branch ${cleanup.branchDeleteFailure.name}: ${cleanup.branchDeleteFailure.reason}`]
+            : []),
+    ];
+}
+function findClaimEntry(entries) {
+    return entries.find((entry) => entry.kind === "claim");
+}
+/** Verdict for the open petition window (after last petition, before claim). */
+function latestCurrentPetitionVerdict(entries) {
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        const entry = entries[index];
+        if (entry.kind === "verdict")
+            return entry;
+        if (entry.kind === "petition")
+            return undefined;
+    }
+    return undefined;
+}
+/**
+ * Crash-recovery head: petition → approved verdict → no claim.
+ * Orchestrator resumes claim delivery only; no gates, petition, or re-judgment.
+ */
+function isApprovedVerdictAwaitingClaim(entries) {
+    const state = deriveContractState(entries);
+    if (state.state !== "petitioned")
+        return false;
+    if (findClaimEntry(entries))
+        return false;
+    return latestCurrentPetitionVerdict(entries)?.data.result === "approved";
+}
+async function recoverCurrentPetitionSeal(cwd, ledger) {
+    let petitionIndex = -1;
+    for (let index = ledger.entries.length - 1; index >= 0; index -= 1) {
+        if (ledger.entries[index]?.kind === "petition") {
+            petitionIndex = index;
+            break;
+        }
+    }
+    if (petitionIndex <= 0)
+        return undefined;
+    const seal = ledger.entries[petitionIndex - 1];
+    if (seal.kind !== "seal" || seal.data.sealedBy !== "petition")
+        return undefined;
+    const commits = await listRefLogCommits(cwd, ledger.head, ledger.ref);
+    const ledgerHead = commits[petitionIndex - 1];
+    if (!ledgerHead || commits.length !== ledger.entries.length) {
+        throw new FlowError("INTERNAL_STATE", `contract ${ledger.contractId} ledger entries do not align with ref-log commits during petition recovery`);
+    }
+    const scopeViolationEvidence = await scopePathEvidence(cwd, effectiveScope(ledger.entries), seal.data.scopeAudit.violations);
+    return {
+        ...seal.data,
+        scopeViolationEvidence,
+        ledgerHead,
+    };
+}
+async function finishApprovedClaim(context, options) {
+    const { cwd, baseBranch, contractId } = context;
+    // Capture arc facts before claim cleanup may remove the delivery worktree cwd.
+    const log = await readContractLog({ cwd, contractId });
+    const claimed = await claimContract({
+        cwd,
+        contractId,
+        actor: "keiyaku",
+        nowMs: options.nowMs,
+    });
+    const cleanup = claimed.cleanup ?? { absent: ["worktree", "branch"] };
+    const warnings = [...(claimed.warnings ?? []), ...cleanupWarnings(cleanup)];
+    return {
+        status: "success",
+        result: "merged",
+        arc: maxArc(log.entries),
+        currentBranch: baseBranch,
+        baseBranch,
+        commit: claimed.mergeCommit,
+        mergedInto: baseBranch,
+        ...(cleanup.deletedBranch ? { deletedBranch: cleanup.deletedBranch } : {}),
+        cleanup,
+        diff: `Merged contract ${contractId} with merge-tree/commit-tree CAS.`,
+        // Prior public outcome carried sealed facts when petition sealed an open arc.
+        ...(options.sealed ? { sealed: options.sealed } : {}),
+        ...(warnings.length > 0 ? { meta: { warnings } } : {}),
+    };
+}
+/**
+ * Settlement claim path: gates → petition → pure verdict → claim delivery.
+ * Stage modules do not call each other; this orchestrator owns the sequence.
+ *
+ * Atomicity equivalence: previously verdictContract appended the verdict entry
+ * then immediately invoked claimContract. That remains two sequential append
+ * windows (verdict then claim). Crash after approved verdict leaves state
+ * petitioned with an approved verdict; the orchestrator detects that head and
+ * resumes claimContract idempotently without re-running gates or judgment.
+ */
+export async function claimKeiyaku(input, context, dependencies) {
+    const { cwd, baseBranch, contractId } = context;
+    // Crash recovery: petition → approved verdict → no claim.
+    // Resume claim delivery only; do not re-gate, re-petition, or re-judge.
+    const existing = await readLedger(cwd, contractId);
+    if (existing && isApprovedVerdictAwaitingClaim(existing.entries)) {
+        const sealed = await recoverCurrentPetitionSeal(cwd, existing);
+        return finishApprovedClaim(context, {
+            nowMs: Date.now(),
+            ...(sealed ? { sealed } : {}),
+        });
+    }
+    const claimResult = "dangerouslyBypassGates" in input && input.dangerouslyBypassGates
+        ? { review: undefined, reviewHeadBeforeWrite: undefined, bypassedByArchitect: true }
+        : {
+            ...(await runClaimGatePipelineOrThrow(input, { cwd, contractId }, {
+                ...dependencies,
+                baseBranch,
+                reviewNumber: await nextReviewResponseNumber(cwd),
+            })),
+            bypassedByArchitect: false,
+        };
+    if (claimResult.review && claimResult.reviewHeadBeforeWrite) {
+        await assertHeadUnchanged(cwd, claimResult.reviewHeadBeforeWrite, "claim review");
+    }
+    const oath = String(input.oath ?? "").trim();
+    if (!oath) {
+        throw new FlowError("OATH_MISSING", "Oath missing.");
+    }
+    // 1. Petition: seal + admit onto the target-local settlement queue.
+    const petition = await petitionContract({
+        cwd,
+        contractId,
+        actor: "keiyaku",
+        nowMs: Date.now(),
+        intent: "claim",
+        oath,
+        appendScope: input.appendScope,
+    });
+    // 2. Pure verdict: judgment facts only; no claim execution.
+    // Capture one clock for verdict + claim so ledger timestamps match the prior
+    // verdict→claim atomic pair (verdict previously forwarded its own nowMs).
+    const judgmentNowMs = Date.now();
+    const verdict = await verdictContract({
+        cwd,
+        contractId,
+        actor: claimResult.reviewerActor ?? "keiyaku",
+        nowMs: judgmentNowMs,
+        result: "approved",
+        summary: claimResult.review?.findings?.trim() || "礼成",
+    });
+    // 3. Execution: approved → claim delivery (same sequential append window as before).
+    // Rejected verdict publication is verdictContract itself (state returns active).
+    if (verdict.result !== "approved") {
+        throw new FlowError("INTERNAL_STATE", `settlement expected approved verdict for ${contractId}, got ${verdict.result}`);
+    }
+    return finishApprovedClaim(context, {
+        nowMs: judgmentNowMs,
+        ...(petition.sealed ? { sealed: petition.sealed } : {}),
+    });
+}
+/** Public settlement entrypoint for CLI petition (claim or forfeit). */
+export async function petitionKeiyaku(input) {
+    const context = await loadCloseContext(input.cwd, input.contractId);
+    const { intent } = input;
+    if (intent === "FORFEIT") {
+        return forfeitKeiyaku(context);
+    }
+    if (intent === "CLAIM") {
+        return claimKeiyaku(input, context, {
+            resolveClaimGateConfig,
+        });
+    }
+    throw new FlowError("INVALID_CLOSE_INTENT", `unsupported close intent: ${intent}`);
+}

package/build/core/{verdict.js → settlement/verdict.js}

@@ -1,8 +1,7 @@
-import { FlowError } from "../flow-error.js";
-import { claimContract } from "./claim.js";
-import { activeLedgerRef, appendWithRetry, readLedger } from "./ledger.js";
-import { assertClaimQueueHead, queueMembership, readQueueReadModel } from "./queue.js";
-import { deriveContractState } from "./status/lifecycle.js";
+import { FlowError } from "../../flow-error.js";
+import { activeLedgerRef, appendWithRetry, readLedger } from "../ledger.js";
+import { assertClaimQueueHead, readQueueReadModel } from "./queue.js";
+import { deriveContractState } from "../status/lifecycle.js";
 function latestVerdict(entries) {
     for (let index = entries.length - 1; index >= 0; index -= 1) {
         const entry = entries[index];
@@ -19,6 +18,10 @@ function assertPetitioned(contractId, entries) {
         throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot verdict from state ${state.state}`);
     }
 }
+/**
+ * Append a verdict entry and return typed judgment facts.
+ * Does not claim, clean up, or otherwise execute delivery.
+ */
 export async function verdictContract(input) {
     const at = new Date(input.nowMs).toISOString();
     const current = await readLedger(input.cwd, input.contractId);
@@ -69,40 +72,9 @@ export async function verdictContract(input) {
     if (verdict.data.result !== input.result) {
         throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} already has ${verdict.data.result} verdict`);
     }
-    if (verdict.data.result === "rejected") {
-        // Rejected verdict naturally returns state to active and clears membership.
-        return {
-            contractId: input.contractId,
-            result: "rejected",
-            summary: verdict.data.summary,
-            queuePosition: null,
-        };
-    }
-    const claimOnApproval = input.claimOnApproval ?? true;
-    if (claimOnApproval) {
-        const claimed = await claimContract({
-            cwd: input.cwd,
-            contractId: input.contractId,
-            actor: "keiyaku",
-            nowMs: input.nowMs,
-            mergeDelivery: input.mergeDelivery,
-            afterMerge: input.afterMerge,
-        });
-        return {
-            contractId: input.contractId,
-            result: "approved",
-            summary: verdict.data.summary,
-            claimed,
-            queuePosition: null,
-        };
-    }
-    // claimOnApproval false remains petitioned at target-local position 1.
-    const model = await readQueueReadModel(input.cwd);
-    const membership = queueMembership(model, input.contractId);
     return {
         contractId: input.contractId,
-        result: "approved",
+        result: verdict.data.result,
         summary: verdict.data.summary,
-        queuePosition: membership?.position ?? 1,
     };
 }

package/build/core/settlement/verification.js

@@ -0,0 +1,59 @@
+import { spawn } from "node:child_process";
+import { getConfig } from "../../config/env.js";
+import { assertSettingsKnobUsable } from "../../config/settings/disease.js";
+import { loadKeiyakuSettings } from "../../config/settings/loader.js";
+import { FlowError } from "../../flow-error.js";
+const AUDIT_OUTPUT_TAIL_BYTES = 8_192;
+function tail(value, limit = AUDIT_OUTPUT_TAIL_BYTES) {
+    if (value.byteLength <= limit) {
+        return { tail: value.toString("utf8"), truncated: false, omittedBytes: 0 };
+    }
+    return {
+        tail: value.subarray(value.byteLength - limit).toString("utf8"),
+        truncated: true,
+        omittedBytes: value.byteLength - limit,
+    };
+}
+export function verificationExecutor(command) {
+    const basename = command.command.split(/[\\/]/).pop() ?? "";
+    const executor = basename.toLowerCase().replace(/\.exe$/, "");
+    if (executor !== "bash" && executor !== "zsh" && executor !== "pwsh") {
+        return { cause: "unsupported_executor" };
+    }
+    const bodyIndex = command.args.findIndex((arg) => arg === "-c" || arg === "-lc" || arg === "-Command");
+    const body = bodyIndex < 0 ? undefined : command.args[bodyIndex + 1];
+    if (body === undefined)
+        return { cause: "missing_command_body" };
+    return { executor, body };
+}
+export async function resolveVerificationCommands(cwd) {
+    const loaded = await loadKeiyakuSettings(cwd);
+    assertSettingsKnobUsable(loaded, "gate");
+    return loaded.knobs?.gate?.commands ?? [];
+}
+export async function runVerificationCommand(cwd, verification) {
+    const started = process.hrtime.bigint();
+    return await new Promise((resolve, reject) => {
+        const child = spawn(verification.command, verification.args, {
+            cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: getConfig().runtimeEnv,
+        });
+        const stdout = [];
+        const stderr = [];
+        child.stdout.on("data", (chunk) => stdout.push(Buffer.from(chunk)));
+        child.stderr.on("data", (chunk) => stderr.push(Buffer.from(chunk)));
+        child.on("error", reject);
+        child.on("close", (code) => {
+            const durationMs = Number((process.hrtime.bigint() - started) / 1000000n);
+            resolve({
+                code: typeof code === "number" ? code : -1,
+                durationMs,
+                stdout: tail(Buffer.concat(stdout)),
+                stderr: tail(Buffer.concat(stderr)),
+            });
+        });
+    }).catch((error) => {
+        throw new FlowError("CLOSE_QUALITY_GATE_FAILED", `verification '${verification.label}' could not start`, { cause: error });
+    });
+}

package/build/core/status/board.js

@@ -1,38 +1,64 @@
 import { loadKeiyakuSettings } from "../../config/settings/loader.js";
 import { observeGitRepository } from "../../git/branches.js";
-import { listContractIds, readLedger } from "../ledger.js";
-import { readProjectionStatusBoard } from "../projection-status.js";
-import { deriveQueueReadModel, queueMembership, } from "../queue.js";
+import { readProjectionStatusBoard } from "../projection/index.js";
+import { deriveQueueReadModel, queueMembership, } from "../settlement/index.js";
 import { findOpenArc, getMaxArc, receiptsAfterFence } from "../seal.js";
-import { readTaskBoard } from "../task.js";
-import { openTaskStore } from "../task-git-store.js";
-import { taskRepositoryFromStore } from "../task-store-repository.js";
+import { openTaskStore, readTaskBoard, taskRepositoryFromStore, taskUpdatedAt, } from "../task/index.js";
 import { deriveBootstrapDiagnostics, deriveContractState, hasCurrentPetitionVerdict, isTerminalState, } from "./lifecycle.js";
 import { commissionTarget, evaluateBaseDrift, latestBase, resolveDefaultBranchFromSettings, } from "./drift.js";
 import { computeClaimReconciliation, } from "./reconciliation.js";
+import { readStatusLedgers } from "./ledger-batch.js";
 function compareTaskStatusRows(left, right) {
-    if (left.pri !== right.pri)
-        return left.pri - right.pri;
-    if (left.createdAt !== right.createdAt)
-        return left.createdAt < right.createdAt ? -1 : 1;
+    const leftUpdated = taskUpdatedAt(left);
+    const rightUpdated = taskUpdatedAt(right);
+    if (leftUpdated !== rightUpdated)
+        return leftUpdated > rightUpdated ? -1 : 1;
     return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
 }
-async function readTaskStatusSummary(cwd) {
+function timestampAge(timestamp, now) {
+    const value = Date.parse(timestamp);
+    return Number.isFinite(value) ? Math.max(0, now - value) : 0;
+}
+export function deriveTaskStatusSummary(board, now) {
+    const eligible = board.tasks.filter((task) => !task.contractId && (task.state === "open" || task.state === "in_progress"));
+    const inProgress = eligible.filter((task) => task.state === "in_progress").length;
+    const topTasks = [
+        ...eligible.filter((task) => task.state === "in_progress").sort(compareTaskStatusRows),
+        ...eligible.filter((task) => task.state === "open" && !task.blocked).sort(compareTaskStatusRows),
+    ]
+        .slice(0, 5)
+        .map((task) => {
+        const updatedAt = taskUpdatedAt(task);
+        return {
+            id: task.id,
+            title: task.title,
+            pri: task.pri,
+            state: task.state,
+            blocked: task.blocked,
+            createdAt: task.createdAt,
+            updatedAt,
+            ageMs: timestampAge(task.createdAt, now),
+            activityAgeMs: timestampAge(updatedAt, now),
+        };
+    });
+    const ready = eligible.filter((task) => task.state === "open" && !task.blocked).length;
+    const blocked = eligible.filter((task) => task.state === "open" && task.blocked).length;
+    if (board.tasks.length === 0 && board.diseases.length === 0)
+        return undefined;
+    return {
+        total: board.tasks.length,
+        inProgress,
+        ready,
+        blocked,
+        omitted: inProgress + ready - topTasks.length,
+        topTasks,
+        diseases: board.diseases,
+    };
+}
+async function readTaskStatusSummary(cwd, now) {
     try {
         const board = await readTaskBoard(taskRepositoryFromStore(await openTaskStore(cwd)));
-        const eligible = board.tasks.filter((task) => !task.contractId && (task.state === "open" || task.state === "in_progress"));
-        const inProgress = eligible.filter((task) => task.state === "in_progress").length;
-        const topTasks = [
-            ...eligible.filter((task) => task.state === "in_progress").sort(compareTaskStatusRows),
-            ...eligible.filter((task) => task.state === "open" && !task.blocked).sort(compareTaskStatusRows),
-        ]
-            .slice(0, 5)
-            .map(({ id, title, pri, createdAt, state, blocked }) => ({ id, title, pri, createdAt, state, blocked }));
-        const ready = eligible.filter((task) => task.state === "open" && !task.blocked).length;
-        const blocked = eligible.filter((task) => task.state === "open" && task.blocked).length;
-        if (board.tasks.length === 0 && board.diseases.length === 0)
-            return undefined;
-        return { total: board.tasks.length, inProgress, ready, blocked, topTasks, diseases: board.diseases };
+        return deriveTaskStatusSummary(board, now);
     }
     catch (error) {
         return {
@@ -40,6 +66,7 @@ async function readTaskStatusSummary(cwd) {
             inProgress: 0,
             ready: 0,
             blocked: 0,
+            omitted: 0,
             topTasks: [],
             diseases: [],
             diagnostic: error instanceof Error ? error.message : String(error),
@@ -141,14 +168,14 @@ function deriveLastActiveAge(entries, now) {
 export async function readKanshiBoard(cwd, now, opts) {
     const targetFilter = opts?.target ?? null;
     const loadedSettings = await loadKeiyakuSettings(cwd);
-    const tasks = await readTaskStatusSummary(cwd);
+    const tasks = await readTaskStatusSummary(cwd, now);
     const repository = await observeGitRepository(cwd);
     if (repository.capability === "unknown")
         throw repository.error;
     if (repository.capability !== "available" || repository.coordinate !== "repository") {
         return {
             contracts: [],
-            projections: readProjectionStatusBoard(cwd, now, { showAll: opts?.showAllProjections }),
+            projections: await readProjectionStatusBoard(cwd, now, { showAll: opts?.showAllProjections }),
             queueLength: 0,
             diseases: loadedSettings.diseases,
             claimReconciliation: null,
@@ -165,22 +192,14 @@ export async function readKanshiBoard(cwd, now, opts) {
     catch {
         defaultBranch = null;
     }
-    const contractIds = await listContractIds(cwd);
     const terminalById = new Map();
-    const ledgers = [];
+    const ledgers = await readStatusLedgers(cwd);
     const readableLedgers = [];
-    for (const id of contractIds) {
-        try {
-            const ledger = await readLedger(cwd, id);
-            if (ledger) {
-                ledgers.push(ledger);
-                readableLedgers.push(ledger);
-                terminalById.set(id, isTerminalState(deriveContractState(ledger.entries)));
-            }
-        }
-        catch (error) {
-            ledgers.push({ id, error: error instanceof Error ? error : new Error(String(error)) });
-        }
+    for (const ledger of ledgers) {
+        if ("error" in ledger)
+            continue;
+        readableLedgers.push(ledger);
+        terminalById.set(ledger.contractId, isTerminalState(deriveContractState(ledger.entries)));
     }
     const queueModel = deriveQueueReadModel(readableLedgers);
     const boardQueueLength = queueModel.targetQueues.reduce((sum, queue) => sum + queue.ordered.length, 0);
@@ -194,6 +213,7 @@ export async function readKanshiBoard(cwd, now, opts) {
             contracts.push({
                 id: item.id,
                 slug: contractSlugFromId(item.id),
+                title: contractSlugFromId(item.id),
                 state: { state: "corrupt", at: 0, reason: item.error.message },
                 queueHeadStalled: false,
                 arcs: 0,
@@ -245,6 +265,7 @@ export async function readKanshiBoard(cwd, now, opts) {
         contracts.push({
             id: item.contractId,
             slug: contractSlugFromId(item.contractId),
+            title: bind?.data.name ?? contractSlugFromId(item.contractId),
             state,
             queuePosition,
             queueHeadStalled: isQueueHeadStall({
@@ -277,7 +298,7 @@ export async function readKanshiBoard(cwd, now, opts) {
     const claimReconciliation = await computeClaimReconciliation(cwd, defaultBranch);
     return {
         contracts: filteredContracts,
-        projections: readProjectionStatusBoard(cwd, now, { showAll: opts?.showAllProjections }),
+        projections: await readProjectionStatusBoard(cwd, now, { showAll: opts?.showAllProjections }),
         queueLength,
         defaultBranch: defaultBranch?.branch,
         defaultHead: defaultBranch?.head,