@astrosheep/keiyaku 2.9.12 → 2.9.13

package/build/core/derived-replay.js

@@ -5,6 +5,9 @@ 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 { isJsonObject } from "./outcome-base.js";
+import { carrierRetirementInputIdentity, deliveryRefInputIdentity, narrowIgnoreInputIdentity, renewDeliveryInputIdentity, sameInputIdentity, taskBoardInputIdentity, targetWorktreeInputIdentity, worktreeInputIdentity, } from "./repository-ledger/identity.js";
+import { resolveAcceptedLifecycleTransaction, } from "./repository-ledger/accepted-tail.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"));
@@ -13,10 +16,101 @@ function receipt(model, surface, status, facts) {
     return {
         surface,
         status,
-        authoritativeHead: model.observedLedgerHead,
+        authoritativeHead: model.contractHead,
         ...(facts ? { facts } : {}),
     };
 }
+function currentTransaction(repository, model) {
+    const node = repository.topology.nodes.find((candidate) => (candidate.type === "transaction"
+        && candidate.contract === model.contract
+        && candidate.finalEntryObjectId === model.contractHead));
+    if (!node || node.type !== "transaction") {
+        throw new FlowError("INTERNAL_STATE", `contract ${model.contract} has no accepted transaction for ${model.contractHead}`);
+    }
+    const accepted = resolveAcceptedLifecycleTransaction({
+        read: repository,
+        transactionObjectId: node.objectId,
+        expectedContract: model.contract,
+    });
+    if (accepted.status !== "accepted") {
+        throw new FlowError("INTERNAL_STATE", `contract ${model.contract} transaction ${node.objectId} is not replayable (${accepted.reason})`);
+    }
+    return accepted;
+}
+function obligation(transactionObjectId, surface, expected) {
+    return {
+        transactionObjectId,
+        surface,
+        expected,
+        idempotencyKey: `${transactionObjectId}:${surface}`,
+    };
+}
+/**
+ * Purely derive every required surface for the accepted transaction that
+ * advanced this folded contract head. No journal, carrier bytes, or filesystem
+ * observation participates in this calculation.
+ */
+export function deriveReplayObligations(input) {
+    const { repository, lifecycle: model, target, expectedCarrierIdentity } = input;
+    const transaction = input.transaction ?? currentTransaction(repository, model);
+    const base = { contractId: model.contract, contractHead: model.contractHead };
+    const terminal = terminalEntry(model);
+    const required = [];
+    const taskIds = model.resources.tasks.map(({ taskId }) => taskId);
+    if (taskIds.length > 0) {
+        required.push(obligation(transaction.transactionObjectId, "task-board", taskBoardInputIdentity({
+            ...base, taskIds, phase: model.phase,
+        })));
+    }
+    if (terminal) {
+        required.push(obligation(transaction.transactionObjectId, "carrier-retirement", carrierRetirementInputIdentity({
+            ...base,
+            target: target.status === "available" ? target.path : `${target.workspace}:${target.reason}`,
+        })), obligation(transaction.transactionObjectId, "worktree", worktreeInputIdentity({
+            ...base,
+            deliveryHead: model.pins.delivery,
+        })), obligation(transaction.transactionObjectId, "delivery-ref", deliveryRefInputIdentity({
+            ...base, deliveryRef: model.resources.deliveryRef,
+        })));
+        if (terminal.entry.kind === "claim" && terminal.entry.data && typeof terminal.entry.data.target === "string") {
+            required.push(obligation(transaction.transactionObjectId, "target-worktree", targetWorktreeInputIdentity({
+                ...base,
+                target: terminal.entry.data.target,
+                targetHead: terminal.entry.data.targetHead,
+                mergeCommit: terminal.entry.data.mergeCommit,
+            })));
+        }
+        if (target.status === "available") {
+            required.push(obligation(transaction.transactionObjectId, "narrow-ignore", narrowIgnoreInputIdentity({
+                ...base,
+                inventory: JSON.stringify(inventoryIgnorePatternsForWorktree(repository, model)),
+                occupancy: `${target.workspace}:${target.root}`,
+            })));
+        }
+        return required;
+    }
+    const deliveryHead = model.pins.delivery;
+    if (deliveryHead !== null) {
+        required.push(obligation(transaction.transactionObjectId, "worktree", worktreeInputIdentity({ ...base, deliveryHead })));
+    }
+    const patterns = inventoryIgnorePatternsForWorktree(repository, model);
+    required.push(obligation(transaction.transactionObjectId, "narrow-ignore", narrowIgnoreInputIdentity({
+        ...base,
+        inventory: JSON.stringify(patterns),
+        occupancy: `${target.workspace}:${target.status === "available" ? target.root : target.reason}`,
+    })), obligation(transaction.transactionObjectId, "carrier", expectedCarrierIdentity));
+    if (transaction.verb === "renew") {
+        const renew = transaction.entries.find((entry) => entry.kind === "renew");
+        if (renew?.kind === "renew") {
+            required.push(obligation(transaction.transactionObjectId, "renew-delivery", renewDeliveryInputIdentity({
+                ...base,
+                oldHead: renew.data.oldHead,
+                newHead: renew.data.newHead,
+            })));
+        }
+    }
+    return required;
+}
 async function gitExit(cwd, args) {
     const result = await runGitProcess(cwd, args);
     if (result.error || (result.status !== 0 && result.status !== 1)) {
@@ -83,14 +177,9 @@ async function replayTaskBoard(cwd, model, adapters) {
                 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] },
+            facts: { taskCount: replay.taskCount, commit: replay.commit, worktree: replay.worktree },
         };
     }
     if (terminal?.entry.kind === "forfeit") {
@@ -113,10 +202,10 @@ async function replayTaskBoard(cwd, model, adapters) {
     const status = await replayCommittedTaskBind(cwd, bind.data.base, taskIds);
     return { status, facts: { taskCount: taskIds.length } };
 }
-function recordSurface(journal, model, surface, run) {
+function recordSurface(journal, replay, run) {
     return journal.run({
-        effect: `${surface}-projection`,
-        idempotencyKey: `${model.contract}:${model.observedLedgerHead}:${surface}`,
+        effect: `${replay.surface}-projection`,
+        idempotencyKey: replay.idempotencyKey,
         run: async () => structuredClone(await run()),
     });
 }
@@ -124,29 +213,65 @@ function recordSurface(journal, model, surface, run) {
 export async function replayCommittedDerivedState(input) {
     const { lifecycle: model, journal } = input;
     const terminal = terminalEntry(model);
+    const transaction = input.transaction ?? currentTransaction(input.repository, model);
+    const expectedCarrierIdentity = input.adapters.expectedCarrierIdentity(model);
+    if (expectedCarrierIdentity.contractId !== model.contract
+        || expectedCarrierIdentity.contractHead !== model.contractHead) {
+        throw new FlowError("INTERNAL_STATE", "carrier identity semantics did not derive the folded contract coordinate");
+    }
+    const obligations = new Map(deriveReplayObligations({
+        ...input,
+        transaction,
+        expectedCarrierIdentity,
+    }).map((item) => [item.surface, item]));
     let projectedTarget = input.target;
     const receipts = [];
-    const run = async (surface, operation) => {
-        const row = await recordSurface(journal, model, surface, operation);
+    const run = async (surface, operation, current) => {
+        const replay = obligations.get(surface);
+        if (!replay)
+            return;
+        const row = await recordSurface(journal, replay, async () => {
+            const actual = await input.adapters.inspectSurface({ obligation: replay });
+            if (sameInputIdentity(actual, replay.expected)) {
+                return current?.() ?? receipt(model, surface, "already-present", { inputIdentity: replay.expected });
+            }
+            return 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?.entry.kind === "claim") {
+        const claim = terminal.entry;
+        await run("target-worktree", async () => {
+            const taskRow = journal.all().find((row) => row.effect === "task-board-projection" && row.status === "succeeded");
+            const taskFacts = taskRow?.status === "succeeded" ? taskRow.receipt?.facts : undefined;
+            const commit = isJsonObject(taskFacts) && typeof taskFacts.commit === "string"
+                ? taskFacts.commit
+                : claim.data.mergeCommit;
+            const warnings = await input.adapters.replayClaimTarget({
+                target: claim.data.target,
+                targetHead: claim.data.targetHead,
+                mergeCommit: commit,
+            });
+            return receipt(model, "target-worktree", warnings.length === 0 ? "created" : "mismatch", {
+                target: claim.data.target,
+                targetHead: claim.data.targetHead,
+                mergeCommit: commit,
+                warnings: [...warnings],
+            });
+        });
+    }
     if (terminal) {
         let carrierRetired = false;
-        await run("carrier", async () => {
+        await run("carrier-retirement", async () => {
             const status = await input.adapters.retireContractView({ lifecycle: model, target: input.target });
-            carrierRetired = true;
-            return receipt(model, "carrier", status);
+            return receipt(model, "carrier-retirement", status);
         });
+        carrierRetired = journal.all().some((row) => (row.effect === "carrier-retirement-projection" && row.status === "succeeded"));
         await run("narrow-ignore", async () => {
             if (!carrierRetired) {
                 throw new FlowError("CARRIER_MATERIALIZATION_FAILED", "cannot retire narrow ignore before carrier retirement");
@@ -159,19 +284,23 @@ export async function replayCommittedDerivedState(input) {
         });
         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 } : {}),
+                ...(cleanup.worktreeRemoveFailure ? { worktreeRemoveFailure: cleanup.worktreeRemoveFailure } : {}),
             });
-        });
+        }, () => receipt(model, "worktree", "already-present", { absent: ["worktree"] }));
         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);
-        });
+        }, () => receipt(model, "delivery-ref", "already-present", {
+            status: "aligned",
+            ref: model.resources.deliveryRef,
+            expected: "absent",
+            observed: "absent",
+        }));
         return receipts;
     }
     await run("worktree", async () => {
@@ -179,6 +308,18 @@ export async function replayCommittedDerivedState(input) {
         projectedTarget = replay.target;
         return receipt(model, "worktree", replay.status);
     });
+    if (obligations.has("renew-delivery")) {
+        await run("renew-delivery", async () => {
+            if (transaction.verb !== "renew")
+                throw new FlowError("INTERNAL_STATE", "renew delivery obligation lacks an accepted renew transaction");
+            const renew = transaction.entries.find((entry) => entry.kind === "renew");
+            if (!renew || renew.kind !== "renew")
+                throw new FlowError("INTERNAL_STATE", "accepted renew transaction lacks a renew entry");
+            if (projectedTarget.status !== "available")
+                throw new FlowError("CARRIER_TARGET_UNAVAILABLE", projectedTarget.reason);
+            return receipt(model, "renew-delivery", await input.adapters.reconcileRenewDelivery({ lifecycle: model, target: projectedTarget, transaction }), { oldHead: renew.data.oldHead, newHead: renew.data.newHead });
+        });
+    }
     await run("narrow-ignore", async () => {
         if (projectedTarget.status !== "available")
             throw new FlowError("CARRIER_TARGET_UNAVAILABLE", projectedTarget.reason);
@@ -187,21 +328,13 @@ export async function replayCommittedDerivedState(input) {
             patterns,
         });
     });
-    let viewStatus = "already-present";
-    let viewProjected = false;
-    await run("contract-view", async () => {
+    await run("carrier", 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 });
+        const status = await input.adapters.materializeContractView({ lifecycle: model, target: projectedTarget });
+        return receipt(model, "carrier", status, { path: projectedTarget.status === "available" ? path.join(projectedTarget.root, KEIYAKU_FILE) : null });
     });
     return receipts;
 }

package/build/core/draft.js

@@ -3,6 +3,7 @@ import { parseToAST } from "./markdown/parser.js";
 import { extractListItems, renderSectionContent } from "./markdown/render.js";
 import { normalizeSectionTitle } from "./markdown/titles.js";
 import { markdownSourceSections, renderScopeFragment, validateScopeFragmentLines } from "./scope.js";
+import { parseVerificationDeclarations, renderVerificationDeclarations, } from "./verification-declaration.js";
 const KNOWN_SECTIONS = new Map([
     ["context", "context"],
     ["objective", "objective"],
@@ -82,6 +83,9 @@ function extractSingleLineDeclarations(section, heading) {
         return trimmed;
     });
 }
+function verificationDeclarations(section, heading) {
+    return parseVerificationDeclarations(renderSectionContent(section), { heading });
+}
 function collectBindDraftNodes(content) {
     // Scope is parsed from source lines below. Hide its body from the Markdown AST
     // so fence-like and heading-like payload bytes cannot acquire structure there.
@@ -183,7 +187,7 @@ export function parsePartialBindDraft(content) {
         partial.criteria = extractSingleLineDeclarations(criteria, "Criteria");
     const verification = sections.get("verification");
     if (verification)
-        partial.verification = extractSingleLineDeclarations(verification, "Verification");
+        partial.verification = verificationDeclarations(verification, "## Verification");
     if (extensions.length > 0)
         partial.extensions = extensions;
     return partial;
@@ -254,7 +258,7 @@ export function renderMissingBindSectionsTemplate(missing) {
             lines.push("## Criteria", "- <declarative acceptance criterion>");
             continue;
         }
-        lines.push("## Verification", "- <executable command or testimony declaration>");
+        lines.push("## Verification", "```bash", "<verification script>", "```");
     }
     return lines.join("\n");
 }
@@ -331,7 +335,7 @@ export function parseBindDraft(content) {
         design: designText,
         scope: parsedScope,
         criteria: extractSingleLineDeclarations(criteria, "Criteria"),
-        verification: verification ? extractSingleLineDeclarations(verification, "Verification") : [],
+        verification: verification ? verificationDeclarations(verification, "## Verification") : [],
         extensions,
     };
 }
@@ -345,7 +349,7 @@ export function renderBindDraft(draft) {
         `## Criteria\n${draft.criteria.map((criterion) => `- ${criterion}`).join("\n")}`,
     ];
     if (draft.verification.length > 0) {
-        sections.push(`## Verification\n${draft.verification.map((declaration) => `- ${declaration}`).join("\n")}`);
+        sections.push(`## Verification\n${renderVerificationDeclarations(draft.verification)}`);
     }
     for (const extension of draft.extensions) {
         const content = normalizeExtensionContent(extension.content);
@@ -391,6 +395,6 @@ export function compileBindDraftFlags(input) {
     if (input.criteria !== undefined)
         sections.push(`## Criteria\n- ${input.criteria}`);
     if (input.verification !== undefined)
-        sections.push(`## Verification\n- ${input.verification}`);
+        sections.push(`## Verification\n\`\`\`bash\n${input.verification}\n\`\`\``);
     return sections.length > 0 ? `${sections.join("\n\n")}\n` : "";
 }

package/build/core/forfeit.js

@@ -88,7 +88,7 @@ export async function forfeitContract(input) {
                 : await context.publishAuthoritative({
                     verb: "forfeit",
                     admittedLedgerHead: admission.ledgerHead,
-                    acceptedLifecycleTail: context.session.lifecycle.history.at(-1).objectId,
+                    acceptedLifecycleTail: context.session.lifecycle.contractHead,
                     entries: [prepared.entry],
                     delivery: {
                         ref: repositoryDeliveryRef(input.contractId),

package/build/core/lifecycle-history.js

@@ -33,3 +33,16 @@ export function effectiveCriteria(entries) {
     }
     return criteria;
 }
+/** Ordered effective contract Verification declarations from admitted lifecycle history. */
+export function effectiveVerification(entries) {
+    const bind = entries.find((entry) => entry.kind === "bind");
+    if (!bind)
+        throw new FlowError("INTERNAL_STATE", "lifecycle history must contain bind entry");
+    let declarations = [...bind.data.verification];
+    for (const entry of entries) {
+        if (entry.kind === "amend" && entry.data.verificationDelta) {
+            declarations = [...entry.data.verificationDelta.replace];
+        }
+    }
+    return declarations;
+}

package/build/core/lifecycle-recovery.js

@@ -1,12 +1,16 @@
 import { withContractCarrierSession } from "./contract-carrier.js";
 import { resolveAcceptedLifecycleTransaction, } from "./repository-ledger/accepted-tail.js";
+import { lifecycleTransactionId } from "./repository-ledger/identity.js";
 export async function reconcileCommittedMutation(plan) {
     const observed = await withContractCarrierSession({ cwd: plan.cwd, contractId: plan.contractId, mode: "observe-only", signal: plan.signal }, async (session) => ({
         model: session.lifecycle,
         repository: session.repository,
     }));
-    const authoritativeHead = observed.model.observedLedgerHead;
-    const accepted = findLatestAcceptedTransaction(observed.repository, plan.contractId, observed.model.history.at(-1)?.objectId ?? null);
+    const authoritativeHead = observed.repository.observedLedgerHead;
+    if (authoritativeHead === null) {
+        throw new Error(`accepted contract ${plan.contractId} has no repository ledger observation`);
+    }
+    const accepted = findLatestAcceptedTransaction(observed.repository, plan.contractId, observed.model.contractHead);
     if (accepted.status === "refused") {
         return {
             kind: "refused",
@@ -38,6 +42,11 @@ export async function reconcileCommittedMutation(plan) {
                 return replayed;
             return observeOrdinaryCoordinate(plan);
         }
+        // A matching retry is still a mutating verb. Its accepted authority never
+        // proves that derived surfaces survived process death or manual removal.
+        const replayed = await alignDerivedTransaction(plan, transaction);
+        if (replayed.kind === "refused")
+            return replayed;
         return {
             kind: "aligned",
             coordinate: { state: "verb-committed", invokedVerb: plan.mutation.verb, transaction, authoritativeHead },
@@ -50,23 +59,7 @@ export async function reconcileCommittedMutation(plan) {
             refusal: { code: "CONTRACT_TERMINAL", message: `contract ${plan.contractId} is terminal (${observed.model.phase})` },
         };
     }
-    const bindObjectId = observed.model.history.find(({ entry }) => entry.kind === "bind")?.objectId;
-    if (!bindObjectId) {
-        return {
-            kind: "refused",
-            authoritativeHead,
-            refusal: { code: "INTERNAL_STATE", message: `contract ${plan.contractId} typed lifecycle has no bind object` },
-        };
-    }
-    return {
-        kind: "aligned",
-        coordinate: {
-            state: "bind-aligned",
-            invokedVerb: plan.mutation.verb,
-            bindObjectId,
-            authoritativeHead,
-        },
-    };
+    return bindAligned(observed.repository, observed.model, plan, authoritativeHead);
 }
 async function alignDerivedTransaction(plan, transaction) {
     return withContractCarrierSession({ cwd: plan.cwd, contractId: plan.contractId, mode: "mutation", signal: plan.signal }, async (session) => {
@@ -81,7 +74,7 @@ async function alignDerivedTransaction(plan, transaction) {
         catch (error) {
             return {
                 kind: "refused",
-                authoritativeHead: session.lifecycle.observedLedgerHead,
+                authoritativeHead: session.pins.repositoryLedgerHead,
                 refusal: {
                     code: "LIFECYCLE_RECONCILIATION_INCOMPLETE",
                     message: error instanceof Error ? error.message : `contract ${plan.contractId} derived replay did not complete`,
@@ -91,18 +84,30 @@ async function alignDerivedTransaction(plan, transaction) {
     });
 }
 async function observeOrdinaryCoordinate(plan) {
-    return withContractCarrierSession({ cwd: plan.cwd, contractId: plan.contractId, mode: "observe-only", signal: plan.signal }, async (session) => bindAligned(session.lifecycle.history, plan, session.lifecycle.observedLedgerHead));
+    return withContractCarrierSession({ cwd: plan.cwd, contractId: plan.contractId, mode: "observe-only", signal: plan.signal }, async (session) => bindAligned(session.repository, session.lifecycle, plan, session.pins.repositoryLedgerHead));
 }
-function bindAligned(history, plan, authoritativeHead) {
-    const bindObjectId = history.find(({ entry }) => entry.kind === "bind")?.objectId;
-    if (!bindObjectId) {
+function bindAligned(repository, lifecycle, plan, authoritativeHead) {
+    const bindObjectId = lifecycle.history.find(({ entry }) => entry.kind === "bind")?.objectId;
+    const transaction = repository.topology.nodes.find((node) => (node.type === "transaction"
+        && node.contract === lifecycle.contract
+        && node.finalEntryObjectId === lifecycle.contractHead));
+    if (!bindObjectId || !transaction || transaction.type !== "transaction") {
         return {
             kind: "refused",
             authoritativeHead,
-            refusal: { code: "INTERNAL_STATE", message: "typed lifecycle has no bind object" },
+            refusal: { code: "INTERNAL_STATE", message: "typed lifecycle lacks a replayable bind transaction" },
         };
     }
-    return { kind: "aligned", coordinate: { state: "bind-aligned", invokedVerb: plan.mutation.verb, bindObjectId, authoritativeHead } };
+    return {
+        kind: "aligned",
+        coordinate: {
+            state: "bind-aligned",
+            invokedVerb: plan.mutation.verb,
+            bindObjectId,
+            transactionObjectId: lifecycleTransactionId(transaction.objectId),
+            authoritativeHead,
+        },
+    };
 }
 function findLatestAcceptedTransaction(read, contractId, finalEntryObjectId) {
     if (finalEntryObjectId === null)
@@ -112,6 +117,6 @@ function findLatestAcceptedTransaction(read, contractId, finalEntryObjectId) {
         && candidate.finalEntryObjectId === finalEntryObjectId);
     if (!node || node.type !== "transaction")
         return { status: "none" };
-    const resolved = resolveAcceptedLifecycleTransaction({ read, transactionObjectId: node.objectId, expectedContract: contractId });
+    const resolved = resolveAcceptedLifecycleTransaction({ read, transactionObjectId: lifecycleTransactionId(node.objectId), expectedContract: contractId });
     return resolved.status === "accepted" ? { status: "accepted", transaction: resolved } : resolved;
 }

package/build/core/lifecycle-runner.js

@@ -5,7 +5,7 @@ import { resolveAcceptedLifecycleTransaction } from "./repository-ledger/accepte
 import { reconcileCommittedMutation, } from "./lifecycle-recovery.js";
 function coordinateObject(pins, target) {
     return {
-        ledgerHead: pins.ledgerHead,
+        ledgerHead: pins.repositoryLedgerHead,
         targetRef: pins.target.ref,
         targetHead: pins.target.head,
         deliveryRef: pins.delivery.ref,
@@ -20,7 +20,7 @@ function sameCoordinates(admission, session) {
 }
 function validateReplayCoordinate(session, coordinate) {
     if (coordinate.state === "bind-aligned") {
-        const currentHead = session.lifecycle.observedLedgerHead;
+        const currentHead = session.pins.repositoryLedgerHead;
         if (coordinate.authoritativeHead !== currentHead) {
             return {
                 code: "LIFECYCLE_REPLAY_COORDINATES_CHANGED",
@@ -55,7 +55,7 @@ function validateReplayCoordinate(session, coordinate) {
         },
         current: {
             status: resolved.status,
-            authoritativeHead: session.lifecycle.observedLedgerHead,
+            authoritativeHead: session.pins.repositoryLedgerHead,
         },
     };
 }
@@ -115,12 +115,12 @@ export async function runLifecycle(plan) {
             };
         }
         const attempt = await withContractCarrierSession({ cwd: plan.cwd, contractId: plan.contractId, mode: "observe-only", signal: plan.signal }, async (session) => {
-            observedHead = session.lifecycle.observedLedgerHead;
+            observedHead = session.pins.repositoryLedgerHead;
             const replayRefusal = validateReplayCoordinate(session, reconciliation.coordinate);
             if (replayRefusal) {
                 return { kind: "refused", outcome: refusedLifecycleFacts({
                         contractId: plan.contractId,
-                        authoritativeHead: session.lifecycle.observedLedgerHead,
+                        authoritativeHead: session.pins.repositoryLedgerHead,
                         ...surfaceCoordinateRefusal(plan.mutation, replayRefusal),
                     }) };
             }
@@ -130,13 +130,13 @@ export async function runLifecycle(plan) {
             }
             catch (error) {
                 if (error instanceof FlowError && !isCancellation(error)) {
-                    return { kind: "refused", outcome: refusedLifecycleFacts({ contractId: plan.contractId, authoritativeHead: session.lifecycle.observedLedgerHead, ...flowRefusal(error) }) };
+                    return { kind: "refused", outcome: refusedLifecycleFacts({ contractId: plan.contractId, authoritativeHead: session.pins.repositoryLedgerHead, ...flowRefusal(error) }) };
                 }
                 throw error;
             }
             return {
                 kind: "admitted",
-                ledgerHead: session.lifecycle.observedLedgerHead,
+                ledgerHead: session.pins.repositoryLedgerHead,
                 lifecycle: session.lifecycle,
                 repository: session.repository,
                 pins: session.pins,
@@ -172,20 +172,20 @@ export async function runLifecycle(plan) {
         throw error;
     }
     try {
-        return await withContractCarrierSession({ cwd: plan.cwd, contractId: plan.contractId, mode: "mutation", signal: plan.signal, ...(plan.renewDeliveryProjector ? { renewDeliveryProjector: plan.renewDeliveryProjector } : {}), ...(plan.terminalWorkspaceCleanup ? { terminalWorkspaceCleanup: plan.terminalWorkspaceCleanup } : {}) }, async (session) => {
-            observedHead = session.lifecycle.observedLedgerHead;
+        return await withContractCarrierSession({ cwd: plan.cwd, contractId: plan.contractId, mode: "mutation", signal: plan.signal, ...(plan.renewDeliveryProjector ? { renewDeliveryProjector: plan.renewDeliveryProjector } : {}), ...(plan.terminalWorkspaceCleanup ? { terminalWorkspaceCleanup: plan.terminalWorkspaceCleanup } : {}), ...(plan.transactionRunner ? { transactionRunner: plan.transactionRunner } : {}) }, async (session) => {
+            observedHead = session.pins.repositoryLedgerHead;
             const replayRefusal = validateReplayCoordinate(session, admission.replay);
             if (replayRefusal) {
                 return { kind: "noncommitted", outcome: refusedLifecycleFacts({
                         contractId: plan.contractId,
-                        authoritativeHead: session.lifecycle.observedLedgerHead,
+                        authoritativeHead: session.pins.repositoryLedgerHead,
                         ...surfaceCoordinateRefusal(plan.mutation, replayRefusal),
                     }) };
             }
             if (!sameCoordinates(admission, session)) {
                 return { kind: "noncommitted", outcome: refusedLifecycleFacts({
                         contractId: plan.contractId,
-                        authoritativeHead: session.lifecycle.observedLedgerHead,
+                        authoritativeHead: session.pins.repositoryLedgerHead,
                         code: "LIFECYCLE_COORDINATES_CHANGED",
                         message: "contract coordinates changed during lifecycle preparation",
                         pinned: coordinateObject(admission.pins, admission.target),
@@ -202,7 +202,7 @@ export async function runLifecycle(plan) {
                 refusal = flowRefusal(error);
             }
             if (refusal) {
-                return { kind: "noncommitted", outcome: refusedLifecycleFacts({ contractId: plan.contractId, authoritativeHead: session.lifecycle.observedLedgerHead, ...refusal }) };
+                return { kind: "noncommitted", outcome: refusedLifecycleFacts({ contractId: plan.contractId, authoritativeHead: session.pins.repositoryLedgerHead, ...refusal }) };
             }
             const effectSession = Object.freeze({
                 stableRoot: session.stableRoot,
@@ -239,7 +239,7 @@ export async function runLifecycle(plan) {
                     if (error instanceof FlowError && !isCancellation(error)) {
                         return { kind: "noncommitted", outcome: refusedLifecycleFacts({
                                 contractId: plan.contractId,
-                                authoritativeHead: session.lifecycle.observedLedgerHead,
+                                authoritativeHead: session.pins.repositoryLedgerHead,
                                 ...flowRefusal(error),
                             }) };
                     }
@@ -274,7 +274,7 @@ export async function runLifecycle(plan) {
                     kind: "noncommitted",
                     outcome: precommitLifecycleFacts({
                         contractId: plan.contractId,
-                        authoritativeHead: session.lifecycle.observedLedgerHead,
+                        authoritativeHead: session.pins.repositoryLedgerHead,
                         journal: session.journal,
                         cancellationObserved: session.cancellationObserved(),
                     }),

package/build/core/log.js

@@ -44,7 +44,7 @@ export async function readContractLog(input) {
             at: entry.at,
             actor: entry.actor,
         })),
-        markdown: renderCurrentContractView(model),
+        markdown: renderCurrentContractView(model, read.observedLedgerHead),
         ...(warning ? { amendmentWarning: warning } : {}),
     };
 }

package/build/core/outcome-base.js

@@ -88,14 +88,14 @@ export class EffectJournal {
     }
 }
 export function carrierLifecycleEffect(carrier) {
-    const idempotencyKey = `carrier:${carrier.ledgerHead}`;
+    const idempotencyKey = `carrier:${carrier.contractHead}`;
     if (carrier.status === "failed") {
         return { effect: "carrier-projection", idempotencyKey, status: "failed", cause: { code: "CARRIER_MATERIALIZATION_FAILED", message: carrier.cause } };
     }
     if (carrier.status === "target-unavailable") {
         return { effect: "carrier-projection", idempotencyKey, status: "failed", cause: { code: "CARRIER_TARGET_UNAVAILABLE", message: carrier.reason } };
     }
-    return { effect: "carrier-projection", idempotencyKey, status: "succeeded", receipt: { ledgerHead: carrier.ledgerHead, status: carrier.status } };
+    return { effect: "carrier-projection", idempotencyKey, status: "succeeded", receipt: { contractHead: carrier.contractHead, status: carrier.status } };
 }
 export function committedLifecycleFacts(input) {
     return {