@astrosheep/keiyaku 0.1.76 → 0.1.78

package/build/config/settings.js

@@ -1,8 +1,10 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { z } from "zod";
+import { isErrnoException } from "../errno.js";
 import { FlowError } from "../flow-error.js";
 import { AGENT_ROLES, CODEX_MODEL_REASONING_EFFORT_CONFIG_KEY, ROUND_TIERS, SETTINGS_FILE, } from "../keiyaku.js";
+import { getKeiyakuHome } from "./keiyaku-home.js";
 const reasoningEffortSchema = z.enum(["low", "medium", "high"]);
 const tomlValueSchema = z.lazy(() => z.union([z.string(), z.number(), z.boolean(), z.array(tomlValueSchema), z.record(z.string(), tomlValueSchema)]));
 function optionalTrimmedString() {
@@ -73,8 +75,6 @@ const opencodeAgentProfileSchema = z
     command: commandSchema,
 })
     .strict();
-export const roundTierSchema = z.enum(ROUND_TIERS);
-export const agentRoleSchema = z.enum(AGENT_ROLES);
 export const agentProfileSchema = z.discriminatedUnion("provider", [
     codexAgentProfileSchema,
     codexSdkAgentProfileSchema,
@@ -132,41 +132,61 @@ export class SettingsParseError extends Error {
     }
 }
 function parseSettings(rawSettings) {
-    let parsed;
-    try {
-        parsed = JSON.parse(rawSettings);
-    }
-    catch (error) {
-        throw new SettingsParseError("INVALID_JSON", "Invalid settings JSON.", { cause: error });
-    }
-    const result = settingsSchema.safeParse(parsed);
+    const result = settingsSchema.safeParse(rawSettings);
     if (!result.success) {
         const issues = result.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`);
         throw new SettingsParseError("INVALID_SCHEMA", `Invalid settings schema. ${issues.join("; ")}`, { issues });
     }
     return result.data;
 }
-export async function loadKeiyakuSettings(cwd) {
-    let rawSettings;
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMerge(base, override) {
+    if (!isPlainObject(base) || !isPlainObject(override)) {
+        return override;
+    }
+    const merged = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        merged[key] = key in merged ? deepMerge(merged[key], value) : value;
+    }
+    return merged;
+}
+async function readOptionalSettings(filePath) {
     try {
-        rawSettings = await fs.readFile(path.join(cwd, SETTINGS_FILE), "utf-8");
+        const raw = await fs.readFile(filePath, "utf-8");
+        return { found: true, value: JSON.parse(raw) };
     }
     catch (error) {
-        if (error?.code === "ENOENT") {
-            return null;
+        if (isErrnoException(error) && error.code === "ENOENT") {
+            return { found: false, value: undefined };
+        }
+        if (error instanceof SyntaxError) {
+            throw new FlowError("INVALID_SETTINGS", `Invalid settings in ${filePath} (must be valid JSON).`, {
+                cause: error,
+            });
         }
         throw error;
     }
+}
+export async function loadKeiyakuSettings(cwd) {
+    const localSettingsPath = path.join(cwd, SETTINGS_FILE);
+    const globalSettingsPath = path.join(getKeiyakuHome(), path.basename(SETTINGS_FILE));
+    const globalSettings = await readOptionalSettings(globalSettingsPath);
+    const localSettings = await readOptionalSettings(localSettingsPath);
+    if (!globalSettings.found && !localSettings.found) {
+        return null;
+    }
+    const resolvedSettings = globalSettings.found && localSettings.found
+        ? deepMerge(globalSettings.value, localSettings.value)
+        : globalSettings.found
+            ? globalSettings.value
+            : localSettings.value;
     try {
-        return parseSettings(rawSettings);
+        return parseSettings(resolvedSettings);
     }
     catch (error) {
         if (error instanceof SettingsParseError) {
-            if (error.code === "INVALID_JSON") {
-                throw new FlowError("INVALID_SETTINGS", `Invalid settings in ${SETTINGS_FILE} (must be valid JSON).`, {
-                    cause: error,
-                });
-            }
             throw new FlowError("INVALID_SETTINGS", `Invalid settings in ${SETTINGS_FILE} (invalid schema).`, {
                 cause: error,
                 hints: error.issues,
@@ -175,9 +195,6 @@ export async function loadKeiyakuSettings(cwd) {
         throw error;
     }
 }
-export function getDefaultAgentProfile(role) {
-    return DEFAULT_AGENT_PROFILES[role];
-}
 export function resolveAgentProfile(settings, name) {
     const configuredProfile = settings?.agent?.[name];
     if (configuredProfile) {

package/build/config/term-presets/resolver.js

@@ -10,9 +10,6 @@ export function resolveTermPreset() {
     }
     throw new Error(`Unsupported ${ENV_KEYS.TERM_PRESET} '${raw}'. Expected '${fallbackPreset}'.`);
 }
-export function listTermPresets() {
-    return [DEFAULT_PRESET];
-}
 function extractPresetAvailableNames(preset) {
     return (preset.availableNames?.map((value) => value.trim()).filter((value) => value.length > 0) ?? []);
 }

package/build/errno.js

@@ -0,0 +1,3 @@
+export function isErrnoException(error) {
+    return error instanceof Error && "code" in error;
+}

package/build/flow-error.js

@@ -88,6 +88,8 @@ function hintForFlowCode(code, context) {
             return "Invalid close intent. Valid values are `CLAIM` and `FORFEIT`.";
         case "INVALID_SETTINGS":
             return `Fix invalid configuration in \`${SETTINGS_FILE}\` and retry.`;
+        case "CONCURRENT_MODIFICATION":
+            return `Concurrent repository changes were detected during \`${context.driveToolName}\`. Retry on the latest branch state.`;
         case "INTERNAL_STATE":
             return "An internal state error occurred. Please verify your repository status.";
         case "REVIEW_REJECTED":

package/build/generated/version.js

@@ -1,2 +1,2 @@
 // Auto-generated by scripts/generate-version.mjs
-export const VERSION = "0.1.76";
+export const VERSION = "0.1.78";

package/build/git/diff/constants.js

@@ -4,3 +4,4 @@ export const MAX_DIFF_LINES_PER_FILE = 80;
 export const INCREMENTAL_DIFF_RANGE = "HEAD~1...HEAD";
 export const TARGETED_DIFF_WARNING = "Warning: no valid diff coordinates found in KEIYAKU_TRACE.md; showing stat-only diff.";
 export const NOT_SHOWN_IN_DETAIL_PREFIX = "--- not shown in detail: ";
+export const DIFF_TRUNCATED_MARKER = "...[truncated]";

package/build/git/diff/filter.js

@@ -1,5 +1,5 @@
 import { NOT_SHOWN_IN_DETAIL_PREFIX } from "./constants.js";
-import { isDeletedDiffSection, parseDiffPathFromHeader, parseUnifiedHunks, splitDiffByFile, truncateTextWithFooter, } from "./parsers.js";
+import { isDeletedDiffSection, parseDiffPathFromHeader, parseUnifiedHunks, splitDiffByFile, truncateDiffSectionByLineCount, } from "./parsers.js";
 function rangesOverlap(aStart, aEnd, bStart, bEnd) {
     return aStart <= bEnd && bStart <= aEnd;
 }
@@ -12,21 +12,6 @@ function buildCoordinateIndex(coordinates) {
     }
     return index;
 }
-export function capTargetedDiffText(diffText, maxChars) {
-    if (diffText.length <= maxChars)
-        return diffText;
-    return truncateTextWithFooter(diffText, maxChars, diffText.length - maxChars);
-}
-function capDiffSectionByLineCount(section, maxLinesPerFile) {
-    if (maxLinesPerFile < 1)
-        return "";
-    const lines = section.split("\n");
-    if (lines.length <= maxLinesPerFile)
-        return section;
-    const truncated = lines.slice(0, maxLinesPerFile);
-    truncated.push(`... [truncated ${lines.length - maxLinesPerFile} lines for this file]`);
-    return truncated.join("\n");
-}
 export function filterDiffByCoordinates(rawPatch, coordinates, maxLinesPerFile = Number.POSITIVE_INFINITY) {
     const sections = splitDiffByFile(rawPatch);
     if (sections.length === 0)
@@ -66,11 +51,11 @@ export function filterDiffByCoordinates(rawPatch, coordinates, maxLinesPerFile =
             ...prelude,
             ...matchingHunks.flatMap((hunk) => [hunk.header, ...hunk.lines]),
         ].join("\n");
-        selectedSectionsByPath.set(coordinate.path, capDiffSectionByLineCount(rendered, maxLinesPerFile));
+        selectedSectionsByPath.set(coordinate.path, truncateDiffSectionByLineCount(rendered, maxLinesPerFile));
     }
     const selectedSections = [
         ...selectedSectionsByPath.values(),
-        ...deletedSections.map((section) => capDiffSectionByLineCount(section, maxLinesPerFile)),
+        ...deletedSections.map((section) => truncateDiffSectionByLineCount(section, maxLinesPerFile)),
     ];
     if (selectedSections.length === 0)
         return "";

package/build/git/diff/parsers.js

@@ -1,58 +1,17 @@
-const SIMPLE_NAME_STATUS_VALUES = ["A", "M", "D", "T", "U", "X", "B"];
-const SIMPLE_NAME_STATUS_SET = new Set(SIMPLE_NAME_STATUS_VALUES);
-function isSimpleNameStatus(status) {
-    return SIMPLE_NAME_STATUS_SET.has(status);
-}
-export function parseNumStat(content) {
-    const rows = [];
-    for (const line of content.split(/\r?\n/)) {
-        if (!line.trim())
-            continue;
-        const [addRaw, delRaw, ...pathParts] = line.split("\t");
-        const filePath = pathParts.join("\t").trim();
-        if (!filePath)
-            continue;
-        const binary = addRaw === "-" || delRaw === "-";
-        rows.push({
-            path: filePath,
-            additions: binary ? 0 : Number.parseInt(addRaw, 10) || 0,
-            deletions: binary ? 0 : Number.parseInt(delRaw, 10) || 0,
-            binary,
-        });
-    }
-    return rows;
-}
-export function parseNameStatus(content) {
-    const map = new Map();
-    for (const line of content.split(/\r?\n/)) {
-        if (!line.trim())
-            continue;
-        const parts = line.split("\t");
-        const statusRaw = (parts[0] ?? "").trim();
-        if (!statusRaw)
-            continue;
-        if ((statusRaw.startsWith("R") || statusRaw.startsWith("C")) && parts.length >= 3) {
-            const scoreRaw = statusRaw.slice(1);
-            const score = Number.parseInt(scoreRaw, 10);
-            const oldPath = (parts[1] ?? "").trim();
-            const path = (parts[2] ?? "").trim();
-            if (!path)
-                continue;
-            const status = statusRaw[0] === "R" ? "R" : "C";
-            map.set(path, { status, score: Number.isFinite(score) ? score : 0, oldPath, path });
-            continue;
-        }
-        const path = (parts[1] ?? "").trim();
-        if (!path)
-            continue;
-        // Git can emit single-letter statuses, possibly in combinations; we keep just the first.
-        const status = statusRaw[0] ?? "";
-        if (!isSimpleNameStatus(status))
-            continue;
-        map.set(path, { status, path });
-    }
-    return map;
-}
+import { Buffer } from "node:buffer";
+import { DIFF_TRUNCATED_MARKER } from "./constants.js";
+const DIFF_GIT_HEADER_PREFIX = "diff --git ";
+const GIT_QUOTED_PATH_ESCAPES = {
+    '"': 34,
+    "\\": 92,
+    a: 7,
+    b: 8,
+    f: 12,
+    n: 10,
+    r: 13,
+    t: 9,
+    v: 11,
+};
 export function splitDiffByFile(content) {
     const sections = [];
     let current = [];
@@ -135,10 +94,83 @@ export function isMissingBaseRevisionError(err) {
         text.includes("unknown revision or path not in the working tree") ||
         text.includes("ambiguous argument"));
 }
+function unescapeQuotedDiffPath(value) {
+    const bytes = [];
+    for (let index = 0; index < value.length; index += 1) {
+        const char = value[index];
+        if (char !== "\\") {
+            bytes.push(...Buffer.from(char ?? "", "utf8"));
+            continue;
+        }
+        const escaped = value[index + 1];
+        if (escaped === undefined) {
+            bytes.push(92);
+            continue;
+        }
+        if (escaped >= "0" && escaped <= "7") {
+            let octal = escaped;
+            let cursor = index + 2;
+            while (cursor < value.length && octal.length < 3) {
+                const digit = value[cursor];
+                if (digit === undefined || digit < "0" || digit > "7")
+                    break;
+                octal += digit;
+                cursor += 1;
+            }
+            bytes.push(Number.parseInt(octal, 8));
+            index = cursor - 1;
+            continue;
+        }
+        const decoded = GIT_QUOTED_PATH_ESCAPES[escaped];
+        if (decoded !== undefined) {
+            bytes.push(decoded);
+            index += 1;
+            continue;
+        }
+        bytes.push(...Buffer.from(escaped, "utf8"));
+        index += 1;
+    }
+    return Buffer.from(bytes).toString("utf8");
+}
+function readDiffHeaderToken(line, startIndex) {
+    let index = startIndex;
+    while (index < line.length && line[index] === " ") {
+        index += 1;
+    }
+    if (index >= line.length)
+        return null;
+    if (line[index] !== '"') {
+        let endIndex = index;
+        while (endIndex < line.length && line[endIndex] !== " ") {
+            endIndex += 1;
+        }
+        return {
+            value: line.slice(index, endIndex),
+            nextIndex: endIndex,
+        };
+    }
+    let endIndex = index + 1;
+    let escaped = false;
+    while (endIndex < line.length) {
+        const char = line[endIndex];
+        if (!escaped && char === '"') {
+            return {
+                value: unescapeQuotedDiffPath(line.slice(index + 1, endIndex)),
+                nextIndex: endIndex + 1,
+            };
+        }
+        escaped = !escaped && char === "\\";
+        endIndex += 1;
+    }
+    return null;
+}
 export function parseDiffPathFromHeader(diffGitLine) {
-    // Format: diff --git a/<path> b/<path>
-    const parts = diffGitLine.split(" ");
-    const bPart = parts[3] ?? "";
+    if (!diffGitLine.startsWith(DIFF_GIT_HEADER_PREFIX))
+        return null;
+    const aPart = readDiffHeaderToken(diffGitLine, DIFF_GIT_HEADER_PREFIX.length);
+    if (!aPart)
+        return null;
+    const bPart = readDiffHeaderToken(diffGitLine, aPart.nextIndex)?.value ?? "";
     if (!bPart.startsWith("b/"))
         return null;
     return bPart.slice(2);
@@ -158,20 +190,76 @@ export function truncateTextWithFooter(text, maxChars, omittedChars) {
     const cut = text.slice(0, maxChars - footer.length);
     return `${cut}${footer}`;
 }
-export function truncateBlockToLineBudget(block, maxChars) {
+function isChangedDiffLine(line) {
+    return (line.startsWith("+") && !line.startsWith("+++")) || (line.startsWith("-") && !line.startsWith("---"));
+}
+function trimUnsafeDiffBoundary(kept, remaining) {
+    if (kept.length === 0 || remaining.length === 0)
+        return kept;
+    const safe = [...kept];
+    while (safe.length > 0 && isChangedDiffLine(safe[safe.length - 1] ?? "") && isChangedDiffLine(remaining[0] ?? "")) {
+        safe.pop();
+    }
+    if ((safe[safe.length - 1] ?? "").startsWith("@@ ")) {
+        safe.pop();
+    }
+    return safe;
+}
+function renderTruncatedDiff(lines) {
+    if (lines.length === 0)
+        return DIFF_TRUNCATED_MARKER;
+    return `${lines.join("\n")}\n${DIFF_TRUNCATED_MARKER}`;
+}
+export function truncateDiffSectionByLineCount(section, maxLines) {
+    if (maxLines < 1)
+        return "";
+    const lines = section.split("\n");
+    if (lines.length <= maxLines)
+        return section;
+    const { prelude, hunks } = parseUnifiedHunks(lines);
+    if (hunks.length === 0 || prelude.length >= maxLines) {
+        return renderTruncatedDiff(trimUnsafeDiffBoundary(lines.slice(0, maxLines), lines.slice(maxLines)));
+    }
+    const kept = [...prelude];
+    let lineCount = prelude.length;
+    for (let index = 0; index < hunks.length; index += 1) {
+        const hunk = hunks[index];
+        const hunkLines = [hunk.header, ...hunk.lines];
+        if (lineCount + hunkLines.length <= maxLines) {
+            kept.push(...hunkLines);
+            lineCount += hunkLines.length;
+            continue;
+        }
+        kept.push(...hunkLines);
+        lineCount += hunkLines.length;
+        break;
+    }
+    if (lineCount >= lines.length)
+        return section;
+    return renderTruncatedDiff(kept);
+}
+export function truncateDiffBlockToCharBudget(block, maxChars) {
     if (maxChars <= 0)
         return "";
     if (block.length <= maxChars)
         return block;
+    if (DIFF_TRUNCATED_MARKER.length >= maxChars) {
+        return DIFF_TRUNCATED_MARKER.slice(0, maxChars);
+    }
     const lines = block.split("\n");
     const kept = [];
     let used = 0;
     for (const line of lines) {
         const delta = (kept.length > 0 ? 1 : 0) + line.length;
-        if (used + delta > maxChars)
+        const reservedMarker = 1 + DIFF_TRUNCATED_MARKER.length;
+        if (used + delta + reservedMarker > maxChars)
             break;
         kept.push(line);
         used += delta;
     }
-    return kept.join("\n");
+    const safe = trimUnsafeDiffBoundary(kept, lines.slice(kept.length));
+    if (safe.length === 0) {
+        return DIFF_TRUNCATED_MARKER.slice(0, maxChars);
+    }
+    return renderTruncatedDiff(safe);
 }

package/build/git/diff/preview.js

@@ -1,6 +1,5 @@
 import { createGit, wrapGitError } from "../core.js";
 import { DIFF_EXCLUDES } from "./constants.js";
-import { parseNumStat } from "./parsers.js";
 export async function getDiffStats(cwd, baseBranch) {
     const git = createGit(cwd);
     let rawNumStat;
@@ -10,7 +9,22 @@ export async function getDiffStats(cwd, baseBranch) {
     catch (err) {
         throw wrapGitError(`diff --numstat ${baseBranch}...HEAD`, err, cwd);
     }
-    const rows = parseNumStat(rawNumStat);
+    const rows = rawNumStat
+        .split(/\r?\n/)
+        .flatMap((line) => {
+        if (!line.trim())
+            return [];
+        const [addRaw, delRaw, ...pathParts] = line.split("\t");
+        const filePath = pathParts.join("\t").trim();
+        if (!filePath)
+            return [];
+        const binary = addRaw === "-" || delRaw === "-";
+        return [{
+                path: filePath,
+                additions: binary ? 0 : Number.parseInt(addRaw, 10) || 0,
+                deletions: binary ? 0 : Number.parseInt(delRaw, 10) || 0,
+            }];
+    });
     return {
         filesChanged: rows.length,
         insertions: rows.reduce((sum, row) => sum + row.additions, 0),

package/build/git/diff/read.js

@@ -1,13 +1,18 @@
 import { createGit, wrapGitError } from "../core.js";
 import { DIFF_EXCLUDES } from "./constants.js";
-import { isMissingBaseRevisionError, splitDiffByFile, totalJoinedLength, truncateBlockToLineBudget, } from "./parsers.js";
-import { renderStatDiffPreviewText } from "./stat.js";
-function buildPatchCommand(range, options) {
+import { isMissingBaseRevisionError, splitDiffByFile, totalJoinedLength, truncateDiffBlockToCharBudget, truncateDiffSectionByLineCount, truncateTextWithFooter, } from "./parsers.js";
+function normalizeDiffTarget(target) {
+    return typeof target === "string" ? [target] : [...target];
+}
+function formatDiffTarget(target) {
+    return typeof target === "string" ? target : target.join(" ");
+}
+function buildPatchCommand(target, options) {
     const args = ["diff", "--no-color", "--no-ext-diff", "--unified=3"];
     if (options.algorithm === "histogram") {
         args.push("--diff-algorithm=histogram");
     }
-    args.push(range, "--", ".", ...DIFF_EXCLUDES);
+    args.push(...normalizeDiffTarget(target), "--", ".", ...DIFF_EXCLUDES);
     return args;
 }
 function renderPatchDiff(output, options) {
@@ -26,11 +31,9 @@ function renderPatchDiff(output, options) {
     let omittedFiles = 0;
     for (let i = 0; i < sections.length; i += 1) {
         const section = sections[i];
-        const content = maxLinesPerFile === undefined ? [...section] : section.slice(0, maxLinesPerFile);
-        if (maxLinesPerFile !== undefined && section.length > maxLinesPerFile) {
-            content.push(`... [truncated ${section.length - maxLinesPerFile} lines for this file]`);
-        }
-        const fileBlock = content.join("\n");
+        const fileBlock = maxLinesPerFile === undefined
+            ? section.join("\n")
+            : truncateDiffSectionByLineCount(section.join("\n"), maxLinesPerFile);
         if (maxChars === undefined) {
             renderedSections.push(fileBlock);
             continue;
@@ -44,7 +47,7 @@ function renderPatchDiff(output, options) {
         if (renderedSections.length === 0) {
             const notice = `... [omitted ${omittedFiles} file(s) to stay under ${maxChars} chars] ...`;
             const partialBudget = Math.max(0, maxChars - totalJoinedLength(["", notice]));
-            const partial = truncateBlockToLineBudget(fileBlock, partialBudget);
+            const partial = truncateDiffBlockToCharBudget(fileBlock, partialBudget);
             if (partial.trim()) {
                 renderedSections.push(partial);
             }
@@ -62,20 +65,29 @@ function renderPatchDiff(output, options) {
     }
     return renderedSections.join("\n\n").trim() || "No diff.";
 }
-export async function readDiff(cwd, range, format, options = {}) {
+export async function readDiff(cwd, target, format, options = {}) {
     const git = createGit(cwd);
+    const formattedTarget = formatDiffTarget(target);
     try {
         if (format === "stat") {
             const statVariant = options.statVariant ?? "summary";
             const args = statVariant === "numstat"
-                ? ["diff", "--numstat", range, "--", ".", ...DIFF_EXCLUDES]
-                : ["diff", "--stat=120,80", "--compact-summary", range, "--", ".", ...DIFF_EXCLUDES];
+                ? ["diff", "--numstat", ...normalizeDiffTarget(target), "--", ".", ...DIFF_EXCLUDES]
+                : ["diff", "--stat=120,80", "--compact-summary", ...normalizeDiffTarget(target), "--", ".", ...DIFF_EXCLUDES];
             const output = await git.raw(args);
-            return statVariant === "summary"
-                ? renderStatDiffPreviewText(output, options.maxChars ?? Number.POSITIVE_INFINITY)
-                : output.trim() || "No diff.";
+            if (statVariant !== "summary") {
+                return output.trim() || "No diff.";
+            }
+            const trimmed = output.trim();
+            if (!trimmed)
+                return "No diff.";
+            const maxChars = options.maxChars ?? Number.POSITIVE_INFINITY;
+            if (trimmed.length <= maxChars) {
+                return trimmed;
+            }
+            return truncateTextWithFooter(trimmed, maxChars, trimmed.length - maxChars);
         }
-        const output = await git.raw(buildPatchCommand(range, options));
+        const output = await git.raw(buildPatchCommand(target, options));
         return renderPatchDiff(output, options);
     }
     catch (error) {
@@ -84,9 +96,9 @@ export async function readDiff(cwd, range, format, options = {}) {
         }
         const commandLabel = format === "stat"
             ? options.statVariant === "numstat"
-                ? `diff --numstat ${range}`
-                : `diff --stat=120,80 --compact-summary ${range}`
-            : `diff --no-color --no-ext-diff --unified=3 ${range}`;
+                ? `diff --numstat ${formattedTarget}`
+                : `diff --stat=120,80 --compact-summary ${formattedTarget}`
+            : `diff --no-color --no-ext-diff --unified=3 ${formattedTarget}`;
         throw wrapGitError(commandLabel, error, cwd);
     }
 }

package/build/git/snapshot.js

@@ -1,7 +1,7 @@
 import * as fs from "fs/promises";
 import * as os from "os";
 import * as path from "path";
-import { MISSING_HEAD_PATTERNS, NOT_GIT_REPOSITORY_PATTERNS, createGit, errorContainsAnyPattern, wrapGitError } from "./core.js";
+import { NOT_GIT_REPOSITORY_PATTERNS, createGit, errorContainsAnyPattern, wrapGitError } from "./core.js";
 async function withTempIndex(cwd, run) {
     const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "keiyaku-git-index-"));
     const tempIndexPath = path.join(tempDir, "index");
@@ -18,26 +18,8 @@ export async function createWorkspaceSnapshot(cwd) {
     try {
         return await withTempIndex(cwd, async (git) => {
             await git.raw(["add", "-A"]);
-            const tree = (await git.raw(["write-tree"])).trim();
-            if (!tree)
-                return undefined;
-            let head;
-            try {
-                head = (await git.revparse(["--verify", "HEAD"])).trim() || undefined;
-            }
-            catch (error) {
-                if (!errorContainsAnyPattern(error, MISSING_HEAD_PATTERNS)) {
-                    throw wrapGitError("rev-parse --verify HEAD", error, cwd);
-                }
-                head = undefined;
-            }
-            const args = ["commit-tree", tree];
-            if (head) {
-                args.push("-p", head);
-            }
-            args.push("-m", "keiyaku ask snapshot");
-            const sha = await git.raw(args);
-            return sha.trim() || undefined;
+            const tree = await git.raw(["write-tree"]);
+            return tree.trim() || undefined;
         });
     }
     catch (error) {
@@ -50,11 +32,10 @@ export async function createWorkspaceSnapshot(cwd) {
 export async function getChangedFilesBetweenSnapshots(cwd, beforeSha, afterSha) {
     const git = createGit(cwd);
     try {
-        const output = await git.raw(["diff", "--name-status", `${beforeSha}..${afterSha}`]);
+        const output = await git.raw(["diff", "--name-status", beforeSha, afterSha]);
         return output.trim();
     }
     catch (err) {
-        throw wrapGitError(`diff --name-status ${beforeSha}..${afterSha}`, err, cwd);
+        throw wrapGitError(`diff --name-status ${beforeSha} ${afterSha}`, err, cwd);
     }
 }
-export { withTempIndex };

package/build/git/worktree.js

@@ -6,6 +6,7 @@ export const DIRTY_FILE_CATEGORY = {
     renamed: "renamed",
     conflicted: "conflicted",
     copied: "copied",
+    untracked: "untracked",
 };
 function normalizeGitPath(filePath) {
     return filePath.trim().replace(/^\.\/+/, "");
@@ -22,6 +23,9 @@ function toDirtyStatusPathSets(status) {
     };
 }
 function deriveDirtyFileCategory(file, statusPathSets) {
+    if (statusPathSets.untracked.has(file.path)) {
+        return DIRTY_FILE_CATEGORY.untracked;
+    }
     if (statusPathSets.conflicted.has(file.path)) {
         return DIRTY_FILE_CATEGORY.conflicted;
     }
@@ -56,10 +60,7 @@ export async function getDirtyFiles(cwd) {
         throw wrapGitError("status --porcelain", err, cwd);
     }
     const statusPathSets = toDirtyStatusPathSets(status);
-    return status.files
-        .filter((file) => !(file.index === "?" && file.working_dir === "?"))
-        .filter((file) => !statusPathSets.untracked.has(file.path))
-        .map((file) => ({
+    return status.files.map((file) => ({
         path: file.path,
         index: file.index,
         working_dir: file.working_dir,

package/build/mcp/responses.js

@@ -142,7 +142,7 @@ function formatReview(review) {
         `Review ${review.review}: ${review.result}`,
         ...formatMaybe("See", review.historyPath, FORMAT_LIST_MAX_ITEM_CHARS),
     ];
-    if (review.result === "rejected" && review.findings?.trim()) {
+    if (review.findings?.trim()) {
         lines.push("", truncateForDisplay(review.findings, DISPLAY_TEXT_MAX_CHARS));
     }
     return lines;
@@ -380,6 +380,7 @@ export function buildPetitionClaimResponse(result, input) {
         ? `Scores: placement=${input.placement} exactness=${input.exactness} containment=${input.containment} idiomatic=${input.idiomatic}  [total: ${input.placement + input.exactness + input.containment + input.idiomatic}/${CLOSE_TOTAL_SCORE_MAX}]`
         : "Claim Gates: bypassed by Architect";
     const diffSection = result.diff ? buildSection(DIFF_OVERVIEW_SECTION_TITLE, result.diff) : null;
+    const reviewSection = result.review ? buildSection(REVIEW_SECTION_TITLE, formatReview(result.review)) : null;
     const infoLines = [
         ...formatMaybe("Result", result.result, INFO_COMMIT_MAX_CHARS),
         ...formatMaybe("Title", input.title, INFO_BRANCH_MAX_CHARS),
@@ -392,7 +393,7 @@ export function buildPetitionClaimResponse(result, input) {
         scoreLine,
         ...formatMaybe("Oath", input.oath, INFO_PLEA_MAX_CHARS),
     ];
-    const text = assembleResponse(`${RESPONSE_MARKERS.claim} Keiyaku Fulfilled (Claim)`, `Merged '${result.deletedBranch}' into '${result.mergedInto}'${result.commit ? ` [${result.commit}]` : ''}. Deleted feature branch.`, [diffSection].filter((section) => section !== null), infoLines);
+    const text = assembleResponse(`${RESPONSE_MARKERS.claim} Keiyaku Fulfilled (Claim)`, `Merged '${result.deletedBranch}' into '${result.mergedInto}'${result.commit ? ` [${result.commit}]` : ''}. Deleted feature branch.`, [diffSection, reviewSection].filter((section) => section !== null), infoLines);
     return {
         content: [{ type: "text", text }],
         structuredContent: buildSuccessStructuredContent(resultData),