@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/core/derived-replay.js

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

package/build/core/draft.js

@@ -1,396 +0,0 @@
-import { FlowError } from "../flow-error.js";
-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";
-const KNOWN_SECTIONS = new Map([
-    ["context", "context"],
-    ["objective", "objective"],
-    ["design & approach", "design"],
-    ["scope", "scope"],
-    ["criteria", "criteria"],
-    ["verification", "verification"],
-]);
-const RETIRED_OR_MALFORMED_CORE_SECTIONS = new Set(["title", "name", "design", "checks"]);
-const BIND_DRAFT_SECTION_ORDER = ["title", "context", "objective", "design", "scope", "criteria", "verification"];
-function invalidBindDraft(message) {
-    throw new FlowError("INVALID_KEIYAKU_DRAFT", `INVALID_BIND_DRAFT: ${message}`);
-}
-function normalizeSectionName(name) {
-    return name.trim().toLowerCase();
-}
-/**
- * Canonicalize extension Markdown by dropping only leading/trailing blank
- * physical lines. Retained lines keep every byte (indentation, trailing
- * spaces, fences, internal blanks). Entirely blank input becomes "".
- */
-function normalizeExtensionContent(content) {
-    const lines = content.split(/\r?\n/);
-    let start = 0;
-    while (start < lines.length && lines[start].trim().length === 0) {
-        start += 1;
-    }
-    let end = lines.length;
-    while (end > start && lines[end - 1].trim().length === 0) {
-        end -= 1;
-    }
-    if (start >= end) {
-        return "";
-    }
-    return lines.slice(start, end).join("\n");
-}
-function findUnexpectedListOnlyLine(section) {
-    for (const child of section.children) {
-        if (child.type === "list")
-            continue;
-        if (child.type === "text") {
-            const line = child.lines.find((candidate) => candidate.trim().length > 0);
-            if (line)
-                return line.trim();
-            continue;
-        }
-        if (child.type === "code_block") {
-            return child.lines.find((line) => line.trim().length > 0)?.trim() ?? "```";
-        }
-        const rendered = renderSectionContent({ ...section, children: [child] }).trim();
-        if (rendered)
-            return rendered.split(/\r?\n/)[0] ?? rendered;
-    }
-    return null;
-}
-function extractSingleLineDeclarations(section, heading) {
-    const unexpected = findUnexpectedListOnlyLine(section);
-    if (unexpected) {
-        invalidBindDraft(`${heading} must be a bullet list; found '${unexpected}'`);
-    }
-    const items = extractListItems(section);
-    if (items.length === 0) {
-        const hasListNode = section.children.some((child) => child.type === "list");
-        if (hasListNode) {
-            invalidBindDraft(`empty ${heading.toLowerCase()} declaration in bind draft`);
-        }
-        invalidBindDraft(`${heading} must be a bullet list; found empty ${heading} section`);
-    }
-    return items.map((item) => {
-        const trimmed = item.trim();
-        if (trimmed.length === 0) {
-            invalidBindDraft(`empty ${heading.toLowerCase()} declaration in bind draft`);
-        }
-        if (item.includes("\n") || item.includes("\r")) {
-            invalidBindDraft(`${heading} declarations must be a single line`);
-        }
-        return trimmed;
-    });
-}
-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.
-    let structuralContent = content;
-    const scopeSources = markdownSourceSections(content)
-        .filter((section) => section.level === 2 && normalizeSectionTitle(section.title) === "scope")
-        .sort((left, right) => right.contentStart - left.contentStart);
-    for (const source of scopeSources) {
-        structuralContent = `${structuralContent.slice(0, source.contentStart)}\`\`\`\nscope\n\`\`\`\n${structuralContent.slice(source.end)}`;
-    }
-    const ast = parseToAST(structuralContent);
-    let title;
-    let seenH1 = false;
-    const sections = new Map();
-    const extensions = [];
-    for (const node of ast.children) {
-        if (node.type !== "section")
-            continue;
-        if (node.level === 1) {
-            if (seenH1) {
-                invalidBindDraft("bind draft allows exactly one H1 heading");
-            }
-            seenH1 = true;
-            title = node.title.trim() || undefined;
-            continue;
-        }
-        if (node.level !== 2)
-            continue;
-        const normalized = normalizeSectionName(node.title);
-        if (RETIRED_OR_MALFORMED_CORE_SECTIONS.has(normalized)) {
-            const replacement = normalized === "checks"
-                ? "Criteria and Verification"
-                : normalized === "design"
-                    ? "Design & Approach"
-                    : "the H1 Title";
-            invalidBindDraft(`obsolete or malformed core section '${node.title}'; use ${replacement}`);
-        }
-        const coreSection = KNOWN_SECTIONS.get(normalized);
-        if (coreSection) {
-            if (sections.has(coreSection)) {
-                invalidBindDraft(`duplicate section '${node.title}' in bind draft`);
-            }
-            sections.set(coreSection, node);
-            continue;
-        }
-        extensions.push({
-            title: node.title.trim(),
-            content: normalizeExtensionContent(renderSectionContent(node)),
-        });
-    }
-    return { ...(title === undefined ? {} : { title }), sections, extensions };
-}
-function parseScopeSection(content) {
-    const sourceSections = markdownSourceSections(content).filter((section) => section.level === 2 && normalizeSectionTitle(section.title) === "scope");
-    if (sourceSections.length !== 1)
-        invalidBindDraft("bind draft must contain exactly one Scope section");
-    const source = sourceSections[0];
-    try {
-        return validateScopeFragmentLines(content.slice(source.contentStart, source.end).split(/\r?\n/), {
-            heading: "## Scope",
-            emptyMessage: "Scope must be a gitignore-subset fragment; found empty Scope section",
-        });
-    }
-    catch (error) {
-        if (error instanceof FlowError)
-            throw new FlowError(error.code, `INVALID_BIND_DRAFT: ${error.message}`);
-        throw error;
-    }
-}
-/**
- * Parse any subset of the bind document grammar. Absent sections stay undefined
- * so callers can merge task defaults under stdin overrides.
- */
-export function parsePartialBindDraft(content) {
-    if (content.trim().length === 0)
-        return {};
-    const { title, sections, extensions } = collectBindDraftNodes(content);
-    const partial = {};
-    if (title !== undefined)
-        partial.title = title;
-    for (const sectionName of ["context", "objective", "design"]) {
-        const section = sections.get(sectionName);
-        if (!section)
-            continue;
-        const text = renderSectionContent(section).trim();
-        const heading = sectionName === "design"
-            ? "Design & Approach"
-            : `${sectionName[0].toUpperCase()}${sectionName.slice(1)}`;
-        if (!text)
-            invalidBindDraft(`${heading} section cannot be empty`);
-        partial[sectionName] = text;
-    }
-    const scope = sections.get("scope");
-    if (scope) {
-        partial.scope = parseScopeSection(content);
-    }
-    const criteria = sections.get("criteria");
-    if (criteria)
-        partial.criteria = extractSingleLineDeclarations(criteria, "Criteria");
-    const verification = sections.get("verification");
-    if (verification)
-        partial.verification = extractSingleLineDeclarations(verification, "Verification");
-    if (extensions.length > 0)
-        partial.extensions = extensions;
-    return partial;
-}
-export function mergeBindDraft(base, override) {
-    return {
-        ...(base.title !== undefined ? { title: base.title } : {}),
-        ...(base.context !== undefined ? { context: base.context } : {}),
-        ...(base.objective !== undefined ? { objective: base.objective } : {}),
-        ...(base.design !== undefined ? { design: base.design } : {}),
-        ...(base.scope !== undefined ? { scope: base.scope } : {}),
-        ...(base.criteria !== undefined ? { criteria: base.criteria } : {}),
-        ...(base.verification !== undefined ? { verification: base.verification } : {}),
-        ...(base.extensions !== undefined ? { extensions: base.extensions } : {}),
-        ...(override.title !== undefined ? { title: override.title } : {}),
-        ...(override.context !== undefined ? { context: override.context } : {}),
-        ...(override.objective !== undefined ? { objective: override.objective } : {}),
-        ...(override.design !== undefined ? { design: override.design } : {}),
-        ...(override.scope !== undefined ? { scope: override.scope } : {}),
-        ...(override.criteria !== undefined ? { criteria: override.criteria } : {}),
-        ...(override.verification !== undefined ? { verification: override.verification } : {}),
-        ...(override.extensions !== undefined ? { extensions: override.extensions } : {}),
-    };
-}
-export function missingBindDraftSections(partial) {
-    const missing = [];
-    if (partial.title === undefined || partial.title.trim().length === 0)
-        missing.push("title");
-    if (partial.context === undefined || partial.context.trim().length === 0)
-        missing.push("context");
-    if (partial.objective === undefined || partial.objective.trim().length === 0)
-        missing.push("objective");
-    if (partial.design === undefined || partial.design.trim().length === 0)
-        missing.push("design");
-    if (partial.scope === undefined || partial.scope.length === 0)
-        missing.push("scope");
-    if (partial.criteria === undefined || partial.criteria.length === 0)
-        missing.push("criteria");
-    return missing;
-}
-/** Paste-ready partial markdown for only the missing required sections. */
-export function renderMissingBindSectionsTemplate(missing) {
-    const lines = [];
-    for (const section of BIND_DRAFT_SECTION_ORDER) {
-        if (!missing.includes(section))
-            continue;
-        if (section === "title") {
-            lines.push("# <title>");
-            continue;
-        }
-        if (section === "context") {
-            lines.push("## Context", "<established facts and constraints>");
-            continue;
-        }
-        if (section === "objective") {
-            lines.push("## Objective", "<what the commission should accomplish>");
-            continue;
-        }
-        if (section === "design") {
-            lines.push("## Design & Approach", "<settled owner, boundaries, flow, state, and failure behavior>");
-            continue;
-        }
-        if (section === "scope") {
-            lines.push("## Scope", "~~~", "<pattern>", "<another-pattern>", "~~~");
-            continue;
-        }
-        if (section === "criteria") {
-            lines.push("## Criteria", "- <declarative acceptance criterion>");
-            continue;
-        }
-        lines.push("## Verification", "- <executable command or testimony declaration>");
-    }
-    return lines.join("\n");
-}
-export function describeMissingBindSections(missing) {
-    const labels = {
-        title: "Title",
-        context: "Context",
-        objective: "Objective",
-        design: "Design & Approach",
-        scope: "Scope",
-        criteria: "Criteria",
-        verification: "Verification",
-    };
-    const named = missing.map((section) => labels[section]);
-    if (named.length === 0)
-        return "";
-    if (named.length === 1)
-        return named[0];
-    if (named.length === 2)
-        return `${named[0]} or ${named[1]}`;
-    return `${named.slice(0, -1).join(", ")}, or ${named[named.length - 1]}`;
-}
-export function materializeBindDraft(partial) {
-    const missing = missingBindDraftSections(partial);
-    if (missing.length > 0) {
-        invalidBindDraft(`missing ${describeMissingBindSections(missing)} in bind draft`);
-    }
-    return {
-        title: partial.title.trim(),
-        context: partial.context.trim(),
-        objective: partial.objective.trim(),
-        design: partial.design.trim(),
-        scope: partial.scope,
-        criteria: partial.criteria,
-        verification: partial.verification ?? [],
-        extensions: partial.extensions ?? [],
-    };
-}
-export function parseBindDraft(content) {
-    const { title, sections, extensions } = collectBindDraftNodes(content);
-    if (!title) {
-        invalidBindDraft("missing H1 Title in bind draft; expected '# <title>' followed by Context, Objective, Design & Approach, Scope, and Criteria; Verification is optional");
-    }
-    const context = sections.get("context");
-    const objective = sections.get("objective");
-    const design = sections.get("design");
-    const scope = sections.get("scope");
-    const criteria = sections.get("criteria");
-    const verification = sections.get("verification");
-    if (!context)
-        invalidBindDraft("missing Context section in bind draft");
-    if (!objective)
-        invalidBindDraft("missing Objective section in bind draft");
-    if (!design)
-        invalidBindDraft("missing Design & Approach section in bind draft");
-    if (!scope)
-        invalidBindDraft("missing Scope section in bind draft");
-    const parsedScope = parseScopeSection(content);
-    if (!criteria)
-        invalidBindDraft("missing Criteria section in bind draft");
-    const contextText = renderSectionContent(context).trim();
-    const objectiveText = renderSectionContent(objective).trim();
-    const designText = renderSectionContent(design).trim();
-    if (!contextText)
-        invalidBindDraft("Context section cannot be empty");
-    if (!objectiveText)
-        invalidBindDraft("Objective section cannot be empty");
-    if (!designText)
-        invalidBindDraft("Design & Approach section cannot be empty");
-    return {
-        title,
-        context: contextText,
-        objective: objectiveText,
-        design: designText,
-        scope: parsedScope,
-        criteria: extractSingleLineDeclarations(criteria, "Criteria"),
-        verification: verification ? extractSingleLineDeclarations(verification, "Verification") : [],
-        extensions,
-    };
-}
-export function renderBindDraft(draft) {
-    const sections = [
-        `# ${draft.title}`,
-        `## Context\n${draft.context}`,
-        `## Objective\n${draft.objective}`,
-        `## Design & Approach\n${draft.design}`,
-        `## Scope\n${renderScopeFragment(draft.scope)}`,
-        `## 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")}`);
-    }
-    for (const extension of draft.extensions) {
-        const content = normalizeExtensionContent(extension.content);
-        if (content.length > 0) {
-            sections.push(`## ${extension.title}\n${content}`);
-        }
-        else {
-            sections.push(`## ${extension.title}`);
-        }
-    }
-    return `${sections.join("\n\n")}\n`;
-}
-export function compileBindDraftFlags(input) {
-    for (const [flag, value] of [
-        ["--title", input.title],
-        ["--context", input.context],
-        ["--objective", input.objective],
-        ["--design", input.design],
-        ["--criteria", input.criteria],
-        ["--verification", input.verification],
-    ]) {
-        if (value !== undefined && (value.includes("\n") || value.includes("\r"))) {
-            throw new FlowError("EMPTY_PARAM", `${flag} must be a single line`);
-        }
-    }
-    const scope = typeof input.scope === "string" ? [input.scope] : input.scope;
-    for (const pattern of scope ?? []) {
-        if (pattern.includes("\n") || pattern.includes("\r")) {
-            throw new FlowError("EMPTY_PARAM", "--scope must be a single line");
-        }
-    }
-    const sections = [];
-    if (input.title !== undefined)
-        sections.push(`# ${input.title}`);
-    if (input.context !== undefined)
-        sections.push(`## Context\n${input.context}`);
-    if (input.objective !== undefined)
-        sections.push(`## Objective\n${input.objective}`);
-    if (input.design !== undefined)
-        sections.push(`## Design & Approach\n${input.design}`);
-    if (scope !== undefined)
-        sections.push(`## Scope\n~~~\n${scope.join("\n")}\n~~~`);
-    if (input.criteria !== undefined)
-        sections.push(`## Criteria\n- ${input.criteria}`);
-    if (input.verification !== undefined)
-        sections.push(`## Verification\n- ${input.verification}`);
-    return sections.length > 0 ? `${sections.join("\n\n")}\n` : "";
-}

package/build/core/execution-coordinate.js

@@ -1,46 +0,0 @@
-import { isCommissionId } from "./ids.js";
-import { assertExactFields, assertNonBlankString, isPlainRecord, } from "./validation.js";
-export function parseExecutionAuthority(value, invalid) {
-    if (!isPlainRecord(value))
-        throw invalid("authority", "must be an object");
-    if (!("kind" in value))
-        throw invalid("authority.kind", "is missing");
-    if (value.kind === "repository") {
-        // repoId is the sole legacy coordinate field accepted on read. It is inert
-        // and deliberately discarded; current writers emit the unit variant.
-        assertExactFields(value, ["kind"], ["repoId"], "authority", invalid);
-        return { kind: "repository" };
-    }
-    if (value.kind === "user") {
-        assertExactFields(value, ["kind"], [], "authority", invalid);
-        return { kind: "user" };
-    }
-    throw invalid("authority.kind", "must be 'repository' or 'user'");
-}
-export function parseExecutionBinding(value, invalid) {
-    if (!isPlainRecord(value))
-        throw invalid("binding", "must be an object");
-    if (!("kind" in value))
-        throw invalid("binding.kind", "is missing");
-    if (value.kind === "commission") {
-        assertExactFields(value, ["kind", "commissionId"], [], "binding", invalid);
-        assertNonBlankString(value.commissionId, "binding.commissionId", invalid);
-        if (!isCommissionId(value.commissionId))
-            throw invalid("binding.commissionId", "must be a full commission ID");
-        return { kind: "commission", commissionId: value.commissionId };
-    }
-    if (value.kind === "bare" || value.kind === "unbound") {
-        assertExactFields(value, ["kind"], [], "binding", invalid);
-        return { kind: value.kind };
-    }
-    throw invalid("binding.kind", "must be 'commission', 'bare', or 'unbound'");
-}
-/** The one durable authority/binding schema used by pacts and response artifacts. */
-export function parseExecutionCoordinates(authorityValue, bindingValue, invalid) {
-    const authority = parseExecutionAuthority(authorityValue, invalid);
-    const binding = parseExecutionBinding(bindingValue, invalid);
-    if (authority.kind === "user" && binding.kind === "commission") {
-        throw invalid("binding.kind", "cannot be 'commission' when authority.kind is 'user'");
-    }
-    return { authority, binding };
-}