@astrosheep/keiyaku 2.9.11 → 2.9.13

package/build/cli/render/wait.js

@@ -2,9 +2,6 @@ import { formatTimelineDuration, renderPendingProjectionTell, renderProjectionAc
 import { displayColumns, resolveLineColumns, truncateColumns } from "./line-width.js";
 import { coreTextResponse, formatTellCommand, projectionRejoinHintLines, textResponse } from "./shared.js";
 import { renderTerminalFailureFace } from "./terminal-failure.js";
-function shortAddress(projectionId) {
-    return /\/([0-9a-f]{8})$/.exec(projectionId)?.[1] ?? projectionId;
-}
 function phaseState(phase) {
     switch (phase) {
         case "done": return "returned";
@@ -34,16 +31,17 @@ function projectionIdentityParts(projectionId) {
     const match = /^(.*)\/([0-9a-f]{8})$/.exec(projectionId);
     return match ? { slug: match[1], shortId: match[2] } : { slug: "", shortId: projectionId };
 }
-function waitHeader(projectionId, akuma, snapshot, maxColumns) {
+function waitHeader(projectionId, akuma, snapshot, maxColumns, alias) {
     const state = waitStateText(snapshot);
     const identity = projectionIdentityParts(projectionId);
     // Slug often mirrors the Akuma name; print once when they are the same fact.
     const description = identity.slug && akuma && identity.slug === akuma
         ? identity.slug
         : [identity.slug, akuma].filter(Boolean).join(" · ");
-    const descriptionBudget = Math.max(0, maxColumns - displayColumns(`${identity.shortId} ·  ─ ${state}`));
+    const descriptionBudget = Math.max(0, maxColumns - displayColumns(`${projectionId}${alias ? ` (${alias})` : ""} ·  ─ ${state}`));
     const visibleDescription = truncateColumns(description, descriptionBudget);
-    const prefix = visibleDescription ? `${identity.shortId} · ${visibleDescription}` : identity.shortId;
+    const canonical = `${projectionId}${alias ? ` (${alias})` : ""}`;
+    const prefix = visibleDescription ? `${canonical} · ${visibleDescription}` : canonical;
     const dashCount = Math.max(1, maxColumns - displayColumns(`${prefix}  ${state}`));
     return `${prefix} ${"─".repeat(dashCount)} ${state}`;
 }
@@ -70,16 +68,16 @@ function ledgerHint(projectionId, snapshot) {
     const file = snapshot.eventLedgerFile ?? "events.jsonl";
     return `· ledger: .keiyaku/projection/${projectionId}/${file}`;
 }
-function recordReviveLines(artifactId) {
+function recordForkLines(artifactId) {
     return [
         `record: ${artifactId}`,
-        "revive starts a new projection from the record:",
-        `  » keiyaku revive ${artifactId}`,
+        "fork starts a new projection from the record:",
+        `  » keiyaku fork ${artifactId}`,
     ];
 }
 function nextActionLines(projectionId, result, state) {
     const snapshot = result.snapshot;
-    const address = shortAddress(projectionId);
+    const address = projectionId;
     if (state === "running") {
         return [...projectionRejoinHintLines(address)];
     }
@@ -101,11 +99,11 @@ function nextActionLines(projectionId, result, state) {
         return snapshot.artifactId
             ? [
                 "The projection is lost — no terminal truth exists.",
-                ...recordReviveLines(snapshot.artifactId),
+                ...recordForkLines(snapshot.artifactId),
             ]
             : [
                 "The projection is lost — no terminal truth exists.",
-                "no record survived — there is nothing to revive.",
+                "no record survived — there is nothing to fork.",
             ];
     }
     if (state === "stalled" || state === "unknown") {
@@ -166,18 +164,27 @@ function identityUnavailableResponse(projectionId, diagnostic) {
         exitCode: 1,
     };
 }
-function returnedResponse(projectionId, result) {
-    // Successful terminal wait is response-only: no header, activity rows,
-    // diagnostics, or rollup. Typed outcomeText is the first byte when present.
+function returnedResponse(projectionId, result, alias) {
+    const identity = `${projectionId}${alias ? ` (${alias})` : ""}`;
     const nextActions = nextActionLines(projectionId, result, "returned");
     if (result.state === "terminal" && result.outcomeText) {
-        return textResponse([result.outcomeText, "", ...nextActions].join("\n"));
+        return textResponse([identity, `answer: ${result.outcomeText}`, ...nextActions].join("\n"));
     }
-    return textResponse(nextActions.join("\n"));
+    return textResponse([identity, ...nextActions].join("\n"));
 }
 export function buildWaitResponse(projectionId, result, options = {}) {
+    const payload = {
+        canonicalId: projectionId,
+        ...(options.inputToken ? { inputToken: options.inputToken } : {}),
+        ...(options.alias ? { alias: options.alias } : {}),
+        result,
+    };
+    const withPayload = (response) => ({
+        ...response,
+        payload: payload,
+    });
     if (result.state === "unknown") {
-        return identityUnavailableResponse(projectionId, result.diagnostic);
+        return withPayload({ ...identityUnavailableResponse(projectionId, result.diagnostic), exitCode: 4 });
     }
     // A plural deadline may observe a verdict whose timestamp is at or after
     // the cutoff. The typed timeout result owns presentation in that case; the
@@ -188,20 +195,23 @@ export function buildWaitResponse(projectionId, result, options = {}) {
         : result.snapshot;
     const maxColumns = Math.min(120, options.maxColumns ?? resolveLineColumns());
     if (result.state === "terminal" && result.verdict.state === "killed") {
-        return {
+        return withPayload({
             ...textResponse(`× killed ${projectionId}`),
             exitCode: 1,
-        };
+        });
     }
     if (snapshot.phase === "startup-timeout") {
-        return startupTimeoutResponse(projectionId, result.pact.akuma);
+        return withPayload(startupTimeoutResponse(projectionId, result.pact.akuma));
     }
     if (snapshot.phase === "unknown") {
-        return unknownResponse(projectionId, result.pact.akuma, snapshot, maxColumns);
+        const response = unknownResponse(projectionId, result.pact.akuma, snapshot, maxColumns);
+        return result.state === "timeout"
+            ? withPayload({ ...response, exitCode: 124 })
+            : withPayload({ ...response, exitCode: 4 });
     }
     const state = phaseState(snapshot.phase);
     if (state === "returned") {
-        return returnedResponse(projectionId, result);
+        return withPayload(returnedResponse(projectionId, result, options.alias));
     }
     const rendered = renderProjectionActivity(snapshot.activity, {
         anchorMs: snapshot.observedAtMs,
@@ -225,21 +235,26 @@ export function buildWaitResponse(projectionId, result, options = {}) {
         ...pendingTellRows(snapshot, maxColumns, activityRows.length),
     ]).map((row) => truncateColumns(row.line, maxColumns));
     const lines = [
-        waitHeader(projectionId, result.pact.akuma, snapshot, maxColumns),
+        waitHeader(projectionId, result.pact.akuma, snapshot, maxColumns, options.alias),
         ...diagnosticLines,
         ...flowLines,
     ];
+    const commandToken = options.inputToken && options.inputToken === options.alias
+        ? options.inputToken
+        : projectionId;
     const nextActions = state === "running" && options.runningActions === false
         ? []
-        : nextActionLines(options.alias ?? projectionId, result, state);
+        : nextActionLines(commandToken, result, state);
     if (nextActions.length > 0)
         lines.push("");
     lines.push(...nextActions);
-    const response = coreTextResponse(lines.join("\n"), result);
+    const response = withPayload(coreTextResponse(lines.join("\n"), result));
+    if (result.state === "timeout")
+        return { ...response, exitCode: 124 };
     if (snapshot.phase === "dismissed")
         return { ...response, exitCode: 130 };
-    if (["failed", "lost", "startup-timeout", "unknown"].includes(snapshot.phase)) {
-        return { ...response, exitCode: 1 };
+    if (result.state === "lost") {
+        return { ...response, exitCode: 4 };
     }
     return response;
 }
@@ -247,11 +262,20 @@ export function buildWaitResponse(projectionId, result, options = {}) {
 export function buildProjectionWaitSetResponse(result) {
     const rendered = result.results
         .slice()
-        .sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0)
+        .sort((left, right) => waitTriage(left) - waitTriage(right)
+        || latestWaitActivity(right) - latestWaitActivity(left)
+        || terminalWaitTime(right) - terminalWaitTime(left)
+        || left.id.localeCompare(right.id))
         .map((member) => ({
         id: member.id,
         result: member.result,
-        response: buildWaitResponse(member.id, member.result, { runningActions: false }),
+        inputToken: member.inputToken,
+        alias: member.alias,
+        response: buildWaitResponse(member.id, member.result, {
+            alias: member.alias,
+            inputToken: member.inputToken,
+            runningActions: false,
+        }),
     }));
     const liveIds = rendered
         .filter((member) => member.result.state === "timeout")
@@ -260,16 +284,60 @@ export function buildProjectionWaitSetResponse(result) {
     if (liveIds.length > 0) {
         blocks.push([
             "Come back for the result:",
-            `  » keiyaku wait ${liveIds.join(" ")} --${result.selection} [--timeout DURATION]`,
+            `  » keiyaku wait ${rendered.filter((member) => member.result.state === "timeout").map((member) => member.inputToken ?? member.id).join(" ")} --${result.selection} [--timeout DURATION]`,
             "Steer them while they work:",
             `  » ${formatTellCommand("<projection-id>", '"your words"')}`,
         ].join("\n"));
     }
     const text = blocks.join("\n\n");
+    const payload = {
+        selection: result.selection,
+        ...(result.selectedId ? { selectedId: result.selectedId } : {}),
+        results: rendered.map((member) => ({
+            canonicalId: member.id,
+            ...(member.inputToken ? { inputToken: member.inputToken } : {}),
+            ...(member.alias ? { alias: member.alias } : {}),
+            result: member.result,
+        })),
+    };
+    const response = coreTextResponse(text, payload);
+    const conditionSatisfied = result.selection === "any" && result.selectedId !== undefined;
     const exitCode = rendered.reduce((current, { response }) => {
+        if (current === 130)
+            return current;
         if (response.exitCode === 130)
             return 130;
-        return response.exitCode === 1 ? 1 : current;
+        if (current === 4)
+            return current;
+        if (response.exitCode === 4)
+            return 4;
+        return response.exitCode === 124 && !conditionSatisfied ? 124 : current;
     }, undefined);
-    return exitCode === undefined ? textResponse(text) : { ...textResponse(text), exitCode };
+    const deadline = !conditionSatisfied && rendered.some((member) => member.result.state === "timeout");
+    return exitCode === undefined && !deadline ? response : { ...response, exitCode: exitCode ?? 124 };
+}
+function waitSnapshot(result) {
+    return result.state === "unknown" ? undefined : result.snapshot;
+}
+function waitTriage(member) {
+    const snapshot = waitSnapshot(member.result);
+    if (member.result.state === "unknown" || member.result.state === "lost")
+        return 0;
+    if (member.result.state === "terminal" && (member.result.verdict.terminalFailure || member.result.verdict.state !== "completed"))
+        return 0;
+    if ((snapshot?.eventDiagnostics?.length ?? 0) > 0)
+        return 0;
+    return member.result.state === "timeout" ? 1 : 2;
+}
+function latestWaitActivity(member) {
+    const snapshot = waitSnapshot(member.result);
+    if (!snapshot || member.result.state !== "timeout")
+        return Number.NEGATIVE_INFINITY;
+    return snapshot.observedAtMs - (snapshot.activityAgeMs ?? snapshot.durationMs);
+}
+function terminalWaitTime(member) {
+    if (member.result.state !== "terminal")
+        return Number.NEGATIVE_INFINITY;
+    const parsed = Date.parse(member.result.verdict.at);
+    return Number.isFinite(parsed) ? parsed : Number.NEGATIVE_INFINITY;
 }

package/build/cli/types.js

@@ -1 +1,2 @@
-export const TASK_SUBCOMMANDS = ["add", "show", "ls", "log", "start", "stop", "hold", "resume", "done", "drop", "update", "doctor"];
+export const TASK_SUBCOMMANDS = ["add", "compose", "show", "ls", "log", "start", "stop", "hold", "resume", "done", "note", "drop", "update", "doctor"];
+export const AKUMA_SUBCOMMANDS = ["list", "ls", "show"];

package/build/config/akuma-loader.js

@@ -6,6 +6,7 @@ import { observeGitRepository } from "../git/branches.js";
 import { BUILTIN_AGENT_PROFILES } from "../keiyaku.js";
 import { getKeiyakuHome } from "./env.js";
 import { agentNameSchema, providerInstanceNameSchema } from "./settings/schema.js";
+import { canonicalizeAkumaName } from "../core/projection/akuma-name.js";
 const nonblankString = z.string().refine((value) => value.trim().length > 0, { message: "must not be blank" });
 const effortOptionsSchema = z.array(nonblankString).superRefine((values, ctx) => {
     if (new Set(values).size !== values.length) {
@@ -129,9 +130,28 @@ async function readLayer(directory, source) {
         };
     }
     const candidates = [];
+    const canonicalFiles = new Map();
+    for (const entry of entries.filter((candidate) => candidate.isFile() && candidate.name.endsWith(".md"))) {
+        const rawName = path.basename(entry.name, ".md");
+        const canonicalName = canonicalizeAkumaName(rawName);
+        const files = canonicalFiles.get(canonicalName) ?? [];
+        files.push(entry.name);
+        canonicalFiles.set(canonicalName, files);
+    }
     for (const entry of entries.filter((candidate) => candidate.isFile() && candidate.name.endsWith(".md")).sort((a, b) => a.name.localeCompare(b.name))) {
         const file = path.join(directory, entry.name);
-        const name = path.basename(entry.name, ".md");
+        const rawName = path.basename(entry.name, ".md");
+        const name = canonicalizeAkumaName(rawName);
+        const collisions = canonicalFiles.get(name);
+        if (collisions.length > 1) {
+            candidates.push(freezeCandidate({
+                name,
+                source,
+                path: file,
+                reason: `akuma name collision after Unicode NFC normalization: ${collisions.sort().join(", ")}`,
+            }));
+            continue;
+        }
         const nameResult = agentNameSchema.safeParse(name);
         if (!nameResult.success) {
             candidates.push(freezeCandidate({

package/build/config/settings/knobs.js

@@ -1,5 +1,11 @@
-export const KNOWN_SETTINGS_KNOBS = ["default", "reviewer", "gate", "defaultBranch", "worktreeBootstrap"];
+export const PROJECTION_ADOPTION_TIMEOUT_DEFAULT_MS = 30_000;
+export const PROJECTION_ADOPTION_TIMEOUT_MIN_MS = 1_000;
+export const PROJECTION_ADOPTION_TIMEOUT_MAX_MS = 600_000;
+export const KNOWN_SETTINGS_KNOBS = ["default", "reviewer", "gate", "defaultBranch", "worktreeBootstrap", "projectionAdoptionTimeoutMs"];
 export const KNOWN_SETTINGS_ROOT_KEYS = [...KNOWN_SETTINGS_KNOBS, "providers"];
+export function resolveProjectionAdoptionTimeoutMs(settings) {
+    return settings?.projectionAdoptionTimeoutMs ?? PROJECTION_ADOPTION_TIMEOUT_DEFAULT_MS;
+}
 export function resolveDefaultAgentName(settings) {
     return settings?.default ?? "akuma-codex";
 }

package/build/config/settings/schema.js

@@ -1,5 +1,7 @@
 import { z } from "zod";
 import { BUILTIN_PROVIDER_INSTANCE_CANDIDATES as REGISTRY_BUILTIN_PROVIDER_INSTANCE_CANDIDATES, providerInstanceSchema as registryProviderInstanceSchema, } from "../../agents/providers/registry.js";
+import { akumaNameSchema } from "../../core/projection/akuma-name.js";
+import { PROJECTION_ADOPTION_TIMEOUT_MAX_MS, PROJECTION_ADOPTION_TIMEOUT_MIN_MS, } from "./knobs.js";
 export const providerInstanceSchema = registryProviderInstanceSchema;
 export const BUILTIN_PROVIDER_INSTANCE_CANDIDATES = REGISTRY_BUILTIN_PROVIDER_INSTANCE_CANDIDATES;
 const PROVIDER_INSTANCE_NAME_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
@@ -10,11 +12,7 @@ export const providerInstanceNameSchema = z
 // Ensure the registry builtin map stays keyed by the closed provider vocabulary.
 const _builtinCheck = BUILTIN_PROVIDER_INSTANCE_CANDIDATES;
 void _builtinCheck;
-const AGENT_NAME_PATTERN = /^[a-zA-Z0-9]+(?:[.-][a-zA-Z0-9]+)*$/;
-export const agentNameSchema = z
-    .string()
-    .min(1, "must not be empty.")
-    .regex(AGENT_NAME_PATTERN, "must contain only alphanumeric characters, dots, and hyphens, and must not start or end with a separator.");
+export const agentNameSchema = akumaNameSchema;
 function optionalTrimmedString() {
     return z.string().transform((value) => {
         const trimmed = value.trim();
@@ -62,6 +60,11 @@ const gateSchema = z
 const WORKTREE_BOOTSTRAP_DEFAULT_TIMEOUT_MS = 300_000;
 const WORKTREE_BOOTSTRAP_MIN_TIMEOUT_MS = 1;
 const WORKTREE_BOOTSTRAP_MAX_TIMEOUT_MS = 3_600_000;
+export const projectionAdoptionTimeoutSchema = z
+    .number()
+    .int("projectionAdoptionTimeoutMs must be an integer.")
+    .min(PROJECTION_ADOPTION_TIMEOUT_MIN_MS, `projectionAdoptionTimeoutMs must be >= ${PROJECTION_ADOPTION_TIMEOUT_MIN_MS}.`)
+    .max(PROJECTION_ADOPTION_TIMEOUT_MAX_MS, `projectionAdoptionTimeoutMs must be <= ${PROJECTION_ADOPTION_TIMEOUT_MAX_MS}.`);
 export const worktreeBootstrapSchema = z
     .object({
     command: z
@@ -97,6 +100,7 @@ const settingsSchema = z
     gate: gateSchema.optional(),
     defaultBranch: optionalTrimmedString(),
     worktreeBootstrap: worktreeBootstrapSchema.optional(),
+    projectionAdoptionTimeoutMs: projectionAdoptionTimeoutSchema.optional(),
 })
     .strict();
 export const knobSchemas = {
@@ -105,4 +109,5 @@ export const knobSchemas = {
     gate: gateSchema,
     defaultBranch: optionalTrimmedString(),
     worktreeBootstrap: worktreeBootstrapSchema,
+    projectionAdoptionTimeoutMs: projectionAdoptionTimeoutSchema,
 };

package/build/core/addressing.js

@@ -237,7 +237,7 @@ export function resolveExplicitContractAddressFromRead(input) {
     const source = input.source ?? (input.raw.startsWith("@") ? "at-address" : "explicit-flag");
     const spelling = { asTyped: commissionSelectorAsTyped(query, source), source };
     if (isResponseArtifactId(query)) {
-        throw new AddressResolutionError("EMPTY_PARAM", `artifact ${query} is a response artifact; expected a commission address`, { repo, workdir, expected: "commission", spelling, candidates: [], inference: [], actual: "artifact" });
+        throw new AddressResolutionError("UNKNOWN_ADDRESS", `artifact ${query} is a response artifact; expected a commission address`, { repo, workdir, expected: "commission", spelling, candidates: [], inference: [], actual: "artifact" });
     }
     const identities = explicitAddressIdentities(input.read, query);
     const attempt = {
@@ -282,7 +282,7 @@ export function resolveExplicitContractAddressFromRead(input) {
     if (unknown.status === "diseased" || unknown.status === "isolated" || unknown.status === "indeterminate") {
         throw contractReadOutcomeError(query, unknown);
     }
-    throw new AddressResolutionError("EMPTY_PARAM", `unknown contract address @${query}`, attempt);
+    throw new AddressResolutionError("UNKNOWN_ADDRESS", `unknown contract address @${query}`, attempt);
 }
 export async function resolveContractAddress(cwd, raw, source = raw?.startsWith("@") ? "at-address" : "explicit-flag", effectiveDirectory = cwd) {
     const workdir = path.resolve(effectiveDirectory);
@@ -348,7 +348,7 @@ export async function resolveContractAddress(cwd, raw, source = raw?.startsWith(
             inference: attempt.inference,
         });
     }
-    throw new AddressResolutionError(operable.length === 0 ? "EMPTY_PARAM" : "CONTRACT_AMBIGUOUS", operable.length === 0
+    throw new AddressResolutionError(operable.length === 0 ? "UNKNOWN_ADDRESS" : "CONTRACT_AMBIGUOUS", operable.length === 0
         ? "no active commission found; pass @place, @slug, full @commission-id, or --contract <addr>"
         : "multiple active commissions found; pass @place, @slug, full @commission-id, or --contract <addr>", attempt);
 }

package/build/core/amend.js

@@ -9,18 +9,31 @@ import { markdownSourceSections, normalizeScopePattern, ScopePatternError, valid
 import { normalizeSectionTitle } from "./markdown/titles.js";
 import { isCompleteLifecycleOutcome } from "./outcome-base.js";
 import { getConfig } from "../config/env.js";
+import { parseVerificationDeclarations } from "./verification-declaration.js";
 function amendScopeHeading(name) {
     return `## Scope ${name[0].toUpperCase()}${name.slice(1)}`;
 }
+function normalizeReplaceVerificationsTitle(title) {
+    // ATX closing markers are structural syntax, not part of the section title.
+    return normalizeSectionTitle(title.replace(/[ \t]+#+[ \t]*$/, ""));
+}
 function parseAmendScopeSections(markdown) {
     const sections = {};
     for (const section of markdownSourceSections(markdown)) {
         if (section.level !== 2)
             continue;
         const title = normalizeSectionTitle(section.title);
+        if (normalizeReplaceVerificationsTitle(section.title) === "replace verifications")
+            continue;
         if (title === "scope add") {
             throw new FlowError("INVALID_KEIYAKU_DRAFT", "Scope Add is obsolete; use ## Scope Append with a fenced gitignore-subset block");
         }
+        if (title.startsWith("scope ") && title !== "scope append") {
+            throw new FlowError("INVALID_KEIYAKU_DRAFT", `unknown structured amendment operation ## ${section.title}`);
+        }
+        if (title.startsWith("replace ") && title !== "replace verifications") {
+            throw new FlowError("INVALID_KEIYAKU_DRAFT", `unknown structured amendment operation ## ${section.title}`);
+        }
         if (title !== "scope append")
             continue;
         if (sections.append) {
@@ -33,11 +46,7 @@ function parseAmendScopeSections(markdown) {
             end: section.end,
         };
     }
-    let prose = markdown;
-    for (const section of Object.values(sections).sort((left, right) => right.start - left.start)) {
-        prose = `${prose.slice(0, section.start)}${prose.slice(section.end)}`;
-    }
-    return { sections, prose };
+    return { sections };
 }
 function scopePatterns(markdown, section) {
     return validateScopeFragmentLines(markdown.slice(section.contentStart, section.end).split(/\r?\n/), {
@@ -56,29 +65,90 @@ function normalizeAmendScopePatterns(patterns) {
         throw error;
     }
 }
+/** Inspect every structural ATX level so a misplaced replacement never becomes prose. */
+function amendAtxHeadings(markdown) {
+    const lines = markdown.split(/\r?\n/);
+    const frontMatterEnd = lines[0]?.trim() === "---"
+        ? lines.findIndex((line, index) => index > 0 && line.trim() === "---")
+        : -1;
+    let fence;
+    const headings = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (index <= frontMatterEnd)
+            continue;
+        if (fence) {
+            const close = line.match(/^ {0,3}(`+|~+)[ \t]*$/);
+            if (close && close[1][0] === fence.delimiter && close[1].length >= fence.length)
+                fence = undefined;
+            continue;
+        }
+        const open = line.match(/^ {0,3}(`{3,}|~{3,})(.*)$/);
+        if (open && !(open[1][0] === "`" && open[2].includes("`"))) {
+            fence = { delimiter: open[1][0], length: open[1].length };
+            continue;
+        }
+        const heading = line.match(/^(#{1,6})(?!#)[ \t]+(.+)$/);
+        if (heading)
+            headings.push({ level: heading[1].length, title: heading[2] });
+    }
+    return headings;
+}
+function parseReplaceVerificationsSection(markdown) {
+    const matchingHeadings = amendAtxHeadings(markdown)
+        .filter((heading) => normalizeReplaceVerificationsTitle(heading.title) === "replace verifications");
+    if (matchingHeadings.some((heading) => heading.level !== 2)) {
+        throw new FlowError("INVALID_KEIYAKU_DRAFT", "Replace Verifications must use the H2 heading '## Replace Verifications'");
+    }
+    if (matchingHeadings.length > 1) {
+        throw new FlowError("INVALID_KEIYAKU_DRAFT", "amend input may contain ## Replace Verifications at most once");
+    }
+    let replacement;
+    for (const section of markdownSourceSections(markdown)) {
+        if (normalizeReplaceVerificationsTitle(section.title) !== "replace verifications")
+            continue;
+        replacement = section;
+    }
+    return replacement;
+}
+function replacementDeclarations(markdown, section) {
+    return parseVerificationDeclarations(markdown.slice(section.contentStart, section.end), {
+        heading: "## Replace Verifications",
+        allowNone: true,
+    });
+}
 export function buildAmendInput(markdown, cwd, contractId, contractAddressSource, appendScope) {
-    const { sections, prose } = parseAmendScopeSections(markdown);
+    const { sections } = parseAmendScopeSections(markdown);
+    const replacement = parseReplaceVerificationsSection(markdown);
     if (sections.append && appendScope && appendScope.length > 0) {
         throw new FlowError("INVALID_KEIYAKU_DRAFT", "amend input may use either --append-scope or ## Scope Append, not both");
     }
     const append = sections.append
         ? scopePatterns(markdown, sections.append)
         : normalizeAmendScopePatterns(appendScope ?? []);
-    if (!prose.trim()) {
+    const verification = replacement ? replacementDeclarations(markdown, replacement) : undefined;
+    const sourceSections = [...Object.values(sections), ...(replacement ? [replacement] : [])];
+    let proseWithoutReplacement = markdown;
+    for (const section of sourceSections.sort((left, right) => right.start - left.start)) {
+        proseWithoutReplacement = `${proseWithoutReplacement.slice(0, section.start)}${proseWithoutReplacement.slice(section.end)}`;
+    }
+    if (!proseWithoutReplacement.trim() && append.length === 0 && verification === undefined) {
         throw new FlowError("EMPTY_PARAM", "amendment cannot be empty");
     }
     return {
         cwd,
         ...(contractId ? { contractId } : {}),
         ...(contractAddressSource ? { contractAddressSource } : {}),
-        amendment: prose,
+        amendment: proseWithoutReplacement,
         ...(append.length > 0 ? { scopeDelta: { add: append } } : {}),
+        ...(verification ? { verificationDelta: { replace: verification } } : {}),
     };
 }
-function requireAmendment(value) {
-    if (!value.trim())
+function requireAmendment(input) {
+    if (!input.amendment.trim() && !input.scopeDelta && !input.verificationDelta) {
         throw new FlowError("EMPTY_PARAM", "amendment cannot be empty");
-    return value;
+    }
+    return input.amendment;
 }
 function assertContractOperable(contractId, model) {
     const state = currentLifecycleState(model);
@@ -95,9 +165,19 @@ function normalizeScopeDelta(scopeDelta) {
         return undefined;
     return { add };
 }
+function normalizeVerificationDelta(verificationDelta) {
+    if (!verificationDelta)
+        return undefined;
+    const replace = verificationDelta.replace.map((declaration) => ({ ...declaration }));
+    if (replace.some((declaration) => !declaration.executor || !declaration.script.trim())) {
+        throw new FlowError("INVALID_KEIYAKU_DRAFT", "Verification replacement declarations must have an executor and nonblank script");
+    }
+    return { replace };
+}
 export async function amendContract(input) {
-    const amendment = requireAmendment(input.amendment);
     const scopeDelta = normalizeScopeDelta(input.scopeDelta);
+    const verificationDelta = normalizeVerificationDelta(input.verificationDelta);
+    const amendment = requireAmendment({ amendment: input.amendment, scopeDelta, verificationDelta });
     const at = new Date(input.nowMs).toISOString();
     const execution = await runLifecycle({
         cwd: input.cwd,
@@ -135,12 +215,16 @@ export async function amendContract(input) {
             return {
                 amendmentNumber: admission.business.amendmentNumber,
                 entry: {
-                    v: 1,
+                    v: 2,
                     kind: "amend",
                     contract: input.contractId,
                     at,
                     actor: input.actor,
-                    data: { amendment, ...(scopeDelta ? { scopeDelta } : {}) },
+                    data: {
+                        amendment,
+                        ...(scopeDelta ? { scopeDelta } : {}),
+                        ...(verificationDelta ? { verificationDelta } : {}),
+                    },
                 },
             };
         },
@@ -162,12 +246,12 @@ export async function amendContract(input) {
         effect: async ({ context, admission, prepared }) => {
             const result = prepared.existing
                 ? await context.replayCommitted({ transactionObjectId: prepared.existing.transactionObjectId })
-                : await context.publishAuthoritative({ verb: "amend", admittedLedgerHead: admission.ledgerHead, acceptedLifecycleTail: context.session.lifecycle.history.at(-1).objectId, entries: [prepared.entry] });
+                : await context.publishAuthoritative({ verb: "amend", admittedLedgerHead: admission.ledgerHead, acceptedLifecycleTail: context.session.lifecycle.contractHead, entries: [prepared.entry] });
             if (result.status === "indeterminate") {
                 return { kind: "precommit-effects-only", authoritativeHead: result.currentHead ?? admission.ledgerHead };
             }
             if (result.status !== "committed") {
-                return { kind: "refused-before-effects", authoritativeHead: result.currentHead ?? context.session.lifecycle.observedLedgerHead, refusal: { code: "LEDGER_CAS_CONFLICT", message: `contract ${input.contractId} changed during amend` } };
+                return { kind: "refused-before-effects", authoritativeHead: result.currentHead ?? context.session.pins.repositoryLedgerHead, refusal: { code: "LEDGER_CAS_CONFLICT", message: `contract ${input.contractId} changed during amend` } };
             }
             return {
                 kind: "committed",
@@ -204,7 +288,7 @@ export async function amendKeiyaku(input) {
     const address = input.address ?? await resolveContractAddress(input.cwd, input.contractId, input.contractAddressSource);
     return await withResolvedAddress(address, async () => {
         const contractId = address.binding.commissionId;
-        const amendment = requireAmendment(input.amendment);
+        const amendment = requireAmendment(input);
         const amendmentWarningThreshold = getConfig().amendmentWarning.threshold;
         const amended = await amendContract({
             cwd: input.cwd,
@@ -214,6 +298,7 @@ export async function amendKeiyaku(input) {
             amendment,
             amendmentWarningThreshold,
             scopeDelta: input.scopeDelta,
+            verificationDelta: input.verificationDelta,
             signal: input.signal,
         });
         if (!isCompleteLifecycleOutcome(amended))

package/build/core/arc.js

@@ -104,14 +104,14 @@ export async function openArc(input) {
                 };
             }
             const scopeEntry = patterns.length === 0 ? null : {
-                v: 1,
+                v: 2,
                 kind: "amend",
                 contract: input.contractId,
                 at,
                 actor: input.actor,
                 data: { amendment: "Scope extended by lifecycle command.", scopeDelta: { add: patterns } },
             };
-            const capture = await captureFoldedSeal(admission.business.targetRoot, admission.business.lifecycle, "HEAD", patterns);
+            const capture = await captureFoldedSeal(admission.business.targetRoot, admission.business.lifecycle, "HEAD", patterns, "refuse");
             const arcNumber = admission.business.lifecycle.intent.arc + 1;
             let sealEntry = null;
             if (capture) {
@@ -158,14 +158,14 @@ export async function openArc(input) {
                 : await context.publishAuthoritative({
                     verb: "arc",
                     admittedLedgerHead: admission.ledgerHead,
-                    acceptedLifecycleTail: context.session.lifecycle.history.at(-1).objectId,
+                    acceptedLifecycleTail: context.session.lifecycle.contractHead,
                     entries: prepared.additions,
                 });
             if (result.status === "indeterminate") {
                 return { kind: "precommit-effects-only", authoritativeHead: result.currentHead ?? admission.ledgerHead };
             }
             if (result.status !== "committed" || prepared.arcNumber === 0) {
-                return { kind: "refused-before-effects", authoritativeHead: result.status === "committed" ? result.head : result.currentHead ?? context.session.lifecycle.observedLedgerHead, refusal: { code: "LEDGER_CAS_CONFLICT", message: `contract ${input.contractId} changed during arc` } };
+                return { kind: "refused-before-effects", authoritativeHead: result.status === "committed" ? result.head : result.currentHead ?? context.session.pins.repositoryLedgerHead, refusal: { code: "LEDGER_CAS_CONFLICT", message: `contract ${input.contractId} changed during arc` } };
             }
             const committedCapture = prepared.capture;
             const sealed = committedCapture && {