@astrosheep/keiyaku 4.5.19 → 4.5.21

package/build/src/akuma/turn-drive.js

@@ -72,7 +72,9 @@ async function startTurnDrive(input) {
         return { kind: "resume-unsupported" };
     const boundTells = drainPendingTells(input.launchTells);
     const schemaJson = input.schemaJson ?? boundTells.find((tell) => tell.schemaJson !== undefined)?.schemaJson;
+    const initiator = input.call === undefined ? boundTells[0]?.initiator : input.initiator;
     const turn = await beginTurn(input.paths, {
+        ...(initiator === undefined ? {} : { initiator }),
         bodySequence: input.bodySequence,
         startedAt: input.now(),
         ...(input.call === undefined ? {} : { call: input.call }),

package/build/src/akuma-body.js

@@ -31,6 +31,7 @@ function contractUpstream(processConfiguration) {
             const [repo, configuration] = await contractDependencies(input.repoRoot, processConfiguration);
             return await executeForwardedAudit({
                 repo,
+                ...(input.observe === undefined ? {} : { observe: input.observe }),
                 contractId: input.contractId,
                 requester: input.requester,
                 includeDirty: input.includeDirty,
@@ -44,6 +45,7 @@ function contractUpstream(processConfiguration) {
             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 }),
@@ -58,6 +60,7 @@ function contractUpstream(processConfiguration) {
             const [repo, configuration] = await contractDependencies(input.repoRoot, processConfiguration);
             return await executeForwardedReview({
                 repo,
+                ...(input.observe === undefined ? {} : { observe: input.observe }),
                 contractId: input.contractId,
                 requester: input.requester,
                 verdict: input.verdict,
@@ -83,11 +86,13 @@ function fleetRequestPort(world) {
             body: input.body,
             tellId: input.tellId,
             recordedAt: input.recordedAt,
+            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
             signal: input.signal,
         }),
         tellAnswer: async (input) => await PublicAkuma.select(world, input.target).tell(input.body, {
             schema: Schema.json(JSON.parse(input.schemaJson), (value) => value),
             ...(input.interrupt === undefined ? {} : { interrupt: input.interrupt }),
+            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
         }),
         kill: async (input) => {
             const result = await executeKillAkuma({ path: world, ids: input.targets, signal: input.signal });

package/build/src/body/amend.js

@@ -16,11 +16,13 @@ function sections(document) {
 function operationSections(document) {
     if (document.frontmatter !== undefined)
         refusal("amend operations may not contain frontmatter");
-    if (indexedHeadings(indexDocument(document), { level: 1 }).length > 0)
+    const openedBy = document.children.find((node) => nonblank(document, node));
+    const heading = openedBy?.type === "section" && openedBy.level === 1 ? openedBy : undefined;
+    if (indexedHeadings(indexDocument(document), { level: 1 }).length > (heading === undefined ? 0 : 1))
         refusal("amend operations may contain H2 sections only");
-    if (document.children.some((node) => node.type !== "section" && nonblank(document, node))) {
+    const outside = [...document.children, ...(heading?.children ?? [])];
+    if (outside.some((node) => node.type !== "section" && nonblank(document, node)))
         refusal("amend operations contain bytes outside H2 sections");
-    }
     return sections(document).map((section) => {
         const title = section.title.trim();
         const match = /^(Add|Update|Replace|Append|Remove):[ ]+(.+)$/.exec(title);
@@ -70,7 +72,7 @@ function criteria(document, section) {
 }
 function verification(document, section) {
     try {
-        return decodeVerificationDeclarations(document, section);
+        return decodeVerificationDeclarations(document, section, { requireTimeout: true });
     }
     catch (error) {
         if (error instanceof VerificationDocumentError)

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

@@ -1,4 +1,6 @@
 import type { DecodedContractDocument } from "./types.js";
 import type { VerificationDefinition } from "../verification/declaration.js";
-export declare function decodeContractDocument(source: string): DecodedContractDocument;
+export declare function decodeContractDocument(source: string, options?: Readonly<{
+    requireTimeout?: boolean;
+}>): DecodedContractDocument;
 export declare function verificationDefinition(document: DecodedContractDocument): VerificationDefinition | null;

package/build/src/body/decode.js

@@ -2,20 +2,60 @@ import { mintDocumentKey, mintDocumentSegmentKey } from "./keys.js";
 import { decodeDocumentEnvelope } from "./envelope.js";
 import { directChildren, normalizeTitle, rawSlice, sectionContent } from "../markdown/query.js";
 import { CONTRACT_SECTIONS, RESERVED_SECTIONS } from "./shape.js";
-import { decodeRegion, RegionDocumentError } from "./region.js";
+import { decodeRegion, regionStructure, RegionDocumentError } from "./region.js";
 import { decodeVerificationDeclarations, VerificationDocumentError } from "./verification.js";
 function refusal(message) {
     throw new TypeError(message);
 }
 function requireSections(sections) {
+    const diagnostics = [];
     for (const [name, spec] of Object.entries(CONTRACT_SECTIONS)) {
         if (spec.required && !sections.has(name))
-            refusal(`contract document is missing ## ${spec.title}`);
+            diagnostics.push(`contract document is missing ## ${spec.title}`);
     }
+    return diagnostics;
 }
 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)
+        return "Verification must contain one or more fenced executor declarations";
+    const other = section.children.filter((node) => node.type !== "code_block" && rawSlice(document, node.span).trim().length > 0);
+    return other.length === 0 ? null : "Verification may contain only fenced executor declarations";
+}
+// Independent structural rules collect together; each predicate mirrors the
+// fence, heading, or reserved-name check its decoder already enforces so a
+// document with several violations is refused once with every diagnostic.
+function structuralDiagnostics(document, sections) {
+    const diagnostics = requireSections(sections);
+    for (const name of RESERVED_SECTIONS) {
+        if (sections.has(name))
+            diagnostics.push(`${name} is not a contract Markdown section`);
+    }
+    const checks = [
+        ["region", (_document, section) => regionStructure(section)],
+        ["criteria", criteriaStructure],
+        ["verification", verificationStructure],
+    ];
+    for (const [name, check] of checks) {
+        const section = sections.get(name);
+        if (section === undefined)
+            continue;
+        const diagnostic = check(document, section);
+        if (diagnostic !== null)
+            diagnostics.push(diagnostic);
+    }
+    return diagnostics;
+}
 function prose(document, section) {
     const value = sectionContent(document, section);
     if (value.trim().length === 0)
@@ -33,12 +73,10 @@ function region(document, section) {
     }
 }
 function criteria(document, section) {
+    const structural = criteriaStructure(document, section);
+    if (structural !== null)
+        refusal(structural);
     const headings = directChildren(section, "heading").filter((heading) => heading.level === 3);
-    if (headings.length === 0)
-        refusal("Criteria 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 may contain only H3 entries");
     const seen = new Set();
     return headings.map((heading, index) => {
         const title = heading.text.trim();
@@ -55,9 +93,9 @@ function criteria(document, section) {
         return { title, body };
     });
 }
-function verification(document, section) {
+function verification(document, section, options) {
     try {
-        return decodeVerificationDeclarations(document, section);
+        return decodeVerificationDeclarations(document, section, options);
     }
     catch (error) {
         if (error instanceof VerificationDocumentError)
@@ -65,7 +103,7 @@ function verification(document, section) {
         throw error;
     }
 }
-export function decodeContractDocument(source) {
+export function decodeContractDocument(source, options = {}) {
     let envelope;
     try {
         envelope = decodeDocumentEnvelope(source, "contract");
@@ -74,11 +112,10 @@ export function decodeContractDocument(source) {
         refusal(error instanceof Error ? error.message : String(error));
     }
     const { document, title, sections, sectionNodes } = envelope;
-    requireSections(sections);
-    for (const name of RESERVED_SECTIONS) {
-        if (sections.has(name))
-            refusal(`${name} is not a contract Markdown section`);
-    }
+    const structural = structuralDiagnostics(document, sections);
+    if (structural.length > 0)
+        refusal(structural.join("\n"));
+    const verificationSection = sections.get("verification");
     const extensions = [...sections.entries()]
         .filter(([name]) => !Object.hasOwn(CONTRACT_SECTIONS, name))
         .map(([, section]) => {
@@ -87,7 +124,6 @@ export function decodeContractDocument(source) {
             refusal(`extension '${section.title}' is empty`);
         return { title: section.title, content };
     });
-    const verificationSection = sections.get("verification");
     const body = {
         title: title.title,
         context: prose(document, requiredSection(sections, "context")),
@@ -95,7 +131,7 @@ export function decodeContractDocument(source) {
         design: prose(document, requiredSection(sections, "design")),
         region: region(document, requiredSection(sections, "region")),
         criteria: criteria(document, requiredSection(sections, "criteria")),
-        verification: verificationSection === undefined ? [] : verification(document, verificationSection),
+        verification: verificationSection === undefined ? [] : verification(document, verificationSection, options),
         extensions,
     };
     const segments = sectionNodes.map((section) => mintDocumentSegmentKey(document.source, section.span));

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

@@ -3,5 +3,13 @@ export declare class RegionDocumentError extends Error {
     constructor(message: string);
 }
 export declare function assertRegionPattern(pattern: string): string;
-export declare function decodeRegion(document: DocumentNode, section: SectionNode): readonly string[];
+/**
+ * Structural refusals are separate from pattern compilation so a caller may aggregate every independent failure.
+ * The three authoring forms — fenced lines, list items, and bare paragraph lines — union freely. Blank lines never
+ * count, and an info string beyond the exact `txt` still implies executable content that belongs to Verification.
+ */
+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[];
 export declare function regionsOverlap(mine: readonly string[], theirs: readonly string[]): readonly [string, string][];

package/build/src/body/region.js

@@ -1,4 +1,3 @@
-import { directChildren, rawSlice } from "../markdown/query.js";
 export class RegionDocumentError extends Error {
     constructor(message) {
         super(message);
@@ -8,9 +7,6 @@ export class RegionDocumentError extends Error {
 function refusal(message) {
     throw new RegionDocumentError(message);
 }
-function nonblank(document, node) {
-    return rawSlice(document, node.span).trim().length > 0;
-}
 function compileSegment(segment, pattern) {
     if (segment === "**")
         return { kind: "deep" };
@@ -113,15 +109,94 @@ function patternsOverlap(left, right) {
     }
     return false;
 }
-export function decodeRegion(document, section) {
-    const blocks = directChildren(section, "code_block");
-    if (blocks.length !== 1 || !blocks[0].closed || (blocks[0].info !== "" && blocks[0].info !== "txt")) {
-        refusal("Region must contain one closed fence with no info string or the exact 'txt' info string");
+const THEMATIC_BREAK = /^ {0,3}(?:(?:-[ \t]*){3,}|(?:\*[ \t]*){3,}|(?:_[ \t]*){3,})$/u;
+const TABLE_DELIMITER = /^ {0,3}\|?[ \t]*:?-+:?[ \t]*(?:\|[ \t]*:?-+:?[ \t]*)*\|?[ \t]*$/u;
+function nonblank(line) {
+    return line.trim().length > 0;
+}
+/** The AST has no table, thematic-break, or HTML block kind, so the Region boundary classifies that prose itself. */
+function foreignProseKind(lines) {
+    for (const line of lines) {
+        if (THEMATIC_BREAK.test(line))
+            return "thematic break";
+        if (/^ {0,3}</u.test(line))
+            return "HTML";
+    }
+    for (let index = 1; index < lines.length; index += 1) {
+        if (lines[index - 1].includes("|") && TABLE_DELIMITER.test(lines[index]))
+            return "table";
+    }
+    return null;
+}
+function nodeKind(node) {
+    return node.type.replaceAll("_", " ");
+}
+function article(kind) {
+    return kind === "HTML" || /^[aeiou]/iu.test(kind) ? "an" : "a";
+}
+function itemLines(item) {
+    const lines = [];
+    for (const child of item.children) {
+        if (child.type === "text")
+            lines.push(...child.lines);
+        else if (child.type === "list")
+            for (const nested of child.items)
+                lines.push(...itemLines(nested));
     }
-    const other = section.children.filter((node) => node !== blocks[0] && nonblank(document, node));
-    if (other.length > 0)
-        refusal("Region may contain only its fenced declaration");
-    const patterns = blocks[0].lines.slice(1, -1).filter((line) => line.trim().length > 0);
+    return lines.filter(nonblank);
+}
+/**
+ * Structural refusals are separate from pattern compilation so a caller may aggregate every independent failure.
+ * The three authoring forms — fenced lines, list items, and bare paragraph lines — union freely. Blank lines never
+ * count, and an info string beyond the exact `txt` still implies executable content that belongs to Verification.
+ */
+export function regionStructure(section) {
+    for (const node of section.children) {
+        if (node.type === "code_block") {
+            if (!node.closed)
+                return "Region fence must be closed";
+            if (node.info !== "" && node.info !== "txt") {
+                return "Region fence may not carry an info string other than the exact 'txt'";
+            }
+            continue;
+        }
+        if (node.type === "list")
+            continue;
+        if (node.type === "text") {
+            const foreign = foreignProseKind(node.lines);
+            if (foreign !== null)
+                return `Region may not contain ${article(foreign)} ${foreign} block`;
+            continue;
+        }
+        const kind = nodeKind(node);
+        return `Region may not contain ${article(kind)} ${kind} block`;
+    }
+    return null;
+}
+function regionPatterns(section) {
+    const patterns = [];
+    for (const node of section.children) {
+        if (node.type === "code_block")
+            patterns.push(...node.lines.slice(1, -1).filter(nonblank));
+        else if (node.type === "list")
+            for (const item of node.items)
+                patterns.push(...itemLines(item));
+        else if (node.type === "text")
+            patterns.push(...node.lines.filter(nonblank));
+    }
+    return patterns;
+}
+/** A whitespace-bearing pattern is almost certainly strayed prose; bind warns and proceeds rather than rejecting. */
+export function regionWarnings(patterns) {
+    return patterns
+        .filter((pattern) => /\s/u.test(pattern))
+        .map((pattern) => `Region pattern '${pattern}' contains whitespace and will never match a path`);
+}
+export function decodeRegion(_document, section) {
+    const structural = regionStructure(section);
+    if (structural !== null)
+        refusal(structural);
+    const patterns = regionPatterns(section);
     if (patterns.length === 0)
         refusal("Region must declare at least one path pattern");
     return patterns.map((pattern) => compileRegionPattern(pattern).source);

package/build/src/body/render.js

@@ -47,7 +47,7 @@ export function renderContractBody(body, currentArc) {
         section(CONTRACT_SECTIONS.context.title, body.context),
         section(CONTRACT_SECTIONS.objective.title, body.objective),
         section(CONTRACT_SECTIONS.design.title, body.design),
-        section(CONTRACT_SECTIONS.region.title, fenced(body.region.join("\n"))),
+        section(CONTRACT_SECTIONS.region.title, body.region.join("\n")),
         section(CONTRACT_SECTIONS.criteria.title, criteria),
         ...(verification.length === 0 ? [] : [section(CONTRACT_SECTIONS.verification.title, verification)]),
         ...body.extensions.map((extension) => section(extension.title, extension.content)),

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

@@ -4,4 +4,6 @@ export type { VerificationDeclaration, VerificationExecutor } from "../verificat
 export declare class VerificationDocumentError extends Error {
     constructor(message: string);
 }
-export declare function decodeVerificationDeclarations(document: DocumentNode, section: SectionNode): readonly VerificationDeclaration[];
+export declare function decodeVerificationDeclarations(document: DocumentNode, section: SectionNode, options?: Readonly<{
+    requireTimeout?: boolean;
+}>): readonly VerificationDeclaration[];

package/build/src/body/verification.js

@@ -6,7 +6,7 @@ export class VerificationDocumentError extends Error {
         this.name = "VerificationDocumentError";
     }
 }
-export function decodeVerificationDeclarations(document, section) {
+export function decodeVerificationDeclarations(document, section, options = {}) {
     const blocks = directChildren(section, "code_block");
     if (blocks.length === 0)
         throw new VerificationDocumentError("Verification must contain one or more fenced executor declarations");
@@ -31,6 +31,9 @@ export function decodeVerificationDeclarations(document, section) {
         if (duration?.kind === "parsed" && duration.milliseconds === 0) {
             throw new VerificationDocumentError("Verification timeout must be positive");
         }
+        if (options.requireTimeout === true && duration === undefined) {
+            throw new VerificationDocumentError("Verification declarations must specify timeout=<duration>");
+        }
         return {
             executor: info[1],
             script,

package/build/src/cli/accepted.js

@@ -24,6 +24,20 @@ function acceptedEnvelope(result, coordinate) {
         ...(result.executionStops.length === 0 ? {} : { executionStops: result.executionStops }),
     };
 }
+/**
+ * The completed placement's movement identity — the reference it advanced and the head it advanced from — is part
+ * of the public accepted shape, so a receipt states the movement without rebuilding it from facts or folded state.
+ */
+function acceptedCompletion(completion) {
+    if (completion === undefined)
+        return undefined;
+    return {
+        integration: completion.integration,
+        ...(completion.predecessor === undefined ? {} : { predecessor: completion.predecessor }),
+        ...(completion.target === undefined ? {} : { target: completion.target }),
+        ...(completion.verification === undefined ? {} : { verification: completion.verification }),
+    };
+}
 function acceptedRegion(result) {
     if (result.overlapFailure !== undefined)
         return { overlapFailure: result.overlapFailure };
@@ -42,6 +56,7 @@ export function acceptedBind(result, coordinates) {
         verb: "bind",
         ...(result.workspace === undefined ? {} : { workspace: result.workspace }),
         target: coordinates.target ?? null,
+        ...(result.warnings === undefined ? {} : { warnings: result.warnings }),
         ...acceptedRegion(result),
     };
 }
@@ -56,6 +71,7 @@ export function acceptedAmend(result, coordinate) {
 export function acceptedDeliver(result, coordinate) {
     const value = result.value;
     const attestation = attestationFor(result.facts, "verified", coordinate);
+    const completion = acceptedCompletion(value.completion);
     const verificationVerdict = value.completion?.verification?.verdict ?? attestation?.data.verdict ?? value.verificationReuse?.verdict;
     return {
         ...acceptedEnvelope(result, coordinate),
@@ -63,7 +79,7 @@ export function acceptedDeliver(result, coordinate) {
         tenderSnapshot: value.tenderSnapshot,
         integration: { changeId: value.integration.changeId },
         ...(value.leading === undefined ? {} : { leading: value.leading }),
-        ...(value.completion === undefined ? {} : { completion: value.completion }),
+        ...(completion === undefined ? {} : { completion }),
         ...(verificationVerdict === undefined ? {} : { verificationVerdict }),
         ...(value.verification === undefined ? {} : { verification: value.verification }),
         ...(value.verificationReuse === undefined ? {} : { verificationReuse: value.verificationReuse }),
@@ -78,6 +94,7 @@ export function acceptedReview(result, coordinate) {
     if (reviewAttestation === undefined)
         throw new Error("accepted review is missing its attestation fact");
     const verificationAttestation = attestationFor(result.facts, "verified", coordinate);
+    const completion = acceptedCompletion(value.completion);
     const verificationVerdict = value.completion?.verification?.verdict ??
         verificationAttestation?.data.verdict ??
         value.verificationReuse?.verdict;
@@ -85,7 +102,7 @@ export function acceptedReview(result, coordinate) {
         ...acceptedEnvelope(result, coordinate),
         verb: "review",
         verdict: reviewAttestation.data.verdict,
-        ...(value.completion === undefined ? {} : { completion: value.completion }),
+        ...(completion === undefined ? {} : { completion }),
         ...(verificationVerdict === undefined ? {} : { verificationVerdict }),
         ...(value.verification === undefined ? {} : { verification: value.verification }),
         ...(value.verificationReuse === undefined ? {} : { verificationReuse: value.verificationReuse }),

package/build/src/cli/commands/akuma-invoke.d.ts

@@ -11,6 +11,7 @@ export type AkumaInvocationResult = Readonly<{
     result: CallResult;
     world: WorldRoot;
     schemaAnswer?: unknown;
+    streamed?: boolean;
 }> | Readonly<{
     kind: "akuma";
     action: "status";
@@ -21,6 +22,7 @@ export type AkumaInvocationResult = Readonly<{
     action: "wait";
     result: AkumaWaitResult;
     alias?: string;
+    streamed?: boolean;
 }> | Readonly<{
     kind: "akuma";
     action: "tell";
@@ -84,7 +86,7 @@ export type AkumaInvocationResult = Readonly<{
 }>;
 type InvokeInput = Readonly<{
     path: WorldRoot;
-    statedCwd?: string;
+    executionCwd?: string;
     home?: string;
     settings?: Settings;
     contract?: KeiyakuContract;