@astrosheep/keiyaku 2.9.8 → 2.9.10

package/build/core/amend.js

@@ -1,13 +1,14 @@
 import { FlowError } from "../flow-error.js";
 import { getCurrentBranch, requireGitRepository } from "../git/branches.js";
-import { activeLedgerRef, appendWithRetry } from "./ledger.js";
-import { refreshContractView } from "./contract-view.js";
-import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
+import { runLifecycle } from "./lifecycle-runner.js";
+import { currentLifecycleState } from "./repository-ledger/read-model.js";
+import { isTerminalState } from "./status/lifecycle.js";
 import { resolveContractAddress, withResolvedAddress } from "./addressing.js";
 import { resolveDefaultBranch } from "./status/drift.js";
 import { markdownSourceSections, normalizeScopePattern, ScopePatternError, validateScopeFragmentLines } from "./scope.js";
 import { normalizeSectionTitle } from "./markdown/titles.js";
-import { resolveContractDeliveryCwd } from "./worktree-path.js";
+import { isCompleteLifecycleOutcome } from "./outcome-base.js";
+import { getConfig } from "../config/env.js";
 function amendScopeHeading(name) {
     return `## Scope ${name[0].toUpperCase()}${name.slice(1)}`;
 }
@@ -79,11 +80,8 @@ function requireAmendment(value) {
         throw new FlowError("EMPTY_PARAM", "amendment cannot be empty");
     return value;
 }
-function assertContractOperable(contractId, entries) {
-    const state = deriveContractState(entries);
-    if (state.state === "corrupt") {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} is corrupt at entry ${state.at}: ${state.reason}`);
-    }
+function assertContractOperable(contractId, model) {
+    const state = currentLifecycleState(model);
     if (isTerminalState(state)) {
         throw new FlowError("INTERNAL_STATE", `contract ${contractId} is terminal (${state.state})`);
     }
@@ -100,53 +98,131 @@ function normalizeScopeDelta(scopeDelta) {
 export async function amendContract(input) {
     const amendment = requireAmendment(input.amendment);
     const scopeDelta = normalizeScopeDelta(input.scopeDelta);
-    const renderCwd = input.renderCwd ?? input.cwd;
     const at = new Date(input.nowMs).toISOString();
-    const ref = activeLedgerRef(input.contractId);
-    let amendmentNumber = 0;
-    const result = await appendWithRetry(input.cwd, ref, (_currentHead, entries) => {
-        if (entries.length === 0)
-            return null;
-        assertContractOperable(input.contractId, entries);
-        amendmentNumber = entries.filter((entry) => entry.kind === "amend").length + 1;
-        const entry = {
-            v: 1,
-            kind: "amend",
-            contract: input.contractId,
-            at,
-            actor: input.actor,
-            data: { amendment, ...(scopeDelta ? { scopeDelta } : {}) },
-        };
-        return entry;
+    const execution = await runLifecycle({
+        cwd: input.cwd,
+        contractId: input.contractId,
+        mutation: {
+            verb: "amend",
+            // Amendment content is not a retry key; the containing Lnew is the sole mutation identity.
+            matchesAccepted: () => false,
+        },
+        signal: input.signal,
+        admit: (session, replay) => {
+            assertContractOperable(input.contractId, session.lifecycle);
+            if (session.target.status !== "available")
+                throw new FlowError("INTERNAL_STATE", session.target.reason);
+            const transaction = replay.state === "verb-committed" ? replay.transaction : undefined;
+            const accepted = transaction?.entries.at(-1);
+            if (accepted && accepted.kind !== "amend")
+                throw new FlowError("INTERNAL_STATE", `accepted transaction ${transaction.transactionObjectId} is not an amend`);
+            const existing = accepted?.kind === "amend" ? { transactionObjectId: transaction.transactionObjectId } : undefined;
+            const amendmentCount = session.lifecycle.history.filter(({ entry }) => entry.kind === "amend").length;
+            return {
+                amendmentNumber: amendmentCount + (existing ? 0 : 1),
+                targetRoot: session.target.root,
+                ...(existing ? { existing } : {}),
+            };
+        },
+        prepare: (admission) => {
+            if (admission.business.existing) {
+                return {
+                    amendmentNumber: admission.business.amendmentNumber,
+                    existing: admission.business.existing,
+                    entry: null,
+                };
+            }
+            return {
+                amendmentNumber: admission.business.amendmentNumber,
+                entry: {
+                    v: 1,
+                    kind: "amend",
+                    contract: input.contractId,
+                    at,
+                    actor: input.actor,
+                    data: { amendment, ...(scopeDelta ? { scopeDelta } : {}) },
+                },
+            };
+        },
+        revalidate: ({ session, admission, prepared }) => {
+            assertContractOperable(input.contractId, session.lifecycle);
+            if (session.target.status !== "available") {
+                return { code: "CARRIER_TARGET_UNAVAILABLE", message: session.target.reason };
+            }
+            if (prepared.existing) {
+                return session.repository.topology.nodes.some((node) => node.objectId === prepared.existing.transactionObjectId)
+                    ? undefined
+                    : { code: "AMEND_STATE_CHANGED", message: "accepted amend changed during replay preparation" };
+            }
+            const amendmentNumber = session.lifecycle.history.filter(({ entry }) => entry.kind === "amend").length + 1;
+            return amendmentNumber === admission.business.amendmentNumber
+                ? undefined
+                : { code: "AMENDMENT_NUMBER_CHANGED", message: "amendment sequence changed during preparation" };
+        },
+        effect: async ({ context, admission, prepared }) => {
+            const result = prepared.existing
+                ? await context.replayCommitted({ transactionObjectId: prepared.existing.transactionObjectId })
+                : await context.publishAuthoritative({ verb: "amend", admittedLedgerHead: admission.ledgerHead, acceptedLifecycleTail: context.session.lifecycle.history.at(-1).objectId, entries: [prepared.entry] });
+            if (result.status === "indeterminate") {
+                return { kind: "precommit-effects-only", authoritativeHead: result.currentHead ?? admission.ledgerHead };
+            }
+            if (result.status !== "committed") {
+                return { kind: "refused-before-effects", authoritativeHead: result.currentHead ?? context.session.lifecycle.observedLedgerHead, refusal: { code: "LEDGER_CAS_CONFLICT", message: `contract ${input.contractId} changed during amend` } };
+            }
+            return {
+                kind: "committed",
+                commit: result,
+                entryKind: "amend",
+                value: {
+                    amendmentNumber: prepared.amendmentNumber,
+                    amendmentWarning: input.amendmentWarningThreshold === undefined
+                        ? undefined
+                        : prepared.amendmentNumber > input.amendmentWarningThreshold
+                            ? { amendmentCount: prepared.amendmentNumber, threshold: input.amendmentWarningThreshold }
+                            : undefined,
+                    targetRoot: admission.business.targetRoot,
+                },
+            };
+        },
     });
-    if (!result.ok) {
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} active ledger disappeared during amend: ${result.reason}`);
-    }
-    if (amendmentNumber === 0) {
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} active ledger disappeared during amend`);
-    }
-    await refreshContractView({ ledgerCwd: input.cwd, renderCwd, contractId: input.contractId });
-    return { contractId: input.contractId, amendmentNumber, ledgerHead: result.head };
+    if (execution.kind === "noncommitted")
+        return execution.outcome;
+    if (execution.kind === "contained")
+        return { ...execution.outcome, contractId: input.contractId };
+    return {
+        ...execution.outcome,
+        contractId: input.contractId,
+        amendmentNumber: execution.payload.amendmentNumber,
+        ...(execution.payload.amendmentWarning ? { amendmentWarning: execution.payload.amendmentWarning } : {}),
+        ledgerHead: execution.outcome.committed.head,
+        carrier: execution.carrier,
+        targetRoot: execution.payload.targetRoot,
+    };
 }
 export async function amendKeiyaku(input) {
     await requireGitRepository(input.cwd, "amend");
     const address = input.address ?? await resolveContractAddress(input.cwd, input.contractId, input.contractAddressSource);
     return await withResolvedAddress(address, async () => {
         const contractId = address.binding.commissionId;
-        const renderCwd = await resolveContractDeliveryCwd(input.cwd, contractId);
         const amendment = requireAmendment(input.amendment);
-        const currentBranch = await getCurrentBranch(renderCwd);
-        const baseBranch = (await resolveDefaultBranch(input.cwd))?.branch ?? currentBranch;
+        const amendmentWarningThreshold = getConfig().amendmentWarning.threshold;
         const amended = await amendContract({
             cwd: input.cwd,
-            renderCwd,
             contractId,
             actor: "keiyaku",
             nowMs: Date.now(),
             amendment,
+            amendmentWarningThreshold,
             scopeDelta: input.scopeDelta,
+            signal: input.signal,
         });
+        if (!isCompleteLifecycleOutcome(amended))
+            return amended;
+        const { targetRoot, ...amendedFacts } = amended;
+        const currentBranch = await getCurrentBranch(targetRoot);
+        const baseBranch = (await resolveDefaultBranch(input.cwd))?.branch ?? currentBranch;
         return {
+            ...amendedFacts,
             status: "success",
             amendmentNumber: amended.amendmentNumber,
             currentBranch,
@@ -154,6 +230,7 @@ export async function amendKeiyaku(input) {
             ledgerCommit: amended.ledgerHead,
             summary: `Appended Amendment ${amended.amendmentNumber} to contract ledger ${contractId}.`,
             address,
+            carrier: amended.carrier,
         };
     });
 }

package/build/core/amendment-criteria.js

@@ -0,0 +1,17 @@
+import { parseToAST } from "./markdown/parser.js";
+import { extractListItems } from "./markdown/render.js";
+import { normalizeSectionTitle } from "./markdown/titles.js";
+/** Criteria declared by one lawful amendment, without imposing bind-document grammar. */
+export function amendmentCriteria(amendment) {
+    const criteria = [];
+    for (const node of parseToAST(amendment).children) {
+        if (node.type !== "section" || node.level !== 2 || normalizeSectionTitle(node.title) !== "criteria")
+            continue;
+        criteria.push(...extractListItems(node).map((item) => item.trim()).filter(Boolean));
+    }
+    return criteria;
+}
+/** Bind declarations first, then amendment declarations in accepted lifecycle order. */
+export function effectiveCriteria(bindCriteria, amendments) {
+    return [...bindCriteria, ...amendments.flatMap(amendmentCriteria)];
+}

package/build/core/amendment-warning.js

@@ -0,0 +1,10 @@
+import { currentLifecycleState } from "./repository-ledger/read-model.js";
+export function deriveAmendmentWarning(model, threshold) {
+    if (model.history[0]?.entry.kind !== "bind")
+        return undefined;
+    const state = currentLifecycleState(model);
+    if (state.state === "claimed" || state.state === "forfeited")
+        return undefined;
+    const amendmentCount = model.history.filter(({ entry }) => entry.kind === "amend").length;
+    return amendmentCount > threshold ? { amendmentCount, threshold } : undefined;
+}

package/build/core/arc.js

@@ -1,19 +1,18 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
 import { requireText, FlowError } from "../flow-error.js";
 import { getCurrentBranch, requireGitRepository } from "../git/branches.js";
 import { assertCleanTrackedWorkingTree } from "../git/worktree.js";
-import { KEIYAKU_FILE, ACTOR_IDENTITY } from "../keiyaku.js";
+import { ACTOR_IDENTITY } from "../keiyaku.js";
 import { normalizeInlineTitle } from "./markdown/titles.js";
 import { parseCommandMarkdown, requireMarkdownTextSection, requireMarkdownTitle, } from "./command-markdown.js";
+import { isCompleteLifecycleOutcome } from "./outcome-base.js";
 import { resolveContractAddress, withResolvedAddress } from "./addressing.js";
-import { activeLedgerRef, appendWithRetry, readLedger } from "./ledger.js";
-import { refreshContractView } from "./contract-view.js";
-import { appendScopeTerms, findOpenArc, getMaxArc, sealCurrentArc } from "./seal.js";
-import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
+import { runLifecycle } from "./lifecycle-runner.js";
+import { captureFoldedSeal, findOpenArc } from "./seal.js";
+import { normalizeScopePattern } from "./scope.js";
+import { currentLifecycleState } from "./repository-ledger/read-model.js";
+import { isTerminalState } from "./status/lifecycle.js";
 import { resolveDefaultBranch } from "./status/drift.js";
 import { persistResponseHistory } from "./transcripts.js";
-import { resolveContractDeliveryCwd } from "./worktree-path.js";
 export function buildArcViews(entries) {
     const arcs = new Map();
     for (const entry of entries) {
@@ -40,13 +39,10 @@ export function findOpenArcView(entries) {
         return null;
     return buildArcViews(entries).find((arc) => arc.arc === open.data.arc) ?? null;
 }
-function assertArcOpenable(contractId, entries) {
-    const state = deriveContractState(entries);
+function assertArcOpenable(contractId, model) {
+    const state = currentLifecycleState(model);
     if (state.state === "bound" || state.state === "active")
         return;
-    if (state.state === "corrupt") {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot open arc from corrupt state at entry ${state.at}`);
-    }
     if (isTerminalState(state) || state.state === "petitioned") {
         throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot open arc from state ${state.state}`);
     }
@@ -55,50 +51,166 @@ export async function openArc(input) {
     const title = requireText("title", input.title);
     const objective = requireText("objective", input.objective);
     const brief = requireText("brief", input.brief);
-    const renderCwd = input.renderCwd ?? input.cwd;
-    const ledger = await readLedger(input.cwd, input.contractId);
-    if (!ledger) {
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} not found or not active`);
-    }
-    assertArcOpenable(input.contractId, ledger.entries);
-    await appendScopeTerms({
+    const patterns = input.appendScope?.map(normalizeScopePattern) ?? [];
+    const at = new Date(input.nowMs).toISOString();
+    const execution = await runLifecycle({
         cwd: input.cwd,
-        renderCwd,
         contractId: input.contractId,
-        patterns: input.appendScope,
-        actor: input.actor,
-        nowMs: input.nowMs,
+        mutation: {
+            verb: "arc",
+            matchesAccepted: (transaction) => {
+                const accepted = transaction.entries.at(-1);
+                const acceptedAmend = transaction.entries.find((entry) => entry.kind === "amend");
+                const acceptedPatterns = acceptedAmend?.kind === "amend" ? acceptedAmend.data.scopeDelta?.add ?? [] : [];
+                return accepted?.kind === "arc"
+                    && accepted.data.title === title
+                    && accepted.data.objective === objective
+                    && accepted.data.brief === brief
+                    && JSON.stringify(acceptedPatterns) === JSON.stringify(patterns);
+            },
+        },
+        signal: input.signal,
+        admit: (session, replay) => {
+            assertArcOpenable(input.contractId, session.lifecycle);
+            if (session.target.status !== "available")
+                throw new FlowError("INTERNAL_STATE", session.target.reason);
+            const accepted = replay.state === "verb-committed" ? replay.transaction.entries.at(-1) : undefined;
+            let existing;
+            if (accepted?.kind === "arc" && replay.state === "verb-committed") {
+                const seal = replay.transaction.entries.find((entry) => entry.kind === "seal");
+                existing = {
+                    transactionObjectId: replay.transaction.transactionObjectId,
+                    arcNumber: accepted.data.arc,
+                    capture: seal?.kind === "seal" ? {
+                        arc: seal.data.arc,
+                        oldFence: seal.data.oldFence,
+                        newFence: seal.data.newFence,
+                        receipts: [...seal.data.receipts],
+                        diffstat: { ...seal.data.diffstat },
+                        scopeAudit: { violations: [...seal.data.scopeAudit.violations] },
+                        scopeViolationEvidence: [],
+                    } : null,
+                };
+            }
+            return { lifecycle: session.lifecycle, targetRoot: session.target.root, ...(existing ? { existing } : {}) };
+        },
+        prepare: async (admission) => {
+            if (admission.business.existing) {
+                return {
+                    additions: [],
+                    arcNumber: admission.business.existing.arcNumber,
+                    capture: admission.business.existing.capture,
+                    existing: admission.business.existing,
+                };
+            }
+            const scopeEntry = patterns.length === 0 ? null : {
+                v: 1,
+                kind: "amend",
+                contract: input.contractId,
+                at,
+                actor: input.actor,
+                data: { amendment: "Scope extended by lifecycle command.", scopeDelta: { add: patterns } },
+            };
+            const capture = await captureFoldedSeal(admission.business.targetRoot, admission.business.lifecycle, "HEAD", patterns);
+            const arcNumber = admission.business.lifecycle.intent.arc + 1;
+            let sealEntry = null;
+            if (capture) {
+                const { scopeViolationEvidence: _evidence, ...durableCapture } = capture;
+                sealEntry = {
+                    v: 2,
+                    kind: "seal",
+                    contract: input.contractId,
+                    at,
+                    actor: "engine",
+                    data: { ...durableCapture, sealedBy: "arc" },
+                };
+            }
+            const arcEntry = {
+                v: 1,
+                kind: "arc",
+                contract: input.contractId,
+                at,
+                actor: input.actor,
+                data: { arc: arcNumber, title, objective, brief },
+            };
+            const additions = scopeEntry
+                ? sealEntry ? [scopeEntry, sealEntry, arcEntry] : [scopeEntry, arcEntry]
+                : sealEntry ? [sealEntry, arcEntry] : [arcEntry];
+            return { additions, arcNumber, capture };
+        },
+        revalidate: async ({ session, prepared }) => {
+            assertArcOpenable(input.contractId, session.lifecycle);
+            if (session.target.status !== "available")
+                return { code: "CARRIER_TARGET_UNAVAILABLE", message: session.target.reason };
+            if (prepared.existing) {
+                return session.repository.topology.nodes.some((node) => node.objectId === prepared.existing.transactionObjectId)
+                    ? undefined
+                    : { code: "ARC_STATE_CHANGED", message: "accepted arc changed during replay preparation" };
+            }
+            await assertCleanTrackedWorkingTree(session.target.root);
+            return session.lifecycle.intent.arc + 1 === prepared.arcNumber
+                ? undefined
+                : { code: "ARC_NUMBER_CHANGED", message: "arc sequence changed during preparation" };
+        },
+        effect: async ({ context, admission, prepared }) => {
+            const result = prepared.existing
+                ? await context.replayCommitted({ transactionObjectId: prepared.existing.transactionObjectId })
+                : await context.publishAuthoritative({
+                    verb: "arc",
+                    admittedLedgerHead: admission.ledgerHead,
+                    acceptedLifecycleTail: context.session.lifecycle.history.at(-1).objectId,
+                    entries: prepared.additions,
+                });
+            if (result.status === "indeterminate") {
+                return { kind: "precommit-effects-only", authoritativeHead: result.currentHead ?? admission.ledgerHead };
+            }
+            if (result.status !== "committed" || prepared.arcNumber === 0) {
+                return { kind: "refused-before-effects", authoritativeHead: result.status === "committed" ? result.head : result.currentHead ?? context.session.lifecycle.observedLedgerHead, refusal: { code: "LEDGER_CAS_CONFLICT", message: `contract ${input.contractId} changed during arc` } };
+            }
+            const committedCapture = prepared.capture;
+            const sealed = committedCapture && {
+                ...committedCapture,
+                sealedBy: "arc",
+                ledgerHead: result.transaction.entryObjectIds[result.transaction.entries.findIndex((entry) => entry.kind === "seal")],
+            };
+            let response;
+            if (input.persistResponse) {
+                await context.journal.run({
+                    effect: "response-history-persistence",
+                    run: async () => {
+                        response = await input.persistResponse({ ledgerHead: result.head, sealed });
+                        return response;
+                    },
+                });
+            }
+            return {
+                kind: "committed",
+                commit: result,
+                entryKind: "arc",
+                value: {
+                    arc: prepared.arcNumber,
+                    sealed,
+                    targetRoot: admission.business.targetRoot,
+                    ...(response ?? {}),
+                },
+            };
+        },
     });
-    // Seal capture needs delivery HEAD; ledger append may use hub or delivery (shared refs).
-    const sealed = await sealCurrentArc({
-        cwd: renderCwd,
-        renderCwd,
+    if (execution.kind === "noncommitted")
+        return execution.outcome;
+    if (execution.kind === "contained")
+        return { ...execution.outcome, contractId: input.contractId };
+    return {
+        ...execution.outcome,
         contractId: input.contractId,
-        sealedBy: "arc",
-        nowMs: input.nowMs,
-    });
-    const at = new Date(input.nowMs).toISOString();
-    let arcNumber = 0;
-    const result = await appendWithRetry(input.cwd, activeLedgerRef(input.contractId), (_head, entries) => {
-        assertArcOpenable(input.contractId, entries);
-        if (findOpenArc(entries)) {
-            throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} still has an open arc after sealing`);
-        }
-        arcNumber = getMaxArc(entries) + 1;
-        return {
-            v: 1,
-            kind: "arc",
-            contract: input.contractId,
-            at,
-            actor: input.actor,
-            data: { arc: arcNumber, title, objective, brief },
-        };
-    });
-    if (!result.ok || arcNumber === 0) {
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} active ledger disappeared during arc`);
-    }
-    await refreshContractView({ ledgerCwd: input.cwd, renderCwd, contractId: input.contractId });
-    return { contractId: input.contractId, arc: arcNumber, ledgerHead: result.head, sealed };
+        arc: execution.payload.arc,
+        ledgerHead: execution.outcome.committed.head,
+        sealed: execution.payload.sealed,
+        carrier: execution.carrier,
+        targetRoot: execution.payload.targetRoot,
+        ...(execution.payload.responsePath ? { responsePath: execution.payload.responsePath } : {}),
+        ...(execution.payload.artifactId ? { artifactId: execution.payload.artifactId } : {}),
+    };
 }
 export function buildArcInput(content, cwd, appendScope = [], contractId, contractAddressSource) {
     const parts = parseCommandMarkdown(content);
@@ -122,21 +234,15 @@ export async function arcKeiyaku(input) {
     const address = input.address ?? await resolveContractAddress(input.cwd, input.contractId, input.contractAddressSource);
     return await withResolvedAddress(address, async () => {
         const contractId = address.binding.commissionId;
-        const renderCwd = await resolveContractDeliveryCwd(input.cwd, contractId);
-        await assertCleanTrackedWorkingTree(renderCwd);
-        try {
-            await fs.access(path.join(renderCwd, KEIYAKU_FILE));
-        }
-        catch {
-            throw new FlowError("MISSING_PROTOCOL_FILES", `missing protocol file for current keiyaku (${KEIYAKU_FILE})`);
-        }
         const title = normalizeInlineTitle(requireText("title", input.title));
         const objective = requireText("objective", input.objective);
         const brief = requireText("brief", input.brief);
         const nowMs = Date.now();
+        const summaryFor = (sealed, arc) => sealed
+            ? `a${sealed.arc} sealed; a${arc} open: ${title}.`
+            : `a${arc} open: ${title}.`;
         const opened = await openArc({
             cwd: input.cwd,
-            renderCwd,
             contractId,
             actor: ACTOR_IDENTITY,
             nowMs,
@@ -144,33 +250,27 @@ export async function arcKeiyaku(input) {
             objective,
             brief,
             appendScope: input.appendScope,
-        });
-        const { currentBranch, baseBranch } = await readBranchLabels(renderCwd);
-        const summary = opened.sealed
-            ? `a${opened.sealed.arc} sealed; a${opened.arc} open: ${title}.`
-            : `a${opened.arc} open: ${title}.`;
-        let responsePath;
-        let artifactId;
-        try {
-            const persisted = await persistResponseHistory({
+            signal: input.signal,
+            persistResponse: async ({ ledgerHead, sealed }) => persistResponseHistory({
                 cwd: input.cwd,
                 tool: "arc",
                 provenance: { authority: { kind: "repository" }, binding: address.binding, evidenceCwd: input.cwd },
                 title,
                 objective,
                 brief,
-                ledgerCommit: opened.ledgerHead,
-                summary,
+                ledgerCommit: ledgerHead,
+                summary: summaryFor(sealed, (sealed?.arc ?? 0) + 1),
                 emptyDiffLabel: "working tree untouched",
-                ...(opened.sealed ? { sealed: opened.sealed } : {}),
-            });
-            responsePath = persisted.responsePath;
-            artifactId = persisted.artifactId;
-        }
-        catch {
-            responsePath = undefined;
-        }
+                ...(sealed ? { sealed } : {}),
+            }),
+        });
+        if (!isCompleteLifecycleOutcome(opened))
+            return opened;
+        const { targetRoot, ...openedFacts } = opened;
+        const { currentBranch, baseBranch } = await readBranchLabels(targetRoot);
+        const summary = summaryFor(opened.sealed, opened.arc);
         return {
+            ...openedFacts,
             status: "success",
             arc: opened.arc,
             currentBranch,
@@ -184,9 +284,10 @@ export async function arcKeiyaku(input) {
             brief,
             ledgerCommit: opened.ledgerHead,
             sealed: opened.sealed ?? undefined,
-            responsePath,
-            artifactId,
+            responsePath: opened.responsePath,
+            artifactId: opened.artifactId,
             address,
+            carrier: opened.carrier,
         };
     });
 }