@astrosheep/keiyaku 2.9.8 → 2.9.10

package/build/core/contract-carrier.js

@@ -0,0 +1,270 @@
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { DatabaseSync } from "node:sqlite";
+import { FlowError } from "../flow-error.js";
+import { createGit, errorContainsAnyPattern, isFullGitObjectId, MISSING_HEAD_PATTERNS, runGitProcess, wrapGitError } from "../git/core.js";
+import { KEIYAKU_FILE } from "../keiyaku.js";
+import { renderCurrentContractView } from "./contract-view.js";
+import { isCommissionId } from "./ids.js";
+import { activeWorkspaceHereContracts } from "./repository-ledger/inventory.js";
+import { lookupCurrentContract, readRepositoryLifecycle, } from "./repository-ledger/read-model.js";
+import { REPOSITORY_LEDGER_REF, } from "./repository-ledger/codec.js";
+import { resolveContractCarrierTarget, stableRepoRoot, } from "./worktree-path.js";
+import { installCarrierRuntimePorts } from "./contract-carrier-runtime.js";
+export { convergeContractCarrier, reconcileContractCarrierProjection, withContractCarrierSession } from "./contract-carrier-runtime.js";
+const BUSY_SLICE_MS = 25;
+const CARRIER_CONTRACT = /^id: (\S+)$/m;
+const CARRIER_PROVENANCE = /^ledger: (\S+)$/m;
+export function acceptedBind(lifecycle) {
+    for (const { entry } of lifecycle.history) {
+        if (entry.kind === "bind")
+            return entry;
+    }
+    throw new FlowError("INTERNAL_STATE", `contract ${lifecycle.contract} lifecycle is missing bind entry`);
+}
+function diagnostic(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export async function projectRenewDeliveryWorktree(target, oldHead, newHead) {
+    if (target.status !== "available")
+        throw new FlowError("CARRIER_TARGET_UNAVAILABLE", target.reason);
+    await projectRenewDeliveryRoot(target.root, oldHead, newHead);
+}
+async function projectRenewDeliveryRoot(root, oldHead, newHead) {
+    const update = await runGitProcess(root, ["read-tree", "-m", "-u", oldHead, newHead]);
+    if (update.status !== 0 || update.error) {
+        throw new FlowError("INTERNAL_STATE", update.stderr.trim() || update.error?.message || `read-tree exited ${String(update.status)}`, { cause: update.error });
+    }
+    const [head, status] = await Promise.all([
+        runGitProcess(root, ["rev-parse", "--verify", "HEAD^{commit}"]),
+        runGitProcess(root, ["status", "--porcelain=v1", "--untracked-files=no"]),
+    ]);
+    if (head.status !== 0 || head.error || head.stdout.trim() !== newHead || status.status !== 0 || status.error || status.stdout !== "") {
+        throw new FlowError("INTERNAL_STATE", "delivery worktree did not align to the committed renew head");
+    }
+}
+/** Reconstruct the folded delivery projection without creating lifecycle facts. */
+export async function reconcileFoldedDeliveryWorktree(input) {
+    const renew = [...input.lifecycle.history].reverse().find(({ entry }) => (entry.kind === "renew" && entry.data.newHead === input.lifecycle.pins.delivery));
+    if (!renew || renew.entry.kind !== "renew")
+        return "already-present";
+    const [index, worktree] = await Promise.all([
+        runGitProcess(input.targetRoot, ["write-tree"]),
+        runGitProcess(input.targetRoot, ["diff-files", "--quiet"]),
+    ]);
+    if (index.status !== 0 || index.error) {
+        throw new FlowError("INTERNAL_STATE", index.stderr.trim() || index.error?.message || "cannot inspect delivery worktree index", { cause: index.error });
+    }
+    const indexTree = index.stdout.trim();
+    const newTree = await resolveCommitTree(input.targetRoot, renew.entry.data.newHead);
+    if (indexTree === newTree)
+        return "already-present";
+    const oldTree = await resolveCommitTree(input.targetRoot, renew.entry.data.oldHead);
+    if (indexTree !== oldTree || worktree.status !== 0 || worktree.error) {
+        throw new FlowError("INTERNAL_STATE", `delivery worktree cannot be safely reconstructed for accepted renew ${renew.objectId}`);
+    }
+    await projectRenewDeliveryRoot(input.targetRoot, renew.entry.data.oldHead, renew.entry.data.newHead);
+    return "created";
+}
+async function resolveCommitTree(cwd, commit) {
+    const result = await runGitProcess(cwd, ["rev-parse", "--verify", `${commit}^{tree}`]);
+    if (result.status !== 0 || result.error) {
+        throw new FlowError("INTERNAL_STATE", result.stderr.trim() || result.error?.message || `cannot resolve tree for ${commit}`, { cause: result.error });
+    }
+    return result.stdout.trim();
+}
+export function observedLedgerHead(observations) {
+    const observation = observations.find((item) => item.ref === REPOSITORY_LEDGER_REF)?.observed;
+    return observation?.status === "present" ? observation.objectId : null;
+}
+function isBusy(error) {
+    const code = error?.code;
+    return code === "SQLITE_BUSY" || code === "SQLITE_LOCKED" || /database is (?:locked|busy)/i.test(diagnostic(error));
+}
+function throwCancelled() {
+    throw new FlowError("CARRIER_GATE_CANCELLED", "contract carrier operation cancelled before durable effects");
+}
+export function checkCancellation(signal) {
+    if (signal?.aborted)
+        throwCancelled();
+}
+export async function acquireGate(stableRoot, signal) {
+    checkCancellation(signal);
+    const directory = path.join(stableRoot, ".keiyaku");
+    await fs.mkdir(directory, { recursive: true });
+    checkCancellation(signal);
+    let database;
+    try {
+        database = new DatabaseSync(path.join(directory, "contract-carrier.sqlite"));
+        database.exec(`PRAGMA busy_timeout = ${BUSY_SLICE_MS}`);
+    }
+    catch (error) {
+        throw new FlowError("CARRIER_GATE_UNAVAILABLE", "contract carrier gate is unavailable", { cause: error });
+    }
+    for (;;) {
+        checkCancellation(signal);
+        try {
+            database.exec("BEGIN IMMEDIATE");
+            return database;
+        }
+        catch (error) {
+            if (!isBusy(error)) {
+                database.close();
+                throw new FlowError("CARRIER_GATE_UNAVAILABLE", "contract carrier gate is unavailable", { cause: error });
+            }
+            await delay(BUSY_SLICE_MS, undefined, signal ? { signal } : undefined).catch(() => throwCancelled());
+        }
+    }
+}
+export function releaseGate(database) {
+    try {
+        database.exec("ROLLBACK");
+    }
+    finally {
+        database.close();
+    }
+}
+/** Serialize cross-process committed replay decisions without exposing gate coordinates. */
+export async function withContractReplayGate(cwd, signal, action) {
+    const stableRoot = await stableRepoRoot(cwd);
+    const gate = await acquireGate(stableRoot, signal);
+    try {
+        return await action(stableRoot);
+    }
+    finally {
+        releaseGate(gate);
+    }
+}
+export async function readCarrierIdentity(target) {
+    try {
+        return parseCarrierIdentity(await fs.readFile(target, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function parseCarrierIdentity(source) {
+    const contractId = source.match(CARRIER_CONTRACT)?.[1] ?? "";
+    const ledgerHead = source.match(CARRIER_PROVENANCE)?.[1] ?? "";
+    return isCommissionId(contractId) && isFullGitObjectId(ledgerHead) ? { contractId, ledgerHead } : null;
+}
+export function carrierMatches(identity, contractId, ledgerHead) {
+    return identity?.contractId === contractId && identity.ledgerHead === ledgerHead;
+}
+export async function retireTerminalHereCarrier(lifecycle, target) {
+    if (target.status !== "available" || target.workspace !== "here")
+        return "already-present";
+    let source;
+    try {
+        source = await fs.readFile(target.path, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return "already-present";
+        throw error;
+    }
+    if (parseCarrierIdentity(source)?.contractId !== lifecycle.contract)
+        return "already-present";
+    try {
+        await fs.unlink(target.path);
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return "already-present";
+        throw error;
+    }
+    return "retired";
+}
+export async function publishCarrier(input) {
+    if (input.target.status === "unavailable") {
+        return { status: "target-unavailable", ledgerHead: input.lifecycle.observedLedgerHead, reason: input.target.reason };
+    }
+    if (input.target.workspace === "here") {
+        const occupants = activeWorkspaceHereContracts(input.repository);
+        if (occupants.length !== 1 || occupants[0] !== input.contractId) {
+            return {
+                status: "failed",
+                ledgerHead: input.lifecycle.observedLedgerHead,
+                target: input.target.path,
+                cause: `workspace-here carrier occupancy does not admit ${input.contractId}`,
+            };
+        }
+    }
+    if (carrierMatches(await readCarrierIdentity(input.target.path), input.contractId, input.lifecycle.observedLedgerHead)) {
+        return { status: "current", ledgerHead: input.lifecycle.observedLedgerHead, target: input.target.path };
+    }
+    const directory = path.dirname(input.target.path);
+    const temporary = path.join(directory, `.${path.basename(KEIYAKU_FILE)}.${process.pid}.${randomUUID()}.tmp`);
+    try {
+        await fs.mkdir(directory, { recursive: true });
+        await fs.writeFile(temporary, renderCurrentContractView(input.lifecycle), { encoding: "utf8", flag: "wx" });
+        if ((await resolveCommitOrNull(input.stableRoot, REPOSITORY_LEDGER_REF)) !== input.lifecycle.observedLedgerHead) {
+            await fs.unlink(temporary);
+            return { status: "failed", ledgerHead: input.lifecycle.observedLedgerHead, target: input.target.path, cause: "authoritative ledger head changed before carrier replacement" };
+        }
+        await (input.contractViewWriter?.replace ?? fs.rename)(temporary, input.target.path);
+        const [activeHead, carrierIdentity] = await Promise.all([
+            resolveCommitOrNull(input.stableRoot, REPOSITORY_LEDGER_REF),
+            readCarrierIdentity(input.target.path),
+        ]);
+        if (activeHead !== input.lifecycle.observedLedgerHead ||
+            !carrierMatches(carrierIdentity, input.contractId, input.lifecycle.observedLedgerHead)) {
+            return { status: "failed", ledgerHead: input.lifecycle.observedLedgerHead, target: input.target.path, cause: "carrier post-check did not prove the published contract identity and ledger head" };
+        }
+        return { status: "materialized", ledgerHead: input.lifecycle.observedLedgerHead, target: input.target.path };
+    }
+    catch (error) {
+        await fs.unlink(temporary).catch(() => undefined);
+        return { status: "failed", ledgerHead: input.lifecycle.observedLedgerHead, target: input.target.path, cause: diagnostic(error) };
+    }
+}
+export async function observe(stableRoot, contractId) {
+    const repository = await readRepositoryLifecycle(stableRoot);
+    const outcome = lookupCurrentContract(repository, contractId);
+    if (outcome.status !== "healthy") {
+        const detail = outcome.status === "absent" ? "not found" : `unavailable (${outcome.status})`;
+        const diagnosticDetail = outcome.status === "absent"
+            ? ""
+            : `: ${outcome.diagnostics.map(({ code, detail: message }) => `${code}: ${message}`).join("; ")}`;
+        throw new FlowError("INTERNAL_STATE", `contract ${contractId} is ${detail} in the repository lifecycle read model${diagnosticDetail}`, {
+            ...(outcome.status === "absent" ? {} : { facts: { kind: "repository_lifecycle_disease", contractId, status: outcome.status, diagnostics: outcome.diagnostics.map((item) => ({ ...item })) } }),
+        });
+    }
+    const lifecycle = outcome.model;
+    const bind = acceptedBind(lifecycle);
+    const target = await resolveContractCarrierTarget(stableRoot, contractId, bind);
+    const targetRef = lifecycle.pins.target.ref;
+    const deliveryRef = lifecycle.resources.deliveryRef;
+    const [targetHead, deliveryHead] = await Promise.all([
+        resolveCommitOrNull(stableRoot, targetRef),
+        resolveCommitOrNull(stableRoot, deliveryRef),
+    ]);
+    return { repository, lifecycle, target, pins: { ledgerHead: lifecycle.observedLedgerHead, target: { ref: targetRef, head: targetHead }, delivery: { ref: deliveryRef, head: deliveryHead } } };
+}
+export async function resolveCommitOrNull(cwd, ref) {
+    try {
+        return (await createGit(cwd).raw(["rev-parse", "--verify", `${ref}^{commit}`])).trim();
+    }
+    catch (error) {
+        if (errorContainsAnyPattern(error, MISSING_HEAD_PATTERNS))
+            return null;
+        throw wrapGitError(`rev-parse ${ref}`, error, cwd);
+    }
+}
+installCarrierRuntimePorts({
+    acceptedBind,
+    acquireGate,
+    carrierMatches,
+    checkCancellation,
+    observe,
+    observedLedgerHead,
+    projectRenewDeliveryWorktree,
+    publishCarrier,
+    readCarrierIdentity,
+    reconcileFoldedDeliveryWorktree,
+    releaseGate,
+    resolveCommitOrNull,
+    retireTerminalHereCarrier,
+});

package/build/core/contract-view.js

@@ -1,11 +1,8 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { FlowError } from "../flow-error.js";
 import { shortCommitHash } from "../git/commits.js";
-import { KEIYAKU_FILE } from "../keiyaku.js";
-import { readLedger } from "./ledger.js";
-import { deriveContractState } from "./status/lifecycle.js";
+import { effectiveCriteria } from "./lifecycle-history.js";
 import { renderScopeFragment } from "./scope.js";
+import { currentLifecycleState, } from "./repository-ledger/read-model.js";
+export { currentLifecycleState } from "./repository-ledger/read-model.js";
 const VERB_COLUMN_WIDTH = 11;
 const TIME_COLUMN_WIDTH = 6;
 const ACTOR_COLUMN_WIDTH = 11;
@@ -73,7 +70,7 @@ function renderSealFacts(entry) {
 }
 function bootstrapTimeoutMs(entries) {
     const bind = entries.find((entry) => entry.kind === "bind");
-    return bind?.data.bootstrap?.timeoutMs;
+    return bind && "bootstrap" in bind.data ? bind.data.bootstrap?.timeoutMs : undefined;
 }
 function renderBootstrapFacts(entry, entries) {
     const duration = `duration ${entry.data.durationMs}ms`;
@@ -114,7 +111,7 @@ function renderEventFacts(entry, entries) {
             return [
                 joinFactClusters([
                     `workspace ${entry.data.workspace}`,
-                    entry.data.place ? `place ${entry.data.place}` : null,
+                    entry.data.workspace === "worktree" ? `place ${entry.data.place}` : null,
                     `base ${shortCommitHash(entry.data.base)}`,
                     `scope ${entry.data.scope.length}`,
                     entry.data.after && entry.data.after.length > 0 ? `after ${entry.data.after.length}` : null,
@@ -147,7 +144,7 @@ function renderEventFacts(entry, entries) {
                 joinFactClusters([
                     entry.data.reason === "manual" ? "裁决人" : entry.data.reason,
                     entry.data.note ? `「${compactWhitespace(entry.data.note)}」` : null,
-                    entry.data.by ? `by ${entry.data.by}` : null,
+                    `by ${entry.data.actor}`,
                 ]),
             ];
     }
@@ -212,21 +209,9 @@ export function renderVerticalLog(input) {
     }
     return renderLedgerRows(input.entries).join("\n");
 }
-/**
- * Sole post-mutation KEIYAKU.md refresh: read the authoritative ledger at
- * ledgerCwd, then write the projection at renderCwd. ledgerCwd and renderCwd
- * are distinct coordinates (hub vs linked delivery worktree).
- */
-export async function refreshContractView(input) {
-    const ledger = await readLedger(input.ledgerCwd, input.contractId);
-    if (!ledger) {
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} active ledger disappeared before render`);
-    }
-    await fs.writeFile(path.join(input.renderCwd, KEIYAKU_FILE), renderContractView({ id: input.contractId, entries: ledger.entries }), "utf8");
-}
 export function renderContractView(input) {
     const bind = input.entries.find((entry) => entry.kind === "bind");
-    const state = deriveContractState(input.entries);
+    const state = input.state;
     if (!bind) {
         return [
             "# Keiyaku Contract",
@@ -235,6 +220,7 @@ export function renderContractView(input) {
             "",
             `id: ${input.id}`,
             `state: ${state.state}`,
+            ...(input.ledgerHead ? [`ledger: ${input.ledgerHead}`] : []),
             "",
             "log:",
             renderVerticalLog(input),
@@ -242,26 +228,36 @@ export function renderContractView(input) {
         ].join("\n");
     }
     return [
-        `# ${bind.data.name}`,
+        `# ${bind.data.title}`,
         "",
         "generated by keiyaku - edits are not read back",
         "",
         `id: ${input.id}`,
         `state: ${state.state}`,
+        ...(input.ledgerHead ? [`ledger: ${input.ledgerHead}`] : []),
         `base: ${bind.data.base}`,
         `workspace: ${bind.data.workspace}`,
-        `place: ${bind.data.place ?? "(none)"}`,
+        `place: ${bind.data.workspace === "worktree" ? bind.data.place : "(none)"}`,
         `after: ${(bind.data.after ?? []).join(", ") || "(none)"}`,
         "",
+        "## Context",
+        bind.data.context,
+        "",
         "## Objective",
         bind.data.objective,
         "",
+        "## Design",
+        bind.data.design,
+        "",
         "## Scope",
-        ...renderScopeFragment(bind.data.scope).split("\n"),
+        ...renderScopeFragment(input.effectiveScope).split("\n"),
         "",
-        "## Checks",
-        ...bind.data.checks.map((check) => `- ${check}`),
+        "## Criteria",
+        ...effectiveCriteria(input.entries).map((criterion) => `- ${criterion}`),
         "",
+        ...(bind.data.verification.length > 0
+            ? ["## Verification", ...bind.data.verification.map((declaration) => `- ${declaration}`), ""]
+            : []),
         ...(bind.data.extensions.length > 0
             ? [
                 ...bind.data.extensions.flatMap((extension) => extension.content.length > 0
@@ -274,3 +270,13 @@ export function renderContractView(input) {
         "",
     ].join("\n");
 }
+export function renderCurrentContractView(model) {
+    const entries = model.history.map(({ entry }) => entry);
+    return renderContractView({
+        id: model.contract,
+        entries,
+        ledgerHead: model.observedLedgerHead,
+        state: currentLifecycleState(model),
+        effectiveScope: model.effectiveScope,
+    });
+}

package/build/core/contract.js

@@ -3,9 +3,13 @@ export const contractStateSchema = z.enum(["bound", "active", "petitioned", "cla
 export const contractRecordSchema = z
     .object({
     id: z.string().trim().min(1),
-    name: z.string().trim().min(1),
+    title: z.string().trim().min(1),
+    context: z.string().trim().min(1),
     objective: z.string().trim().min(1),
+    design: z.string().trim().min(1),
     scope: z.array(z.string().trim().min(1)).min(1),
+    criteria: z.array(z.string().trim().min(1)).min(1),
+    verification: z.array(z.string().trim().min(1)).min(1),
     base: z.string().trim().min(1),
     place: z.string().trim().min(1).nullable().optional(),
     after: z.array(z.string().trim().min(1)),

package/build/core/derived-replay.js

@@ -0,0 +1,207 @@
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { FlowError } from "../flow-error.js";
+import { runGitProcess } from "../git/core.js";
+import { KEIYAKU_FILE } from "../keiyaku.js";
+import { inventoryIgnorePatternsForWorktree } from "./repository-ledger/inventory.js";
+import { readTaskBoardGeneration, reconcileTaskForfeit, replayClaimTasks, replayCommittedTaskBind, } from "./task/index.js";
+function terminalEntry(model) {
+    return [...model.history].reverse().find(({ entry }) => (entry.kind === "claim" || entry.kind === "forfeit"));
+}
+function receipt(model, surface, status, facts) {
+    return {
+        surface,
+        status,
+        authoritativeHead: model.observedLedgerHead,
+        ...(facts ? { facts } : {}),
+    };
+}
+async function gitExit(cwd, args) {
+    const result = await runGitProcess(cwd, args);
+    if (result.error || (result.status !== 0 && result.status !== 1)) {
+        throw new FlowError("INTERNAL_STATE", result.stderr.trim() || result.error?.message || `git ${args.join(" ")} exited ${String(result.status)}`, {
+            cause: result.error,
+        });
+    }
+    return result.status;
+}
+/** Materialize exact per-worktree ignore bytes admitted by typed inventory. */
+export async function materializeInventoryIgnore(targetRoot, patterns) {
+    const ignorePath = path.join(targetRoot, ".gitignore");
+    const expected = patterns.length === 0 ? "" : `${patterns.join("\n")}\n`;
+    const tracked = await gitExit(targetRoot, ["ls-files", "--error-unmatch", "--", ".gitignore"]) === 0;
+    if (tracked) {
+        if (patterns.length === 0)
+            return "already-present";
+        const ignored = await gitExit(targetRoot, ["check-ignore", "-q", "--", KEIYAKU_FILE]) === 0;
+        if (!ignored)
+            throw new FlowError("CARRIER_MATERIALIZATION_FAILED", "tracked .gitignore does not ignore the generated contract view");
+        return "already-present";
+    }
+    let existing = null;
+    try {
+        existing = await fs.readFile(ignorePath, "utf8");
+    }
+    catch (error) {
+        if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT")
+            throw error;
+    }
+    if (patterns.length === 0) {
+        if (existing === null)
+            return "already-present";
+        if (existing !== `${[".gitignore", KEIYAKU_FILE].join("\n")}\n`)
+            return "already-present";
+        await fs.unlink(ignorePath);
+        return "created";
+    }
+    if (existing === expected)
+        return "already-present";
+    if (existing !== null)
+        throw new FlowError("CARRIER_MATERIALIZATION_FAILED", "untracked .gitignore is not a proven generated rendering");
+    const temporary = `${ignorePath}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        await fs.writeFile(temporary, expected, { encoding: "utf8", flag: "wx" });
+        await fs.rename(temporary, ignorePath);
+    }
+    catch (error) {
+        await fs.unlink(temporary).catch(() => undefined);
+        throw error;
+    }
+    return "created";
+}
+async function replayTaskBoard(cwd, model, adapters) {
+    const taskIds = model.resources.tasks.map(({ taskId }) => taskId);
+    const terminal = terminalEntry(model);
+    if (terminal?.entry.kind === "claim") {
+        const replay = taskIds.length === 0
+            ? { commit: terminal.entry.data.mergeCommit, taskCount: 0, worktree: "ref-only" }
+            : await replayClaimTasks({
+                cwd,
+                contractId: model.contract,
+                targetRef: terminal.entry.data.target,
+                taskIds,
+                updatedAt: terminal.entry.at,
+            });
+        const warnings = await adapters.replayClaimTarget({
+            target: terminal.entry.data.target,
+            targetHead: terminal.entry.data.targetHead,
+            mergeCommit: replay.commit,
+        });
+        return {
+            status: taskIds.length === 0 ? "already-present" : replay.worktree === "ref-only" ? "ref-only" : "created",
+            facts: { taskCount: replay.taskCount, commit: replay.commit, worktree: replay.worktree, warnings: [...warnings] },
+        };
+    }
+    if (terminal?.entry.kind === "forfeit") {
+        if (taskIds.length === 0)
+            return { status: "already-present", facts: { taskCount: 0 } };
+        const generation = await readTaskBoardGeneration(cwd);
+        await reconcileTaskForfeit({
+            cwd,
+            contractId: model.contract,
+            expectedGeneration: generation,
+            publishLedger: async () => undefined,
+        });
+        return { status: "created", facts: { taskCount: taskIds.length } };
+    }
+    if (taskIds.length === 0)
+        return { status: "already-present", facts: { taskCount: 0 } };
+    const bind = model.history.find(({ entry }) => entry.kind === "bind")?.entry;
+    if (!bind || bind.kind !== "bind")
+        throw new FlowError("INTERNAL_STATE", `contract ${model.contract} has no typed bind`);
+    const status = await replayCommittedTaskBind(cwd, bind.data.base, taskIds);
+    return { status, facts: { taskCount: taskIds.length } };
+}
+function recordSurface(journal, model, surface, run) {
+    return journal.run({
+        effect: `${surface}-projection`,
+        idempotencyKey: `${model.contract}:${model.observedLedgerHead}:${surface}`,
+        run: async () => structuredClone(await run()),
+    });
+}
+/** Sole phase-driven owner for replaying projections from an accepted folded head. */
+export async function replayCommittedDerivedState(input) {
+    const { lifecycle: model, journal } = input;
+    const terminal = terminalEntry(model);
+    let projectedTarget = input.target;
+    const receipts = [];
+    const run = async (surface, operation) => {
+        const row = await recordSurface(journal, model, surface, operation);
+        if (row.status === "succeeded")
+            receipts.push(row.receipt);
+    };
+    await run("status", async () => receipt(model, "status", "already-present", { phase: model.phase }));
+    await run("registry", async () => receipt(model, "registry", terminal ? "retired" : "already-present", {
+        source: "repository-ledger-fold",
+        effectiveScope: [...model.effectiveScope],
+    }));
+    await run("task-board", async () => {
+        const replay = await replayTaskBoard(input.cwd, model, input.adapters);
+        return receipt(model, "task-board", replay.status, replay.facts);
+    });
+    if (terminal) {
+        let carrierRetired = false;
+        await run("carrier", async () => {
+            const status = await input.adapters.retireContractView({ lifecycle: model, target: input.target });
+            carrierRetired = true;
+            return receipt(model, "carrier", status);
+        });
+        await run("narrow-ignore", async () => {
+            if (!carrierRetired) {
+                throw new FlowError("CARRIER_MATERIALIZATION_FAILED", "cannot retire narrow ignore before carrier retirement");
+            }
+            if (input.target.status !== "available") {
+                return receipt(model, "narrow-ignore", "already-present", { patterns: [] });
+            }
+            const patterns = inventoryIgnorePatternsForWorktree(input.repository, model);
+            return receipt(model, "narrow-ignore", await materializeInventoryIgnore(input.target.root, patterns), { patterns });
+        });
+        await run("worktree", async () => {
+            const cleanup = await input.adapters.cleanupWorkspace(input.cwd, model);
+            if (cleanup.worktreeRemoveFailure)
+                throw new FlowError("INTERNAL_STATE", cleanup.worktreeRemoveFailure.reason);
+            return receipt(model, "worktree", cleanup.absent.includes("worktree") ? "already-present" : "retired", {
+                absent: cleanup.absent,
+                ...(cleanup.removedWorktreePath ? { removedWorktreePath: cleanup.removedWorktreePath } : {}),
+            });
+        });
+        await run("delivery-ref", async () => {
+            const observation = await input.adapters.observeDeliveryRef(input.cwd, model.contract);
+            return observation.status === "aligned"
+                ? receipt(model, "delivery-ref", "already-present", observation)
+                : receipt(model, "delivery-ref", "mismatch", observation);
+        });
+        return receipts;
+    }
+    await run("worktree", async () => {
+        const replay = await input.adapters.reconcileActiveWorktree();
+        projectedTarget = replay.target;
+        return receipt(model, "worktree", replay.status);
+    });
+    await run("narrow-ignore", async () => {
+        if (projectedTarget.status !== "available")
+            throw new FlowError("CARRIER_TARGET_UNAVAILABLE", projectedTarget.reason);
+        const patterns = inventoryIgnorePatternsForWorktree(input.repository, model);
+        return receipt(model, "narrow-ignore", await materializeInventoryIgnore(projectedTarget.root, patterns), {
+            patterns,
+        });
+    });
+    let viewStatus = "already-present";
+    let viewProjected = false;
+    await run("contract-view", async () => {
+        const incomplete = journal.all().find((row) => row.status !== "succeeded");
+        if (incomplete) {
+            throw new FlowError("CARRIER_MATERIALIZATION_FAILED", `cannot advance carrier checkpoint while ${incomplete.effect} is ${incomplete.status}`);
+        }
+        viewStatus = await input.adapters.materializeContractView({ lifecycle: model, target: projectedTarget });
+        viewProjected = true;
+        return receipt(model, "contract-view", viewStatus, { path: projectedTarget.status === "available" ? path.join(projectedTarget.root, KEIYAKU_FILE) : null });
+    });
+    await run("carrier", async () => {
+        if (!viewProjected)
+            throw new FlowError("CARRIER_MATERIALIZATION_FAILED", "contract view was not materialized");
+        return receipt(model, "carrier", viewStatus, { checkpoint: model.observedLedgerHead });
+    });
+    return receipts;
+}