@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/core/amend.js

@@ -1,321 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { getCurrentBranch, requireGitRepository } from "../git/branches.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 { isCompleteLifecycleOutcome } from "./outcome-base.js";
-import { getConfig } from "../config/env.js";
-import { parseVerificationDeclarations } from "./verification-declaration.js";
-function amendScopeHeading(name) {
-    return `## Scope ${name[0].toUpperCase()}${name.slice(1)}`;
-}
-function normalizeReplaceVerificationsTitle(title) {
-    // ATX closing markers are structural syntax, not part of the section title.
-    return normalizeSectionTitle(title.replace(/[ \t]+#+[ \t]*$/, ""));
-}
-function parseAmendScopeSections(markdown) {
-    const sections = {};
-    for (const section of markdownSourceSections(markdown)) {
-        if (section.level !== 2)
-            continue;
-        const title = normalizeSectionTitle(section.title);
-        if (normalizeReplaceVerificationsTitle(section.title) === "replace verifications")
-            continue;
-        if (title === "scope add") {
-            throw new FlowError("INVALID_KEIYAKU_DRAFT", "Scope Add is obsolete; use ## Scope Append with a fenced gitignore-subset block");
-        }
-        if (title.startsWith("scope ") && title !== "scope append") {
-            throw new FlowError("INVALID_KEIYAKU_DRAFT", `unknown structured amendment operation ## ${section.title}`);
-        }
-        if (title.startsWith("replace ") && title !== "replace verifications") {
-            throw new FlowError("INVALID_KEIYAKU_DRAFT", `unknown structured amendment operation ## ${section.title}`);
-        }
-        if (title !== "scope append")
-            continue;
-        if (sections.append) {
-            throw new FlowError("INVALID_KEIYAKU_DRAFT", `amend input may contain ${amendScopeHeading("append")} at most once`);
-        }
-        sections.append = {
-            name: "append",
-            start: section.start,
-            contentStart: section.contentStart,
-            end: section.end,
-        };
-    }
-    return { sections };
-}
-function scopePatterns(markdown, section) {
-    return validateScopeFragmentLines(markdown.slice(section.contentStart, section.end).split(/\r?\n/), {
-        heading: amendScopeHeading(section.name),
-        emptyMessage: `amend input has an empty ${amendScopeHeading(section.name)} section`,
-    });
-}
-function normalizeAmendScopePatterns(patterns) {
-    try {
-        return patterns.map((pattern) => normalizeScopePattern(pattern));
-    }
-    catch (error) {
-        if (error instanceof ScopePatternError) {
-            throw new FlowError("INVALID_KEIYAKU_DRAFT", error.message);
-        }
-        throw error;
-    }
-}
-/** Inspect every structural ATX level so a misplaced replacement never becomes prose. */
-function amendAtxHeadings(markdown) {
-    const lines = markdown.split(/\r?\n/);
-    const frontMatterEnd = lines[0]?.trim() === "---"
-        ? lines.findIndex((line, index) => index > 0 && line.trim() === "---")
-        : -1;
-    let fence;
-    const headings = [];
-    for (let index = 0; index < lines.length; index += 1) {
-        const line = lines[index];
-        if (index <= frontMatterEnd)
-            continue;
-        if (fence) {
-            const close = line.match(/^ {0,3}(`+|~+)[ \t]*$/);
-            if (close && close[1][0] === fence.delimiter && close[1].length >= fence.length)
-                fence = undefined;
-            continue;
-        }
-        const open = line.match(/^ {0,3}(`{3,}|~{3,})(.*)$/);
-        if (open && !(open[1][0] === "`" && open[2].includes("`"))) {
-            fence = { delimiter: open[1][0], length: open[1].length };
-            continue;
-        }
-        const heading = line.match(/^(#{1,6})(?!#)[ \t]+(.+)$/);
-        if (heading)
-            headings.push({ level: heading[1].length, title: heading[2] });
-    }
-    return headings;
-}
-function parseReplaceVerificationsSection(markdown) {
-    const matchingHeadings = amendAtxHeadings(markdown)
-        .filter((heading) => normalizeReplaceVerificationsTitle(heading.title) === "replace verifications");
-    if (matchingHeadings.some((heading) => heading.level !== 2)) {
-        throw new FlowError("INVALID_KEIYAKU_DRAFT", "Replace Verifications must use the H2 heading '## Replace Verifications'");
-    }
-    if (matchingHeadings.length > 1) {
-        throw new FlowError("INVALID_KEIYAKU_DRAFT", "amend input may contain ## Replace Verifications at most once");
-    }
-    let replacement;
-    for (const section of markdownSourceSections(markdown)) {
-        if (normalizeReplaceVerificationsTitle(section.title) !== "replace verifications")
-            continue;
-        replacement = section;
-    }
-    return replacement;
-}
-function replacementDeclarations(markdown, section) {
-    return parseVerificationDeclarations(markdown.slice(section.contentStart, section.end), {
-        heading: "## Replace Verifications",
-        allowNone: true,
-    });
-}
-export function buildAmendInput(markdown, cwd, contractId, contractAddressSource, appendScope) {
-    const { sections } = parseAmendScopeSections(markdown);
-    const replacement = parseReplaceVerificationsSection(markdown);
-    if (sections.append && appendScope && appendScope.length > 0) {
-        throw new FlowError("INVALID_KEIYAKU_DRAFT", "amend input may use either --append-scope or ## Scope Append, not both");
-    }
-    const append = sections.append
-        ? scopePatterns(markdown, sections.append)
-        : normalizeAmendScopePatterns(appendScope ?? []);
-    const verification = replacement ? replacementDeclarations(markdown, replacement) : undefined;
-    const sourceSections = [...Object.values(sections), ...(replacement ? [replacement] : [])];
-    let proseWithoutReplacement = markdown;
-    for (const section of sourceSections.sort((left, right) => right.start - left.start)) {
-        proseWithoutReplacement = `${proseWithoutReplacement.slice(0, section.start)}${proseWithoutReplacement.slice(section.end)}`;
-    }
-    if (!proseWithoutReplacement.trim() && append.length === 0 && verification === undefined) {
-        throw new FlowError("EMPTY_PARAM", "amendment cannot be empty");
-    }
-    return {
-        cwd,
-        ...(contractId ? { contractId } : {}),
-        ...(contractAddressSource ? { contractAddressSource } : {}),
-        amendment: proseWithoutReplacement,
-        ...(append.length > 0 ? { scopeDelta: { add: append } } : {}),
-        ...(verification ? { verificationDelta: { replace: verification } } : {}),
-    };
-}
-function requireAmendment(input) {
-    if (!input.amendment.trim() && !input.scopeDelta && !input.verificationDelta) {
-        throw new FlowError("EMPTY_PARAM", "amendment cannot be empty");
-    }
-    return input.amendment;
-}
-function assertContractOperable(contractId, model) {
-    const state = currentLifecycleState(model);
-    if (isTerminalState(state)) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} is terminal (${state.state})`);
-    }
-}
-function normalizeScopeDelta(scopeDelta) {
-    if (!scopeDelta)
-        return undefined;
-    // Scope patterns are gitignore text; do not requireText/trim, or escaped trailing spaces die.
-    const add = normalizeAmendScopePatterns(scopeDelta.add);
-    if (add.length === 0)
-        return undefined;
-    return { add };
-}
-function normalizeVerificationDelta(verificationDelta) {
-    if (!verificationDelta)
-        return undefined;
-    const replace = verificationDelta.replace.map((declaration) => ({ ...declaration }));
-    if (replace.some((declaration) => !declaration.executor || !declaration.script.trim())) {
-        throw new FlowError("INVALID_KEIYAKU_DRAFT", "Verification replacement declarations must have an executor and nonblank script");
-    }
-    return { replace };
-}
-export async function amendContract(input) {
-    const scopeDelta = normalizeScopeDelta(input.scopeDelta);
-    const verificationDelta = normalizeVerificationDelta(input.verificationDelta);
-    const amendment = requireAmendment({ amendment: input.amendment, scopeDelta, verificationDelta });
-    const at = new Date(input.nowMs).toISOString();
-    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: 2,
-                    kind: "amend",
-                    contract: input.contractId,
-                    at,
-                    actor: input.actor,
-                    data: {
-                        amendment,
-                        ...(scopeDelta ? { scopeDelta } : {}),
-                        ...(verificationDelta ? { verificationDelta } : {}),
-                    },
-                },
-            };
-        },
-        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.contractHead, 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.pins.repositoryLedgerHead, 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 (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 amendment = requireAmendment(input);
-        const amendmentWarningThreshold = getConfig().amendmentWarning.threshold;
-        const amended = await amendContract({
-            cwd: input.cwd,
-            contractId,
-            actor: "keiyaku",
-            nowMs: Date.now(),
-            amendment,
-            amendmentWarningThreshold,
-            scopeDelta: input.scopeDelta,
-            verificationDelta: input.verificationDelta,
-            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,
-            baseBranch,
-            ledgerCommit: amended.ledgerHead,
-            summary: `Appended Amendment ${amended.amendmentNumber} to contract ledger ${contractId}.`,
-            address,
-            carrier: amended.carrier,
-        };
-    });
-}

package/build/core/amendment-criteria.js

@@ -1,17 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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,293 +0,0 @@
-import { requireText, FlowError } from "../flow-error.js";
-import { getCurrentBranch, requireGitRepository } from "../git/branches.js";
-import { assertCleanTrackedWorkingTree } from "../git/worktree.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 { 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";
-export function buildArcViews(entries) {
-    const arcs = new Map();
-    for (const entry of entries) {
-        if (entry.kind === "arc") {
-            arcs.set(entry.data.arc, {
-                arc: entry.data.arc,
-                title: entry.data.title,
-                objective: entry.data.objective,
-                brief: entry.data.brief,
-                open: entry,
-            });
-        }
-        if (entry.kind === "seal") {
-            const arc = arcs.get(entry.data.arc);
-            if (arc)
-                arc.seal = entry;
-        }
-    }
-    return [...arcs.values()].sort((left, right) => left.arc - right.arc);
-}
-export function findOpenArcView(entries) {
-    const open = findOpenArc(entries);
-    if (!open)
-        return null;
-    return buildArcViews(entries).find((arc) => arc.arc === open.data.arc) ?? null;
-}
-function assertArcOpenable(contractId, model) {
-    const state = currentLifecycleState(model);
-    if (state.state === "bound" || state.state === "active")
-        return;
-    if (isTerminalState(state) || state.state === "petitioned") {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot open arc from state ${state.state}`);
-    }
-}
-export async function openArc(input) {
-    const title = requireText("title", input.title);
-    const objective = requireText("objective", input.objective);
-    const brief = requireText("brief", input.brief);
-    const patterns = input.appendScope?.map(normalizeScopePattern) ?? [];
-    const at = new Date(input.nowMs).toISOString();
-    const execution = await runLifecycle({
-        cwd: input.cwd,
-        contractId: input.contractId,
-        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: 2,
-                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, "refuse");
-            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.contractHead,
-                    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.pins.repositoryLedgerHead, 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 ?? {}),
-                },
-            };
-        },
-    });
-    if (execution.kind === "noncommitted")
-        return execution.outcome;
-    if (execution.kind === "contained")
-        return { ...execution.outcome, contractId: input.contractId };
-    return {
-        ...execution.outcome,
-        contractId: input.contractId,
-        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);
-    return {
-        cwd,
-        ...(contractId ? { contractId } : {}),
-        ...(contractAddressSource ? { contractAddressSource } : {}),
-        title: requireMarkdownTitle(parts),
-        objective: requireMarkdownTextSection(parts, "Objective"),
-        brief: requireMarkdownTextSection(parts, "Brief"),
-        appendScope,
-    };
-}
-async function readBranchLabels(cwd) {
-    const currentBranch = await getCurrentBranch(cwd);
-    const baseBranch = (await resolveDefaultBranch(cwd))?.branch ?? currentBranch;
-    return { currentBranch, baseBranch };
-}
-export async function arcKeiyaku(input) {
-    await requireGitRepository(input.cwd, "arc");
-    const address = input.address ?? await resolveContractAddress(input.cwd, input.contractId, input.contractAddressSource);
-    return await withResolvedAddress(address, async () => {
-        const contractId = address.binding.commissionId;
-        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,
-            contractId,
-            actor: ACTOR_IDENTITY,
-            nowMs,
-            title,
-            objective,
-            brief,
-            appendScope: input.appendScope,
-            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: ledgerHead,
-                summary: summaryFor(sealed, (sealed?.arc ?? 0) + 1),
-                emptyDiffLabel: "working tree untouched",
-                ...(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,
-            baseBranch,
-            commit: opened.ledgerHead,
-            // CLI/render synthesizes public face bytes from sealed typed facts.
-            diff: "",
-            summary,
-            title,
-            objective,
-            brief,
-            ledgerCommit: opened.ledgerHead,
-            sealed: opened.sealed ?? undefined,
-            responsePath: opened.responsePath,
-            artifactId: opened.artifactId,
-            address,
-            carrier: opened.carrier,
-        };
-    });
-}