@astrosheep/keiyaku 2.9.3 → 2.9.4

package/build/agents/providers/codex-sdk.js

@@ -1,329 +0,0 @@
-import { z } from "zod";
-import { Codex, } from "@openai/codex-sdk";
-import { CODEX_MODEL_REASONING_EFFORT_CONFIG_KEY } from "../../keiyaku.js";
-import { appendDebugBlock, appendDebugLog } from "../../telemetry/debug-log.js";
-import { SUBAGENT_SESSION_VERSION } from "../session.js";
-import { createProjectionDriver } from "../harness/execution-handle.js";
-import { boundActivityExcerpt } from "../harness/activity-values.js";
-import { buildSubagentEnv, emitProviderEvidence, sha256Utf8 } from "../harness/runtime.js";
-import { coerceString } from "../harness/runtime.js";
-import { AGENT_PLAN_ITEM_TEXT_MAX_CHARS, AGENT_PLAN_MAX_ITEMS, AGENT_THOUGHT_TEXT_MAX_CHARS, } from "../harness/events.js";
-import { appendEventType, renderEventTypeSummary } from "./event-type-tail.js";
-/** Identity-only opacity boundary for Codex SDK ThreadOptions modelReasoningEffort. */
-function toCodexSdkModelReasoningEffort(effort) {
-    return effort;
-}
-function withCodexSdkModelReasoningEffort(threadOptions) {
-    const raw = threadOptions.modelReasoningEffort;
-    if (typeof raw !== "string")
-        return threadOptions;
-    return {
-        ...threadOptions,
-        modelReasoningEffort: toCodexSdkModelReasoningEffort(raw),
-    };
-}
-let codexConstructor = Codex;
-function getCodexConstructor(override) {
-    if (override)
-        return override;
-    return codexConstructor;
-}
-/** @deprecated Use CodexSdkOptions.codexConstructor instead. */
-export function setCodexSdkConstructorForTests(constructor) {
-    codexConstructor = constructor;
-}
-/** @deprecated Use CodexSdkOptions.codexConstructor instead. */
-export function resetCodexSdkConstructorForTests() {
-    codexConstructor = Codex;
-}
-export const codexThreadSchema = z.object({ threadId: z.string().trim().min(1) });
-const CODEX_EVENT_THREAD_STARTED = "thread.started";
-const CODEX_EVENT_TURN_STARTED = "turn.started";
-const CODEX_EVENT_TURN_FAILED = "turn.failed";
-const CODEX_EVENT_ERROR = "error";
-const CODEX_EVENT_ITEM_STARTED = "item.started";
-const CODEX_EVENT_ITEM_COMPLETED = "item.completed";
-const CODEX_EVENT_ITEM_UPDATED = "item.updated";
-const CODEX_EVENT_TURN_COMPLETED = "turn.completed";
-const CODEX_SDK_PROVIDER = "codex-sdk";
-const CODEX_SDK_ACKNOWLEDGED_UNPERSISTED = new Set([CODEX_EVENT_THREAD_STARTED]);
-const CODEX_SDK_MAPPED = new Set([
-    CODEX_EVENT_TURN_STARTED,
-    CODEX_EVENT_TURN_COMPLETED,
-    CODEX_EVENT_TURN_FAILED,
-    CODEX_EVENT_ERROR,
-    CODEX_EVENT_ITEM_STARTED,
-    CODEX_EVENT_ITEM_UPDATED,
-    CODEX_EVENT_ITEM_COMPLETED,
-]);
-function codexSdkIngressDisposition(type) {
-    if (CODEX_SDK_ACKNOWLEDGED_UNPERSISTED.has(type))
-        return "acknowledged-unpersisted";
-    if (CODEX_SDK_MAPPED.has(type))
-        return "mapped";
-    return "unknown";
-}
-function extractAgentMessage(event) {
-    if (event.type !== CODEX_EVENT_ITEM_COMPLETED && event.type !== CODEX_EVENT_ITEM_UPDATED) {
-        return undefined;
-    }
-    if (event.item.type !== "agent_message")
-        return undefined;
-    const text = coerceString(event.item.text);
-    if (!text)
-        return undefined;
-    return { id: event.item.id, text };
-}
-function codexActivityCall(item) {
-    switch (item.type) {
-        case "command_execution": return { kind: "run", command: item.command };
-        case "file_change": return {
-            kind: "fileChange",
-            changes: item.changes.map((change) => ({ op: change.kind, path: change.path })),
-        };
-        case "mcp_tool_call": return { kind: "other", display: `${item.server}.${item.tool}` };
-        case "web_search": return { kind: "search", query: item.query };
-    }
-}
-function codexMcpResultMessage(item) {
-    if (item.error?.message)
-        return boundActivityExcerpt(item.error.message);
-    const text = item.result?.content.flatMap((block) => (block.type === "text" && typeof block.text === "string" ? [block.text] : [])).join("\n");
-    return text ? boundActivityExcerpt(text) : undefined;
-}
-function codexActivityResult(item) {
-    switch (item.type) {
-        case "command_execution": return {
-            status: item.status === "failed" || (item.exit_code !== undefined && item.exit_code !== 0) ? "error" : "ok",
-            ...(item.aggregated_output ? { message: boundActivityExcerpt(item.aggregated_output) } : {}),
-            ...(item.exit_code === undefined ? {} : { exitCode: item.exit_code }),
-        };
-        case "file_change": return { status: item.status === "failed" ? "error" : "ok" };
-        case "mcp_tool_call": {
-            const message = codexMcpResultMessage(item);
-            return { status: item.status === "failed" ? "error" : "ok", ...(message ? { message } : {}) };
-        }
-        case "web_search": return { status: "ok" };
-    }
-}
-function emitCodexSemanticEvent(builder, event) {
-    if (event.type === CODEX_EVENT_TURN_STARTED) {
-        builder.emit({ type: "turn", phase: "started" });
-        return;
-    }
-    if (event.type === CODEX_EVENT_TURN_COMPLETED) {
-        builder.emit({
-            type: "usage",
-            inputTokens: event.usage.input_tokens,
-            outputTokens: event.usage.output_tokens,
-            cachedInputTokens: event.usage.cached_input_tokens,
-        });
-        builder.emit({ type: "turn", phase: "completed" });
-        return;
-    }
-    if (event.type !== CODEX_EVENT_ITEM_STARTED &&
-        event.type !== CODEX_EVENT_ITEM_UPDATED &&
-        event.type !== CODEX_EVENT_ITEM_COMPLETED) {
-        return;
-    }
-    if (event.item.type === "reasoning" &&
-        (event.type === CODEX_EVENT_ITEM_UPDATED || event.type === CODEX_EVENT_ITEM_COMPLETED)) {
-        const truncated = event.item.text.length > AGENT_THOUGHT_TEXT_MAX_CHARS;
-        builder.emit({
-            type: "thought",
-            id: event.item.id,
-            text: event.item.text.slice(0, AGENT_THOUGHT_TEXT_MAX_CHARS),
-            final: event.type === CODEX_EVENT_ITEM_COMPLETED,
-            ...(truncated ? { truncated: true } : {}),
-        });
-        return;
-    }
-    if (event.item.type === "todo_list") {
-        builder.emit({
-            type: "plan",
-            id: event.item.id,
-            items: event.item.items.slice(0, AGENT_PLAN_MAX_ITEMS).map((item) => ({
-                text: item.text.slice(0, AGENT_PLAN_ITEM_TEXT_MAX_CHARS),
-                done: item.completed,
-            })),
-        });
-        return;
-    }
-    if (event.item.type !== "command_execution" &&
-        event.item.type !== "file_change" &&
-        event.item.type !== "mcp_tool_call" &&
-        event.item.type !== "web_search") {
-        return;
-    }
-    const phase = event.type === CODEX_EVENT_ITEM_STARTED
-        ? "started"
-        : event.type === CODEX_EVENT_ITEM_UPDATED
-            ? "updated"
-            : "completed";
-    builder.emit({
-        type: "activity",
-        phase,
-        id: event.item.id,
-        tool: event.item.type,
-        call: codexActivityCall(event.item),
-        ...(phase === "started" ? {} : { result: codexActivityResult(event.item) }),
-    });
-}
-/** @deprecated Use the codex-app-server adapter. */
-export async function startCodexSdk(prompt, cwd, options) {
-    const threadId = options.threadId?.trim();
-    const recordedEventTypes = [];
-    let totalEventCount = 0;
-    let activeAbort;
-    let runReturned = false;
-    appendDebugLog(`startCodexSdk: executable=${options.executable ?? "codex"} model=${options.model ?? "default"} ${CODEX_MODEL_REASONING_EFFORT_CONFIG_KEY}=${String(options.config?.[CODEX_MODEL_REASONING_EFFORT_CONFIG_KEY] ?? "default")} mode=${threadId ? "resume" : "fresh"}`, { cwd, section: CODEX_SDK_PROVIDER });
-    return createProjectionDriver({
-        steerMode: "replay",
-        initialTurn: options.initialTurn,
-        onIngress: options.onIngress,
-        async abort(mode) {
-            activeAbort?.abort();
-            if (mode === "force" && !runReturned) {
-                throw new Error("codex-sdk cannot guarantee forced termination");
-            }
-        },
-        async run(builder) {
-            activeAbort = new AbortController();
-            const linked = options.signal ?? builder.signal;
-            const onOuterAbort = () => activeAbort?.abort();
-            linked.addEventListener("abort", onOuterAbort, { once: true });
-            if (linked.aborted)
-                onOuterAbort();
-            builder.signal.addEventListener("abort", onOuterAbort, { once: true });
-            try {
-                const env = buildSubagentEnv();
-                const codexOptions = {
-                    codexPathOverride: options.executable,
-                    profile: options.profile,
-                    config: options.config,
-                    env,
-                };
-                const sdk = new (getCodexConstructor(options.codexConstructor))(codexOptions);
-                const threadOptions = withCodexSdkModelReasoningEffort(options.threadOptions);
-                const thread = threadId ? sdk.resumeThread(threadId, threadOptions) : sdk.startThread(threadOptions);
-                const streamed = await thread.runStreamed(prompt, { signal: activeAbort.signal });
-                const eventIterator = streamed.events[Symbol.asyncIterator]();
-                // The SDK iterable is lazy: its first next() starts the native run.
-                // Record outbound bytes immediately before that crossing, then ack only
-                // after it settles (including a legitimate no-event completion).
-                if (options.onEvidence) {
-                    emitProviderEvidence(options.onEvidence, {
-                        type: "outbound",
-                        provider: CODEX_SDK_PROVIDER,
-                        direction: "input",
-                        kind: "replay-prompt",
-                        ...sha256Utf8(prompt),
-                    }, (text) => builder.emit({ type: "diagnostic", text }));
-                }
-                const firstEvent = await eventIterator.next();
-                if (options.onEvidence) {
-                    emitProviderEvidence(options.onEvidence, {
-                        type: "ack",
-                        provider: CODEX_SDK_PROVIDER,
-                        fence: { kind: "ordinal", ordinal: 0 },
-                        outbound: "run",
-                    }, (text) => builder.emit({ type: "diagnostic", text }));
-                }
-                const events = async function* () {
-                    if (!firstEvent.done)
-                        yield firstEvent.value;
-                    while (true) {
-                        const next = await eventIterator.next();
-                        if (next.done)
-                            return;
-                        yield next.value;
-                    }
-                };
-                let resumeToken;
-                let lastAgentMessage;
-                let turnFailedMessage;
-                let streamErrorMessage;
-                for await (const event of events()) {
-                    if (activeAbort.signal.aborted) {
-                        throw Object.assign(new Error(`${CODEX_SDK_PROVIDER} exec cancelled by client`), { name: "AbortError" });
-                    }
-                    totalEventCount += 1;
-                    appendEventType(recordedEventTypes, event.type);
-                    builder.ingress(CODEX_SDK_PROVIDER, event.type, event, codexSdkIngressDisposition(event.type), () => {
-                        if (event.type === CODEX_EVENT_THREAD_STARTED) {
-                            resumeToken = event.thread_id;
-                            if (options.onEvidence)
-                                emitProviderEvidence(options.onEvidence, { type: "session", provider: CODEX_SDK_PROVIDER, threadId: resumeToken }, (text) => builder.emit({ type: "diagnostic", text }));
-                        }
-                        else if (event.type === CODEX_EVENT_TURN_STARTED && !resumeToken) {
-                            builder.emit({
-                                type: "fail",
-                                message: `${CODEX_SDK_PROVIDER} exec emitted turn.started before thread.started with thread_id`,
-                            });
-                            throw new Error(`${CODEX_SDK_PROVIDER} exec emitted turn.started before thread.started with thread_id`);
-                        }
-                        else if (event.type === CODEX_EVENT_TURN_FAILED) {
-                            turnFailedMessage = coerceString(event.error.message) ?? `${CODEX_SDK_PROVIDER} turn failed`;
-                        }
-                        else if (event.type === CODEX_EVENT_ERROR) {
-                            streamErrorMessage = coerceString(event.message) ?? `${CODEX_SDK_PROVIDER} stream error`;
-                            builder.emit({ type: "diagnostic", text: `${streamErrorMessage}\n` });
-                        }
-                        emitCodexSemanticEvent(builder, event);
-                        const message = extractAgentMessage(event);
-                        if (message) {
-                            lastAgentMessage = message.text;
-                            builder.emit({ type: "message", id: message.id, text: message.text });
-                        }
-                    });
-                }
-                if (turnFailedMessage) {
-                    builder.emit({ type: "diagnostic", text: turnFailedMessage });
-                    builder.emit({ type: "fail", message: turnFailedMessage });
-                    throw new Error(turnFailedMessage);
-                }
-                if (streamErrorMessage && !lastAgentMessage) {
-                    builder.emit({ type: "fail", message: streamErrorMessage });
-                    throw new Error(streamErrorMessage);
-                }
-                if (!resumeToken) {
-                    appendDebugLog(`Missing required codex event: ${CODEX_EVENT_THREAD_STARTED} with thread_id.`, {
-                        cwd,
-                        section: CODEX_SDK_PROVIDER,
-                    });
-                    appendDebugBlock("codex-sdk stdout event types", renderEventTypeSummary(recordedEventTypes, totalEventCount), {
-                        cwd,
-                        section: CODEX_SDK_PROVIDER,
-                    });
-                    builder.emit({
-                        type: "fail",
-                        message: `${CODEX_SDK_PROVIDER} exec succeeded but did not emit a ${CODEX_EVENT_THREAD_STARTED} event with thread_id`,
-                    });
-                    throw new Error(`${CODEX_SDK_PROVIDER} exec succeeded but did not emit a ${CODEX_EVENT_THREAD_STARTED} event with thread_id`);
-                }
-                const finalMessage = lastAgentMessage ?? "";
-                const session = {
-                    provider: "codex-sdk",
-                    version: SUBAGENT_SESSION_VERSION,
-                    handle: { threadId: resumeToken },
-                };
-                if (options.onEvidence)
-                    emitProviderEvidence(options.onEvidence, { type: "checkpoint", provider: CODEX_SDK_PROVIDER, fence: { kind: "ordinal", ordinal: 1 }, source: "response" }, (text) => builder.emit({ type: "diagnostic", text }));
-                builder.emit({
-                    type: "done",
-                    finalMessage,
-                    session,
-                });
-                return { finalMessage, session };
-            }
-            catch (error) {
-                appendDebugLog(`startCodexSdk error: ${error instanceof Error ? `${error.name}: ${error.message}` : String(error)}`, { cwd, section: CODEX_SDK_PROVIDER });
-                throw error;
-            }
-            finally {
-                runReturned = true;
-                linked.removeEventListener("abort", onOuterAbort);
-            }
-        },
-    });
-}

package/build/cli/commands/task/view/meta.js

@@ -1,8 +0,0 @@
-export const meta = {
-    command: "task view",
-    summary: "View one task",
-    usage: ["keiyaku task view [-C|--cwd DIR] ID [--json]"],
-    stdin: "none",
-    flags: ["cwd", "json"],
-    purpose: "Read one task from the working-tree board.",
-};

package/build/core/command-io.js

@@ -1,174 +0,0 @@
-import { ACTOR_IDENTITY } from "../keiyaku.js";
-import { FlowError } from "../flow-error.js";
-import { parseMarkdownListSection, parseMarkdownStructure } from "./markdown/sections.js";
-import { KeiyakuParseError } from "./markdown/types.js";
-import { normalizeSectionTitle } from "./markdown/titles.js";
-import { isBlankScopePatternLine, normalizeScopePattern, ScopePatternError } from "./scope.js";
-function amendScopeHeading(name) {
-    return `## Scope ${name[0].toUpperCase()}${name.slice(1)}`;
-}
-function sourceLines(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, end, next });
-        start = next;
-    }
-    return lines;
-}
-function amendHeading(line) {
-    const match = line.match(/^ {0,3}(#{1,2})(?!#)[ \t]+(.+)$/);
-    if (!match)
-        return null;
-    const level = match[1].length;
-    const title = normalizeSectionTitle(match[2]);
-    if (level !== 2)
-        return { level };
-    if (title === "scope add")
-        return { level, name: "add" };
-    return { level };
-}
-function amendFence(line) {
-    const match = line.match(/^ {0,3}(`{3,}|~{3,})/);
-    if (!match)
-        return null;
-    const marker = match[1];
-    return { delimiter: marker[0], length: marker.length };
-}
-function parseAmendScopeSections(markdown) {
-    const lines = sourceLines(markdown);
-    const sections = {};
-    let active;
-    let fence;
-    let frontMatterEnd = -1;
-    if (lines[0]?.text.trim() === "---") {
-        for (let index = 1; index < lines.length; index += 1) {
-            if (lines[index].text.trim() === "---") {
-                frontMatterEnd = index;
-                break;
-            }
-        }
-    }
-    const finishActive = (end) => {
-        if (!active)
-            return;
-        sections[active.name] = { ...active, end };
-        active = undefined;
-    };
-    for (let index = 0; index < lines.length; index += 1) {
-        const line = lines[index];
-        if (index <= frontMatterEnd)
-            continue;
-        const marker = amendFence(line.text);
-        if (fence) {
-            if (marker && marker.delimiter === fence.delimiter && marker.length >= fence.length) {
-                fence = undefined;
-            }
-            continue;
-        }
-        if (marker) {
-            fence = marker;
-            continue;
-        }
-        const heading = amendHeading(line.text);
-        if (!heading)
-            continue;
-        finishActive(line.start);
-        if (!heading.name)
-            continue;
-        if (sections[heading.name]) {
-            throw new FlowError("INVALID_KEIYAKU_DRAFT", `amend input may contain ${amendScopeHeading(heading.name)} at most once`);
-        }
-        active = { name: heading.name, start: line.start, contentStart: line.next };
-    }
-    finishActive(markdown.length);
-    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 };
-}
-function scopePatterns(markdown, section) {
-    const patterns = markdown
-        .slice(section.contentStart, section.end)
-        .split(/\r?\n/)
-        .filter((line) => !isBlankScopePatternLine(line))
-        .map((pattern) => {
-        try {
-            // Do not trim() here: gitignore treats trailing `\ ` as a significant space.
-            return normalizeScopePattern(pattern);
-        }
-        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", `amend input has an empty ${amendScopeHeading(section.name)} section`);
-    }
-    return patterns;
-}
-export function buildAmendInput(markdown, cwd, contractId, contractAddressSource) {
-    const { sections, prose } = parseAmendScopeSections(markdown);
-    const add = sections.add ? scopePatterns(markdown, sections.add) : [];
-    if (!prose.trim()) {
-        throw new FlowError("EMPTY_PARAM", "amendment cannot be empty");
-    }
-    return {
-        cwd,
-        ...(contractId ? { contractId } : {}),
-        ...(contractAddressSource ? { contractAddressSource } : {}),
-        amendment: prose,
-        ...(sections.add ? { scopeDelta: { add } } : {}),
-    };
-}
-export function defaultActorClock(nowMs = Date.now()) {
-    return { actor: ACTOR_IDENTITY, nowMs };
-}
-export function parseCommandMarkdown(content) {
-    try {
-        const parsed = parseMarkdownStructure(content);
-        const sections = new Map();
-        for (const [key, lines] of parsed.sections.entries()) {
-            sections.set(key, lines.join("\n").trim());
-        }
-        return { title: parsed.title, sections };
-    }
-    catch (error) {
-        if (error instanceof KeiyakuParseError) {
-            throw new FlowError("INVALID_KEIYAKU_DRAFT", error.message, { cause: error });
-        }
-        throw error;
-    }
-}
-export function requireMarkdownTextSection(parts, name) {
-    const normalized = normalizeSectionTitle(name);
-    const value = parts.sections.get(normalized)?.trim();
-    if (!value) {
-        throw new FlowError("INVALID_KEIYAKU_DRAFT", `missing required section: ## ${name}`);
-    }
-    return value;
-}
-export function requireMarkdownListSection(parts, name) {
-    const text = requireMarkdownTextSection(parts, name);
-    const items = parseMarkdownListSection(text)
-        .map((item) => item.trim())
-        .filter((item) => item.length > 0);
-    if (items.length === 0) {
-        throw new FlowError("INVALID_KEIYAKU_DRAFT", `missing required section: ## ${name}`);
-    }
-    return items;
-}
-export function requireMarkdownTitle(parts) {
-    const title = parts.title?.trim();
-    if (!title) {
-        throw new FlowError("INVALID_KEIYAKU_DRAFT", "missing required title: # Title");
-    }
-    return title;
-}

package/build/core/path-coordinate.js

@@ -1,27 +0,0 @@
-import * as fs from "node:fs";
-import * as fsPromises from "node:fs/promises";
-import * as path from "node:path";
-/**
- * Git for Windows may emit native, slash-normalized, or MSYS drive paths.
- * Keep one host-native spelling before using a coordinate as a filesystem cwd.
- */
-export function normalizeGitPath(raw, platform = process.platform) {
-    const value = raw.trim();
-    if (platform !== "win32")
-        return path.normalize(value);
-    const msysDrive = value.match(/^\/([A-Za-z])(?:\/|$)(.*)$/);
-    if (msysDrive)
-        return path.win32.normalize(`${msysDrive[1].toUpperCase()}:/${msysDrive[2]}`);
-    const normalized = path.win32.normalize(value);
-    return normalized.replace(/^([a-z]):/, (_, drive) => `${drive.toUpperCase()}:`);
-}
-export function gitCommonRootPath(raw, platform = process.platform) {
-    const paths = platform === "win32" ? path.win32 : path.posix;
-    return paths.dirname(normalizeGitPath(raw, platform));
-}
-export async function resolveGitCommonRoot(raw) {
-    return await fsPromises.realpath(gitCommonRootPath(raw));
-}
-export function resolveGitCommonRootSync(raw) {
-    return fs.realpathSync(gitCommonRootPath(raw));
-}

package/build/core/petition-claim.js

@@ -1,117 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { readContractLog } from "./log.js";
-import { petitionContract } from "./petition.js";
-import { verdictContract } from "./verdict.js";
-import { nextReviewResponseNumber } from "./transcripts.js";
-import { buildClaimGatePipeline, } from "./petition-claim-gates.js";
-import { assertHeadUnchanged } from "./petition-head-guard.js";
-async function throwClaimGateFailure(failure, input, context, dependencies) {
-    const { cwd, contractId } = context;
-    void contractId;
-    void dependencies;
-    if (failure.reviewHeadBeforeWrite) {
-        await assertHeadUnchanged(cwd, failure.reviewHeadBeforeWrite, "claim review");
-    }
-    throw new FlowError(failure.code, failure.message, {
-        hints: failure.hints,
-        review: failure.review,
-    });
-}
-async function runClaimGatePipelineOrThrow(input, context, dependencies) {
-    const { verificationCommands } = await dependencies.resolveClaimGateConfig(context.cwd);
-    let review;
-    let reviewHeadBeforeWrite;
-    let reviewerActor;
-    for (const gate of buildClaimGatePipeline()) {
-        const result = await gate.evaluate({
-            cwd: context.cwd,
-            contractId: context.contractId,
-            input,
-            verificationCommands,
-            baseBranch: dependencies.baseBranch,
-            reviewNumber: dependencies.reviewNumber,
-        });
-        if (result.review) {
-            review = result.review;
-            reviewHeadBeforeWrite = result.reviewHeadBeforeWrite;
-        }
-        if (result.reviewerActor)
-            reviewerActor = result.reviewerActor;
-        if (!result.pass) {
-            await throwClaimGateFailure(result, input, context, dependencies);
-        }
-    }
-    return { review, reviewHeadBeforeWrite, reviewerActor };
-}
-function maxArc(entries) {
-    return entries.filter((entry) => entry.kind === "arc").length;
-}
-function cleanupWarnings(cleanup) {
-    return [
-        ...(cleanup.worktreeRemoveFailure
-            ? [`Could not remove contract worktree ${cleanup.worktreeRemoveFailure.path}: ${cleanup.worktreeRemoveFailure.reason}`]
-            : []),
-        ...(cleanup.branchDeleteFailure
-            ? [`Could not delete contract branch ${cleanup.branchDeleteFailure.name}: ${cleanup.branchDeleteFailure.reason}`]
-            : []),
-    ];
-}
-export async function claimKeiyaku(input, context, dependencies) {
-    const { cwd, baseBranch, contractId } = context;
-    const claimResult = "dangerouslyBypassGates" in input && input.dangerouslyBypassGates
-        ? { review: undefined, reviewHeadBeforeWrite: undefined, bypassedByArchitect: true }
-        : {
-            ...(await runClaimGatePipelineOrThrow(input, { cwd, contractId }, {
-                ...dependencies,
-                baseBranch,
-                reviewNumber: await nextReviewResponseNumber(cwd),
-            })),
-            bypassedByArchitect: false,
-        };
-    if (claimResult.review && claimResult.reviewHeadBeforeWrite) {
-        await assertHeadUnchanged(cwd, claimResult.reviewHeadBeforeWrite, "claim review");
-    }
-    const oath = String(input.oath ?? "").trim();
-    if (!oath) {
-        throw new FlowError("OATH_MISSING", "Oath missing.");
-    }
-    const petition = await petitionContract({
-        cwd,
-        contractId,
-        actor: "keiyaku",
-        nowMs: Date.now(),
-        intent: "claim",
-        oath,
-        waivePaths: input.waivePaths,
-    });
-    const log = await readContractLog({ cwd, contractId });
-    const verdict = await verdictContract({
-        cwd,
-        contractId,
-        actor: claimResult.reviewerActor ?? "keiyaku",
-        nowMs: Date.now(),
-        result: "approved",
-        summary: claimResult.review?.findings?.trim() || "礼成",
-    });
-    if (!verdict.claimed) {
-        throw new FlowError("INTERNAL_STATE", `approved verdict for ${contractId} did not produce an engine claim`);
-    }
-    const cleanup = verdict.claimed.cleanup ?? { absent: ["worktree", "branch"] };
-    const warnings = [...(verdict.claimed.warnings ?? []), ...cleanupWarnings(cleanup)];
-    return {
-        status: "success",
-        result: "merged",
-        arc: maxArc(log.entries),
-        currentBranch: baseBranch,
-        baseBranch,
-        commit: verdict.claimed.mergeCommit,
-        mergedInto: baseBranch,
-        ...(cleanup.deletedBranch ? { deletedBranch: cleanup.deletedBranch } : {}),
-        cleanup,
-        diff: `Merged contract ${contractId} with merge-tree/commit-tree CAS.`,
-        ...(petition.sealed ? { sealed: petition.sealed } : {}),
-        ...(warnings.length > 0
-            ? { meta: { warnings } }
-            : {}),
-    };
-}