@astrosheep/keiyaku 0.1.47 → 0.1.49

package/build/utils/keiyaku-document/render.js

@@ -0,0 +1,68 @@
+function renderListItemFirstLine(item) {
+    const content = renderNodeContent(item);
+    if (!content) {
+        return `${" ".repeat(item.indent)}${item.marker}`;
+    }
+    const [firstLine, ...rest] = content.split("\n");
+    const prefix = `${" ".repeat(item.indent)}${item.marker}${firstLine.length > 0 ? " " : ""}${firstLine}`;
+    if (rest.length === 0) {
+        return prefix;
+    }
+    return [prefix, ...rest].join("\n");
+}
+export function renderBlock(node) {
+    switch (node.type) {
+        case "section": {
+            const header = `${"#".repeat(node.level)} ${node.title}`;
+            const body = renderNodeContent(node);
+            return body ? `${header}\n${body}` : header;
+        }
+        case "list":
+            return node.items.map((item) => renderListItemFirstLine(item)).join("\n");
+        case "code_block":
+            return node.lines.join("\n");
+        case "blockquote":
+            return node.lines.map((line) => `${node.marker}${line}`).join("\n");
+        case "text":
+            return node.value;
+        case "heading":
+            return `${"#".repeat(node.level)} ${node.text}`;
+    }
+}
+export function renderNodeContent(node) {
+    switch (node.type) {
+        case "document":
+            return node.children.map((child) => renderBlock(child)).join("\n");
+        case "section":
+            return node.children.map((child) => renderBlock(child)).join("\n");
+        case "list":
+            return renderBlock(node);
+        case "list_item":
+            return node.children.map((child) => renderBlock(child)).join("\n");
+        case "code_block":
+            return node.lines.join("\n");
+        case "blockquote":
+            return node.lines.map((line) => `${node.marker}${line}`).join("\n");
+        case "text":
+            return node.value;
+        case "heading":
+            return `${"#".repeat(node.level)} ${node.text}`;
+    }
+}
+export function renderSectionContent(sectionNode) {
+    return sectionNode.children.map((child) => renderBlock(child)).join("\n");
+}
+export function extractListItems(sectionNode) {
+    const items = [];
+    for (const child of sectionNode.children) {
+        if (child.type !== "list")
+            continue;
+        for (const item of child.items) {
+            const rendered = renderNodeContent(item).trimEnd();
+            if (rendered.trim().length > 0) {
+                items.push(rendered);
+            }
+        }
+    }
+    return items;
+}

package/build/utils/keiyaku-document/sections.js

@@ -0,0 +1,105 @@
+import { parseToAST } from "./parser.js";
+import { extractListItems, renderBlock, renderSectionContent } from "./render.js";
+import { KeiyakuParseError } from "./types.js";
+function normalizeSectionTitle(title) {
+    return title.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function splitByHeadingBlocks(sectionNode) {
+    const groups = [];
+    let currentGroup = [];
+    const commitGroup = () => {
+        if (currentGroup.length === 0)
+            return;
+        const rendered = currentGroup.map((node) => renderBlock(node)).join("\n").trim();
+        if (rendered.length > 0) {
+            groups.push(rendered);
+        }
+        currentGroup = [];
+    };
+    for (const child of sectionNode.children) {
+        if (child.type === "heading" && child.level >= 2) {
+            commitGroup();
+            currentGroup = [child];
+            continue;
+        }
+        currentGroup.push(child);
+    }
+    commitGroup();
+    return groups;
+}
+export function hasTopLevelHeaders(text) {
+    const ast = parseToAST(text, { allowSections: false });
+    return (() => {
+        const stack = [ast];
+        while (stack.length > 0) {
+            const node = stack.pop();
+            if (!node)
+                continue;
+            if (node.type === "heading" && node.level <= 2)
+                return true;
+            // We intentionally do not inspect code block lines for headings.
+            if (node.type === "code_block" || node.type === "text")
+                continue;
+            if (node.type === "document" || node.type === "section" || node.type === "list_item") {
+                stack.push(...node.children);
+            }
+            else if (node.type === "list") {
+                stack.push(...node.items);
+            }
+        }
+        return false;
+    })();
+}
+export function parseMarkdownListSection(text) {
+    const ast = parseToAST(text, { allowSections: false });
+    const pseudoSection = {
+        type: "section",
+        level: 2,
+        title: "",
+        children: ast.children,
+    };
+    const listItems = extractListItems(pseudoSection);
+    if (listItems.length > 0) {
+        return listItems;
+    }
+    const nonHeadingSection = {
+        type: "section",
+        level: 2,
+        title: "",
+        children: pseudoSection.children.filter((child) => child.type !== "heading"),
+    };
+    const fallback = renderSectionContent(nonHeadingSection).trim();
+    return fallback ? [fallback] : [];
+}
+export function parseMarkdownSections(text) {
+    const ast = parseToAST(text, { allowSections: false });
+    const pseudoSection = {
+        type: "section",
+        level: 2,
+        title: "",
+        children: ast.children,
+    };
+    return splitByHeadingBlocks(pseudoSection);
+}
+export function parseMarkdownStructure(content) {
+    const ast = parseToAST(content);
+    const sections = new Map();
+    let title;
+    for (const node of ast.children) {
+        if (node.type !== "section")
+            continue;
+        if (node.level === 1 && !title) {
+            title = node.title.trim() || undefined;
+            continue;
+        }
+        if (node.level !== 2)
+            continue;
+        const normalizedSection = normalizeSectionTitle(node.title);
+        if (sections.has(normalizedSection)) {
+            throw new KeiyakuParseError(`invalid keiyaku draft: duplicate section header '${normalizedSection}'`);
+        }
+        const body = renderSectionContent(node).trim();
+        sections.set(normalizedSection, body ? body.split("\n") : []);
+    }
+    return { title, sections };
+}

package/build/utils/keiyaku-document/types.js

@@ -0,0 +1,6 @@
+export class KeiyakuParseError extends Error {
+    constructor(message, cause) {
+        super(message, cause === undefined ? undefined : { cause });
+        this.name = "KeiyakuParseError";
+    }
+}

package/build/utils/keiyaku-document.test.js

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { extractListItems, hasTopLevelHeaders, KeiyakuParseError, parseToAST, parseMarkdownStructure, parseMarkdownListSection, renderSectionContent, } from "./keiyaku-document.js";
+import { extractListItems, hasTopLevelHeaders, KeiyakuParseError, parseToAST, parseMarkdownStructure, parseMarkdownListSection, renderSectionContent, } from "./keiyaku-document/index.js";
 import { computeHeadingDelta, demoteMarkdownHeadings, renderMarkdownSections, } from "../workflow/markdown-normalization.js";
 test("parseToAST models H1/H2 sections and keeps H3+ headers as heading nodes", () => {
     const markdown = [
@@ -55,6 +55,17 @@ test("parseToAST keeps fenced code blocks as structured nodes", () => {
     assert.equal(section.children[0]?.type === "code_block" ? section.children[0].lines.join("\n") : "", "```md\n## Not A Section\n```");
     assert.equal(section.children[1]?.type === "text" ? section.children[1].value : "", "After fence.");
 });
+test("parseToAST keeps blockquote blocks as structured nodes", () => {
+    const markdown = ["## Summary", "> ## Outcome", "> Implemented parser.", ">", "> ## Changes", "> - Added tests."].join("\n");
+    const ast = parseToAST(markdown);
+    const section = ast.children[0];
+    assert.equal(section?.type, "section");
+    if (section?.type !== "section")
+        return;
+    assert.equal(section.children[0]?.type, "blockquote");
+    assert.equal(section.children[0]?.type === "blockquote" ? section.children[0].value : "", "## Outcome\nImplemented parser.\n\n## Changes\n- Added tests.");
+    assert.equal(section.children[0]?.type === "blockquote" ? renderSectionContent(section) : "", "> ## Outcome\n> Implemented parser.\n> \n> ## Changes\n> - Added tests.");
+});
 test("parseMarkdownListSection flattens list items and ignores source headers", () => {
     const markdown = [
         "## Group A",

package/build/utils/trace.js

@@ -2,10 +2,12 @@ import * as fs from "fs/promises";
 import * as path from "path";
 import { TRACE_FILE } from "../common/constants.js";
 import { RESPONSE_MARKERS } from "../common/response-style.js";
-import { parseToAST } from "./keiyaku-document.js";
+import { parseToAST } from "./keiyaku-document/index.js";
 const DIFF_COORDINATES_SECTION_PREFIX = "Diff Coordinates";
 const DIFF_COORDINATES_FENCE = "```keiyaku-coords";
 const DIFF_COORDINATE_LINE_RE = /^(.*):(\d+)(?:-(\d+))?$/;
+const BLOCKQUOTE_PREFIX = "> ";
+const EMPTY_BLOCKQUOTE_LINE = ">";
 async function fileExists(cwd, filepath) {
     try {
         await fs.access(path.join(cwd, filepath));
@@ -33,6 +35,7 @@ export async function appendReview(cwd, round, reason) {
 export async function appendRoundReport(cwd, report) {
     const summaryText = report.summary.trim().length > 0 ? report.summary : "Unknown error.";
     const tracePath = path.join(cwd, TRACE_FILE);
+    const quotedSummary = summaryText.split(/\r?\n/).map((line) => (line.length > 0 ? `${BLOCKQUOTE_PREFIX}${line}` : EMPTY_BLOCKQUOTE_LINE));
     const lines = [
         "",
         "---",
@@ -41,9 +44,7 @@ export async function appendRoundReport(cwd, report) {
         "### Status",
         report.status,
         "### Summary",
-        "```markdown",
-        summaryText,
-        "```",
+        ...quotedSummary,
     ];
     if (report.errorMessage) {
         lines.push("### Error", report.errorMessage);
@@ -62,9 +63,7 @@ export async function appendRoundSystemNote(cwd, round, note) {
         "### Status",
         "FAILED",
         "### Summary",
-        "```markdown",
-        "Subagent execution cancelled by user/client.",
-        "```",
+        `${BLOCKQUOTE_PREFIX}Subagent execution cancelled by user/client.`,
         "### Error",
         note,
         "",

package/build/workflow/ask-execution.js

@@ -0,0 +1,81 @@
+import { TRACE_FILE } from "../common/constants.js";
+import { appendAsk } from "../utils/trace.js";
+import { appendDebugLog } from "../utils/debug-log.js";
+import { logWarn } from "../utils/logger.js";
+import { runAsk } from "./ask.js";
+import { assertKeiyakuProtocolFiles } from "./keiyaku.js";
+import { persistAskHistory } from "../utils/ask-history.js";
+import * as git from "../utils/git.js";
+const ASK_TRACE_COMMIT_PREFIX = "ask: ";
+const ASK_TRACE_COMMIT_SUMMARY_MAX_CHARS = 50;
+function buildAskTraceCommitMessage(request) {
+    const summary = request.replaceAll(/\s+/g, " ").trim().slice(0, ASK_TRACE_COMMIT_SUMMARY_MAX_CHARS);
+    return `${ASK_TRACE_COMMIT_PREFIX}${summary}`;
+}
+export async function runAskAndPersist(input) {
+    const result = await runAsk(input);
+    let warning;
+    let savedTo;
+    try {
+        let commit;
+        try {
+            commit = await git.getLatestCommitHash(input.cwd);
+        }
+        catch {
+            // Ask can run outside git repos; history should still be persisted.
+            commit = undefined;
+        }
+        savedTo = await persistAskHistory({
+            cwd: input.cwd,
+            request: input.request,
+            context: input.context,
+            summary: result.summary,
+            sessionId: input.sessionId,
+            branch: result.currentBranch,
+            commit,
+        });
+    }
+    catch (historyError) {
+        const historyErrorMessage = historyError instanceof Error ? historyError.message : String(historyError);
+        appendDebugLog(`tool ask history logging failed: ${historyErrorMessage}`, {
+            cwd: input.cwd,
+            section: "script",
+        });
+        warning = `Failed to persist ask history: ${historyErrorMessage}`;
+    }
+    try {
+        await appendAsk(input.cwd, {
+            request: input.request,
+            context: input.context,
+            summary: result.summary,
+            diffStats: result.diffStats,
+        });
+        try {
+            const activeState = await git.getActiveKeiyakuGitState(input.cwd);
+            if (activeState) {
+                await assertKeiyakuProtocolFiles(input.cwd);
+                try {
+                    await git.addFiles(input.cwd, TRACE_FILE);
+                    await git.commit(input.cwd, buildAskTraceCommitMessage(input.request));
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    const commitWarning = `Failed to commit ask trace update: ${message}`;
+                    logWarn(commitWarning, { cwd: input.cwd, section: "script" });
+                    warning = warning ? `${warning}\n${commitWarning}` : commitWarning;
+                }
+            }
+        }
+        catch {
+            // Non-active keiyaku or missing protocol files should not block ask.
+        }
+    }
+    catch (askTraceError) {
+        const askTraceErrorMessage = askTraceError instanceof Error ? askTraceError.message : String(askTraceError);
+        appendDebugLog(`tool ask trace logging failed: ${askTraceErrorMessage}`, {
+            cwd: input.cwd,
+            section: "script",
+        });
+    }
+    return { result, warning, savedTo };
+}

package/build/workflow/drive.js

@@ -1,17 +1,18 @@
 import * as fs from "fs/promises";
 import * as path from "path";
-import { KEIYAKU_BRANCH_PREFIX, KEIYAKU_DRAFT_FILE, KEIYAKU_FILE, TRACE_FILE } from "../common/constants.js";
+import { INCREMENTAL_DIFF_MAX_CHARS, KEIYAKU_BRANCH_PREFIX, KEIYAKU_DRAFT_FILE, KEIYAKU_FILE, TRACE_FILE, } from "../common/constants.js";
 import { FlowError, requireText, wrapFlowError } from "../common/errors.js";
 import { appendRoundSystemNote, appendReview, computeTraceState, parseDiffCoordinates, readTraceContent, } from "../utils/trace.js";
 import * as git from "../utils/git.js";
-import { KeiyakuParseError, parseMarkdownStructure } from "../utils/keiyaku-document.js";
+import { KeiyakuParseError, parseMarkdownStructure } from "../utils/keiyaku-document/index.js";
 import { logWarn } from "../utils/logger.js";
 import { renderToolRoundSummary } from "./round-summary.js";
-import { assertCleanWorkingTree, buildNoActiveKeiyakuGuidance, ensureKeiyakuFiles } from "./contract.js";
+import { assertCleanWorkingTree, assertKeiyakuProtocolFiles, buildNoActiveKeiyakuGuidance } from "./keiyaku.js";
 import { buildRoundCommitMessage, runAndRecordRound } from "./round.js";
 import { resolveIncrementalDiffMode } from "../config/incremental-diff-mode.js";
 import { buildIteratePlan } from "./iterate-plan.js";
 import { readBaseRules } from "./base-rules.js";
+import { resolveWorkflowHints } from "./response-meta.js";
 function normalizeSectionTitle(title) {
     return title.trim().toLowerCase().replace(/\s+/g, " ");
 }
@@ -57,7 +58,7 @@ export async function driveServant(input) {
         throw new FlowError("MISSING_KEIYAKU_BASE", `branch ${keiyakuBranch} is missing base metadata; cannot continue drive`);
     }
     await assertCleanWorkingTree(cwd, [KEIYAKU_DRAFT_FILE]);
-    await ensureKeiyakuFiles(cwd);
+    await assertKeiyakuProtocolFiles(cwd);
     const keiyakuContent = await fs.readFile(path.join(cwd, KEIYAKU_FILE), "utf-8");
     const parsedKeiyaku = parseKeiyakuStructure(keiyakuContent);
     const traceContent = await readTraceContent(cwd);
@@ -94,7 +95,10 @@ export async function driveServant(input) {
                 coordinates = undefined;
             }
         }
-        const diff = await git.getIncrementalDiff(cwd, incrementalDiffMode, coordinates);
+        const diff = await git.getIncrementalDiff(cwd, incrementalDiffMode, {
+            coordinates,
+            maxChars: INCREMENTAL_DIFF_MAX_CHARS,
+        });
         return {
             status: "success",
             round: plan.targetRound,
@@ -103,6 +107,7 @@ export async function driveServant(input) {
             currentBranch: keiyakuBranch,
             baseBranch,
             commit,
+            meta: { hints: resolveWorkflowHints("drive") },
         };
     }
     catch (err) {

package/build/workflow/iterate-plan.js

@@ -1,6 +1,6 @@
 import { ITERATE_PRIOR_ROUND_SUMMARY_COUNT } from "../common/constants.js";
 import { FlowError } from "../common/errors.js";
-import { parseToAST, renderSectionContent } from "../utils/keiyaku-document.js";
+import { parseToAST, renderSectionContent } from "../utils/keiyaku-document/index.js";
 import { buildIteratePrompt } from "./prompts.js";
 function readRoundSectionNumber(title) {
     const match = /^round\s+(\d+)$/i.exec(title.trim());

package/build/workflow/keiyaku-draft.js

@@ -1,5 +1,5 @@
 import { FlowError } from "../common/errors.js";
-import { KeiyakuParseError, parseToAST, renderSectionContent, } from "../utils/keiyaku-document.js";
+import { KeiyakuParseError, parseToAST, renderSectionContent, } from "../utils/keiyaku-document/index.js";
 import { computeHeadingDelta } from "./markdown-normalization.js";
 const KNOWN_DRAFT_SECTIONS = new Set([
     "goal",

package/build/workflow/{contract.js → keiyaku.js}

@@ -1,13 +1,13 @@
 import * as fs from "fs/promises";
 import * as path from "path";
-import { resolveTermPreset } from "../config/term-presets.js";
+import { resolveTermPreset } from "../config/term-presets/index.js";
 import { KEIYAKU_FILE, TRACE_FILE } from "../common/constants.js";
 import { FlowError } from "../common/errors.js";
 import * as git from "../utils/git.js";
 import { resolveOath } from "./oath.js";
 export { resolveOath };
 const DIRTY_WORKTREE_LIST_LIMIT = 10;
-export async function ensureKeiyakuFiles(cwd) {
+export async function assertKeiyakuProtocolFiles(cwd) {
     const keiyakuPath = path.join(cwd, KEIYAKU_FILE);
     const tracePath = path.join(cwd, TRACE_FILE);
     try {

package/build/workflow/markdown-normalization.js

@@ -1,4 +1,4 @@
-import { parseToAST, renderNodeContent, } from "../utils/keiyaku-document.js";
+import { parseToAST, renderNodeContent, } from "../utils/keiyaku-document/index.js";
 export function computeHeadingDelta(shallowest, minLevel) {
     if (shallowest === null || shallowest >= minLevel) {
         return 0;
@@ -19,7 +19,7 @@ export function demoteMarkdownHeadings(text, minLevel = 3) {
             if (node.type === "heading") {
                 shallowest = shallowest === null ? node.level : Math.min(shallowest, node.level);
             }
-            if (node.type === "code_block" || node.type === "text")
+            if (node.type === "code_block" || node.type === "blockquote" || node.type === "text")
                 continue;
             if (node.type === "document" || node.type === "section" || node.type === "list_item") {
                 stack.push(...node.children);
@@ -41,6 +41,7 @@ export function demoteMarkdownHeadings(text, minLevel = 3) {
                 return nextLevel === node.level ? node : { ...node, level: nextLevel };
             }
             case "code_block":
+            case "blockquote":
             case "text":
                 return node;
             case "document":

package/build/workflow/present.js

@@ -1,13 +1,15 @@
 import * as fs from "fs/promises";
 import * as path from "path";
+import { spawn } from "node:child_process";
 import { KEIYAKU_ARCHIVE_TAG_PREFIX, KEIYAKU_BRANCH_PREFIX, KEIYAKU_DRAFT_FILE, KEIYAKU_FILE, TRACE_FILE, } from "../common/constants.js";
-import { resolveTermPreset } from "../config/term-presets.js";
+import { resolveTermPreset } from "../config/term-presets/index.js";
 import { logInfo, logWarn } from "../utils/logger.js";
 import { FlowError, wrapFlowError } from "../common/errors.js";
+import { readDraftSnapshot, restoreDraftSnapshot } from "../utils/draft.js";
 import * as git from "../utils/git.js";
 import { appendVerdict, computeTraceState, readTraceContent } from "../utils/trace.js";
 import { oathMatches } from "./oath.js";
-import { assertCleanWorkingTree, buildNoActiveKeiyakuGuidance, ensureKeiyakuFiles, resolveOath } from "./contract.js";
+import { assertCleanWorkingTree, assertKeiyakuProtocolFiles, buildNoActiveKeiyakuGuidance, resolveOath } from "./keiyaku.js";
 const DIMENSIONS = [
     "placement",
     "exactness",
@@ -32,6 +34,10 @@ const DIMENSION_STANDARDS = {
 const VERDICT_DENIED_CODE = "VERDICT_DENIED";
 const VERDICT_SETTINGS_FILE = path.join(".keiyaku", "settings.json");
 const DIMENSION_KEY_SET = new Set(DIMENSIONS);
+const CLAIM_VERIFICATION_COMMANDS = [
+    { command: "npm", args: ["test"], label: "npm test" },
+    { command: "npm", args: ["run", "test:typecheck"], label: "npm run test:typecheck" },
+];
 function clampThreshold(value, fallback) {
     if (typeof value !== "number" || !Number.isFinite(value))
         return fallback;
@@ -118,6 +124,58 @@ function collectScores(input) {
         cohesive: input.cohesive,
     };
 }
+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: process.env,
+        });
+        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 = 1200) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return "(no output)";
+    if (trimmed.length <= maxChars)
+        return trimmed;
+    return `${trimmed.slice(0, maxChars)}\n… (+${trimmed.length - maxChars} chars)`;
+}
+async function runClaimVerificationGate(cwd) {
+    for (const command of CLAIM_VERIFICATION_COMMANDS) {
+        logInfo(`[CLAIM] Running verification: ${command.label}`, { cwd, section: "script", progressOnly: true });
+        const result = await runCommand({
+            cwd,
+            command: command.command,
+            args: command.args,
+        });
+        if (result.code !== 0) {
+            throw new FlowError("CLOSE_QUALITY_GATE_FAILED", `CLAIM blocked: verification failed at '${command.label}' (exit ${result.code}).`, {
+                suggestion: [
+                    `Fix failures from '${command.label}', then retry CLAIM.`,
+                    `stdout:\n${clipCommandOutput(result.stdout)}`,
+                    `stderr:\n${clipCommandOutput(result.stderr)}`,
+                ].join("\n\n"),
+            });
+        }
+    }
+}
 export function buildCommandmentFailureMessage(violationTitle, score, threshold, definition, driveCommandName) {
     return `${violationTitle} score too low (${score} < ${threshold})\n${definition}\nIdentify what needs to change to meet this standard. Then use \`${driveCommandName}\` to implement those improvements in the code. Score edits without new implementation evidence are treated as oath violation.`;
 }
@@ -155,14 +213,7 @@ export async function presentWork(input) {
     }
     const title = keiyakuBranch.slice(KEIYAKU_BRANCH_PREFIX.length);
     const petition = input.petition;
-    let draftKept = false;
-    try {
-        const stat = await fs.stat(path.join(cwd, KEIYAKU_DRAFT_FILE));
-        draftKept = stat.isFile();
-    }
-    catch {
-        // ignored
-    }
+    const draftSnapshot = await readDraftSnapshot(cwd);
     if (petition === "FORFEIT") {
         const archiveTag = `${KEIYAKU_ARCHIVE_TAG_PREFIX}${title}`;
         let round = 0;
@@ -181,6 +232,9 @@ export async function presentWork(input) {
                 await git.discardAllWorkingTreeChanges(cwd);
             }
             await git.checkoutBranch(cwd, baseBranch);
+            if (draftSnapshot) {
+                await restoreDraftSnapshot(cwd, draftSnapshot);
+            }
             await git.deleteBranch(cwd, keiyakuBranch, true);
             await git.clearKeiyakuBase(cwd, keiyakuBranch);
         }
@@ -199,10 +253,10 @@ export async function presentWork(input) {
                 ? `Forfeited without merge. Dropped ${droppedChanges.length} local change(s).`
                 : "Forfeited without merge.",
             droppedChanges,
-            draftKept,
+            draftPath: draftSnapshot?.path ?? null,
         };
     }
-    await ensureKeiyakuFiles(cwd);
+    await assertKeiyakuProtocolFiles(cwd);
     let traceContent = await readTraceContent(cwd);
     if (petition === "CLAIM") {
         const driveCommandName = resolveTermPreset().tools.drive.name;
@@ -239,6 +293,7 @@ export async function presentWork(input) {
             await appendDeniedVerdictWithAuditCommit(cwd, title, scores, ["Oath mismatch."]);
             throw oathMismatchError;
         }
+        await runClaimVerificationGate(cwd);
         await assertCleanWorkingTree(cwd, [KEIYAKU_DRAFT_FILE]);
         try {
             const invokeDiffLog = `[CLAIM] Collecting diff preview against base '${baseBranch}'`;
@@ -282,7 +337,7 @@ export async function presentWork(input) {
                 mergedInto: baseBranch,
                 deletedBranch: keiyakuBranch,
                 diff,
-                draftKept,
+                draftPath: draftSnapshot?.path ?? null,
             };
         }
         catch (err) {