@astrosheep/keiyaku 4.5.20 → 4.5.21

package/build/src/akuma/heart/timeline.js

@@ -57,7 +57,7 @@ function decodeTimelineRows(database, rows) {
     const facts = new Map();
     const turns = database
         .prepare(`SELECT sequence, body_sequence, started_at, end_sequence, outcome,
-    history_id, session_json, answer, answer_json, schema_json, diagnostic, completed_at FROM turns
+    history_id, session_json, answer, answer_json, schema_json, initiator, diagnostic, completed_at FROM turns
     WHERE sequence IN (SELECT value FROM json_each(?)) OR end_sequence IN (SELECT value FROM json_each(?))`)
         .all(sequences("turn-start"), sequences("turn-end"));
     for (const row of turns) {

package/build/src/akuma/provider.d.ts

@@ -1,7 +1,7 @@
 import { decodeResumeCoordinate, encodeResumeCoordinate, type ResumeCoordinate } from "./coordinate.js";
 import type { ProviderOptions, ReadonlyRestraint } from "./provider-recipe.js";
 export type { ResumeCoordinate } from "./coordinate.js";
-export declare const AKUMA_REQUESTS_ENV = "AKUMA_REQUESTS";
+export { AKUMA_REQUESTS_ENV } from "./providers/execution-environment.js";
 export declare const AGENT_EVENT_TEXT_LIMIT = 16384;
 export declare const AGENT_THOUGHT_TEXT_LIMIT = 4000;
 export declare const AGENT_EVENT_QUEUE_LIMIT = 256;

package/build/src/akuma/provider.js

@@ -1,5 +1,5 @@
 import { decodeResumeCoordinate, encodeResumeCoordinate } from "./coordinate.js";
-export const AKUMA_REQUESTS_ENV = "AKUMA_REQUESTS";
+export { AKUMA_REQUESTS_ENV } from "./providers/execution-environment.js";
 export const AGENT_EVENT_TEXT_LIMIT = 16_384;
 export const AGENT_THOUGHT_TEXT_LIMIT = 4_000;
 export const AGENT_EVENT_QUEUE_LIMIT = 256;

package/build/src/akuma/providers/acp/core.js

@@ -1,7 +1,8 @@
 import { Readable, Writable } from "node:stream";
 import { spawnStdioProcess } from "../../../runtime/proc/stdio.js";
 import { abortable } from "../../abort.js";
-import { AKUMA_REQUESTS_ENV, AgentEventChannel, } from "../../provider.js";
+import { AgentEventChannel, } from "../../provider.js";
+import { akumaExecutionEnvironment } from "../execution-environment.js";
 import { EMPTY_ACP_EVENT_STATE, flushAcpEvents, mapAcpUpdate, } from "./events.js";
 function diagnostic(acp, error) {
     if (!(error instanceof Error))
@@ -156,11 +157,7 @@ export async function startAcpSession(launch, input, dependencies = {}, custody)
     const child = (dependencies.spawnProcess ?? spawnStdioProcess)({
         argv: launch.argv,
         cwd: input.cwd,
-        env: {
-            ...globalThis.process.env,
-            ...launch.env,
-            ...(input.requests === undefined ? {} : { [AKUMA_REQUESTS_ENV]: input.requests.dir }),
-        },
+        env: akumaExecutionEnvironment(globalThis.process.env, launch.env, input.requests?.dir),
     });
     custody?.own({
         closed: child.exited.then(() => undefined),

package/build/src/akuma/providers/claude/index.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { abortable } from "../../abort.js";
-import { AKUMA_REQUESTS_ENV, AgentEventChannel, createProviderAttempt, } from "../../provider.js";
+import { AgentEventChannel, createProviderAttempt, } from "../../provider.js";
+import { akumaExecutionEnvironment } from "../execution-environment.js";
 import { emitClaudeMessage } from "./events.js";
 import { claudeUserMessage, createClaudeInput, isClaudeTurnEnded } from "./input.js";
 export { CLAUDE_MESSAGE_DISPOSITIONS, CLAUDE_SYSTEM_DISPOSITIONS } from "./events.js";
@@ -38,8 +39,11 @@ class ReceiptChannel {
     }
 }
 function admitClaudeOptions(options) {
-    if (options.sandbox !== undefined) {
-        return { kind: "refused", diagnostic: "Claude provider does not support the sandbox option" };
+    if (options.sandbox === "full-access" && options.readonly === true) {
+        return { kind: "refused", diagnostic: "Claude full-access sandbox cannot combine with readonly" };
+    }
+    if (options.sandbox === "full-access" && options.network === "disabled") {
+        return { kind: "refused", diagnostic: "Claude full-access sandbox cannot combine with disabled network" };
     }
     if (options.network !== undefined) {
         return { kind: "refused", diagnostic: "Claude provider does not support the network option" };
@@ -67,18 +71,11 @@ function claudeQueryOptions(input, execution, abortController) {
         abortController,
         ...(input.requests === undefined ? {} : { additionalDirectories: [input.requests.dir] }),
         ...(execution.executable === undefined ? {} : { pathToClaudeCodeExecutable: execution.executable }),
-        ...(execution.env === undefined && input.requests === undefined
-            ? {}
-            : {
-                env: {
-                    ...process.env,
-                    ...execution.env,
-                    ...(input.requests === undefined ? {} : { [AKUMA_REQUESTS_ENV]: input.requests.dir }),
-                },
-            }),
+        env: akumaExecutionEnvironment(process.env, execution.env, input.requests?.dir),
         permissionMode: mode,
         ...(mode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}),
         settingSources: ["user", "project", "local"],
+        ...(input.options.sandbox === "full-access" ? { sandbox: { enabled: false } } : {}),
         ...(input.options.model === undefined ? {} : { model: input.options.model }),
         ...(input.options.effort === undefined ? {} : { effort: input.options.effort }),
         ...(input.options.systemPrompt === undefined || input.options.systemPrompt.length === 0

package/build/src/akuma/providers/codex-app-server/index.js

@@ -1,5 +1,6 @@
 import { LineRpcProcess } from "../../../runtime/proc/line-rpc.js";
-import { AgentEventChannel, AKUMA_REQUESTS_ENV, createProviderAttempt, } from "../../provider.js";
+import { AgentEventChannel, createProviderAttempt, } from "../../provider.js";
+import { akumaExecutionEnvironment } from "../execution-environment.js";
 import { codexNotificationResult, codexObject, codexText } from "./events.js";
 export { CODEX_ITEM_DISPOSITIONS, CODEX_NOTIFICATION_DISPOSITIONS } from "./events.js";
 function diagnostic(error) {
@@ -106,7 +107,7 @@ async function forkCodex(execution, input, custody) {
     const server = new LineRpcProcess({
         argv: [execution.executable ?? "codex", "app-server", "--listen", "stdio://"],
         cwd: input.cwd,
-        ...(execution.env === undefined ? {} : { env: { ...process.env, ...execution.env } }),
+        env: akumaExecutionEnvironment(process.env, execution.env),
     });
     const closed = new Promise((resolve) => server.onExit(() => resolve()));
     custody.own({
@@ -137,15 +138,7 @@ function codexServer(execution, input) {
     return new LineRpcProcess({
         argv: [execution.executable ?? "codex", "app-server", "--listen", "stdio://"],
         cwd: input.cwd,
-        ...(execution.env === undefined && input.requests === undefined
-            ? {}
-            : {
-                env: {
-                    ...process.env,
-                    ...execution.env,
-                    ...(input.requests === undefined ? {} : { [AKUMA_REQUESTS_ENV]: input.requests.dir }),
-                },
-            }),
+        env: akumaExecutionEnvironment(process.env, execution.env, input.requests?.dir),
     });
 }
 async function startCodex(execution, input, custody) {

package/build/src/akuma/providers/execution-environment.d.ts

@@ -0,0 +1,6 @@
+export declare const AKUMA_REQUESTS_ENV = "AKUMA_REQUESTS";
+declare const PARENT_HARNESS_IDENTITY_KEYS: readonly ["CLAUDE_CODE_SESSION_ID", "CLAUDE_CODE_CHILD_SESSION", "CLAUDECODE", "CODEX_THREAD_ID", "OPENCODE_SESSION_ID", "PI_SESSION_ID", "PI_SESSION_FILE", "PASEO_AGENT_ID", "SQUARE_PARTICIPANT_NAME"];
+type Environment = Readonly<Record<string, string | undefined>>;
+/** Construct the environment for one isolated Akuma execution or native child. */
+export declare function akumaExecutionEnvironment(inherited: Environment, overrides?: Environment, requests?: string, nativeIdentity?: readonly (typeof PARENT_HARNESS_IDENTITY_KEYS)[number][]): Record<string, string>;
+export {};

package/build/src/akuma/providers/execution-environment.js

@@ -0,0 +1,24 @@
+export const AKUMA_REQUESTS_ENV = "AKUMA_REQUESTS";
+const PARENT_HARNESS_IDENTITY_KEYS = [
+    "CLAUDE_CODE_SESSION_ID",
+    "CLAUDE_CODE_CHILD_SESSION",
+    "CLAUDECODE",
+    "CODEX_THREAD_ID",
+    "OPENCODE_SESSION_ID",
+    "PI_SESSION_ID",
+    "PI_SESSION_FILE",
+    "PASEO_AGENT_ID",
+    "SQUARE_PARTICIPANT_NAME",
+];
+/** Construct the environment for one isolated Akuma execution or native child. */
+export function akumaExecutionEnvironment(inherited, overrides = {}, requests, nativeIdentity = []) {
+    const preserved = Object.fromEntries(nativeIdentity.flatMap((key) => (inherited[key] === undefined ? [] : [[key, inherited[key]]])));
+    const environment = Object.fromEntries(Object.entries({ ...inherited, ...overrides }).flatMap(([key, value]) => value === undefined ? [] : [[key, value]]));
+    for (const key of PARENT_HARNESS_IDENTITY_KEYS)
+        delete environment[key];
+    Object.assign(environment, preserved);
+    delete environment[AKUMA_REQUESTS_ENV];
+    if (requests !== undefined)
+        environment[AKUMA_REQUESTS_ENV] = requests;
+    return environment;
+}

package/build/src/akuma/providers/opencode-sdk/index.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { AKUMA_REQUESTS_ENV, AgentEventChannel, createProviderAttempt, } from "../../provider.js";
+import { AgentEventChannel, createProviderAttempt, } from "../../provider.js";
 import { createEventState, mapEvent } from "./events.js";
 import { coordinate, loadOpencode, OPENCODE_SDK_PROVIDER, parseModel } from "./session.js";
 function object(value) {
@@ -204,12 +204,13 @@ async function forceDisposeOpencode(abortController, close, finish) {
 }
 async function loadDriveRuntime(execution, input, signal, loader, onRuntime) {
     const runtime = await loadOpencode({
-        ...execution,
-        env: {
-            ...execution.env,
-            ...(input.requests === undefined ? {} : { [AKUMA_REQUESTS_ENV]: input.requests.dir }),
-        },
-    }, input.cwd, signal, loader, onRuntime);
+        execution,
+        cwd: input.cwd,
+        signal,
+        ...(loader === undefined ? {} : { loader }),
+        ...(onRuntime === undefined ? {} : { onRuntime }),
+        ...(input.requests === undefined ? {} : { requests: input.requests.dir }),
+    });
     if (signal.aborted) {
         await runtime.close();
         signal.throwIfAborted();
@@ -343,22 +344,28 @@ export function createOpencodeProvider(input = { name: OPENCODE_SDK_PROVIDER, ki
         fork: (input) => createProviderAttempt(new AbortController().signal, async (custody) => {
             const sessionId = opencodeSessionId(input.session);
             let close;
-            const runtime = await loadOpencode(execution, input.cwd, custody.signal, loader, (ready) => {
-                let closing;
-                let settleRuntimeClosed;
-                let rejectRuntimeClosed;
-                const runtimeClosed = new Promise((resolve, reject) => {
-                    settleRuntimeClosed = resolve;
-                    rejectRuntimeClosed = reject;
-                });
-                close = () => {
-                    if (closing === undefined) {
-                        closing = ready.close();
-                        void closing.then(settleRuntimeClosed, rejectRuntimeClosed);
-                    }
-                    return closing;
-                };
-                custody.own({ closed: runtimeClosed, abort: close, forceDispose: close });
+            const runtime = await loadOpencode({
+                execution,
+                cwd: input.cwd,
+                signal: custody.signal,
+                ...(loader === undefined ? {} : { loader }),
+                onRuntime: (ready) => {
+                    let closing;
+                    let settleRuntimeClosed;
+                    let rejectRuntimeClosed;
+                    const runtimeClosed = new Promise((resolve, reject) => {
+                        settleRuntimeClosed = resolve;
+                        rejectRuntimeClosed = reject;
+                    });
+                    close = () => {
+                        if (closing === undefined) {
+                            closing = ready.close();
+                            void closing.then(settleRuntimeClosed, rejectRuntimeClosed);
+                        }
+                        return closing;
+                    };
+                    custody.own({ closed: runtimeClosed, abort: close, forceDispose: close });
+                },
             });
             try {
                 const result = await runtime.client.session.fork({

package/build/src/akuma/providers/opencode-sdk/session.d.ts

@@ -23,5 +23,12 @@ export type OpencodeRuntime = Readonly<{
     };
     close: () => Promise<void>;
 }>;
-export declare function loadOpencode(execution: ProviderExecution, cwd: string, signal: AbortSignal, loader?: OpencodeSdkLoader, onRuntime?: (runtime: OpencodeRuntime) => void): Promise<OpencodeRuntime>;
+export declare function loadOpencode(input: Readonly<{
+    execution: ProviderExecution;
+    cwd: string;
+    signal: AbortSignal;
+    loader?: OpencodeSdkLoader;
+    onRuntime?: (runtime: OpencodeRuntime) => void;
+    requests?: string;
+}>): Promise<OpencodeRuntime>;
 export declare function coordinate(sessionId: string): ResumeCoordinate;

package/build/src/akuma/providers/opencode-sdk/session.js

@@ -1,5 +1,6 @@
 import net from "node:net";
 import { abortable } from "../../abort.js";
+import { akumaExecutionEnvironment } from "../execution-environment.js";
 import { spawnDetachedProcess } from "../../../runtime/proc/run.js";
 export const OPENCODE_SDK_PROVIDER = "opencode-sdk";
 export function parseModel(model) {
@@ -37,9 +38,10 @@ async function availablePort() {
         });
     });
 }
-export async function loadOpencode(execution, cwd, signal, loader, onRuntime) {
+export async function loadOpencode(input) {
+    const { execution, cwd, signal, loader, onRuntime, requests } = input;
     if (loader) {
-        const loaded = await abortable(loader(cwd, execution, signal), signal);
+        const loaded = await abortable(loader(cwd, { ...execution, env: akumaExecutionEnvironment(process.env, execution.env, requests) }, signal), signal);
         let closing;
         const runtime = {
             client: loaded.client,
@@ -64,11 +66,10 @@ export async function loadOpencode(execution, cwd, signal, loader, onRuntime) {
     const owned = await spawnDetachedProcess({
         argv: [execution.executable ?? "opencode", "serve", "--hostname", "127.0.0.1", "--port", String(port)],
         cwd,
-        env: {
-            ...process.env,
+        env: akumaExecutionEnvironment(process.env, {
             ...(execution.config === undefined ? {} : { OPENCODE_CONFIG_CONTENT: JSON.stringify(execution.config) }),
             ...execution.env,
-        },
+        }, requests),
         log: `${cwd}/.opencode.log`,
     });
     const { createOpencodeClient } = await import("@opencode-ai/sdk");

package/build/src/akuma/providers/pi/events.js

@@ -89,7 +89,9 @@ function searchCall(name, value) {
     };
 }
 function fileChangeCall(name, value) {
-    if (name !== "edit" || typeof value.path !== "string")
+    // Native write cannot prove creation versus overwrite and reports no patch, so
+    // it joins the conservative update operation with unknown diffstat.
+    if ((name !== "edit" && name !== "write") || typeof value.path !== "string")
         return undefined;
     return { kind: "fileChange", changes: [{ op: "update", path: value.path }] };
 }
@@ -158,7 +160,10 @@ function translateMessage(event, state) {
     }
     const text = textContent(message.content);
     state.answer = text;
-    if (hasTextContent(message.content)) {
+    // Gemini emits an empty text block alongside every tool-use message. It is
+    // transport scaffolding, not narration; an ordinary terminal empty answer
+    // remains public evidence.
+    if (hasTextContent(message.content) && !(message.stopReason === "toolUse" && text.length === 0)) {
         translated.push({ type: "assistant", text });
     }
     return translated;

package/build/src/akuma/providers/pi/index.js

@@ -1,5 +1,6 @@
 import { abortable } from "../../abort.js";
-import { AKUMA_REQUESTS_ENV, AgentEventChannel, createProviderAttempt, } from "../../provider.js";
+import { akumaExecutionEnvironment } from "../execution-environment.js";
+import { AgentEventChannel, createProviderAttempt, } from "../../provider.js";
 import { piTerminalFailure, translatePiEvent } from "./events.js";
 const PI_THINKING_LEVELS = new Set(["minimal", "low", "medium", "high", "xhigh", "max"]);
 const MODEL_PATTERN = /^[^/\s]+\/[^\s]+$/u;
@@ -56,7 +57,7 @@ async function piCreateOptions(sdk, input) {
             (await import("@earendil-works/pi-coding-agent")).createBashToolDefinition(input.cwd, {
                 spawnHook: (context) => ({
                     ...context,
-                    env: { ...context.env, [AKUMA_REQUESTS_ENV]: input.requests.dir },
+                    env: akumaExecutionEnvironment(context.env, {}, input.requests.dir, ["PI_SESSION_ID", "PI_SESSION_FILE"]),
                 }),
             }),
         ];

package/build/src/akuma/request-rendezvous.js

@@ -135,9 +135,14 @@ async function observePublishedRequest(input, id, transportId, path) {
     }
     try {
         for (;;) {
-            // The service flushes this bounded snapshot before its receipt, including fast commands.
-            await consumeProgress();
-            const response = await readRequestReceipt(input, path, id);
+            let response;
+            try {
+                response = await readRequestReceipt(input, path, id);
+            }
+            finally {
+                // A visible receipt guarantees its final progress was already published, even on failure.
+                await consumeProgress();
+            }
             if (response !== undefined)
                 return response;
             if (!(await access(input.directory).then(() => true, () => false))) {

package/build/src/akuma/turn-drive.d.ts

@@ -25,6 +25,7 @@ export type DriveTurnInput = Readonly<{
     body: string;
     call?: string;
     launchTells: readonly TellFact[];
+    initiator?: string;
     schemaJson?: string;
     supervisor: BodySupervisor;
     runtimeSpawn(launch: AkumaCallRequestChildLaunch): Promise<OwnedProcess | void>;

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

@@ -86,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][];