@astrosheep/keiyaku 2.9.11 → 2.9.13

package/build/core/status/board.js

@@ -1,15 +1,15 @@
 import { availableParallelism } from "node:os";
-import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { loadKeiyakuSettings } from "../../config/settings/loader.js";
 import { observeGitRepository } from "../../git/branches.js";
 import { currentLifecycleState } from "../repository-ledger/read-model.js";
-import { parseCarrierIdentity } from "../contract-carrier.js";
+import { verifyCarrier } from "../contract-carrier.js";
+import { resolveExplicitContractAddressFromRead, } from "../addressing.js";
 import { KEIYAKU_FILE } from "../../keiyaku.js";
 import { lookupCurrentContract, } from "../repository-ledger/read-model.js";
-import { readExactProjectionStatus, readOperationalProjectionStatusBoard, } from "../projection/index.js";
+import { readOperationalProjectionStatusBoard, readProjectionRosterStatusBoard, paginateProjectionStatusRoster, selectProjectionStatus, } from "../projection/index.js";
 import { deriveQueueReadModel, queueMembership, } from "../settlement/index.js";
-import { openTaskStore, readTaskBoard, taskRepositoryFromStore, taskUpdatedAt, } from "../task/index.js";
+import { openTaskStore, readTaskBoard, taskRepositoryFromStore, taskUpdatedAt, taskNamespaceFromScope, } from "../task/index.js";
 import { replayBlockingFact, } from "./lifecycle.js";
 import { findRegisteredContractWorktreePathFromModel, stableRepoRoot } from "../worktree-path.js";
 import { evaluateBaseDrift, resolveDefaultBranchFromSettings, } from "./drift.js";
@@ -28,27 +28,32 @@ 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" || task.state === "on_hold"));
+function taskStatusRow(task, now) {
+    const updatedAt = taskUpdatedAt(task);
+    return {
+        id: task.id,
+        localId: task.id,
+        namespace: task.namespace,
+        coordinate: task.coordinate,
+        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),
+    };
+}
+export function deriveTaskStatusSummary(board, now, attribution = new Map()) {
+    const eligible = board.tasks.filter((task) => !attribution.has(task.namespace ?? "")
+        && (task.state === "open" || task.state === "in_progress" || task.state === "on_hold"));
     const inProgress = eligible.filter((task) => task.state === "in_progress").length;
     const onHold = eligible.filter((task) => task.state === "on_hold").length;
     const topTasks = eligible
         .filter((task) => task.state === "in_progress" || task.state === "on_hold")
         .sort(compareTaskStatusRows)
-        .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),
-        };
-    });
+        .map((task) => taskStatusRow(task, now));
     const ready = eligible.filter((task) => task.state === "open" && !task.blocked).length;
     const blocked = eligible.filter((task) => task.state === "open" && task.blocked).length;
     return {
@@ -60,12 +65,65 @@ export function deriveTaskStatusSummary(board, now) {
         omitted: ready + blocked,
         topTasks,
         diseases: board.diseases,
+        contractProgress: deriveContractTaskProgress(board, now, attribution),
     };
 }
-async function readTaskStatusSummary(cwd, now) {
+function deriveContractTaskProgress(board, now, attribution) {
+    const grouped = new Map();
+    for (const task of board.tasks) {
+        const fact = task.namespace === null ? undefined : attribution.get(task.namespace);
+        if (!fact || task.state === "drop")
+            continue;
+        const group = grouped.get(fact.contractId) ?? { fact, tasks: [] };
+        group.tasks.push(task);
+        grouped.set(fact.contractId, group);
+    }
+    return [...grouped.values()].map(({ fact, tasks }) => {
+        const ordered = [...tasks].sort(compareTaskStatusRows);
+        const visible = ordered.map((task) => taskStatusRow(task, now));
+        const current = visible.find((task) => task.state === "in_progress" || task.state === "on_hold" || task.state === "open");
+        return {
+            contractId: fact.contractId,
+            namespace: fact.namespace,
+            total: tasks.length,
+            done: tasks.filter((task) => task.state === "done").length,
+            inProgress: tasks.filter((task) => task.state === "in_progress").length,
+            onHold: tasks.filter((task) => task.state === "on_hold").length,
+            ready: tasks.filter((task) => task.state === "open" && !task.blocked).length,
+            blocked: tasks.filter((task) => task.state === "open" && task.blocked).length,
+            ...(current ? { current } : {}),
+            tasks: visible,
+        };
+    }).sort((left, right) => left.contractId.localeCompare(right.contractId));
+}
+export function deriveContractTaskNamespaceAttribution(facts) {
+    const byNamespace = new Map();
+    for (const fact of facts) {
+        const prior = byNamespace.get(fact.namespace);
+        if (prior && prior.contractId !== fact.contractId) {
+            throw new Error(`task namespace ${fact.namespace} is attributed to multiple contracts`);
+        }
+        byNamespace.set(fact.namespace, fact);
+    }
+    return byNamespace;
+}
+/** Attribute namespaces only from accepted lifecycle scope facts. */
+export function contractTaskNamespaceFacts(models) {
+    return models.flatMap((model) => {
+        const namespaces = model.effectiveScope.flatMap((term) => taskNamespaceFromScope(term) ?? []);
+        if (namespaces.length !== 1)
+            return [];
+        return [{
+                contractId: model.contract,
+                namespace: namespaces[0],
+                lifecycle: model.phase === "claimed" || model.phase === "forfeited" ? "terminal" : "active",
+            }];
+    });
+}
+async function readTaskStatusSummary(cwd, now, attribution = new Map()) {
     try {
         const board = await readTaskBoard(taskRepositoryFromStore(await openTaskStore(cwd)));
-        return deriveTaskStatusSummary(board, now);
+        return deriveTaskStatusSummary(board, now, attribution);
     }
     catch (error) {
         return {
@@ -77,6 +135,7 @@ async function readTaskStatusSummary(cwd, now) {
             omitted: 0,
             topTasks: [],
             diseases: [],
+            contractProgress: [],
             diagnostic: error instanceof Error ? error.message : String(error),
         };
     }
@@ -113,6 +172,9 @@ function bootstrapReplayBlockers(model) {
         : [];
 }
 function deriveNextStep(input) {
+    if (input.state.state === "claimed" || input.state.state === "forfeited") {
+        return { kind: "terminal", detail: input.state.state };
+    }
     if (input.state.state === "corrupt") {
         return { kind: "inspect-log", detail: "inspect log" };
     }
@@ -123,9 +185,6 @@ function deriveNextStep(input) {
     if (input.state.state === "petitioned") {
         return { kind: "await-claim", detail: "await claim" };
     }
-    if (input.baseDrift.state === "drift" || input.baseDrift.state === "orphaned") {
-        return { kind: "renew", detail: "renew" };
-    }
     // Derived a0 (bound/active, no explicit arc) petitions directly; explicit open arcs still suggest arc work.
     if (input.currentArc.state === "open" && input.currentArc.number === 0) {
         return { kind: "petition", detail: "petition" };
@@ -171,24 +230,24 @@ export async function evaluateDistinctBaseDrifts(cwd, bases, defaultBranch, eval
 export async function readKanshiBoard(cwd, now, opts) {
     const targetFilter = opts?.target ?? null;
     const loadedSettings = await loadKeiyakuSettings(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") {
-        const exactProjection = opts?.projectionId === undefined
+        const exactProjection = opts?.projectionAddress === undefined
             ? undefined
-            : await readExactProjectionStatus(cwd, now, opts.projectionId);
+            : await selectProjectionStatus(cwd, now, { kind: "address", token: opts.projectionAddress });
         return {
             contracts: [],
             contractsObservable: false,
             commissionPlaces: new Map(),
-            projections: opts?.projectionId === undefined
-                ? await readOperationalProjectionStatusBoard(cwd, now)
-                : exactProjection ? { rows: [exactProjection] } : null,
+            projections: opts?.projectionAddress === undefined
+                ? opts?.roster ? await readProjectionRosterStatusBoard(cwd, now) : await readOperationalProjectionStatusBoard(cwd, now)
+                : exactProjection?.board ?? null,
             queueLength: 0,
             diseases: loadedSettings.diseases,
             targetFilter,
+            tasks: await readTaskStatusSummary(cwd, now),
             // Task and contract boards are repository organs; a non-repository cwd
             // cannot truthfully turn their absence into a zero count.
         };
@@ -203,7 +262,18 @@ export async function readKanshiBoard(cwd, now, opts) {
         defaultBranch = null;
     }
     const lifecycle = await readStatusLifecycle(cwd);
+    const taskAttribution = deriveContractTaskNamespaceAttribution(contractTaskNamespaceFacts(lifecycle.contracts));
+    const tasks = await readTaskStatusSummary(cwd, now, taskAttribution);
     const stableRoot = await stableRepoRoot(cwd);
+    const commissionFilter = opts?.commission === undefined
+        ? undefined
+        : resolveExplicitContractAddressFromRead({
+            read: lifecycle,
+            stableRoot,
+            workdir: cwd,
+            raw: opts.commission.raw,
+            source: opts.commission.source,
+        }).address.binding.commissionId;
     const terminalById = new Map(lifecycle.contracts.map((model) => [
         model.contract,
         model.phase === "claimed" || model.phase === "forfeited",
@@ -227,16 +297,19 @@ export async function readKanshiBoard(cwd, now, opts) {
         commissionPlaces.set(model.contract, model.resources.worktree?.place ?? null);
         derivedTargetById.set(model.contract, model.pins.target.ref);
         const base = model.pins.base;
-        // Terminal lifecycle facts retire their carrier and worktree projections.
-        // Do not interpret a different active workspace-here carrier as terminal
-        // replay debt.
-        if (model.phase === "claimed" || model.phase === "forfeited")
+        const terminal = model.phase === "claimed" || model.phase === "forfeited";
+        // Terminal contracts retire from the aggregate board. An exact selector
+        // may still open the folded row as a read-only carrier for its task
+        // namespace, including completed tasks.
+        if (terminal && commissionFilter !== model.contract)
             continue;
         const after = model.causal.after.map((id) => ({ id, terminal: terminalById.get(id) ?? false }));
         const currentArc = deriveCurrentArc(model);
-        const baseDrift = base
-            ? baseDrifts.get(base) ?? { state: "unknown", label: "n/a (base drift unavailable)" }
-            : { state: "unknown", label: "n/a (no default branch)" };
+        const baseDrift = terminal
+            ? { state: "unknown", label: "n/a (terminal contract)" }
+            : base
+                ? baseDrifts.get(base) ?? { state: "unknown", label: "n/a (base drift unavailable)" }
+                : { state: "unknown", label: "n/a (no default branch)" };
         const nextStep = deriveNextStep({
             id: model.contract,
             state,
@@ -244,40 +317,39 @@ export async function readKanshiBoard(cwd, now, opts) {
             baseDrift,
             after,
         });
-        if (nextStep.kind === "renew" && baseDrift.state === "drift") {
-            nextStep.hint = `run: keiyaku @${model.contract} renew — follows ${baseDrift.defaultBranch} ▲${baseDrift.behindBy}`;
-        }
-        const membership = queueMembership(queueModel, model.contract);
+        const membership = terminal ? undefined : queueMembership(queueModel, model.contract);
         const queuePosition = membership?.position ?? null;
         const targetQueueLength = membership?.queueLength ?? 0;
-        const replayBlockers = bootstrapReplayBlockers(model);
-        const carrierRoot = model.resources.worktree === null
-            ? stableRoot
-            : await findRegisteredContractWorktreePathFromModel(stableRoot, model);
-        if (model.resources.worktree !== null && carrierRoot === undefined) {
+        const replayBlockers = terminal ? [] : bootstrapReplayBlockers(model);
+        const carrierRoot = terminal
+            ? undefined
+            : model.resources.worktree === null
+                ? stableRoot
+                : await findRegisteredContractWorktreePathFromModel(stableRoot, model);
+        if (!terminal && model.resources.worktree !== null && carrierRoot === undefined) {
             replayBlockers.unshift(replayBlockingFact(model.contract, "worktree"));
         }
-        else if (carrierRoot !== undefined) {
-            let carrierIdentity = null;
-            try {
-                carrierIdentity = parseCarrierIdentity(await fs.readFile(path.join(carrierRoot, KEIYAKU_FILE), "utf8"));
-            }
-            catch {
-                carrierIdentity = null;
-            }
-            if (carrierIdentity?.contractId !== model.contract || carrierIdentity.ledgerHead !== model.observedLedgerHead) {
-                const reason = carrierIdentity === null
+        else if (!terminal && carrierRoot !== undefined) {
+            const verification = await verifyCarrier({ target: path.join(carrierRoot, KEIYAKU_FILE), lifecycle: model });
+            if (verification.status !== "current") {
+                const actual = "actual" in verification ? verification.actual : null;
+                const reason = verification.status === "missing" || verification.status === "invalid-header"
                     ? "missing-or-invalid"
-                    : carrierIdentity.contractId !== model.contract
-                        ? "contract-id-mismatch"
-                        : "ledger-head-mismatch";
+                    : verification.status === "modified"
+                        ? "carrier-modified"
+                        : actual?.contractId !== model.contract
+                            ? "contract-id-mismatch"
+                            : actual?.contractHead !== model.contractHead
+                                ? "contract-head-mismatch"
+                                : "carrier-digest-mismatch";
                 replayBlockers.push(replayBlockingFact(model.contract, "carrier", {
                     reason,
-                    expected: { contractId: model.contract, ledgerHead: model.observedLedgerHead },
-                    observed: carrierIdentity,
+                    expected: verification.expected,
+                    observed: actual,
                 }));
             }
         }
+        const taskProgress = tasks?.contractProgress.find((progress) => progress.contractId === model.contract);
         contracts.push({
             id: model.contract,
             slug: contractSlugFromId(model.contract),
@@ -301,6 +373,7 @@ export async function readKanshiBoard(cwd, now, opts) {
             lifecycleDiagnostics: outcome.diagnostics,
             replayBlockers,
             queueDiagnostics: membership ? [...membership.diagnostics] : [],
+            ...(taskProgress ? { tasks: taskProgress } : {}),
         });
     }
     for (const contract of lifecycle.isolatedContracts) {
@@ -317,30 +390,66 @@ export async function readKanshiBoard(cwd, now, opts) {
             replayBlockers: [], queueDiagnostics: [],
         });
     }
-    const filteredContracts = targetFilter === null
-        ? contracts
-        : contracts.filter((contract) => {
-            const derived = derivedTargetById.get(contract.id);
-            return derived === undefined || derived === targetFilter;
-        });
+    const filteredContracts = contracts.filter((contract) => {
+        if (commissionFilter !== undefined && contract.id !== commissionFilter)
+            return false;
+        if (targetFilter === null)
+            return true;
+        const derived = derivedTargetById.get(contract.id);
+        return derived === undefined || derived === targetFilter;
+    });
     const queueLength = targetFilter === null
         ? boardQueueLength
         : (queueModel.targetQueues.find((queue) => queue.target === targetFilter)?.ordered.length ?? 0);
-    const exactProjection = opts?.projectionId === undefined
+    const exactProjection = opts?.projectionAddress === undefined
         ? undefined
-        : await readExactProjectionStatus(cwd, now, opts.projectionId);
+        : await selectProjectionStatus(cwd, now, { kind: "address", token: opts.projectionAddress });
+    const operationalProjections = opts?.projectionAddress === undefined
+        ? opts?.roster ? await readProjectionRosterStatusBoard(cwd, now) : await readOperationalProjectionStatusBoard(cwd, now)
+        : undefined;
+    // The aggregate reader deliberately folds terminal rows before their identity
+    // is opened. A commission scope therefore keeps only attributable live rows,
+    // never an aggregate whose counts could include a different commission.
+    const selectedProjections = opts?.projectionAddress === undefined
+        ? commissionFilter === undefined
+            ? operationalProjections ?? null
+            : operationalProjections
+                ? {
+                    rows: operationalProjections.rows.filter((row) => row.binding?.kind === "commission" && row.binding.commissionId === commissionFilter),
+                }
+                : null
+        : exactProjection?.board ?? null;
+    const projections = opts?.roster && selectedProjections
+        ? paginateProjectionStatusRoster(selectedProjections, { limit: opts.rosterLimit, offset: opts.rosterOffset })
+        : selectedProjections;
+    const filteredCommissionPlaces = commissionFilter === undefined
+        ? commissionPlaces
+        : new Map([[commissionFilter, commissionPlaces.get(commissionFilter) ?? null]]);
     return {
         contracts: filteredContracts,
         contractsObservable: true,
-        commissionPlaces,
-        projections: opts?.projectionId === undefined
-            ? await readOperationalProjectionStatusBoard(cwd, now)
-            : exactProjection ? { rows: [exactProjection] } : null,
+        commissionPlaces: filteredCommissionPlaces,
+        projections,
         queueLength,
         defaultBranch: defaultBranch?.branch,
         defaultHead: defaultBranch?.head,
         diseases: loadedSettings.diseases,
         targetFilter,
-        ...(tasks ? { tasks } : {}),
+        ...(tasks ? {
+            tasks: commissionFilter === undefined
+                ? tasks
+                : {
+                    ...tasks,
+                    total: 0,
+                    inProgress: 0,
+                    onHold: 0,
+                    ready: 0,
+                    blocked: 0,
+                    omitted: 0,
+                    topTasks: [],
+                    contractProgress: tasks.contractProgress.filter((progress) => progress.contractId === commissionFilter),
+                },
+        } : {}),
+        ...(commissionFilter === undefined ? {} : { commissionFilter }),
     };
 }

package/build/core/status/drift.js

@@ -2,7 +2,8 @@ import { assertSettingsKnobUsable } from "../../config/settings/disease.js";
 import { loadKeiyakuSettings } from "../../config/settings/loader.js";
 import { FlowError } from "../../flow-error.js";
 import { resolveLocalBranchHead } from "../../git/refs.js";
-import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, wrapGitError } from "../../git/core.js";
+import { readCommitCoordinate, commitCoordinateFailureError } from "../../git/commits.js";
+import { createGit } from "../../git/core.js";
 function findBindEntry(entries) {
     return entries.find((entry) => entry.kind === "bind");
 }
@@ -26,15 +27,12 @@ export function commissionTarget(entries) {
     };
 }
 export async function resolveCommit(cwd, ref) {
-    const git = createGit(cwd);
-    try {
-        return (await git.raw(["rev-parse", "--verify", `${ref}^{commit}`])).trim();
-    }
-    catch (error) {
-        if (errorContainsAnyPattern(error, MISSING_HEAD_PATTERNS))
-            return null;
-        throw wrapGitError(`rev-parse ${ref}`, error, cwd);
-    }
+    const read = await readCommitCoordinate(cwd, ref);
+    if (read.status === "ok")
+        return read.coordinate.commit;
+    if (read.status === "missing" || read.status === "non-commit")
+        return null;
+    throw commitCoordinateFailureError(read, cwd);
 }
 export async function readSettingsDiseases(cwd) {
     const loaded = await loadKeiyakuSettings(cwd);

package/build/core/task/board.js

@@ -198,6 +198,7 @@ export function buildTaskBoardFromDocuments(documents) {
             from: [...task.from],
             supersedes: [...task.supersedes],
             relatesTo: [...task.relatesTo],
+            notes: task.notes.map((note) => ({ ...note })),
             createdAt: task.createdAt,
             ...(task.updatedAt === undefined ? {} : { updatedAt: task.updatedAt }),
             creator: task.creator,

package/build/core/task/commands.js

@@ -21,6 +21,7 @@ function documentFromView(view) {
         from: [...view.from],
         supersedes: [...view.supersedes],
         relatesTo: [...view.relatesTo],
+        notes: view.notes.map((note) => ({ ...note })),
         createdAt: view.createdAt,
         ...(view.updatedAt === undefined ? {} : { updatedAt: view.updatedAt }),
         creator: view.creator,
@@ -140,6 +141,7 @@ export async function createTask(repository, input, deps) {
             from,
             supersedes,
             relatesTo,
+            notes: [],
             createdAt: dateTimestamp("createdAt", now),
             updatedAt: dateTimestamp("updatedAt", now),
             creator: input.creator,
@@ -322,6 +324,26 @@ export async function doneTask(repository, fullId, now = new Date()) {
     }, (id) => `Done task ${id}`, now);
 }
 export async function dropTask(repository, fullId, now = new Date()) {
+    return dropTaskWithNote(repository, fullId, undefined, now);
+}
+export async function appendTaskNote(repository, fullId, input, now = new Date()) {
+    nonblank("task note actor", input.actor);
+    nonblank("task note text", input.text);
+    return repository.mutate((board) => {
+        requireHealthy(board);
+        const id = resolveTaskId(board, fullId);
+        const current = requireExisting(board, id);
+        const document = documentFromView(current);
+        document.notes.push({ actor: input.actor, timestamp: dateTimestamp("task note timestamp", now), text: input.text });
+        document.updatedAt = advancedTaskUpdatedAt(current, now);
+        return replaceDocument(document, `Note task ${id}`);
+    });
+}
+export async function dropTaskWithNote(repository, fullId, note, now = new Date()) {
+    if (note !== undefined) {
+        nonblank("task note actor", note.actor);
+        nonblank("task note text", note.text);
+    }
     return transition(repository, fullId, (document) => {
         rejectBound(document, "drop");
         if (document.state !== "open" && document.state !== "in_progress" && document.state !== "on_hold") {
@@ -329,6 +351,9 @@ export async function dropTask(repository, fullId, now = new Date()) {
         }
         document.state = "drop";
         delete document.startedAt;
+        if (note !== undefined) {
+            document.notes.push({ actor: note.actor, timestamp: dateTimestamp("task note timestamp", now), text: note.text });
+        }
     }, (id) => `Drop task ${id}`, now);
 }
 export function selectSoleInProgress(board) {