@astrosheep/keiyaku 0.1.0

package/build/logic.js

@@ -0,0 +1,530 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import { isSubagentExecError, resolveSubagentConfig, runSubagentExec } from "./subagent-exec/index.js";
+import { KEIYAKU_FILE, TRACE_FILE } from "./constants.js";
+import { appendDebugBlock, appendDebugLog } from "./debug-log.js";
+import { asMessage, FlowError, wrapFlowError } from "./errors.js";
+import * as git from "./git.js";
+import { appendRoundReport, appendRoundSystemNote, appendReview, buildIteratePlan, computeTraceState, readTraceContent, } from "./trace.js";
+import { buildAskPrompt, buildStartPrompt } from "./prompts.js";
+import { resolveTermPreset } from "./term-presets.js";
+const DEFAULT_JUDGMENT_OATH = "I, [your name], solemnly swear that I have scrutinized this change line by line with my own eyes. This oath is handwritten as a testament to my responsibility. If logic fails where I claimed it sound, I shall bear the mark of this oversight forever.\n\nSigned: [your name]";
+const JUDGMENT_OATH_ENV_KEY = "KEIYAKU_JUDGMENT_OATH";
+const LEGACY_JUDGMENT_OATH_ENV_KEY = "KEIYAKU_SEAL_OATH";
+const JUDGMENT_OATH_NAME_PLACEHOLDER = "[your name]";
+const JUDGMENT_INVOKE_FLAGS = ["metPrecise", "metMinimal", "metIsolated", "metIdiomatic", "metCohesive"];
+const FALLBACK_DEFAULT_SUBAGENT_NAME = "servant-tier-A";
+const BASE_CRITERIA_FILE = path.join(".keiyaku", "base-criteria.md");
+const BASE_CONSTRAINTS_FILE = path.join(".keiyaku", "base-constraints.md");
+function parseMarkdownList(text) {
+    return text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => /^[-*]\s+/.test(line))
+        .map((line) => line.replace(/^[-*]\s+/, "").trim())
+        .filter((line) => line.length > 0);
+}
+function renderBulletList(items) {
+    if (items.length === 0)
+        return "- (none)";
+    return items.map((item) => `- ${item}`).join("\n");
+}
+function renderKeiyaku(title, goal, context, baseConstraints, taskConstraints, baseCriteria, taskCriteria) {
+    let content = `# ${title}\n\n## Context\n${context}\n\n## Goal\n${goal}`;
+    content += `\n\n## Constraints`;
+    content += `\n\n### Base Constraints\n${renderBulletList(baseConstraints)}`;
+    content += `\n\n### Task Constraints\n${renderBulletList(taskConstraints)}`;
+    content += `\n\n## Acceptance Criteria`;
+    content += `\n\n### Base Criteria\n${renderBulletList(baseCriteria)}`;
+    content += `\n\n### Task Criteria\n${renderBulletList(taskCriteria)}`;
+    return content;
+}
+function buildMergeMessage(title, keiyakuContent, reportContent) {
+    return `keiyaku(${title}): done\n\n---\n${keiyakuContent}\n---\n${reportContent}\n---\n`;
+}
+function resolveConfiguredSubagentName() {
+    const fromEnv = process.env.KEIYAKU_SUBAGENT_NAME_OVERRIDE?.trim();
+    if (!fromEnv)
+        return undefined;
+    resolveSubagentConfig(fromEnv);
+    return fromEnv;
+}
+function resolveRoundSubagentName(subagentName) {
+    const configured = resolveConfiguredSubagentName();
+    const name = configured || subagentName?.trim() || FALLBACK_DEFAULT_SUBAGENT_NAME;
+    resolveSubagentConfig(name);
+    return name;
+}
+export function resolveJudgmentOath() {
+    const configured = process.env[JUDGMENT_OATH_ENV_KEY];
+    if (configured !== undefined)
+        return configured;
+    const legacyConfigured = process.env[LEGACY_JUDGMENT_OATH_ENV_KEY];
+    if (legacyConfigured !== undefined)
+        return legacyConfigured;
+    return DEFAULT_JUDGMENT_OATH;
+}
+function judgmentOathMatches(inputOath, expectedOath) {
+    const actual = inputOath?.trim();
+    if (!actual)
+        return false;
+    const expected = expectedOath.trim();
+    if (!expected.includes(JUDGMENT_OATH_NAME_PLACEHOLDER)) {
+        return actual === expected;
+    }
+    const parts = expected.split(JUDGMENT_OATH_NAME_PLACEHOLDER);
+    let cursor = 0;
+    for (let idx = 0; idx < parts.length; idx += 1) {
+        const part = parts[idx] ?? "";
+        if (!actual.startsWith(part, cursor)) {
+            return false;
+        }
+        cursor += part.length;
+        if (idx === parts.length - 1)
+            break;
+        const nextPart = parts[idx + 1] ?? "";
+        const nextPartIndex = nextPart ? actual.indexOf(nextPart, cursor) : actual.length;
+        if (nextPartIndex < 0) {
+            return false;
+        }
+        const replacement = actual.slice(cursor, nextPartIndex);
+        if (replacement.trim().length === 0) {
+            return false;
+        }
+        cursor = nextPartIndex;
+    }
+    return cursor === actual.length;
+}
+function getMergeConflictFiles(err) {
+    if (err && typeof err === "object" && "git" in err) {
+        const gitPayload = err.git;
+        if (gitPayload && typeof gitPayload === "object") {
+            const detail = gitPayload;
+            if (detail.failed === true && Array.isArray(detail.conflicts)) {
+                const files = detail.conflicts
+                    .map((entry) => entry?.file)
+                    .filter((value) => typeof value === "string" && value.trim().length > 0);
+                if (files.length > 0) {
+                    return Array.from(new Set(files));
+                }
+            }
+        }
+    }
+    // Fallback for git clients that only expose merge conflict details in the message text.
+    const text = asMessage(err);
+    const matches = Array.from(text.matchAll(/CONFLICT[^\n]* in ([^\n]+)/g));
+    const files = matches.map((entry) => entry[1]?.trim()).filter((value) => Boolean(value));
+    if (files.length > 0)
+        return Array.from(new Set(files));
+    if (text.includes("CONFLICT"))
+        return ["(unknown)"];
+    return [];
+}
+function summarizeForTrace(message) {
+    return message.replace(/\s+/g, " ").trim().slice(0, 500) || "Unknown error.";
+}
+function toSnippet(raw, maxChars = 4000) {
+    const text = raw.trim();
+    if (!text)
+        return undefined;
+    if (text.length <= maxChars)
+        return text;
+    const marker = `\n...[truncated ${text.length - maxChars} chars]...\n`;
+    const side = Math.floor((maxChars - marker.length) / 2);
+    const head = text.slice(0, side);
+    const tail = text.slice(text.length - side);
+    return `${head}${marker}${tail}`;
+}
+function describeSubagentFailure(error, subagentName, round) {
+    const message = asMessage(error);
+    if (isSubagentExecError(error)) {
+        return {
+            errorType: "subagent_execution_error",
+            errorCode: error.code,
+            message: error.message,
+            subagentName,
+            round,
+            timeoutMs: error.timeoutMs,
+            exitCode: error.exitCode,
+            stderrSnippet: toSnippet(error.stderr),
+        };
+    }
+    return {
+        errorType: "subagent_execution_error",
+        errorCode: "SUBAGENT_EXEC_ERROR",
+        message,
+        subagentName,
+        round,
+        timeoutMs: null,
+        exitCode: null,
+    };
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === "AbortError";
+}
+function buildDriveReason(directive, context) {
+    const normalizedDirective = requireText("directive", directive);
+    const normalizedContext = context?.trim();
+    if (!normalizedContext) {
+        return normalizedDirective;
+    }
+    return `${normalizedDirective}\n\nNew context:\n${normalizedContext}`;
+}
+async function runSubagent(subagentName, prompt, cwd, round, signal) {
+    const { identity } = resolveTermPreset();
+    if (process.env.KEIYAKU_FAKE_SUBAGENT === "1") {
+        return `Mock ${identity} '${subagentName}' completed round ${round}.`;
+    }
+    const startLog = `[${identity}] Running execution for '${subagentName}' in ${cwd}`;
+    console.error(startLog);
+    appendDebugLog(startLog, { cwd, section: "script" });
+    const result = await runSubagentExec(subagentName, prompt, cwd, { signal });
+    const summary = result.finalMessage || `${identity} completed successfully.`;
+    if (result.stderr.trim()) {
+        appendDebugBlock("subagent stderr", result.stderr, { cwd, section: "codex-stderr" });
+    }
+    return summary;
+}
+function normalizeTitleForBranch(title) {
+    const normalized = title
+        .trim()
+        .toLowerCase()
+        .replace(/[^\p{Script=Han}a-z0-9]+/gu, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-+/, "")
+        .replace(/-+$/, "");
+    if (!normalized) {
+        throw new FlowError("INVALID_BRANCH_TITLE", "title cannot be converted to a valid branch name; use letters/numbers");
+    }
+    return normalized;
+}
+async function ensureKeiyakuFiles(cwd) {
+    const keiyakuPath = path.join(cwd, KEIYAKU_FILE);
+    const tracePath = path.join(cwd, TRACE_FILE);
+    try {
+        await fs.access(keiyakuPath);
+        await fs.access(tracePath);
+    }
+    catch {
+        throw new FlowError("MISSING_PROTOCOL_FILES", `missing protocol files for current keiyaku (${KEIYAKU_FILE} or ${TRACE_FILE})`);
+    }
+}
+function requireText(name, value) {
+    const normalized = value.trim();
+    if (!normalized) {
+        throw new FlowError("EMPTY_PARAM", `parameter '${name}' cannot be empty`);
+    }
+    return normalized;
+}
+async function assertCleanWorkingTree(cwd) {
+    const dirtyPaths = await git.getDirtyPaths(cwd);
+    if (dirtyPaths.length > 0) {
+        const listed = dirtyPaths.slice(0, 5).join(", ");
+        const suffix = dirtyPaths.length > 5 ? ` and ${dirtyPaths.length} files total` : "";
+        throw new FlowError("DIRTY_WORKTREE", `working tree has uncommitted changes (${listed}${suffix})`);
+    }
+}
+function collectRoundFiles(dirtyPaths) {
+    const filtered = dirtyPaths.filter((p) => p !== TRACE_FILE);
+    return Array.from(new Set(filtered)).sort();
+}
+async function appendRoundResult(cwd, round, summary, subagentFailure) {
+    const dirtyPaths = await git.getDirtyPaths(cwd);
+    const filesModified = collectRoundFiles(dirtyPaths);
+    if (subagentFailure) {
+        const errorText = summarizeForTrace(subagentFailure.message);
+        await appendRoundReport(cwd, {
+            round,
+            status: "FAILED",
+            summary,
+            filesModified,
+            errorMessage: errorText,
+        });
+        return;
+    }
+    await appendRoundReport(cwd, {
+        round,
+        status: "SUCCESS",
+        summary,
+        filesModified,
+    });
+}
+async function runAndRecordRound(cwd, titleToken, round, prompt, options) {
+    const roundSubagent = resolveRoundSubagentName(options.subagentName);
+    let summary;
+    let subagentFailure;
+    try {
+        summary = await runSubagent(roundSubagent, prompt, cwd, round, options.signal);
+    }
+    catch (err) {
+        if (isAbortError(err)) {
+            if (options.onAbort) {
+                await options.onAbort();
+            }
+            throw err;
+        }
+        subagentFailure = describeSubagentFailure(err, roundSubagent, round);
+        const failureLog = `[Subagent failure] name=${subagentFailure.subagentName} round=${subagentFailure.round} code=${subagentFailure.errorCode} timeoutMs=${subagentFailure.timeoutMs ?? "unknown"} exitCode=${subagentFailure.exitCode ?? "none"}`;
+        console.error(failureLog);
+        appendDebugLog(failureLog, { cwd, section: "script" });
+        if (subagentFailure.stderrSnippet) {
+            const failureStderrLog = `[Subagent failure stderr]\n${subagentFailure.stderrSnippet}`;
+            console.error(failureStderrLog);
+            appendDebugBlock("subagent failure stderr", subagentFailure.stderrSnippet, { cwd, section: "codex-stderr" });
+        }
+        summary =
+            options.failureMode === "round_specific"
+                ? `Round ${round} completed with subagent execution failure recorded in trace.`
+                : "Round 1 completed with subagent execution failure recorded in trace.";
+    }
+    await appendRoundResult(cwd, round, summary, subagentFailure);
+    await git.addFiles(cwd, "-A");
+    await git.commit(cwd, `keiyaku(${titleToken}): round ${round}`);
+    return { summary, ...(subagentFailure ? { subagentFailure } : {}) };
+}
+export async function handleKeiyaku(input) {
+    const { cwd, signal, subagentName } = input;
+    const finalTitle = requireText("title", input.title);
+    const finalGoal = requireText("goal", input.goal);
+    const finalContext = requireText("context", input.context);
+    const finalCriteria = requireText("criteria", input.criteria);
+    const taskCriteria = parseMarkdownList(finalCriteria);
+    const normalizedTaskCriteria = taskCriteria.length > 0 ? taskCriteria : [finalCriteria];
+    const finalConstraints = input.constraints?.trim();
+    const taskConstraints = finalConstraints ? parseMarkdownList(finalConstraints) : [];
+    const normalizedTaskConstraints = finalConstraints && taskConstraints.length > 0 ? taskConstraints : finalConstraints ? [finalConstraints] : [];
+    const directive = input.directive?.trim();
+    const isRepo = await git.isGitRepo(cwd);
+    if (!isRepo) {
+        throw new FlowError("NOT_GIT_REPO", `${cwd} is not a git repository`);
+    }
+    const existingKeiyaku = await git.getActiveKeiyakuBranch(cwd);
+    if (existingKeiyaku) {
+        throw new FlowError("ACTIVE_KEIYAKU_EXISTS", `active keiyaku already exists (${existingKeiyaku}); run invoke_judgment first`);
+    }
+    const existingBranches = await git.listLocalKeiyakuBranches(cwd);
+    if (existingBranches.length > 0) {
+        const branchWarning = `[keiyaku] existing local keiyaku branches detected (non-blocking): ${existingBranches.join(", ")}`;
+        console.error(branchWarning);
+        appendDebugLog(branchWarning, { cwd, section: "script" });
+    }
+    await assertCleanWorkingTree(cwd);
+    const baseBranch = await git.getCurrentBranch(cwd);
+    const branchToken = normalizeTitleForBranch(finalTitle);
+    const keiyakuBranch = `keiyaku/${branchToken}`;
+    await git.assertValidBranchName(cwd, keiyakuBranch);
+    let createdBranch = false;
+    try {
+        await git.createAndCheckoutBranch(cwd, keiyakuBranch);
+        createdBranch = true;
+        await git.setKeiyakuBase(cwd, keiyakuBranch, baseBranch);
+        const switchedLog = `Switched to branch: ${keiyakuBranch} (base: ${baseBranch})`;
+        console.error(switchedLog);
+        appendDebugLog(switchedLog, { cwd, section: "script" });
+        let baseCriteria = [];
+        try {
+            const baseCriteriaRaw = await fs.readFile(path.join(cwd, BASE_CRITERIA_FILE), "utf-8");
+            baseCriteria = parseMarkdownList(baseCriteriaRaw);
+        }
+        catch (error) {
+            const isMissingFile = error?.code === "ENOENT";
+            if (!isMissingFile) {
+                throw error;
+            }
+        }
+        let baseConstraints = [];
+        try {
+            const baseConstraintsRaw = await fs.readFile(path.join(cwd, BASE_CONSTRAINTS_FILE), "utf-8");
+            baseConstraints = parseMarkdownList(baseConstraintsRaw);
+        }
+        catch (error) {
+            const isMissingFile = error?.code === "ENOENT";
+            if (!isMissingFile) {
+                throw error;
+            }
+        }
+        const keiyakuContent = renderKeiyaku(finalTitle, finalGoal, finalContext, baseConstraints, normalizedTaskConstraints, baseCriteria, normalizedTaskCriteria);
+        await fs.writeFile(path.join(cwd, KEIYAKU_FILE), keiyakuContent);
+        await fs.writeFile(path.join(cwd, TRACE_FILE), "# Keiyaku Trace\n");
+        await git.addFiles(cwd, [KEIYAKU_FILE, TRACE_FILE]);
+        await git.commit(cwd, `keiyaku(${branchToken}): open`);
+        const prompt = buildStartPrompt(finalTitle, finalGoal, directive);
+        const { summary, subagentFailure } = await runAndRecordRound(cwd, branchToken, 1, prompt, {
+            signal,
+            subagentName,
+            failureMode: "standard",
+        });
+        const trace = await fs.readFile(path.join(cwd, TRACE_FILE), "utf-8");
+        const diff = await git.getKeiyakuDiff(cwd, baseBranch);
+        return {
+            round: 1,
+            trace,
+            diff,
+            summary,
+            branch: keiyakuBranch,
+            baseBranch,
+            ...(subagentFailure ? { subagentFailure } : {}),
+        };
+    }
+    catch (err) {
+        if (createdBranch) {
+            try {
+                await git.checkoutBranch(cwd, baseBranch);
+            }
+            catch {
+                // best effort
+            }
+            try {
+                if (await git.hasLocalBranch(cwd, keiyakuBranch)) {
+                    await git.deleteBranch(cwd, keiyakuBranch, true);
+                }
+            }
+            catch {
+                // best effort
+            }
+            await git.clearKeiyakuBase(cwd, keiyakuBranch);
+        }
+        throw wrapFlowError("start keiyaku", err);
+    }
+}
+export async function handleAsk(input) {
+    const { cwd, signal, subagentName } = input;
+    const request = requireText("request", input.request);
+    const context = requireText("context", input.context);
+    const prompt = buildAskPrompt(request, context);
+    // TODO: enforce read-only access and persist summary to .keiyaku/notes/.
+    const summary = await runSubagent(resolveRoundSubagentName(subagentName), prompt, cwd, 0, signal);
+    return { summary };
+}
+export async function invokeJudgment(input) {
+    const { cwd } = input;
+    const isRepo = await git.isGitRepo(cwd);
+    if (!isRepo) {
+        throw new FlowError("NOT_GIT_REPO", `${cwd} is not a git repository`);
+    }
+    const keiyakuBranch = await git.getActiveKeiyakuBranch(cwd);
+    if (!keiyakuBranch) {
+        throw new FlowError("NOT_ACTIVE_KEIYAKU_BRANCH", "current branch is not an active keiyaku branch (run invoke_judgment on keiyaku/*)");
+    }
+    const baseBranch = await git.getKeiyakuBase(cwd, keiyakuBranch);
+    if (!baseBranch) {
+        throw new FlowError("MISSING_KEIYAKU_BASE", `branch ${keiyakuBranch} is missing base metadata; cannot continue judgment`);
+    }
+    const title = keiyakuBranch.slice("keiyaku/".length);
+    const intent = input.intent;
+    if (intent === "DROP") {
+        await assertCleanWorkingTree(cwd);
+        try {
+            await git.checkoutBranch(cwd, baseBranch);
+            await git.deleteBranch(cwd, keiyakuBranch, true);
+            await git.clearKeiyakuBase(cwd, keiyakuBranch);
+        }
+        catch (err) {
+            throw wrapFlowError(`execute DROP (${keiyakuBranch} -> ${baseBranch})`, err);
+        }
+        return { status: "dropped", branch: keiyakuBranch, baseBranch };
+    }
+    await ensureKeiyakuFiles(cwd);
+    const traceContent = await readTraceContent(cwd);
+    if (intent === "INVOKE") {
+        const missingOrFalse = JUDGMENT_INVOKE_FLAGS.filter((name) => input[name] !== true);
+        if (missingOrFalse.length > 0) {
+            throw new FlowError("JUDGMENT_QUALITY_GATE_FAILED", `INVOKE blocked: iterate until ${missingOrFalse.join(", ")} are met`);
+        }
+        const expectedOath = resolveJudgmentOath();
+        if (!judgmentOathMatches(input.oath, expectedOath)) {
+            throw new FlowError("JUDGMENT_OATH_MISMATCH", `Oath mismatch. Correct oath: ${expectedOath}`);
+        }
+        await assertCleanWorkingTree(cwd);
+        try {
+            const invokeDiffLog = `[INVOKE] Collecting diff stats against base '${baseBranch}'`;
+            console.error(invokeDiffLog);
+            appendDebugLog(invokeDiffLog, { cwd, section: "script" });
+            const diffStats = await git.getKeiyakuDiffStats(cwd, baseBranch);
+            const invokeReadLog = "[INVOKE] Reading keiyaku protocol files";
+            console.error(invokeReadLog);
+            appendDebugLog(invokeReadLog, { cwd, section: "script" });
+            const keiyakuContent = await fs.readFile(path.join(cwd, KEIYAKU_FILE), "utf-8");
+            const message = buildMergeMessage(title, keiyakuContent, traceContent);
+            const invokeCleanupLog = "[INVOKE] Removing protocol files and creating cleanup commit";
+            console.error(invokeCleanupLog);
+            appendDebugLog(invokeCleanupLog, { cwd, section: "script" });
+            await fs.unlink(path.join(cwd, KEIYAKU_FILE));
+            await fs.unlink(path.join(cwd, TRACE_FILE));
+            await git.addFiles(cwd, "-A");
+            await git.commit(cwd, `keiyaku(${title}): cleanup`);
+            const invokeCheckoutLog = `[INVOKE] Checking out base branch '${baseBranch}'`;
+            console.error(invokeCheckoutLog);
+            appendDebugLog(invokeCheckoutLog, { cwd, section: "script" });
+            await git.checkoutBranch(cwd, baseBranch);
+            const invokeMergeLog = `[INVOKE] Merging '${keiyakuBranch}' into '${baseBranch}'`;
+            console.error(invokeMergeLog);
+            appendDebugLog(invokeMergeLog, { cwd, section: "script" });
+            await git.merge(cwd, keiyakuBranch, message);
+            const invokeFinalizeLog = `[INVOKE] Deleting merged branch '${keiyakuBranch}' and clearing metadata`;
+            console.error(invokeFinalizeLog);
+            appendDebugLog(invokeFinalizeLog, { cwd, section: "script" });
+            await git.deleteBranch(cwd, keiyakuBranch);
+            await git.clearKeiyakuBase(cwd, keiyakuBranch);
+            return { status: "done", branch: keiyakuBranch, baseBranch, diffStats };
+        }
+        catch (err) {
+            const conflictFiles = getMergeConflictFiles(err);
+            if (conflictFiles.length > 0) {
+                throw new FlowError("DONE_MERGE_CONFLICT", `INVOKE merge conflict between ${keiyakuBranch} and ${baseBranch} (CONFLICTS: ${conflictFiles.join(", ")})`, err);
+            }
+            throw wrapFlowError(`execute INVOKE (merge ${keiyakuBranch} into ${baseBranch})`, err);
+        }
+    }
+    throw new Error(`unsupported judgment intent: ${intent}`);
+}
+export async function handleDrive(input) {
+    const { cwd, directive, context, subagentName, signal } = input;
+    const isRepo = await git.isGitRepo(cwd);
+    if (!isRepo) {
+        throw new FlowError("NOT_GIT_REPO", `${cwd} is not a git repository`);
+    }
+    const keiyakuBranch = await git.getActiveKeiyakuBranch(cwd);
+    if (!keiyakuBranch) {
+        throw new FlowError("NOT_ACTIVE_KEIYAKU_BRANCH", "current branch is not an active keiyaku branch (run drive on keiyaku/*)");
+    }
+    const baseBranch = await git.getKeiyakuBase(cwd, keiyakuBranch);
+    if (!baseBranch) {
+        throw new FlowError("MISSING_KEIYAKU_BASE", `branch ${keiyakuBranch} is missing base metadata; cannot continue drive`);
+    }
+    await ensureKeiyakuFiles(cwd);
+    const traceContent = await readTraceContent(cwd);
+    const traceState = computeTraceState(traceContent);
+    const title = keiyakuBranch.slice("keiyaku/".length);
+    const reason = buildDriveReason(directive, context);
+    try {
+        const plan = buildIteratePlan(title, traceState, traceContent, reason);
+        await appendReview(cwd, plan.targetRound, plan.reviewReason);
+        await git.addFiles(cwd, TRACE_FILE);
+        await git.commit(cwd, `keiyaku(${title}): iterate round ${plan.targetRound}`);
+        const { summary, subagentFailure } = await runAndRecordRound(cwd, title, plan.targetRound, plan.prompt, {
+            signal,
+            subagentName,
+            failureMode: "round_specific",
+            onAbort: async () => {
+                await appendRoundSystemNote(cwd, plan.targetRound, "Subagent execution cancelled by user/client.");
+                await git.addFiles(cwd, TRACE_FILE);
+                await git.commit(cwd, `keiyaku(${title}): round ${plan.targetRound} cancelled`);
+            },
+        });
+        const trace = await fs.readFile(path.join(cwd, TRACE_FILE), "utf-8");
+        const diff = await git.getKeiyakuDiff(cwd, baseBranch);
+        return {
+            round: plan.targetRound,
+            trace,
+            diff,
+            summary,
+            branch: keiyakuBranch,
+            baseBranch,
+            ...(subagentFailure ? { subagentFailure } : {}),
+        };
+    }
+    catch (err) {
+        throw wrapFlowError(`execute DRIVE (${keiyakuBranch})`, err);
+    }
+}

package/build/prompts.js

@@ -0,0 +1,77 @@
+export function buildStartPrompt(title, goal, directive) {
+    const goalBlock = `\nGoal (immutable):\n${goal}\n`;
+    const directiveBlock = directive ? `\nDirective (Round 1 only):\n${directive}\n` : "";
+    return `You are working on a keiyaku (${title}).${goalBlock}${directiveBlock}
+
+This is Round 1 (initial implementation).
+
+How to interpret these fields:
+- Goal = the mission (what done looks like overall). Immutable.
+- Directive = Round 1 focus/scope guardrail. If present, follow it even if it means not completing the full Goal in Round 1.
+
+1. Read KEIYAKU.md — this is the immutable mission definition (Goal, Context, Constraints, Acceptance Criteria). If the Goal shown above differs from KEIYAKU.md, treat KEIYAKU.md as the source of truth.
+2. If KEIYAKU.md has a "Focus" section, treat it as the implementation priority for this round.
+3. Treat both Base + Task Constraints and Base + Task Criteria as mandatory mission boundaries.
+4. Read KEIYAKU_TRACE.md for prior context if present.
+5. **CRITICAL EXECUTION**: 
+   - **Directive is your Leash**: If a Directive is provided, focus ONLY on that scope. Do NOT try to be a hero and finish the entire Goal in Round 1. We iterate.
+   - **Constraints are Absolute**: Base Constraints and Task Constraints are both binding. Do NOT drift.
+   - **Criteria is the North Star**: Base Criteria and Task Criteria jointly define done. Keep both in view while executing the Directive.
+   - **Architect's Vision**: Respect the existing structure. Modify with precision, not with a sledgehammer.
+6. At the end, output a clear implementation report in plain text with exactly 4 sections:
+   - One line summary: What was done, what's the outcome.
+   - Modification: Files touched. What changed — explain the logic delta, not just what was edited. Evidence — paste raw output, logs, or observed behavior.
+   - Aesthetics Gap
+Self-critique. Identify where this diff deviates from the ideal:
+
+precise — right place, layer, abstraction
+minimal — smallest diff that solves it
+isolated — no unrelated changes riding along
+idiomatic — fits the codebase's voice
+cohesive — each unit does one thing
+   - Blindspots: What you're not sure about. Untested paths, unverified assumptions, worried-about edges.
+
+Do NOT run git commands. Do NOT edit KEIYAKU_TRACE.md directly.`;
+}
+export function buildIteratePrompt(title, round, reason) {
+    return `You are working on a keiyaku (${title}).
+
+This is Round ${round} (iteration after review).
+
+Latest review reason you must address in this round:
+${reason}
+
+1. Read KEIYAKU.md — mission definition remains immutable (including Base + Task Constraints and Base + Task Criteria).
+2. If KEIYAKU.md has a "Focus" section, treat it as the implementation priority for this round.
+3. Read KEIYAKU_TRACE.md — review previous rounds and locate the latest "## Review ${round}" section.
+4. **STRICT ITERATION**: 
+   - **Fix the Core**: Resolve the review reason first. No excuses.
+   - **Zero Drift**: While fixing, do NOT violate Base/Task Constraints or miss Base/Task Criteria.
+   - **Clean Diff**: Keep the modification surgical. I am watching.
+5. Modify the code accordingly.
+6. At the end, output a clear implementation report in plain text with exactly 4 sections:
+   - One line summary: What was done, what's the outcome.
+   - Modification: Files touched. What changed — explain the logic delta, not just what was edited. Evidence — paste raw output, logs, or observed behavior.
+   - Aesthetics Gap
+Self-critique. Identify where this diff deviates from the ideal:
+
+precise — right place, layer, abstraction
+minimal — smallest diff that solves it
+isolated — no unrelated changes riding along
+idiomatic — fits the codebase's voice
+cohesive — each unit does one thing
+   - Blindspots: What you're not sure about. Untested paths, unverified assumptions, worried-about edges.
+
+Do NOT run git commands. Do NOT edit KEIYAKU_TRACE.md directly.`;
+}
+export function buildAskPrompt(request, context) {
+    return `You are in an ask session. No code changes. No git commands.
+
+Request:
+${request}
+
+Context:
+${context}
+
+Provide a clear reasoning summary in plain text.`;
+}