@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/core/execution-pact.js

@@ -1,126 +0,0 @@
-import * as path from "node:path";
-import { ProjectionStateError } from "./atomic-publish.js";
-import { parseExecutionBinding as parseCanonicalExecutionBinding, parseExecutionCoordinates, } from "./execution-coordinate.js";
-import { assertExactFields, assertNonBlankString, isPlainRecord, } from "./validation.js";
-const TOP_LEVEL_FIELDS = [
-    "version",
-    "pid",
-    "akuma",
-    "provider",
-    "authority",
-    "binding",
-    "mintedAt",
-    "workspaceRoot",
-];
-const TOP_LEVEL_OPTIONAL_FIELDS = ["effectivePolicy"];
-const PACT_FIELD_NAMES = TOP_LEVEL_FIELDS.filter((field) => field !== "authority");
-function pactError(pactPath, field, reason) {
-    return new ProjectionStateError(`invalid projection pact at ${pactPath}: field '${field}' ${reason}`);
-}
-function pactInvalid(pactPath) {
-    return (field, reason) => pactError(pactPath, field, reason);
-}
-/** Parse the pre-publication authority choice without inventing a durable identity. */
-export function parseExecutionAuthoritySelection(value, pactPath = "projection identity", expectedKind) {
-    if (!isPlainRecord(value))
-        throw pactError(pactPath, "authority", "must be an object");
-    assertExactFields(value, ["kind"], [], "authority", pactInvalid(pactPath));
-    if (value.kind !== "repository" && value.kind !== "user") {
-        throw pactError(pactPath, "authority.kind", "must be 'repository' or 'user'");
-    }
-    if (expectedKind !== undefined && value.kind !== expectedKind) {
-        throw pactError(pactPath, "authority.kind", `must be '${expectedKind}' for this projection mint`);
-    }
-    return { kind: value.kind };
-}
-/** Parse and validate an execution binding without inventing authority identity. */
-export function parseExecutionBinding(value, pactPath = "projection identity") {
-    return parseCanonicalExecutionBinding(value, (field, reason) => pactError(pactPath, field, reason));
-}
-export function assertExecutionPactCoordinates(authorityValue, bindingValue, pactPath = "projection identity") {
-    return parseExecutionCoordinates(authorityValue, bindingValue, (field, reason) => pactError(pactPath, field, reason));
-}
-function parseEffectivePolicy(value, pactPath) {
-    if (!isPlainRecord(value))
-        throw pactError(pactPath, "effectivePolicy", "must be an object");
-    assertExactFields(value, [], ["access", "network", "webSearch"], "effectivePolicy", pactInvalid(pactPath));
-    if (value.access !== undefined && value.access !== "read" && value.access !== "write" && value.access !== "auto") {
-        throw pactError(pactPath, "effectivePolicy.access", "must be 'read', 'write', or 'auto'");
-    }
-    if (value.network !== undefined && value.network !== "disabled" && value.network !== "enabled") {
-        throw pactError(pactPath, "effectivePolicy.network", "must be 'disabled' or 'enabled'");
-    }
-    if (value.webSearch !== undefined && !["disabled", "cached", "live"].includes(String(value.webSearch))) {
-        throw pactError(pactPath, "effectivePolicy.webSearch", "must be 'disabled', 'cached', or 'live'");
-    }
-    return value;
-}
-function parseExecutionPactFieldsRecord(value, pactPath) {
-    if (value.version !== 1)
-        throw pactError(pactPath, "version", "must equal 1");
-    if (!Number.isInteger(value.pid) || value.pid < 0) {
-        throw pactError(pactPath, "pid", "must be a non-negative integer");
-    }
-    const invalid = pactInvalid(pactPath);
-    assertNonBlankString(value.akuma, "akuma", invalid);
-    assertNonBlankString(value.provider, "provider", invalid);
-    assertNonBlankString(value.mintedAt, "mintedAt", invalid);
-    const mintedAtMs = Date.parse(value.mintedAt);
-    if (!Number.isFinite(mintedAtMs) || new Date(mintedAtMs).toISOString() !== value.mintedAt) {
-        throw pactError(pactPath, "mintedAt", "must be an ISO-8601 timestamp");
-    }
-    assertNonBlankString(value.workspaceRoot, "workspaceRoot", invalid);
-    if (!path.isAbsolute(value.workspaceRoot)) {
-        throw pactError(pactPath, "workspaceRoot", "must be an absolute path");
-    }
-    const binding = parseExecutionBinding(value.binding, pactPath);
-    return {
-        version: 1,
-        pid: value.pid,
-        akuma: value.akuma,
-        provider: value.provider,
-        binding,
-        mintedAt: value.mintedAt,
-        workspaceRoot: value.workspaceRoot,
-        ...(value.effectivePolicy !== undefined
-            ? { effectivePolicy: parseEffectivePolicy(value.effectivePolicy, pactPath) }
-            : {}),
-    };
-}
-/** Validate every pact field that exists before a repository identity is minted. */
-export function parseExecutionPactFields(value, pactPath = "projection identity") {
-    if (!isPlainRecord(value))
-        throw pactError(pactPath, "$", "must be an object");
-    assertExactFields(value, PACT_FIELD_NAMES, TOP_LEVEL_OPTIONAL_FIELDS, "", pactInvalid(pactPath));
-    return parseExecutionPactFieldsRecord(value, pactPath);
-}
-export function parseExecutionPact(value, pactPath = "projection identity") {
-    if (!isPlainRecord(value))
-        throw pactError(pactPath, "$", "must be an object");
-    assertExactFields(value, TOP_LEVEL_FIELDS, TOP_LEVEL_OPTIONAL_FIELDS, "", pactInvalid(pactPath));
-    const fields = parseExecutionPactFieldsRecord(value, pactPath);
-    const { authority, binding } = assertExecutionPactCoordinates(value.authority, fields.binding, pactPath);
-    return {
-        version: fields.version,
-        pid: fields.pid,
-        akuma: fields.akuma,
-        provider: fields.provider,
-        authority,
-        binding,
-        mintedAt: fields.mintedAt,
-        workspaceRoot: fields.workspaceRoot,
-        ...(fields.effectivePolicy !== undefined ? { effectivePolicy: fields.effectivePolicy } : {}),
-    };
-}
-export function parseExecutionPactJson(raw, pactPath = "projection identity") {
-    let value;
-    try {
-        value = JSON.parse(raw);
-    }
-    catch (error) {
-        throw new ProjectionStateError(`invalid projection pact at ${pactPath}: field '$' contains malformed JSON`, {
-            cause: error,
-        });
-    }
-    return parseExecutionPact(value, pactPath);
-}

package/build/core/forfeit.js

@@ -1,132 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { assertCleanTrackedWorkingTree } from "../git/worktree.js";
-import { runLifecycle } from "./lifecycle-runner.js";
-import { currentLifecycleState } from "./repository-ledger/read-model.js";
-import { isTerminalState } from "./status/lifecycle.js";
-import { terminalCleanupFacts } from "./worktree-path.js";
-import { repositoryDeliveryRef } from "./repository-ledger/codec.js";
-export async function forfeitContract(input) {
-    const at = new Date(input.nowMs).toISOString();
-    const requestedNote = input.note?.trim() || undefined;
-    const execution = await runLifecycle({
-        cwd: input.cwd,
-        contractId: input.contractId,
-        mutation: {
-            verb: "forfeit",
-        },
-        signal: input.signal,
-        ...(input.terminalWorkspaceCleanup ? { terminalWorkspaceCleanup: input.terminalWorkspaceCleanup } : {}),
-        admit: async (session, replay) => {
-            const state = currentLifecycleState(session.lifecycle);
-            if (state.state !== "forfeited" && isTerminalState(state))
-                throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} cannot forfeit from state ${state.state}`);
-            if (state.state === "forfeited") {
-                const transaction = replay.state === "verb-committed" ? replay.transaction : undefined;
-                const existing = transaction?.entries.at(-1);
-                if (!existing || existing.kind !== "forfeit")
-                    throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} forfeited without an accepted forfeit transaction`);
-                return {
-                    state,
-                    delivery: { status: "absent" },
-                    existing: { transactionObjectId: transaction.transactionObjectId, entry: existing },
-                    ...(session.target.status === "available" ? { targetRoot: session.target.root } : {}),
-                };
-            }
-            if (session.target.status === "available")
-                await assertCleanTrackedWorkingTree(session.target.root);
-            if (session.lifecycle.petition.state === "awaiting-verdict") {
-                throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} has a pending settlement`);
-            }
-            if (session.lifecycle.petition.state === "approved" && session.lifecycle.petition.intent !== "forfeit") {
-                throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} has an approved non-forfeit settlement`);
-            }
-            if (!session.pins.delivery.head)
-                throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} delivery ref is absent before forfeit`);
-            return {
-                state,
-                delivery: { status: "present", head: session.pins.delivery.head },
-                ...(session.target.status === "available" ? { targetRoot: session.target.root } : {}),
-            };
-        },
-        prepare: (admission) => ({
-            ...(admission.business.existing ? { existing: admission.business.existing } : {}),
-            entry: admission.business.existing?.entry ?? {
-                v: 2,
-                kind: "forfeit",
-                contract: input.contractId,
-                at,
-                actor: input.actor,
-                data: {
-                    reason: input.reason,
-                    actor: input.actor,
-                    finalHead: admission.business.delivery.status === "present"
-                        ? admission.business.delivery.head
-                        : admission.business.existing.entry.data.finalHead,
-                    ...(requestedNote ? { note: requestedNote } : {}),
-                },
-            },
-        }),
-        revalidate: async ({ session, admission, prepared }) => {
-            const state = currentLifecycleState(session.lifecycle);
-            if (prepared.existing) {
-                return session.repository.topology.nodes.some((node) => node.objectId === prepared.existing.transactionObjectId)
-                    ? undefined
-                    : { code: "FORFEIT_STATE_CHANGED", message: "accepted forfeit entry changed during replay preparation" };
-            }
-            if (session.target.status === "available")
-                await assertCleanTrackedWorkingTree(session.target.root);
-            if (admission.business.delivery.status !== "present" || session.pins.delivery.head !== admission.business.delivery.head) {
-                return { code: "FORFEIT_DELIVERY_CHANGED", message: "contract delivery changed during forfeit preparation" };
-            }
-            return state.state === admission.business.state.state
-                ? undefined
-                : { code: "FORFEIT_STATE_CHANGED", message: "contract lifecycle changed during forfeit preparation" };
-        },
-        effect: async ({ context, admission, prepared }) => {
-            const publication = prepared.existing
-                ? await context.replayCommitted({ transactionObjectId: prepared.existing.transactionObjectId, carrier: "retire" })
-                : await context.publishAuthoritative({
-                    verb: "forfeit",
-                    admittedLedgerHead: admission.ledgerHead,
-                    acceptedLifecycleTail: context.session.lifecycle.history.at(-1).objectId,
-                    entries: [prepared.entry],
-                    delivery: {
-                        ref: repositoryDeliveryRef(input.contractId),
-                        expectedOid: admission.business.delivery.status === "present" ? admission.business.delivery.head : null,
-                    },
-                });
-            if (publication.status === "indeterminate") {
-                return { kind: "precommit-effects-only", authoritativeHead: publication.currentHead ?? admission.ledgerHead };
-            }
-            if (publication.status !== "committed") {
-                return { kind: "refused-before-effects", authoritativeHead: publication.currentHead ?? admission.ledgerHead, refusal: { code: "LEDGER_CAS_CONFLICT", message: `contract ${input.contractId} changed during forfeit` } };
-            }
-            const published = publication;
-            await context.session.completeReplay("retire");
-            const cleanupRow = context.journal.all().find((row) => row.effect === "worktree-projection" && row.status === "succeeded");
-            const cleanupFacts = cleanupRow?.status === "succeeded" ? cleanupRow.receipt?.facts : undefined;
-            const deliveryRefRow = context.journal.all().find((row) => row.effect === "delivery-ref-projection" && row.status === "succeeded");
-            const deliveryRefFacts = deliveryRefRow?.status === "succeeded" ? deliveryRefRow.receipt?.facts : undefined;
-            const cleanup = terminalCleanupFacts(cleanupFacts, deliveryRefFacts);
-            if (!cleanup)
-                throw new FlowError("INTERNAL_STATE", "terminal replay completed without typed cleanup facts");
-            return { kind: "committed", commit: published, entryKind: "forfeit", value: { cleanup } };
-        },
-    });
-    if (execution.kind === "noncommitted")
-        return execution.outcome;
-    if (execution.kind === "contained")
-        return { ...execution.outcome, contractId: input.contractId };
-    return { ...execution.outcome, contractId: input.contractId, cleanup: execution.payload.cleanup, carrier: execution.carrier };
-}
-export async function forfeitContractCommand(input) {
-    return await forfeitContract({
-        cwd: input.cwd,
-        contractId: input.contractId,
-        actor: input.actor,
-        nowMs: input.nowMs,
-        reason: "manual",
-        note: input.note,
-        signal: input.signal,
-    });
-}

package/build/core/hints.js

@@ -1,34 +0,0 @@
-import { TOOL_NAMES } from "../keiyaku.js";
-import { renderTemplate } from "../flow-error.js";
-const GUIDANCE_BRANCH_LIST_LIMIT = 3;
-const ARCHITECT_TOOL_NAMES = {
-    bind: TOOL_NAMES.bind,
-    arc: TOOL_NAMES.arc,
-    renew: TOOL_NAMES.renew,
-    call: TOOL_NAMES.call,
-    amend: TOOL_NAMES.amend,
-    close: TOOL_NAMES.close,
-};
-export function buildNoActiveKeiyakuGuidance(input) {
-    const targetToolName = ARCHITECT_TOOL_NAMES[input.toolName];
-    const message = `Current workspace '${input.currentBranch}' is not addressing an active Keiyaku contract.`;
-    if (input.localKeiyakuBranches.length > 0) {
-        const listedBranches = input.localKeiyakuBranches.slice(0, GUIDANCE_BRANCH_LIST_LIMIT).join(", ");
-        const branchList = `${listedBranches}${input.localKeiyakuBranches.length > GUIDANCE_BRANCH_LIST_LIMIT ? ", ..." : ""}`;
-        return {
-            message,
-            hints: [
-                `An addressed active contract is required for \`${targetToolName}\`.`,
-                `Known local contract workspaces: ${branchList}.`,
-                renderTemplate("A new mission can be opened with `${bind}`.", ARCHITECT_TOOL_NAMES),
-            ],
-        };
-    }
-    return {
-        message,
-        hints: [
-            "No local contract workspaces were found.",
-            renderTemplate("A new mission can be opened with `${bind}`.", ARCHITECT_TOOL_NAMES),
-        ],
-    };
-}

package/build/core/identifier-slug.js

@@ -1,116 +0,0 @@
-import * as crypto from "node:crypto";
-const SLUG_CHARACTER = /[\p{Letter}\p{Number}\p{Mark}]/u;
-const SLUG_LETTER_OR_NUMBER = /[\p{Letter}\p{Number}]/u;
-const WINDOWS_RESERVED_BASENAME = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])$/u;
-/**
- * Leaves room in a portable 255-byte filename component for identity prefixes,
- * collision ordinals, extensions, and temporary-write bookkeeping.
- */
-export const IDENTIFIER_SLUG_MAX_UTF8_BYTES = 120;
-export const TASK_IDENTIFIER_MAX_UTF8_BYTES = 48;
-const TASK_IDENTIFIER_DIGEST_HEX_LENGTH = 8;
-export class IdentifierSlugError extends Error {
-    code = "INVALID_IDENTIFIER_SLUG";
-    constructor(message, options) {
-        super(message, options);
-        this.name = "IdentifierSlugError";
-    }
-}
-function utf8Bytes(value) {
-    return Buffer.byteLength(value, "utf8");
-}
-function normalizedIdentifierSlug(value, maxUtf8Bytes) {
-    let slug = "";
-    let pendingSeparator = false;
-    for (const character of value.normalize("NFKC").toLowerCase()) {
-        if (SLUG_CHARACTER.test(character)) {
-            const addition = `${pendingSeparator && slug ? "-" : ""}${character}`;
-            if (utf8Bytes(slug) + utf8Bytes(addition) > maxUtf8Bytes)
-                return { slug, truncated: true };
-            slug += addition;
-            pendingSeparator = false;
-        }
-        else if (slug) {
-            pendingSeparator = true;
-        }
-    }
-    return { slug, truncated: false };
-}
-function truncateNormalizedIdentifierSlug(value, maxUtf8Bytes) {
-    let prefix = "";
-    for (const character of value) {
-        if (utf8Bytes(prefix) + utf8Bytes(character) > maxUtf8Bytes)
-            break;
-        prefix += character;
-    }
-    return prefix.replace(/-+$/u, "");
-}
-function validatedIdentifierSlug(slug, maxUtf8Bytes) {
-    if (!slug || !SLUG_LETTER_OR_NUMBER.test(slug)) {
-        throw new IdentifierSlugError("text cannot be converted to a portable identifier slug; use at least one Unicode letter or number");
-    }
-    if (WINDOWS_RESERVED_BASENAME.test(slug)) {
-        const portable = `${slug}-id`;
-        if (utf8Bytes(portable) > maxUtf8Bytes) {
-            throw new IdentifierSlugError("text normalizes to a reserved Windows filename within the configured byte bound");
-        }
-        return portable;
-    }
-    return slug;
-}
-function completeNormalizedIdentifierSlug(value) {
-    let slug = "";
-    let pendingSeparator = false;
-    for (const character of value.normalize("NFKC").toLowerCase()) {
-        if (SLUG_CHARACTER.test(character)) {
-            slug += `${pendingSeparator && slug ? "-" : ""}${character}`;
-            pendingSeparator = false;
-        }
-        else if (slug) {
-            pendingSeparator = true;
-        }
-    }
-    return validatedIdentifierSlug(slug, Number.MAX_SAFE_INTEGER);
-}
-/**
- * Normalize human text into one Unicode-safe, portable identifier slug.
- * NFKC makes canonically and compatibly equivalent input deterministic. All
- * non-letter/number/mark runs become one ASCII hyphen, then the result is
- * truncated at a Unicode code-point boundary to the shared UTF-8 byte bound.
- */
-export function normalizeIdentifierSlug(value, maxUtf8Bytes = IDENTIFIER_SLUG_MAX_UTF8_BYTES) {
-    if (!Number.isSafeInteger(maxUtf8Bytes) || maxUtf8Bytes < 1 || maxUtf8Bytes > IDENTIFIER_SLUG_MAX_UTF8_BYTES) {
-        throw new IdentifierSlugError(`slug byte bound must be from 1 through ${IDENTIFIER_SLUG_MAX_UTF8_BYTES}`);
-    }
-    return validatedIdentifierSlug(normalizedIdentifierSlug(value, maxUtf8Bytes).slug, maxUtf8Bytes);
-}
-/**
- * Allocate a newly generated task ID. Persisted task documents remain
- * addressable at their original ID; this limit applies only to new IDs.
- */
-export function taskIdentifierSlug(value, collisionSuffix = "") {
-    const suffixBytes = utf8Bytes(collisionSuffix);
-    const availableBytes = TASK_IDENTIFIER_MAX_UTF8_BYTES - suffixBytes;
-    if (availableBytes < TASK_IDENTIFIER_DIGEST_HEX_LENGTH + 2) {
-        throw new IdentifierSlugError("task collision suffix leaves no room for a bounded identifier");
-    }
-    const normalized = completeNormalizedIdentifierSlug(value);
-    if (utf8Bytes(normalized) <= TASK_IDENTIFIER_MAX_UTF8_BYTES) {
-        return `${truncateNormalizedIdentifierSlug(normalized, availableBytes)}${collisionSuffix}`;
-    }
-    const prefixBytes = availableBytes - TASK_IDENTIFIER_DIGEST_HEX_LENGTH - 1;
-    const prefix = truncateNormalizedIdentifierSlug(normalized, prefixBytes);
-    const digest = crypto.createHash("sha256").update(normalized, "utf8").digest("hex")
-        .slice(0, TASK_IDENTIFIER_DIGEST_HEX_LENGTH);
-    return `${prefix}-${digest}${collisionSuffix}`;
-}
-export function isNormalizedIdentifierSlug(value) {
-    if (!value || utf8Bytes(value) > IDENTIFIER_SLUG_MAX_UTF8_BYTES)
-        return false;
-    try {
-        return normalizeIdentifierSlug(value) === value;
-    }
-    catch {
-        return false;
-    }
-}

package/build/core/ids.js

@@ -1,90 +0,0 @@
-import { createGit, wrapGitError } from "../git/core.js";
-import { IdentifierSlugError, isNormalizedIdentifierSlug, normalizeIdentifierSlug, } from "./identifier-slug.js";
-const CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-const ULID_RE = /^[0-9A-HJKMNP-TV-Z]{26}$/;
-/** Canonical commission identity: slugified lowercase hyphen segments + `.` + Crockford ULID. */
-export const COMMISSION_ID_RE = /^([\p{Letter}\p{Number}\p{Mark}]+(?:-[\p{Letter}\p{Number}\p{Mark}]+)*)\.([0-9A-HJKMNP-TV-Z]{26})$/u;
-/** Minted opaque repository identity: `repo_` + ULID. */
-export function isCommissionId(value) {
-    const match = COMMISSION_ID_RE.exec(value);
-    return match !== null && isNormalizedIdentifierSlug(match[1]);
-}
-export class ContractIdError extends Error {
-    code = "INVALID_CONTRACT_ID";
-    constructor(message, options) {
-        super(message, options);
-        this.name = "ContractIdError";
-    }
-}
-export function slugifyContractTitle(title) {
-    try {
-        return normalizeIdentifierSlug(title);
-    }
-    catch (error) {
-        if (error instanceof IdentifierSlugError) {
-            throw new ContractIdError(`contract title ${error.message}`, { cause: error });
-        }
-        throw error;
-    }
-}
-/** Human-facing slug from a commission ID (`<slug>.<ULID>`). Splits on the last `.`. */
-export function commissionSlug(commissionId) {
-    const separator = commissionId.lastIndexOf(".");
-    return separator > 0 ? commissionId.slice(0, separator) : commissionId;
-}
-/**
- * Human-facing contract coordinate: `<slug> @<place>` in worktree state, `<slug>` in here state.
- * Full ULID never appears in this string.
- */
-export function formatCommissionCoordinate(input) {
-    const slug = commissionSlug(input.commissionId);
-    return input.place && input.place !== slug ? `${slug} @${input.place}` : slug;
-}
-function encodeTime(nowMs) {
-    if (!Number.isSafeInteger(nowMs) || nowMs < 0 || nowMs > 0xffffffffffff) {
-        throw new ContractIdError("ULID timestamp must be a safe 48-bit millisecond integer");
-    }
-    let value = nowMs;
-    const chars = Array.from({ length: 10 }, () => "0");
-    for (let index = 9; index >= 0; index -= 1) {
-        chars[index] = CROCKFORD[value % 32];
-        value = Math.floor(value / 32);
-    }
-    return chars.join("");
-}
-function encodeRandom(randomBytes) {
-    if (randomBytes.length !== 10) {
-        throw new ContractIdError("ULID random input must contain exactly 10 bytes");
-    }
-    let bits = "";
-    for (const byte of randomBytes) {
-        if (!Number.isInteger(byte) || byte < 0 || byte > 255) {
-            throw new ContractIdError("ULID random input must contain byte values");
-        }
-        bits += byte.toString(2).padStart(8, "0");
-    }
-    const chars = [];
-    for (let offset = 0; offset < 80; offset += 5) {
-        chars.push(CROCKFORD[Number.parseInt(bits.slice(offset, offset + 5), 2)]);
-    }
-    return chars.join("");
-}
-export function createUlid(nowMs, randomBytes) {
-    const ulid = `${encodeTime(nowMs)}${encodeRandom(randomBytes)}`;
-    if (!ULID_RE.test(ulid)) {
-        throw new ContractIdError(`invalid ULID generated: ${ulid}`);
-    }
-    return ulid;
-}
-export function buildContractId(input) {
-    return `${slugifyContractTitle(input.title)}.${createUlid(input.nowMs, input.randomBytes)}`;
-}
-export async function assertValidContractId(cwd, id) {
-    const git = createGit(cwd);
-    try {
-        await git.raw(["check-ref-format", "--branch", id]);
-    }
-    catch (error) {
-        throw wrapGitError(`check-ref-format --branch ${id}`, error, cwd);
-    }
-}

package/build/core/lifecycle-history.js

@@ -1,35 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { normalizeSectionTitle } from "./markdown/titles.js";
-import { markdownSourceSections } from "./scope.js";
-export function effectiveScope(entries) {
-    const bind = entries.find((entry) => entry.kind === "bind");
-    if (!bind)
-        throw new FlowError("INTERNAL_STATE", "lifecycle history must contain bind entry");
-    const scope = [...bind.data.scope];
-    for (const entry of entries) {
-        if (entry.kind === "amend" && entry.data.scopeDelta)
-            scope.push(...entry.data.scopeDelta.add);
-    }
-    return scope;
-}
-/** Ordered contract-wide criteria derived from admitted lifecycle history. */
-export function effectiveCriteria(entries) {
-    const bind = entries.find((entry) => entry.kind === "bind");
-    if (!bind)
-        throw new FlowError("INTERNAL_STATE", "lifecycle history must contain bind entry");
-    const criteria = [...bind.data.criteria];
-    for (const entry of entries) {
-        if (entry.kind !== "amend")
-            continue;
-        for (const section of markdownSourceSections(entry.data.amendment)) {
-            if (section.level !== 2 || normalizeSectionTitle(section.title) !== "criteria")
-                continue;
-            for (const line of entry.data.amendment.slice(section.contentStart, section.end).split(/\r?\n/)) {
-                const match = line.match(/^\s*-\s+(.+)$/);
-                if (match)
-                    criteria.push(match[1].trim());
-            }
-        }
-    }
-    return criteria;
-}

package/build/core/lifecycle-recovery.js

@@ -1,117 +0,0 @@
-import { withContractCarrierSession } from "./contract-carrier.js";
-import { resolveAcceptedLifecycleTransaction, } from "./repository-ledger/accepted-tail.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);
-    if (accepted.status === "refused") {
-        return {
-            kind: "refused",
-            authoritativeHead,
-            refusal: {
-                code: "OUTSTANDING_REPLAY_UNPROVEN",
-                message: `contract ${plan.contractId} recovery transaction is not accepted by the current typed ledger fold`,
-                facts: { reason: accepted.reason, transactionObjectId: accepted.transactionObjectId },
-            },
-        };
-    }
-    if (accepted.status === "accepted") {
-        if (accepted.transaction.verb === "bind" || accepted.transaction.verb === "bootstrap") {
-            const replayed = await alignDerivedTransaction(plan, accepted.transaction);
-            if (replayed.kind === "refused")
-                return replayed;
-            return observeOrdinaryCoordinate(plan);
-        }
-        if (accepted.transaction.verb !== plan.mutation.verb) {
-            const replayed = await alignDerivedTransaction(plan, accepted.transaction);
-            if (replayed.kind === "refused")
-                return replayed;
-            return observeOrdinaryCoordinate(plan);
-        }
-        const transaction = accepted.transaction;
-        if (plan.mutation.matchesAccepted && !plan.mutation.matchesAccepted(transaction)) {
-            const replayed = await alignDerivedTransaction(plan, transaction);
-            if (replayed.kind === "refused")
-                return replayed;
-            return observeOrdinaryCoordinate(plan);
-        }
-        return {
-            kind: "aligned",
-            coordinate: { state: "verb-committed", invokedVerb: plan.mutation.verb, transaction, authoritativeHead },
-        };
-    }
-    if (observed.model.phase === "claimed" || observed.model.phase === "forfeited") {
-        return {
-            kind: "refused",
-            authoritativeHead,
-            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,
-        },
-    };
-}
-async function alignDerivedTransaction(plan, transaction) {
-    return withContractCarrierSession({ cwd: plan.cwd, contractId: plan.contractId, mode: "mutation", signal: plan.signal }, async (session) => {
-        try {
-            await session.replayCommitted({
-                transactionObjectId: transaction.transactionObjectId,
-                ...(transaction.verb === "claim" || transaction.verb === "forfeit" ? { carrier: "retire" } : {}),
-            });
-            await session.completeReplay(transaction.verb === "claim" || transaction.verb === "forfeit" ? "retire" : "project");
-            return { kind: "aligned" };
-        }
-        catch (error) {
-            return {
-                kind: "refused",
-                authoritativeHead: session.lifecycle.observedLedgerHead,
-                refusal: {
-                    code: "LIFECYCLE_RECONCILIATION_INCOMPLETE",
-                    message: error instanceof Error ? error.message : `contract ${plan.contractId} derived replay did not complete`,
-                },
-            };
-        }
-    });
-}
-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));
-}
-function bindAligned(history, plan, authoritativeHead) {
-    const bindObjectId = history.find(({ entry }) => entry.kind === "bind")?.objectId;
-    if (!bindObjectId) {
-        return {
-            kind: "refused",
-            authoritativeHead,
-            refusal: { code: "INTERNAL_STATE", message: "typed lifecycle has no bind object" },
-        };
-    }
-    return { kind: "aligned", coordinate: { state: "bind-aligned", invokedVerb: plan.mutation.verb, bindObjectId, authoritativeHead } };
-}
-function findLatestAcceptedTransaction(read, contractId, finalEntryObjectId) {
-    if (finalEntryObjectId === null)
-        return { status: "none" };
-    const node = read.topology.nodes.find((candidate) => candidate.type === "transaction"
-        && candidate.contract === contractId
-        && candidate.finalEntryObjectId === finalEntryObjectId);
-    if (!node || node.type !== "transaction")
-        return { status: "none" };
-    const resolved = resolveAcceptedLifecycleTransaction({ read, transactionObjectId: node.objectId, expectedContract: contractId });
-    return resolved.status === "accepted" ? { status: "accepted", transaction: resolved } : resolved;
-}