@astrosheep/keiyaku 2.9.4 → 2.9.6

package/build/core/renew.js

@@ -3,7 +3,7 @@ import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, parseRevList
 import { readLedger } from "./ledger.js";
 import { hasStrandableProjectionGeneration } from "./projection/index.js";
 import { refreshContractView } from "./contract-view.js";
-import { appendRenewSettlement, captureRenewSeal, captureSeal, findOpenArc, getFence, getMaxArc, receiptsAfterFence } from "./seal.js";
+import { appendRenewSettlement, appendScopeTerms, captureRenewSeal, captureSeal, findOpenArc, getFence, getMaxArc, receiptsAfterFence } from "./seal.js";
 import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
 import { commissionTarget, latestBase } from "./status/drift.js";
 import { findContractWorktreePath, findRegisteredContractWorktreePath, stableRepoRoot } from "./worktree-path.js";
@@ -13,7 +13,7 @@ import { createRecoveryRef, deleteRecoveryRef } from "../git/refs.js";
 import { resolveContractAddress, withResolvedAddress } from "./addressing.js";
 import { ACTOR_IDENTITY } from "../keiyaku.js";
 import { persistResponseHistory } from "./transcripts.js";
-import { convergeRenewRecoverySession, readRenewRecoverySession, removeRenewRecoverySession, writeRenewRecoverySession, } from "./renew-session.js";
+import { convergeRenewRecoverySession, assertNoRenewRecoverySession, removeRenewRecoverySession, writeRenewRecoverySession, } from "./renew-session.js";
 function assertOperable(contractId, entries) {
     const state = deriveContractState(entries);
     if (state.state === "corrupt") {
@@ -47,7 +47,7 @@ const RENEW_RECOVERY_REF_PREFIX = "refs/keiyaku/recovery/renew";
 function renewRecoveryRef(contractId, oldHead) {
     return `${RENEW_RECOVERY_REF_PREFIX}/${contractId}/${oldHead}`;
 }
-async function rewriteBranch(input) {
+export async function rewriteRenewBranch(input) {
     const { cwd, contractId, oldHead, recoveryRef, newBase, oldBase, branch, preserveConflict } = input;
     const git = createGit(cwd);
     const originalBranch = branch ? await getCurrentBranch(cwd) : undefined;
@@ -160,7 +160,7 @@ async function assertRenewCoordinates(input) {
 }
 async function finishRenew(input) {
     const capture = input.capture === undefined
-        ? await captureSeal(input.repositoryRoot, input.entries, input.oldHead, input.waivePaths)
+        ? await captureSeal(input.repositoryRoot, input.entries, input.oldHead)
         : input.capture;
     const settlement = await appendRenewSettlement({
         cwd: input.repositoryRoot,
@@ -198,11 +198,7 @@ export async function renewContract(input) {
     const repositoryRoot = await stableRepoRoot(input.cwd);
     const worktreePath = await findContractWorktreePath(repositoryRoot, input.contractId);
     const rewriteCwd = worktreePath ?? input.cwd;
-    if (await readRenewRecoverySession(repositoryRoot, input.contractId)) {
-        throw new FlowError("RENEW_SESSION_OPEN", `renew recovery session is open for ${input.contractId}`, {
-            facts: { kind: "renew_session", commission: input.contractId, nextAction: "continue-or-abort" },
-        });
-    }
+    await assertNoRenewRecoverySession(repositoryRoot, input.contractId);
     if (input.resolveConflicts && !worktreePath) {
         throw new FlowError("INTERNAL_STATE", `renew --resolve requires ${input.contractId}'s registered contract worktree`);
     }
@@ -233,12 +229,27 @@ export async function renewContract(input) {
         targetHead,
         entries: ledger.entries,
     });
-    const capture = await captureSeal(input.cwd, ledger.entries, oldHead, input.waivePaths);
     if (getMaxArc(ledger.entries) > 0 && !findOpenArc(ledger.entries)) {
         const loose = await receiptsAfterFence(input.cwd, ledger.entries, oldHead);
         if (loose.length > 0)
             throw looseCommitError(input.contractId, loose);
     }
+    if (oldBase !== targetHead) {
+        const deliveryWorktree = worktreePath ?? repositoryRoot;
+        await assertNoInFlightProjection(repositoryRoot, input.contractId, deliveryWorktree, input.nowMs);
+    }
+    await appendScopeTerms({
+        cwd: repositoryRoot,
+        renderCwd: rewriteCwd,
+        contractId: input.contractId,
+        patterns: input.appendScope,
+        actor: input.actor,
+        nowMs: input.nowMs,
+    });
+    const currentLedger = input.appendScope?.length ? await readLedger(repositoryRoot, input.contractId) : ledger;
+    if (!currentLedger)
+        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} disappeared while appending scope`);
+    const capture = await captureSeal(input.cwd, currentLedger.entries, oldHead);
     if (oldBase === targetHead) {
         return {
             contractId: input.contractId,
@@ -246,14 +257,12 @@ export async function renewContract(input) {
             newBase: targetHead,
             oldHead,
             newHead: oldHead,
-            ledgerHead: ledger.head,
+            ledgerHead: currentLedger.head,
             alreadyFresh: true,
             sealed: null,
             recoveryCleanup: null,
         };
     }
-    const deliveryWorktree = worktreePath ?? repositoryRoot;
-    await assertNoInFlightProjection(repositoryRoot, input.contractId, deliveryWorktree, input.nowMs);
     const recoveryRef = renewRecoveryRef(input.contractId, oldHead);
     await createRecoveryRef(input.cwd, recoveryRef, oldHead);
     if (input.resolveConflicts) {
@@ -266,7 +275,7 @@ export async function renewContract(input) {
         });
     }
     try {
-        await rewriteBranch({
+        await rewriteRenewBranch({
             cwd: rewriteCwd,
             contractId: input.contractId,
             oldHead,
@@ -287,8 +296,8 @@ export async function renewContract(input) {
     return await finishRenew({
         repositoryRoot,
         rewriteCwd,
-        ledgerHead: ledger.head,
-        entries: ledger.entries,
+        ledgerHead: currentLedger.head,
+        entries: currentLedger.entries,
         contractId: input.contractId,
         oldBase,
         oldHead,
@@ -390,19 +399,29 @@ export async function continueRenewContract(input) {
             facts: { kind: "renew_session", commission: input.contractId, nextAction: "abort" },
         });
     }
+    await appendScopeTerms({
+        cwd: repositoryRoot,
+        renderCwd: rewriteCwd,
+        contractId: input.contractId,
+        patterns: input.appendScope,
+        actor: input.actor,
+        nowMs: input.nowMs,
+    });
+    const currentLedger = input.appendScope?.length ? await readLedger(repositoryRoot, input.contractId) : ledger;
+    if (!currentLedger)
+        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} disappeared while appending scope`);
     const capture = await captureRenewSeal({
         cwd: repositoryRoot,
-        entries: ledger.entries,
+        entries: currentLedger.entries,
         receiptHead: session.oldHead,
         contentBase: session.newBase,
         contentHead: newHead,
-        waivePaths: input.waivePaths,
     });
     return await finishRenew({
         repositoryRoot,
         rewriteCwd,
-        ledgerHead: ledger.head,
-        entries: ledger.entries,
+        ledgerHead: currentLedger.head,
+        entries: currentLedger.entries,
         contractId: input.contractId,
         oldBase: session.oldBase,
         oldHead: session.oldHead,
@@ -469,7 +488,7 @@ export async function renewKeiyaku(input) {
             contractId,
             actor: ACTOR_IDENTITY,
             nowMs: Date.now(),
-            waivePaths: input.waivePaths,
+            appendScope: input.appendScope,
             resolveConflicts: input.resolveConflicts,
         });
         return await buildRenewOutcome(input.cwd, address, renewed);
@@ -530,7 +549,7 @@ export async function continueRenewKeiyaku(input) {
         contractId: input.address.binding.commissionId,
         actor: ACTOR_IDENTITY,
         nowMs: Date.now(),
-        waivePaths: input.waivePaths,
+        appendScope: input.appendScope,
     })));
 }
 export async function abortRenewKeiyaku(input) {

package/build/core/scope.js

@@ -1,3 +1,4 @@
+import { FlowError } from "../flow-error.js";
 export class ScopePatternError extends Error {
     code = "INVALID_SCOPE_PATTERN";
     constructor(message) {
@@ -31,10 +32,136 @@ function stripUnescapedTrailingSpaces(value) {
 function canonicalizeScopePatternInput(pattern) {
     return stripUnescapedTrailingSpaces(pattern.replace(/^\s+/, ""));
 }
-/** True when a raw Scope Add / list line has no pattern after gitignore blank rules. */
+/** True when a raw scope line has no pattern after gitignore blank rules. */
 export function isBlankScopePatternLine(line) {
     return canonicalizeScopePatternInput(line).length === 0;
 }
+/** Parse Keiyaku's source-line Scope opener, not a normalized Markdown node. */
+export function parseScopeFenceOpening(line) {
+    const match = line.match(/^(`{3,})$/);
+    return match ? { length: match[1].length } : null;
+}
+/** Keiyaku closer: column-zero backticks, at least opener length, then whitespace. */
+export function isScopeFenceClosing(line, fence) {
+    const match = line.match(/^(`+)[ \t]*$/);
+    return Boolean(match && match[1].length >= fence.length);
+}
+function fencedScopeError(heading, detail) {
+    return new FlowError("INVALID_KEIYAKU_DRAFT", `${heading} must contain exactly one fenced gitignore-subset block; ${detail}. ` +
+        `Paste-ready canonical example:\n\n${heading}\n\`\`\`\nfoo\nbar\n\`\`\``);
+}
+/** Validate and normalize the one fenced block that constitutes a Scope body. */
+export function validateScopeFragmentLines(lines, options) {
+    const first = lines.findIndex((line) => line.trim().length > 0);
+    if (first === -1)
+        throw fencedScopeError(options.heading, "found no fenced block");
+    const fence = parseScopeFenceOpening(lines[first]);
+    if (!fence)
+        throw fencedScopeError(options.heading, `offending line '${lines[first]}'`);
+    let close = -1;
+    for (let index = first + 1; index < lines.length; index += 1) {
+        if (isScopeFenceClosing(lines[index], fence)) {
+            close = index;
+            break;
+        }
+    }
+    if (close === -1)
+        throw fencedScopeError(options.heading, "the fenced block is not closed");
+    const outside = lines.slice(close + 1).find((line) => line.trim().length > 0);
+    if (outside !== undefined) {
+        throw fencedScopeError(options.heading, `offending line '${outside}' appears outside the fenced block`);
+    }
+    const patterns = [];
+    for (const line of lines.slice(first + 1, close)) {
+        if (isBlankScopePatternLine(line))
+            continue;
+        try {
+            patterns.push(normalizeScopePattern(line));
+        }
+        catch (error) {
+            if (error instanceof ScopePatternError) {
+                throw new FlowError("INVALID_KEIYAKU_DRAFT", error.message);
+            }
+            throw error;
+        }
+    }
+    if (patterns.length === 0)
+        throw new FlowError("INVALID_KEIYAKU_DRAFT", options.emptyMessage);
+    return patterns;
+}
+function sourceFenceOpening(line) {
+    const match = line.match(/^ {0,3}(`{3,}|~{3,})(.*)$/);
+    if (!match)
+        return null;
+    const marker = match[1];
+    if (marker[0] === "`" && match[2].includes("`"))
+        return null;
+    return { delimiter: marker[0], length: marker.length };
+}
+function sourceFenceClosing(line, fence) {
+    const match = line.match(/^ {0,3}(`+|~+)[ \t]*$/);
+    return Boolean(match && match[1][0] === fence.delimiter && match[1].length >= fence.length);
+}
+/** Locate structural H1/H2 source ranges while leaving fenced headings inert. */
+export function markdownSourceSections(markdown) {
+    const lines = [];
+    let start = 0;
+    while (start < markdown.length) {
+        const newline = markdown.indexOf("\n", start);
+        const end = newline === -1 ? markdown.length : newline;
+        const next = newline === -1 ? markdown.length : newline + 1;
+        const raw = markdown.slice(start, end);
+        lines.push({ text: raw.endsWith("\r") ? raw.slice(0, -1) : raw, start, next });
+        start = next;
+    }
+    let frontMatterEnd = -1;
+    if (lines[0]?.text.trim() === "---") {
+        frontMatterEnd = lines.findIndex((line, index) => index > 0 && line.text.trim() === "---");
+    }
+    const headings = [];
+    let fence = null;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (index <= frontMatterEnd)
+            continue;
+        if (fence) {
+            if (sourceFenceClosing(line.text, fence))
+                fence = null;
+            continue;
+        }
+        const opening = sourceFenceOpening(line.text);
+        if (opening) {
+            fence = opening;
+            continue;
+        }
+        // Column-0 only: indented ATX-looking lines inside list items remain content.
+        const heading = line.text.match(/^(#{1,2})(?!#)[ \t]+(.+)$/);
+        if (!heading)
+            continue;
+        headings.push({
+            level: heading[1].length,
+            title: heading[2],
+            start: line.start,
+            contentStart: line.next,
+        });
+    }
+    return headings.map((heading, index) => {
+        const next = heading.level === 2
+            ? headings.slice(index + 1).find((candidate) => candidate.level === 2)
+            : headings[index + 1];
+        return { ...heading, end: next?.start ?? markdown.length };
+    });
+}
+/** Render canonical Scope bytes with a fence that content cannot close. */
+export function renderScopeFragment(patterns) {
+    let longestRun = 0;
+    for (const pattern of patterns) {
+        for (const run of pattern.match(/`+/g) ?? [])
+            longestRun = Math.max(longestRun, run.length);
+    }
+    const fence = "`".repeat(Math.max(3, longestRun + 1));
+    return `${fence}\n${patterns.join("\n")}\n${fence}`;
+}
 /**
  * Canonicalize a scope Gitignore-like pattern for matching and persistence.
  * Strips only a cosmetic leading `./` (including after `!`); preserves meaningful
@@ -57,7 +184,7 @@ export function normalizeScopePattern(pattern) {
     return negative ? `!${body}` : body;
 }
 /**
- * Normalize a path to Git diff form for exact waiver comparison:
+ * Normalize a path to Git diff form for matcher comparison:
  * either slash convention, collapse separators, and strip cosmetic `./` or `/`.
  * Leading and trailing spaces are significant path bytes and must remain unchanged.
  */

package/build/core/seal.js

@@ -4,7 +4,7 @@ import { KEIYAKU_FILE } from "../keiyaku.js";
 import { formatLedgerEntryCommitMessage } from "./entry.js";
 import { activeLedgerRef, appendWithRetry, readLedger } from "./ledger.js";
 import { refreshContractView } from "./contract-view.js";
-import { normalizeScopePath, scopePathEvidence, } from "./scope.js";
+import { normalizeScopePattern, scopePathEvidence, } from "./scope.js";
 import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
 import { casUpdateRefLog, createRefLogCommit } from "./ref-log.js";
 function findBind(entries) {
@@ -103,20 +103,41 @@ async function scopeViolations(cwd, paths, scope) {
     const auditedPaths = paths.filter((changedPath) => changedPath !== KEIYAKU_FILE);
     return (await scopePathEvidence(cwd, scope, auditedPaths)).filter((evidence) => !evidence.matched);
 }
-async function auditScope(cwd, entries, paths, waivePaths) {
+async function auditScope(cwd, entries, paths) {
     const scope = effectiveScope(entries);
     const scopeViolationEvidence = await scopeViolations(cwd, paths, scope);
-    const waivedPaths = new Set(waivePaths.map(normalizeScopePath));
-    const unwaived = scopeViolationEvidence.filter((violation) => !waivedPaths.has(violation.path));
-    if (unwaived.length > 0) {
-        throw new ScopeAuditError(findBind(entries).contract, scope, unwaived);
+    if (scopeViolationEvidence.length > 0) {
+        throw new ScopeAuditError(findBind(entries).contract, scope, scopeViolationEvidence);
     }
     const violations = scopeViolationEvidence.map((violation) => violation.path);
     return {
-        scopeAudit: { violations, waived: violations.length > 0 },
+        scopeAudit: { violations },
         scopeViolationEvidence,
     };
 }
+const APPEND_SCOPE_AMENDMENT = "Scope extended by lifecycle command.";
+export async function appendScopeTerms(input) {
+    if (!input.patterns || input.patterns.length === 0)
+        return null;
+    const patterns = input.patterns.map(normalizeScopePattern);
+    const at = new Date(input.nowMs).toISOString();
+    const result = await appendWithRetry(input.cwd, activeLedgerRef(input.contractId), (_head, entries) => {
+        assertOperable(input.contractId, entries);
+        return {
+            v: 1,
+            kind: "amend",
+            contract: input.contractId,
+            at,
+            actor: input.actor,
+            data: { amendment: APPEND_SCOPE_AMENDMENT, scopeDelta: { add: patterns } },
+        };
+    });
+    if (!result.ok) {
+        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} active ledger disappeared while appending scope`);
+    }
+    await refreshContractView({ ledgerCwd: input.cwd, renderCwd: input.renderCwd, contractId: input.contractId });
+    return result.head;
+}
 export class ScopeAuditError extends FlowError {
     scopeViolationEvidence;
     constructor(_contractId, scope, evidence) {
@@ -159,7 +180,7 @@ export function petitionSealSource(entries) {
     };
 }
 /** Shared read-only owner for the seal capture and its compact changed-path evidence. */
-export async function previewSeal(cwd, entries, head = "HEAD", waivePaths = []) {
+export async function previewSeal(cwd, entries, head = "HEAD") {
     const arc = currentSealArc(entries);
     if (arc === null)
         return { capture: null, paths: [] };
@@ -170,7 +191,7 @@ export async function previewSeal(cwd, entries, head = "HEAD", waivePaths = [])
         changedPaths(cwd, oldFence, newFence),
         diffstat(cwd, oldFence, newFence),
     ]);
-    const scopeAudit = await auditScope(cwd, entries, paths, waivePaths);
+    const scopeAudit = await auditScope(cwd, entries, paths);
     return {
         capture: {
             arc,
@@ -183,8 +204,8 @@ export async function previewSeal(cwd, entries, head = "HEAD", waivePaths = [])
         paths,
     };
 }
-export async function captureSeal(cwd, entries, head = "HEAD", waivePaths = []) {
-    return (await previewSeal(cwd, entries, head, waivePaths)).capture;
+export async function captureSeal(cwd, entries, head = "HEAD") {
+    return (await previewSeal(cwd, entries, head)).capture;
 }
 /** Preserve original receipt hashes while auditing the rebased delivery content. */
 export async function captureRenewSeal(input) {
@@ -208,7 +229,7 @@ export async function captureRenewSeal(input) {
         newFence: receiptHead,
         receipts,
         diffstat: stat,
-        ...await auditScope(input.cwd, input.entries, paths, input.waivePaths ?? []),
+        ...await auditScope(input.cwd, input.entries, paths),
     };
 }
 export async function sealCurrentArc(input) {
@@ -217,7 +238,7 @@ export async function sealCurrentArc(input) {
         throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} not found or not active`);
     }
     assertOperable(input.contractId, ledger.entries);
-    const capture = input.capture ?? await captureSeal(input.cwd, ledger.entries, "HEAD", input.waivePaths);
+    const capture = input.capture ?? await captureSeal(input.cwd, ledger.entries, "HEAD");
     if (!capture)
         return null;
     const at = new Date(input.nowMs).toISOString();
@@ -235,7 +256,7 @@ export async function sealCurrentArc(input) {
         }
         const { scopeViolationEvidence: _scopeViolationEvidence, ...durableCapture } = capture;
         return {
-            v: 1,
+            v: 2,
             kind: "seal",
             contract: input.contractId,
             at,
@@ -277,7 +298,7 @@ export async function appendRenewSettlement(input) {
     if (input.capture) {
         const { scopeViolationEvidence: _evidence, ...durableCapture } = input.capture;
         const sealEntry = {
-            v: 1,
+            v: 2,
             kind: "seal",
             contract: input.contractId,
             at,

package/build/core/settlement/petition-claim-gates.js

@@ -1,4 +1,3 @@
-import { spawn } from "node:child_process";
 import { getConfig } from "../../config/env.js";
 import { assertSettingsKnobUsable } from "../../config/settings/disease.js";
 import { resolveReviewerAgentName } from "../../config/settings/knobs.js";
@@ -15,6 +14,7 @@ import { persistResponseHistory } from "../transcripts.js";
 import { logInfo } from "../../telemetry/logger.js";
 import { execSubagent } from "../call/call.js";
 import { readContractLog } from "../log.js";
+import { runVerificationCommand } from "./verification.js";
 const CLAIM_VERIFICATION_OUTPUT_MAX_CHARS = 1200;
 const REVIEW_PASS_TOKEN = "PASS";
 const REVIEW_REJECTION_MESSAGE = "CLAIM rejected by independent reviewer.";
@@ -48,31 +48,6 @@ function buildReviewAttemptBlock(reviewNumber) {
         "Focus on whether the previous concerns have been addressed.",
     ];
 }
-async function runCommand(options) {
-    return await new Promise((resolve, reject) => {
-        const child = spawn(options.command, options.args, {
-            cwd: options.cwd,
-            stdio: ["ignore", "pipe", "pipe"],
-            env: getConfig().runtimeEnv,
-        });
-        let stdout = "";
-        let stderr = "";
-        child.stdout.on("data", (chunk) => {
-            stdout += String(chunk);
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr += String(chunk);
-        });
-        child.on("error", reject);
-        child.on("close", (code) => {
-            resolve({
-                code: typeof code === "number" ? code : -1,
-                stdout,
-                stderr,
-            });
-        });
-    });
-}
 function clipCommandOutput(value, maxChars = CLAIM_VERIFICATION_OUTPUT_MAX_CHARS) {
     const trimmed = value.trim();
     if (!trimmed)
@@ -128,11 +103,7 @@ export function createCommandVerificationGate() {
         async evaluate({ cwd, verificationCommands }) {
             for (const verification of verificationCommands) {
                 logInfo(`[CLAIM] Running verification: ${verification.label}`, { cwd, section: "script", progressOnly: true });
-                const result = await runCommand({
-                    cwd,
-                    command: verification.command,
-                    args: verification.args,
-                });
+                const result = await runVerificationCommand(cwd, verification);
                 if (result.code !== 0) {
                     return {
                         pass: false,
@@ -141,8 +112,8 @@ export function createCommandVerificationGate() {
                         facts: {
                             kind: "verification_failure",
                             label: verification.label,
-                            stdout: clipCommandOutput(result.stdout),
-                            stderr: clipCommandOutput(result.stderr),
+                            stdout: clipCommandOutput(result.stdout.tail),
+                            stderr: clipCommandOutput(result.stderr.tail),
                         },
                     };
                 }

package/build/core/settlement/petition-preview.js

@@ -55,7 +55,7 @@ export async function previewPetition(input) {
     let seal;
     if (freshness.result === "pass" && arc.result === "pass" && state.result === "pass") {
         try {
-            const sealPreview = await previewSeal(context.deliveryCwd, context.ledger.entries, "HEAD", input.waivePaths);
+            const sealPreview = await previewSeal(context.deliveryCwd, context.ledger.entries, "HEAD");
             seal = { name: "seal", result: "pass", detail: sealPathDetail(sealPreview.paths) };
         }
         catch (error) {

package/build/core/settlement/petition.js

@@ -3,7 +3,7 @@ import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, wrapGitError
 import { parseCommandMarkdown } from "../command-markdown.js";
 import { activeLedgerRef, appendWithRetry, readLedger } from "../ledger.js";
 import { allocateSettlementSeat, queueMembership, readQueueReadModel } from "./queue.js";
-import { findOpenArc, getMaxArc, receiptsAfterFence, sealCurrentArc } from "../seal.js";
+import { appendScopeTerms, findOpenArc, getMaxArc, receiptsAfterFence, sealCurrentArc } from "../seal.js";
 import { deriveContractState } from "../status/lifecycle.js";
 import { commissionTarget, latestBase } from "../status/drift.js";
 import { findContractWorktreePath } from "../worktree-path.js";
@@ -73,13 +73,20 @@ export async function petitionContract(input) {
     await assertPetitionFresh(input.cwd, input.contractId, ledger.entries, base);
     await assertPetitionArcReady(deliveryCwd, input.contractId, ledger.entries);
     assertPetitionable(input.contractId, ledger.entries);
+    await appendScopeTerms({
+        cwd: input.cwd,
+        renderCwd: deliveryCwd,
+        contractId: input.contractId,
+        patterns: input.intent === "claim" ? input.appendScope : undefined,
+        actor: input.actor,
+        nowMs: input.nowMs,
+    });
     const sealed = await sealCurrentArc({
         cwd: deliveryCwd,
         renderCwd: deliveryCwd,
         contractId: input.contractId,
         sealedBy: "petition",
         nowMs: input.nowMs,
-        waivePaths: input.intent === "claim" ? input.waivePaths : undefined,
     });
     const allocated = await allocateSettlementSeat(input.cwd, {
         target: target.ref,
@@ -148,6 +155,6 @@ export function buildPetitionClaimInput(input) {
         plea: `Settle contract ${input.contractId} through the petition pipeline.`,
         oath,
         signal: input.signal,
-        waivePaths: input.waivePaths,
+        appendScope: input.appendScope,
     };
 }

package/build/core/settlement/settlement.js

@@ -1,5 +1,3 @@
-import { assertSettingsKnobUsable } from "../../config/settings/disease.js";
-import { loadKeiyakuSettings } from "../../config/settings/loader.js";
 import { FlowError } from "../../flow-error.js";
 import { readCurrentContractContext } from "../context.js";
 import { readLedger } from "../ledger.js";
@@ -13,6 +11,7 @@ import { scopePathEvidence } from "../scope.js";
 import { nextReviewResponseNumber } from "../transcripts.js";
 import { claimContract } from "./claim.js";
 import { buildClaimGatePipeline, } from "./petition-claim-gates.js";
+import { resolveVerificationCommands } from "./verification.js";
 import { forfeitKeiyaku } from "./petition-forfeit.js";
 import { assertHeadUnchanged } from "./petition-head-guard.js";
 import { petitionContract } from "./petition.js";
@@ -23,13 +22,7 @@ async function resolveClaimGateConfig(cwd) {
         verificationCommands: [],
     };
     try {
-        const loaded = await loadKeiyakuSettings(cwd);
-        assertSettingsKnobUsable(loaded, "gate");
-        const gate = loaded.knobs?.gate;
-        if (!gate) {
-            return merged;
-        }
-        merged.verificationCommands = gate.commands ?? merged.verificationCommands;
+        merged.verificationCommands = await resolveVerificationCommands(cwd);
         return merged;
     }
     catch (error) {
@@ -255,7 +248,7 @@ export async function claimKeiyaku(input, context, dependencies) {
         nowMs: Date.now(),
         intent: "claim",
         oath,
-        waivePaths: input.waivePaths,
+        appendScope: input.appendScope,
     });
     // 2. Pure verdict: judgment facts only; no claim execution.
     // Capture one clock for verdict + claim so ledger timestamps match the prior

package/build/core/settlement/verification.js

@@ -0,0 +1,59 @@
+import { spawn } from "node:child_process";
+import { getConfig } from "../../config/env.js";
+import { assertSettingsKnobUsable } from "../../config/settings/disease.js";
+import { loadKeiyakuSettings } from "../../config/settings/loader.js";
+import { FlowError } from "../../flow-error.js";
+const AUDIT_OUTPUT_TAIL_BYTES = 8_192;
+function tail(value, limit = AUDIT_OUTPUT_TAIL_BYTES) {
+    if (value.byteLength <= limit) {
+        return { tail: value.toString("utf8"), truncated: false, omittedBytes: 0 };
+    }
+    return {
+        tail: value.subarray(value.byteLength - limit).toString("utf8"),
+        truncated: true,
+        omittedBytes: value.byteLength - limit,
+    };
+}
+export function verificationExecutor(command) {
+    const basename = command.command.split(/[\\/]/).pop() ?? "";
+    const executor = basename.toLowerCase().replace(/\.exe$/, "");
+    if (executor !== "bash" && executor !== "zsh" && executor !== "pwsh") {
+        return { cause: "unsupported_executor" };
+    }
+    const bodyIndex = command.args.findIndex((arg) => arg === "-c" || arg === "-lc" || arg === "-Command");
+    const body = bodyIndex < 0 ? undefined : command.args[bodyIndex + 1];
+    if (body === undefined)
+        return { cause: "missing_command_body" };
+    return { executor, body };
+}
+export async function resolveVerificationCommands(cwd) {
+    const loaded = await loadKeiyakuSettings(cwd);
+    assertSettingsKnobUsable(loaded, "gate");
+    return loaded.knobs?.gate?.commands ?? [];
+}
+export async function runVerificationCommand(cwd, verification) {
+    const started = process.hrtime.bigint();
+    return await new Promise((resolve, reject) => {
+        const child = spawn(verification.command, verification.args, {
+            cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: getConfig().runtimeEnv,
+        });
+        const stdout = [];
+        const stderr = [];
+        child.stdout.on("data", (chunk) => stdout.push(Buffer.from(chunk)));
+        child.stderr.on("data", (chunk) => stderr.push(Buffer.from(chunk)));
+        child.on("error", reject);
+        child.on("close", (code) => {
+            const durationMs = Number((process.hrtime.bigint() - started) / 1000000n);
+            resolve({
+                code: typeof code === "number" ? code : -1,
+                durationMs,
+                stdout: tail(Buffer.concat(stdout)),
+                stderr: tail(Buffer.concat(stderr)),
+            });
+        });
+    }).catch((error) => {
+        throw new FlowError("CLOSE_QUALITY_GATE_FAILED", `verification '${verification.label}' could not start`, { cause: error });
+    });
+}