@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/core/status/board.js

@@ -1,455 +0,0 @@
-import { availableParallelism } from "node:os";
-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 { 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 { readOperationalProjectionStatusBoard, readProjectionRosterStatusBoard, paginateProjectionStatusRoster, selectProjectionStatus, } from "../projection/index.js";
-import { deriveQueueReadModel, queueMembership, } from "../settlement/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";
-import { readRepositoryLifecycleSummaries as readStatusLifecycle } from "../repository-ledger/read-model.js";
-// Git object reads benefit from overlap, but a hard cap avoids process and disk contention.
-const STATUS_DRIFT_MAX_CONCURRENCY = 8;
-const STATUS_DRIFT_CONCURRENCY = Math.min(STATUS_DRIFT_MAX_CONCURRENCY, availableParallelism());
-function compareTaskStatusRows(left, right) {
-    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;
-}
-function timestampAge(timestamp, now) {
-    const value = Date.parse(timestamp);
-    return Number.isFinite(value) ? Math.max(0, now - value) : 0;
-}
-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) => 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 {
-        total: eligible.length,
-        inProgress,
-        onHold,
-        ready,
-        blocked,
-        omitted: ready + blocked,
-        topTasks,
-        diseases: board.diseases,
-        contractProgress: deriveContractTaskProgress(board, now, attribution),
-    };
-}
-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, attribution);
-    }
-    catch (error) {
-        return {
-            total: 0,
-            inProgress: 0,
-            onHold: 0,
-            ready: 0,
-            blocked: 0,
-            omitted: 0,
-            topTasks: [],
-            diseases: [],
-            contractProgress: [],
-            diagnostic: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-function isQueueHeadStall(input) {
-    return (input.queuePosition === 1 &&
-        input.queueLength > 1 &&
-        input.state.state === "petitioned" &&
-        !input.hasVerdict);
-}
-function contractSlugFromId(id) {
-    const dot = id.indexOf(".");
-    if (dot > 0)
-        return id.slice(0, dot);
-    return id;
-}
-function deriveCurrentArc(model) {
-    return {
-        number: model.intent.arc,
-        objective: model.intent.objective,
-        state: model.phase === "active" ? "open" : "closed",
-    };
-}
-function bindTitle(model) {
-    const bind = model.history.find(({ entry }) => entry.kind === "bind")?.entry;
-    return bind?.kind === "bind" ? bind.data.title : model.intent.title;
-}
-function lifecycleDiseaseReason(read, contract) {
-    return read.diagnostics.filter((diagnostic) => diagnostic.contract === contract).map((diagnostic) => diagnostic.detail).join("; ");
-}
-function bootstrapReplayBlockers(model) {
-    return model.bootstrapReplay.state === "pending"
-        ? [replayBlockingFact(model.contract, "bootstrap")]
-        : [];
-}
-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" };
-    }
-    const pendingAfter = input.after.filter((item) => !item.terminal).map((item) => contractSlugFromId(item.id));
-    if (pendingAfter.length > 0) {
-        return { kind: "wait-after", detail: `finish after ${pendingAfter.join(",")}` };
-    }
-    if (input.state.state === "petitioned") {
-        return { kind: "await-claim", detail: "await claim" };
-    }
-    // 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" };
-    }
-    if (input.currentArc.state === "open") {
-        return { kind: "arc", detail: "arc" };
-    }
-    if (input.state.state === "active" && input.currentArc.number > 0) {
-        return { kind: "petition", detail: "petition" };
-    }
-    return { kind: "arc", detail: "arc" };
-}
-function deriveLastActiveAge(model, now) {
-    const last = model.history.at(-1)?.entry;
-    if (!last)
-        return {};
-    const atMs = Date.parse(last.at);
-    if (!Number.isFinite(atMs)) {
-        return { lastActivityAt: last.at };
-    }
-    return {
-        lastActivityAt: last.at,
-        lastActiveMs: Math.max(0, now - atMs),
-    };
-}
-export async function evaluateDistinctBaseDrifts(cwd, bases, defaultBranch, evaluate = evaluateBaseDrift) {
-    const uniqueBases = [...new Set(bases)];
-    const results = new Map();
-    let nextIndex = 0;
-    const worker = async () => {
-        while (nextIndex < uniqueBases.length) {
-            const index = nextIndex++;
-            const base = uniqueBases[index];
-            if (base === undefined)
-                return;
-            results.set(base, await evaluate(cwd, base, defaultBranch));
-        }
-    };
-    const workerCount = Math.min(STATUS_DRIFT_CONCURRENCY, uniqueBases.length);
-    await Promise.all(Array.from({ length: workerCount }, () => worker()));
-    return results;
-}
-export async function readKanshiBoard(cwd, now, opts) {
-    const targetFilter = opts?.target ?? null;
-    const loadedSettings = await loadKeiyakuSettings(cwd);
-    const repository = await observeGitRepository(cwd);
-    if (repository.capability === "unknown")
-        throw repository.error;
-    if (repository.capability !== "available" || repository.coordinate !== "repository") {
-        const exactProjection = opts?.projectionAddress === undefined
-            ? undefined
-            : await selectProjectionStatus(cwd, now, { kind: "address", token: opts.projectionAddress });
-        return {
-            contracts: [],
-            contractsObservable: false,
-            commissionPlaces: new Map(),
-            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.
-        };
-    }
-    // Status is a pure reader: use the same resolver, but retain its ability to
-    // open when the defaultBranch knob itself is diseased.
-    let defaultBranch = null;
-    try {
-        defaultBranch = await resolveDefaultBranchFromSettings(cwd, loadedSettings, false);
-    }
-    catch {
-        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",
-    ]));
-    const queueModel = deriveQueueReadModel(lifecycle);
-    const boardQueueLength = queueModel.targetQueues.reduce((sum, queue) => sum + queue.ordered.length, 0);
-    const baseDrifts = await evaluateDistinctBaseDrifts(cwd, lifecycle.contracts.flatMap((model) => {
-        const outcome = lookupCurrentContract(lifecycle, model.contract);
-        return outcome.status === "healthy" && !terminalById.get(model.contract) ? [model.pins.base] : [];
-    }), defaultBranch);
-    const contracts = [];
-    const commissionPlaces = new Map();
-    // Folded target pins are retained only for post-assembly filtering.
-    const derivedTargetById = new Map();
-    for (const model of lifecycle.contracts) {
-        const outcome = lookupCurrentContract(lifecycle, model.contract);
-        const diseaseReason = lifecycleDiseaseReason(lifecycle, model.contract);
-        const state = outcome.status === "healthy"
-            ? currentLifecycleState(model)
-            : { state: "corrupt", at: 0, reason: diseaseReason || "isolated lifecycle disease" };
-        commissionPlaces.set(model.contract, model.resources.worktree?.place ?? null);
-        derivedTargetById.set(model.contract, model.pins.target.ref);
-        const base = model.pins.base;
-        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 = 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,
-            currentArc,
-            baseDrift,
-            after,
-        });
-        const membership = terminal ? undefined : queueMembership(queueModel, model.contract);
-        const queuePosition = membership?.position ?? null;
-        const targetQueueLength = membership?.queueLength ?? 0;
-        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 (!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"
-                    : 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: verification.expected,
-                    observed: actual,
-                }));
-            }
-        }
-        const taskProgress = tasks?.contractProgress.find((progress) => progress.contractId === model.contract);
-        contracts.push({
-            id: model.contract,
-            slug: contractSlugFromId(model.contract),
-            title: bindTitle(model),
-            state,
-            queuePosition,
-            queueHeadStalled: isQueueHeadStall({
-                queuePosition,
-                queueLength: targetQueueLength,
-                state,
-                hasVerdict: model.petition.state === "approved",
-            }),
-            arcs: model.intent.arc,
-            currentArc,
-            nextStep,
-            ...deriveLastActiveAge(model, now),
-            place: model.resources.worktree?.place ?? null,
-            base,
-            baseDrift,
-            after,
-            lifecycleDiagnostics: outcome.diagnostics,
-            replayBlockers,
-            queueDiagnostics: membership ? [...membership.diagnostics] : [],
-            ...(taskProgress ? { tasks: taskProgress } : {}),
-        });
-    }
-    for (const contract of lifecycle.isolatedContracts) {
-        if (lifecycle.contracts.some((model) => model.contract === contract))
-            continue;
-        const reason = lifecycleDiseaseReason(lifecycle, contract) || "isolated lifecycle disease";
-        derivedTargetById.set(contract, undefined);
-        contracts.push({
-            id: contract, slug: contractSlugFromId(contract), title: contractSlugFromId(contract),
-            state: { state: "corrupt", at: 0, reason }, queueHeadStalled: false, arcs: 0,
-            currentArc: { number: 0, objective: "", state: "closed" }, nextStep: { kind: "inspect-log", detail: "inspect log" },
-            baseDrift: { state: "unknown", label: "n/a (corrupt ledger)" }, after: [], corruptReason: reason,
-            lifecycleDiagnostics: lifecycle.diagnostics.filter((diagnostic) => diagnostic.contract === contract),
-            replayBlockers: [], queueDiagnostics: [],
-        });
-    }
-    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?.projectionAddress === undefined
-        ? undefined
-        : 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: filteredCommissionPlaces,
-        projections,
-        queueLength,
-        defaultBranch: defaultBranch?.branch,
-        defaultHead: defaultBranch?.head,
-        diseases: loadedSettings.diseases,
-        targetFilter,
-        ...(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

@@ -1,113 +0,0 @@
-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 { readCommitCoordinate, commitCoordinateFailureError } from "../../git/commits.js";
-import { createGit } from "../../git/core.js";
-function findBindEntry(entries) {
-    return entries.find((entry) => entry.kind === "bind");
-}
-export function latestBase(entries) {
-    for (let index = entries.length - 1; index >= 0; index -= 1) {
-        const entry = entries[index];
-        if (entry.kind === "renew")
-            return entry.data.newBase;
-    }
-    return entries.find((entry) => entry.kind === "bind")?.data.base;
-}
-/** Commission settlement target from the bind entry. Schema guarantees refs/heads/<name>. */
-export function commissionTarget(entries) {
-    const bind = findBindEntry(entries);
-    if (!bind)
-        return undefined;
-    const ref = bind.data.target;
-    return {
-        ref,
-        branch: ref.slice("refs/heads/".length),
-    };
-}
-export async function resolveCommit(cwd, ref) {
-    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);
-    return loaded.diseases;
-}
-export async function readDefaultBranchOverride(cwd) {
-    const loaded = await loadKeiyakuSettings(cwd);
-    return loaded.knobs?.defaultBranch;
-}
-export async function resolveDefaultBranchFromSettings(cwd, loaded, rejectDiseasedOverride) {
-    if (rejectDiseasedOverride)
-        assertSettingsKnobUsable(loaded, "defaultBranch");
-    const override = loaded.knobs?.defaultBranch;
-    if (override) {
-        const resolved = await resolveLocalBranchHead(cwd, override);
-        if (!resolved) {
-            const source = loaded.knobSources.defaultBranch;
-            if (source === undefined) {
-                throw new Error("admitted defaultBranch has no settings source coordinate");
-            }
-            throw new FlowError("INVALID_SETTINGS", `${source.coordinate} defaultBranch '${override}' does not resolve`, {
-                facts: {
-                    kind: "invalid_settings",
-                    diseases: [{
-                            source: source.source,
-                            coordinate: source.coordinate,
-                            knob: "defaultBranch",
-                            reason: `defaultBranch '${override}' does not resolve as a local branch`,
-                        }],
-                },
-            });
-        }
-        const branch = resolved.ref.slice("refs/heads/".length);
-        return { branch, head: resolved.head };
-    }
-    const git = createGit(cwd);
-    for (const branch of ["main", "master"]) {
-        const head = await resolveCommit(cwd, branch);
-        if (head)
-            return { branch, head };
-    }
-    try {
-        const originHead = (await git.raw(["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"])).trim();
-        if (originHead) {
-            const head = await resolveCommit(cwd, originHead);
-            if (head)
-                return { branch: originHead, head };
-        }
-    }
-    catch {
-        // Fall through to local branch heuristics.
-    }
-    return null;
-}
-export async function resolveDefaultBranch(cwd) {
-    return resolveDefaultBranchFromSettings(cwd, await loadKeiyakuSettings(cwd), true);
-}
-export async function evaluateBaseDrift(cwd, base, defaultBranch) {
-    if (!defaultBranch)
-        return { state: "unknown", label: "n/a (no default branch)" };
-    if (base === defaultBranch.head) {
-        return { state: "green", defaultBranch: defaultBranch.branch, defaultHead: defaultBranch.head };
-    }
-    const git = createGit(cwd);
-    try {
-        await git.raw(["merge-base", "--is-ancestor", base, defaultBranch.head]);
-        const behindBy = Number.parseInt((await git.raw(["rev-list", "--count", `${base}..${defaultBranch.head}`])).trim(), 10);
-        return {
-            state: "drift",
-            defaultBranch: defaultBranch.branch,
-            defaultHead: defaultBranch.head,
-            behindBy: Number.isFinite(behindBy) ? behindBy : 0,
-        };
-    }
-    catch {
-        return { state: "orphaned", defaultBranch: defaultBranch.branch, defaultHead: defaultBranch.head };
-    }
-}

package/build/core/status/lifecycle.js

@@ -1,11 +0,0 @@
-export function isTerminalState(state) {
-    return state.state === "claimed" || state.state === "forfeited";
-}
-export function replayBlockingFact(contract, surface, carrierMismatch) {
-    return {
-        kind: "incomplete-replay",
-        surface,
-        recoveryCommand: `keiyaku bind --contract ${contract}`,
-        ...(carrierMismatch ? { carrierMismatch } : {}),
-    };
-}