@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/akuma-body.js

@@ -1,14 +1,19 @@
-import { LEASH_HELD_EXIT, runAkumaBody } from "./akuma/body.js";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { bodyLaunchSchema, LEASH_HELD_EXIT, runAkumaBody } from "./akuma/body.js";
 import { worldRootForAkumaPaths } from "./akuma/identity.js";
-import { World } from "./world.js";
-import { fleetRequestPort } from "./akuma/fleet-owner-port.js";
-import { fleetRequestCommands } from "./akuma/fleet-request.js";
-import { worktreeHooksFrom } from "./git/hooks.js";
-import { contractRequestCommands, executeForwardedAudit, executeForwardedDeliver, executeForwardedReview, } from "./library/contract-operations.js";
-import { Repo } from "./library/repo.js";
-import { requireBranchesToBeUpToDateFrom, settings } from "./settings.js";
-import { executeTaskMutation, taskMutationRequestCommands } from "./task/mutation.js";
 import { composeRequestCommands } from "./akuma/request-wire.js";
+import { localExecutionContext } from "./akuma/requests.js";
+import { selectionRequestPort } from "./akuma/selection-owner-port.js";
+import { selectionRequestCommands } from "./akuma/selection-request.js";
+import { composeContractLibrary } from "./library/contract-composition.js";
+import { contractRequestCommands } from "./library/contract-operations.js";
+import { createKeiyakuHandle } from "./library/keiyaku.js";
+import { Repo } from "./library/repo.js";
+import { settings } from "./settings.js";
+import { Tasks } from "./task/index.js";
+import { taskMutationRequestCommands } from "./task/mutation.js";
+import { World } from "./world.js";
 async function contractDependencies(repoRoot, processConfiguration) {
     const repo = await Repo.at({
         path: repoRoot,
@@ -23,82 +28,112 @@ async function contractDependencies(repoRoot, processConfiguration) {
     });
     return [repo, configuration];
 }
+function contractChannel(repo, contractId, requester, configuration) {
+    return composeContractLibrary(localExecutionContext(), createKeiyakuHandle, {
+        settings: configuration,
+        actor: requester,
+    }).select({
+        repo,
+        id: contractId,
+    });
+}
 function contractUpstream(processConfiguration) {
     return {
         audit: async (input) => {
             const [repo, configuration] = await contractDependencies(input.repoRoot, processConfiguration);
-            return await executeForwardedAudit({
-                repo,
-                ...(input.observe === undefined ? {} : { observe: input.observe }),
-                contractId: input.contractId,
-                requester: input.requester,
+            return await contractChannel(repo, input.contractId, input.requester, configuration).audit({
                 includeDirty: input.includeDirty,
                 showDiff: input.showDiff,
-                requireBranchesToBeUpToDate: requireBranchesToBeUpToDateFrom({ settings: configuration }),
-                hooks: worktreeHooksFrom({ settings: configuration }),
                 signal: input.signal,
-            });
+            }, input.observe === undefined ? undefined : { observe: input.observe });
         },
         deliver: async (input) => {
             const [repo, configuration] = await contractDependencies(input.repoRoot, processConfiguration);
-            return await executeForwardedDeliver({
-                repo,
-                ...(input.observe === undefined ? {} : { observe: input.observe }),
-                contractId: input.contractId,
-                requester: input.requester,
-                ...(input.message === undefined ? {} : { message: input.message }),
+            return await contractChannel(repo, input.contractId, input.requester, configuration).deliver({
                 includeDirty: input.includeDirty,
                 materializeConflict: input.materializeConflict,
-                requireBranchesToBeUpToDate: requireBranchesToBeUpToDateFrom({ settings: configuration }),
-                hooks: worktreeHooksFrom({ settings: configuration }),
+                ...(input.message === undefined ? {} : { message: input.message }),
+                ...(input.overwrite === undefined ? {} : { overwrite: input.overwrite }),
                 signal: input.signal,
-            });
+            }, input.observe === undefined ? undefined : { observe: input.observe });
         },
         review: async (input) => {
             const [repo, configuration] = await contractDependencies(input.repoRoot, processConfiguration);
-            return await executeForwardedReview({
-                repo,
-                ...(input.observe === undefined ? {} : { observe: input.observe }),
-                contractId: input.contractId,
-                requester: input.requester,
+            return await contractChannel(repo, input.contractId, input.requester, configuration).review({
                 verdict: input.verdict,
-                signal: input.signal,
                 ...(input.summary === undefined ? {} : { summary: input.summary }),
-                hooks: worktreeHooksFrom({ settings: configuration }),
-            });
+                signal: input.signal,
+            }, input.observe === undefined ? undefined : { observe: input.observe });
         },
     };
 }
+const TASK_LIFECYCLE = {
+    start: async (handle, input) => await handle.start(input),
+    stop: async (handle, input) => await handle.stop(input),
+    hold: async (handle, input) => await handle.hold(input),
+    resume: async (handle, input) => await handle.resume(input),
+    done: async (handle, input) => await handle.done(input),
+    drop: async (handle, input) => await handle.drop(input),
+};
+/**
+ * The upper Body edge composes the forced-local Tasks SDK the descriptor
+ * execution entries consume. Each ability is one ordinary local product
+ * operation; no generic task(request) dispatcher is introduced here.
+ */
 function taskMutationRequestPort() {
     return {
-        task: async (input) => await executeTaskMutation({
-            world: input.world,
-            request: input.request,
-            requester: input.requester,
-            signal: input.signal,
+        add: async ({ world, options }) => await Tasks.of(world).add(options),
+        addDocument: async ({ world, document }) => await Tasks.of(world).addDocument(document),
+        compose: async ({ world, markdown, defaultNamespace, actor, signal }) => await Tasks.of(world).compose({
+            markdown,
+            namespace: defaultNamespace,
+            actor,
+            ...(signal === undefined ? {} : { signal }),
+        }),
+        update: async ({ world, id, options }) => await Tasks.of(world).task({ id }).update(options),
+        lifecycle: async ({ world, verb, id, note, signal }) => await TASK_LIFECYCLE[verb](Tasks.of(world).task({ id }), {
+            ...(note === undefined ? {} : { note }),
+            ...(signal === undefined ? {} : { signal }),
+        }),
+        batch: async ({ world, verb, ids, note, signal }) => await Tasks.of(world).batch({
+            verb,
+            ids,
+            ...(note === undefined ? {} : { note }),
+            ...(signal === undefined ? {} : { signal }),
         }),
     };
 }
-const encoded = process.argv[2];
-if (encoded === undefined)
-    throw new TypeError("Akuma body launch payload is missing");
-const launch = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
-const mappedHome = process.env.KEIYAKU_HOME?.trim();
-const mappedGitPath = process.env.KEIYAKU_GIT_PATH;
-if (mappedGitPath !== undefined && mappedGitPath.trim().length === 0) {
-    throw new TypeError("KEIYAKU_GIT_PATH requires a nonblank value");
-}
-const configuration = {
-    ...(mappedHome === undefined || mappedHome.length === 0 ? {} : { home: mappedHome }),
-    ...(mappedGitPath === undefined ? {} : { gitPath: mappedGitPath }),
-};
 export async function externalRequestCommandsFor(launch, processConfiguration) {
     const world = await World.prove(worldRootForAkumaPaths(launch.paths));
     return {
         world,
-        commands: composeRequestCommands(fleetRequestCommands(fleetRequestPort(world)), contractRequestCommands(contractUpstream(processConfiguration)), taskMutationRequestCommands(taskMutationRequestPort())),
+        commands: composeRequestCommands(selectionRequestCommands(selectionRequestPort(world)), contractRequestCommands(contractUpstream(processConfiguration)), taskMutationRequestCommands(taskMutationRequestPort())),
     };
 }
-const { world, commands: externalCommands } = await externalRequestCommandsFor(launch, configuration);
-if ((await runAkumaBody(launch, world, externalCommands)) === "held")
-    process.exitCode = LEASH_HELD_EXIT;
+function bodyProcessConfiguration() {
+    const mappedHome = process.env.KEIYAKU_HOME?.trim();
+    const mappedGitPath = process.env.KEIYAKU_GIT_PATH;
+    if (mappedGitPath !== undefined && mappedGitPath.trim().length === 0) {
+        throw new TypeError("KEIYAKU_GIT_PATH requires a nonblank value");
+    }
+    return {
+        ...(mappedHome === undefined || mappedHome.length === 0 ? {} : { home: mappedHome }),
+        ...(mappedGitPath === undefined ? {} : { gitPath: mappedGitPath }),
+    };
+}
+async function runBodyEntrypoint() {
+    const encoded = process.argv[2];
+    if (encoded === undefined)
+        throw new TypeError("Akuma body launch payload is missing");
+    const launch = bodyLaunchSchema.parse(JSON.parse(Buffer.from(encoded, "base64url").toString("utf8")));
+    const { world, commands } = await externalRequestCommandsFor(launch, bodyProcessConfiguration());
+    if ((await runAkumaBody(launch, world, commands)) === "held")
+        process.exitCode = LEASH_HELD_EXIT;
+}
+/** Only the spawned entrypoint launches a Body; importing this module composes commands without side effects. */
+function invokedAsBodyEntrypoint() {
+    const entry = process.argv[1];
+    return entry !== undefined && resolve(entry) === resolve(fileURLToPath(import.meta.url));
+}
+if (invokedAsBodyEntrypoint())
+    await runBodyEntrypoint();

package/build/src/body/amend.d.ts

@@ -3,3 +3,8 @@ export declare function applyAmendDocument(source: string, current: DecodedContr
     document: string;
     changedSections: ReadonlySet<string>;
 }>;
+/** Caller syntax is decoded before any repository observation; current-dependent application stays pure. */
+export declare function prepareAmendDocument(source: string): (current: DecodedContractDocument) => Readonly<{
+    document: string;
+    changedSections: ReadonlySet<string>;
+}>;

package/build/src/body/amend.js

@@ -1,9 +1,10 @@
 import { decodeVerificationDeclarations, VerificationDocumentError } from "./verification.js";
 import { parseToAST } from "../markdown/parse.js";
-import { directChildren, indexDocument, indexedHeadings, normalizeTitle, rawSlice, sectionContent, } from "../markdown/query.js";
-import { decodeRegion, RegionDocumentError } from "./region.js";
+import { indexDocument, indexedHeadings, normalizeTitle, rawSlice, sectionContent } from "../markdown/query.js";
+import { decodeRegionOrRefusal } from "./region.js";
 import { contractSectionName, RESERVED_SECTIONS } from "./shape.js";
 import { renderAmendedContractBody } from "./render.js";
+import { decodeCriteria } from "./criteria.js";
 function refusal(message) {
     throw new TypeError(message);
 }
@@ -37,39 +38,6 @@ function prose(document, section, label) {
         refusal(`${label} operation body must be nonblank`);
     return value;
 }
-function region(document, section) {
-    try {
-        return decodeRegion(document, section);
-    }
-    catch (error) {
-        if (error instanceof RegionDocumentError)
-            refusal(error.message);
-        throw error;
-    }
-}
-function criteria(document, section) {
-    const headings = directChildren(section, "heading").filter((heading) => heading.level === 3);
-    if (headings.length === 0)
-        refusal("Criteria operation must contain one or more H3 entries");
-    const before = rawSlice(document, { start: section.contentStart, end: headings[0].span.start });
-    if (before.trim().length > 0)
-        refusal("Criteria operation may contain only H3 entries");
-    const seen = new Set();
-    return headings.map((heading, index) => {
-        const title = heading.text.trim();
-        const key = normalizeTitle(title);
-        if (title.length === 0 || seen.has(key))
-            refusal("criteria operation contains duplicate or empty titles");
-        seen.add(key);
-        const body = rawSlice(document, {
-            start: heading.span.end,
-            end: headings[index + 1]?.span.start ?? section.span.end,
-        });
-        if (body.trim().length === 0)
-            refusal(`criterion '${title}' operation body is empty`);
-        return { title, body };
-    });
-}
 function verification(document, section) {
     try {
         return decodeVerificationDeclarations(document, section, { requireTimeout: true });
@@ -154,7 +122,7 @@ function applyUpdate(body, operation, document) {
     body.extensions[index] = { ...extension, content: prose(document, operation.section, "extension") };
 }
 function addedCriteria(body, operation, document) {
-    const added = criteria(document, operation.section);
+    const added = decodeCriteria(document, operation.section, "amend");
     if (added.some((candidate) => criterionIndex(body, candidate.title) >= 0)) {
         refusal(`${operation.kind} Criteria targets an existing criterion`);
     }
@@ -213,11 +181,11 @@ function applyReplace(body, operation, document) {
         return;
     }
     if (target === "region") {
-        body.region = region(document, operation.section);
+        body.region = decodeRegionOrRefusal(document, operation.section);
         return;
     }
     if (target === "criteria") {
-        const replacement = criteria(document, operation.section);
+        const replacement = decodeCriteria(document, operation.section, "amend");
         body.criteria = [...replacement];
         body.criterionIndexes = new Map(replacement.map((criterion, index) => [normalizeTitle(criterion.title), index]));
         return;
@@ -262,28 +230,36 @@ function applyOperation(body, operation, document) {
 function operationKey(operation) {
     return `${operation.kind}:${operation.target}`;
 }
-function apply(source, current) {
+function apply(document, operations, current) {
+    const changed = new Set();
+    const body = cloneBody(current);
+    for (const operation of operations) {
+        changed.add(normalizeTitle(operation.target));
+        applyOperation(body, operation, document);
+    }
+    return { body: completeBody(body), changed };
+}
+export function applyAmendDocument(source, current) {
+    return prepareAmendDocument(source)(current);
+}
+/** Caller syntax is decoded before any repository observation; current-dependent application stays pure. */
+export function prepareAmendDocument(source) {
     const document = parseToAST(source);
     const operations = operationSections(document);
     if (operations.length === 0)
         refusal("amend requires at least one H2 operation");
     const seen = new Set();
-    const changed = new Set();
-    const body = cloneBody(current);
     for (const operation of operations) {
         const key = operationKey(operation);
         if (seen.has(key))
             refusal(`duplicate amend operation '${key}'`);
         seen.add(key);
-        changed.add(normalizeTitle(operation.target));
-        applyOperation(body, operation, document);
     }
-    return { body: completeBody(body), changed };
-}
-export function applyAmendDocument(source, current) {
-    const result = apply(source, current);
-    return {
-        document: renderAmendedContractBody(current.document.bytes, result.body, result.changed),
-        changedSections: result.changed,
+    return (current) => {
+        const result = apply(document, operations, current);
+        return {
+            document: renderAmendedContractBody(current.document.bytes, result.body, result.changed),
+            changedSections: result.changed,
+        };
     };
 }

package/build/src/body/arc.d.ts

@@ -1,2 +1,4 @@
-import type { ArcData } from "../core/facts/types.js";
-export declare function decodeArcDocument(source: string): Readonly<Omit<ArcData, "seq">>;
+export declare function decodeArcDocument(source: string): Readonly<{
+    title: string;
+    body: string;
+}>;

package/build/src/body/arc.js

@@ -1,29 +1,22 @@
-import { sectionContent } from "../markdown/query.js";
-import { decodeDocumentEnvelope } from "./envelope.js";
-function refusal(message) {
-    throw new TypeError(message);
-}
-function requiredProse(document, sections, name) {
-    const section = sections.get(name);
-    if (section === undefined)
-        refusal(`arc document is missing ## ${name[0].toUpperCase()}${name.slice(1)}`);
-    const value = sectionContent(document, section);
-    if (value.trim().length === 0)
-        refusal(`arc section '${section.title}' is empty`);
-    return value;
-}
+import { parseToAST } from "../markdown/parse.js";
+import { indexDocument, indexedHeadings } from "../markdown/query.js";
+const ARC_SHAPE = "arc document requires exactly one nonblank H1 chapter name (# <name>) followed by a freeform Markdown body (which may be empty)";
 export function decodeArcDocument(source) {
-    const { document, title, sections } = decodeDocumentEnvelope(source, "arc");
-    if (title.title.trim().length === 0)
-        refusal("arc title must be nonblank");
-    for (const [name, section] of sections) {
-        if (name !== "objective" && name !== "brief") {
-            refusal(`arc document does not allow ## ${section.title}`);
-        }
+    let document;
+    try {
+        document = parseToAST(source);
+    }
+    catch {
+        throw new TypeError(ARC_SHAPE);
+    }
+    const titles = indexedHeadings(indexDocument(document), { level: 1 }).filter((node) => node.type === "section");
+    const title = titles[0];
+    if (document.frontmatter !== undefined ||
+        titles.length !== 1 ||
+        title === undefined ||
+        title.title.trim().length === 0 ||
+        source.slice(0, title.span.start).trim().length !== 0) {
+        throw new TypeError(ARC_SHAPE);
     }
-    return {
-        title: title.title,
-        objective: requiredProse(document, sections, "objective"),
-        brief: requiredProse(document, sections, "brief"),
-    };
+    return { title: title.title, body: source.slice(title.contentStart) };
 }

package/build/src/body/criteria.d.ts

@@ -0,0 +1,6 @@
+import type { DocumentNode, SectionNode } from "../markdown/types.js";
+import type { ContractCriterion } from "./types.js";
+type CriteriaContext = "contract" | "amend";
+export declare function criteriaStructure(document: DocumentNode, section: SectionNode, context?: CriteriaContext): string | null;
+export declare function decodeCriteria(document: DocumentNode, section: SectionNode, context?: CriteriaContext): readonly ContractCriterion[];
+export {};

package/build/src/body/criteria.js

@@ -0,0 +1,37 @@
+import { directChildren, normalizeTitle, rawSlice } from "../markdown/query.js";
+function criteriaHeadings(section) {
+    return directChildren(section, "heading").filter((heading) => heading.level === 3);
+}
+export function criteriaStructure(document, section, context = "contract") {
+    const label = context === "amend" ? "Criteria operation" : "Criteria";
+    const headings = criteriaHeadings(section);
+    if (headings.length === 0)
+        return `${label} must contain one or more H3 entries`;
+    const before = rawSlice(document, { start: section.contentStart, end: headings[0].span.start });
+    return before.trim().length === 0 ? null : `${label} may contain only H3 entries`;
+}
+export function decodeCriteria(document, section, context = "contract") {
+    const structural = criteriaStructure(document, section, context);
+    if (structural !== null)
+        throw new TypeError(structural);
+    const headings = criteriaHeadings(section);
+    const seen = new Set();
+    return headings.map((heading, index) => {
+        const title = heading.text.trim();
+        const key = normalizeTitle(title);
+        if (title.length === 0 || seen.has(key)) {
+            throw new TypeError(context === "amend"
+                ? "criteria operation contains duplicate or empty titles"
+                : `duplicate criterion '${title}'`);
+        }
+        seen.add(key);
+        const body = rawSlice(document, {
+            start: heading.span.end,
+            end: headings[index + 1]?.span.start ?? section.span.end,
+        });
+        if (body.trim().length === 0) {
+            throw new TypeError(context === "amend" ? `criterion '${title}' operation body is empty` : `criterion '${title}' is empty`);
+        }
+        return { title, body };
+    });
+}

package/build/src/body/decode.js

@@ -1,8 +1,9 @@
 import { mintDocumentKey, mintDocumentSegmentKey } from "./keys.js";
 import { decodeDocumentEnvelope } from "./envelope.js";
-import { directChildren, normalizeTitle, rawSlice, sectionContent } from "../markdown/query.js";
+import { criteriaStructure, decodeCriteria } from "./criteria.js";
+import { directChildren, rawSlice, sectionContent } from "../markdown/query.js";
 import { CONTRACT_SECTIONS, RESERVED_SECTIONS } from "./shape.js";
-import { decodeRegion, regionStructure, RegionDocumentError } from "./region.js";
+import { decodeRegionOrRefusal, regionStructure } from "./region.js";
 import { decodeVerificationDeclarations, VerificationDocumentError } from "./verification.js";
 function refusal(message) {
     throw new TypeError(message);
@@ -18,13 +19,6 @@ function requireSections(sections) {
 function requiredSection(sections, name) {
     return sections.get(name);
 }
-function criteriaStructure(document, section) {
-    const headings = directChildren(section, "heading").filter((heading) => heading.level === 3);
-    if (headings.length === 0)
-        return "Criteria must contain one or more H3 entries";
-    const before = rawSlice(document, { start: section.contentStart, end: headings[0].span.start });
-    return before.trim().length === 0 ? null : "Criteria may contain only H3 entries";
-}
 function verificationStructure(document, section) {
     const blocks = directChildren(section, "code_block");
     if (blocks.length === 0)
@@ -62,37 +56,6 @@ function prose(document, section) {
         refusal(`contract section '${section.title}' is empty`);
     return value;
 }
-function region(document, section) {
-    try {
-        return decodeRegion(document, section);
-    }
-    catch (error) {
-        if (error instanceof RegionDocumentError)
-            refusal(error.message);
-        throw error;
-    }
-}
-function criteria(document, section) {
-    const structural = criteriaStructure(document, section);
-    if (structural !== null)
-        refusal(structural);
-    const headings = directChildren(section, "heading").filter((heading) => heading.level === 3);
-    const seen = new Set();
-    return headings.map((heading, index) => {
-        const title = heading.text.trim();
-        const key = normalizeTitle(title);
-        if (seen.has(key))
-            refusal(`duplicate criterion '${title}'`);
-        seen.add(key);
-        const body = rawSlice(document, {
-            start: heading.span.end,
-            end: headings[index + 1]?.span.start ?? section.span.end,
-        });
-        if (body.trim().length === 0)
-            refusal(`criterion '${title}' is empty`);
-        return { title, body };
-    });
-}
 function verification(document, section, options) {
     try {
         return decodeVerificationDeclarations(document, section, options);
@@ -129,8 +92,8 @@ export function decodeContractDocument(source, options = {}) {
         context: prose(document, requiredSection(sections, "context")),
         objective: prose(document, requiredSection(sections, "objective")),
         design: prose(document, requiredSection(sections, "design")),
-        region: region(document, requiredSection(sections, "region")),
-        criteria: criteria(document, requiredSection(sections, "criteria")),
+        region: decodeRegionOrRefusal(document, requiredSection(sections, "region")),
+        criteria: decodeCriteria(document, requiredSection(sections, "criteria")),
         verification: verificationSection === undefined ? [] : verification(document, verificationSection, options),
         extensions,
     };

package/build/src/body/region.d.ts

@@ -12,4 +12,9 @@ export declare function regionStructure(section: SectionNode): string | null;
 /** A whitespace-bearing pattern is almost certainly strayed prose; bind warns and proceeds rather than rejecting. */
 export declare function regionWarnings(patterns: readonly string[]): readonly string[];
 export declare function decodeRegion(_document: DocumentNode, section: SectionNode): readonly string[];
+/** Region decoding for body parsers: document errors surface as plain TypeError refusals. */
+export declare function decodeRegionOrRefusal(document: DocumentNode, section: SectionNode): readonly string[];
+export type RegionRelation = "same" | "mine-within-theirs" | "theirs-within-mine" | "intersect";
+export type RegionOverlapPair = readonly [mine: string, theirs: string, relation: RegionRelation];
+export declare function regionsOverlapWithRelation(mine: readonly string[], theirs: readonly string[]): readonly RegionOverlapPair[];
 export declare function regionsOverlap(mine: readonly string[], theirs: readonly string[]): readonly [string, string][];

package/build/src/body/region.js

@@ -201,16 +201,59 @@ export function decodeRegion(_document, section) {
         refusal("Region must declare at least one path pattern");
     return patterns.map((pattern) => compileRegionPattern(pattern).source);
 }
-export function regionsOverlap(mine, theirs) {
+/** Region decoding for body parsers: document errors surface as plain TypeError refusals. */
+export function decodeRegionOrRefusal(document, section) {
+    try {
+        return decodeRegion(document, section);
+    }
+    catch (error) {
+        if (error instanceof RegionDocumentError)
+            throw new TypeError(error.message);
+        throw error;
+    }
+}
+function literalPrefixWithDeepTail(pattern) {
+    if (pattern.segments.at(-1)?.kind !== "deep")
+        return null;
+    const prefix = pattern.segments.slice(0, -1);
+    if (prefix.some((segment) => segment.kind !== "segment" || segment.characters.some((character) => character === "*" || character === "?")))
+        return null;
+    return prefix.map((segment) => segment.characters.join(""));
+}
+function patternWithin(container, candidate) {
+    const prefix = literalPrefixWithDeepTail(container);
+    if (prefix === null)
+        return false;
+    const candidateSegments = candidate.segments;
+    if (candidateSegments.length < prefix.length)
+        return false;
+    return prefix.every((value, index) => {
+        const segment = candidateSegments[index];
+        return segment?.kind === "segment" && segment.characters.join("") === value;
+    });
+}
+function relationOf(mine, theirs) {
+    if (mine.source === theirs.source)
+        return "same";
+    if (patternWithin(theirs, mine))
+        return "mine-within-theirs";
+    if (patternWithin(mine, theirs))
+        return "theirs-within-mine";
+    return "intersect";
+}
+export function regionsOverlapWithRelation(mine, theirs) {
     const myPatterns = mine.map((pattern) => compileRegionPattern(pattern));
     const theirPatterns = theirs.map((pattern) => compileRegionPattern(pattern));
     const overlaps = [];
     for (const myPattern of myPatterns) {
         for (const theirPattern of theirPatterns) {
             if (patternsOverlap(myPattern.segments, theirPattern.segments)) {
-                overlaps.push([myPattern.source, theirPattern.source]);
+                overlaps.push([myPattern.source, theirPattern.source, relationOf(myPattern, theirPattern)]);
             }
         }
     }
     return overlaps;
 }
+export function regionsOverlap(mine, theirs) {
+    return regionsOverlapWithRelation(mine, theirs).map(([minePattern, theirsPattern]) => [minePattern, theirsPattern]);
+}

package/build/src/body/render.js

@@ -31,10 +31,8 @@ function arcSection(arc) {
         String(arc.seq),
         "### Title",
         content(arc.title),
-        "### Objective",
-        content(arc.objective),
-        "### Brief",
-        content(arc.brief),
+        "### Body",
+        content(arc.body.replace(/^(?:\r?\n)+/u, "")),
     ].join("\n\n");
 }
 export function renderContractBody(body, currentArc) {

package/build/src/cli/activity.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The one process-facing activity driver for observing Call, Ask and Wait. It owns the live frame's
+ * whole lifetime — settled-row emission, redrawable frame, one conclusion and honest close — so the
+ * three modes supply only their typed observation port and their native conclusion, never a second frame.
+ */
+export declare class ActivityDriver {
+    private readonly stream;
+    private lines;
+    private concluded;
+    constructor(stream?: NodeJS.WriteStream);
+    /** Emit one settled row block, then redraw the retained live frame beneath it. */
+    settle(rows: readonly string[], frame: readonly string[]): void;
+    /** Replace the redrawable live frame. Non-TTY streams keep settled rows only. */
+    redraw(frame: readonly string[]): void;
+    /** Conclude the frame once with its final body and release it. */
+    conclude(body: string): void;
+    /**
+     * Close on failure or cancellation without inventing a conclusion. Any still-in-flight rows are
+     * emitted with their unresolved marks so the terminal shows what never settled, then the frame is
+     * released; a mode that already concluded contributes no rows and this is a no-op.
+     */
+    close(inFlight?: readonly string[]): void;
+    private write;
+    private draw;
+    private clear;
+}