@astrosheep/keiyaku 0.1.47 → 0.1.49

package/build/workflow/response-builders.js

@@ -6,6 +6,12 @@ const FORMAT_LIST_MAX_ITEMS = 16;
 const FORMAT_LIST_MAX_ITEM_CHARS = 400;
 const RULES_SECTION_MAX_CHARS = 5000;
 const BRANCH_LABEL = "Branch";
+const INFO_SECTION_TITLE = "Info";
+const HINTS_SECTION_TITLE = "Hints";
+const STATUS_KEIYAKU_SECTION_TITLE = "Keiyaku";
+const STATUS_BLOCKED_SECTION_TITLE = "Blocked";
+const STATUS_ACTIVE_SUMMARY_PREFIX = "● Active";
+const STATUS_INACTIVE_SUMMARY = "○ Inactive";
 // --- Helpers ---
 function truncateForDisplay(raw, maxChars = DISPLAY_TEXT_MAX_CHARS) {
     const text = raw.trim();
@@ -31,6 +37,15 @@ function formatList(label, items, opts) {
     const tail = items.length > maxItems ? [`...(+${items.length - maxItems} more)`] : [];
     return [...head, ...shown, ...tail];
 }
+function formatHints(hints, opts) {
+    const maxItems = opts?.maxItems ?? FORMAT_LIST_MAX_ITEMS;
+    const maxItemChars = opts?.maxItemChars ?? FORMAT_LIST_MAX_ITEM_CHARS;
+    if (hints.length === 0)
+        return [];
+    const shown = hints.slice(0, maxItems).map((hint) => `• ${truncateForDisplay(hint, maxItemChars)}`);
+    const tail = hints.length > maxItems ? [`...(+${hints.length - maxItems} more)`] : [];
+    return [...shown, ...tail];
+}
 function buildSection(title, content) {
     const body = Array.isArray(content) ? content.join("\n") : content;
     const normalized = body.trim();
@@ -38,10 +53,12 @@ function buildSection(title, content) {
         return null;
     return { title, body };
 }
-function formatOperationReadiness(label, readiness) {
+function formatBlockedOperation(label, blockers) {
+    if (blockers.length === 0)
+        return [];
     return [
-        `${label} Available: ${readiness.available ? "yes" : "no"}`,
-        ...formatList(`${label} Blockers`, readiness.blockers, { maxItems: 10, maxItemChars: 300 }),
+        `${label}:`,
+        ...formatList(`${label} Blockers`, blockers, { maxItems: 10, maxItemChars: 300 }),
     ];
 }
 function buildSuccessStructuredContent(data) {
@@ -57,8 +74,9 @@ export function buildKeiyakuSuccessResponse(result, input) {
     const responseData = normalizedRules ? { ...resultData, rules: normalizedRules } : { ...resultData };
     const summarySection = buildSection("Summary", result.summary);
     const rulesSection = buildSection("Rules", truncateForDisplay(normalizedRules, RULES_SECTION_MAX_CHARS));
+    const hintsSection = buildSection(HINTS_SECTION_TITLE, formatHints(result.meta?.hints ?? [], { maxItems: 12, maxItemChars: 400 }));
     const diffSection = buildSection(DIFF_OVERVIEW_SECTION_TITLE, result.diff);
-    const infoLines = [
+    const infoSection = buildSection(INFO_SECTION_TITLE, [
         ...formatMaybe("Identity", input.name, 120),
         ...formatMaybe("Consumed from_file and deleted", result.consumedFromFile, 300),
         ...formatList("Existing local keiyaku branches (non-blocking)", result.existingBranches ?? [], {
@@ -68,12 +86,11 @@ export function buildKeiyakuSuccessResponse(result, input) {
         ...formatMaybe(BRANCH_LABEL, result.currentBranch, 200),
         ...formatMaybe("Base Branch", result.baseBranch, 200),
         ...formatMaybe("Commit", result.commit, 100),
-        ...(input.nextHints?.start ?? []),
-    ];
+    ]);
     const summaryLine = result.commit
         ? `Created branch '${result.currentBranch}' (base: '${result.baseBranch}') [${result.commit}].`
         : `Created branch '${result.currentBranch}' (base: '${result.baseBranch}').`;
-    const text = assembleResponse(`${RESPONSE_MARKERS.round} Started (Round ${result.round})`, summaryLine, [summarySection, rulesSection, diffSection].filter((section) => section !== null), infoLines);
+    const text = assembleResponse(`${RESPONSE_MARKERS.round} Started (Round ${result.round})`, summaryLine, [summarySection, rulesSection, infoSection, diffSection, hintsSection].filter((section) => section !== null));
     return {
         content: [{ type: "text", text }],
         structuredContent: buildSuccessStructuredContent(responseData),
@@ -82,18 +99,18 @@ export function buildKeiyakuSuccessResponse(result, input) {
 export function buildDriveResponse(result, input) {
     const { status: _status, ...resultData } = result;
     const summarySection = buildSection("Summary", result.summary);
+    const hintsSection = buildSection(HINTS_SECTION_TITLE, formatHints(result.meta?.hints ?? [], { maxItems: 12, maxItemChars: 400 }));
     const diffSection = buildSection(DIFF_OVERVIEW_SECTION_TITLE, result.diff);
-    const infoLines = [
+    const infoSection = buildSection(INFO_SECTION_TITLE, [
         ...formatMaybe("Identity", input.name, 120),
         ...formatMaybe(BRANCH_LABEL, result.currentBranch, 200),
         ...formatMaybe("Base Branch", result.baseBranch, 200),
         ...formatMaybe("Commit", result.commit, 100),
-        ...(input.nextHints?.drive ?? []),
-    ];
+    ]);
     const summaryLine = result.commit
         ? `Updated branch '${result.currentBranch}' [${result.commit}].`
         : `Updated branch '${result.currentBranch}'.`;
-    const text = assembleResponse(`${RESPONSE_MARKERS.round} Driven (Round ${result.round})`, summaryLine, [summarySection, diffSection].filter((section) => section !== null), infoLines);
+    const text = assembleResponse(`${RESPONSE_MARKERS.round} Driven (Round ${result.round})`, summaryLine, [summarySection, infoSection, diffSection, hintsSection].filter((section) => section !== null));
     return {
         content: [{ type: "text", text }],
         structuredContent: buildSuccessStructuredContent(resultData),
@@ -135,13 +152,14 @@ export function buildCloseDoneResponse(result, input) {
         `Scores: placement=${input.placement} exactness=${input.exactness} containment=${input.containment} idiomatic=${input.idiomatic} cohesive=${input.cohesive}  [total: ${input.placement + input.exactness + input.containment + input.idiomatic + input.cohesive}/50]`,
         ...formatMaybe("Oath", input.oath, 220),
     ];
-    const text = assembleResponse(`${RESPONSE_MARKERS.claim} Keiyaku Fulfilled (Claim)`, `Merged '${result.deletedBranch}' into '${result.mergedInto}'${result.commit ? ` [${result.commit}]` : ''}. Deleted feature branch.${result.draftKept ? " Draft 'KEIYAKU.draft.md' kept." : ''}`, [diffSection].filter((section) => section !== null), infoLines);
+    const draftPathMessage = result.draftPath ? ` Draft kept at '${result.draftPath}'.` : "";
+    const text = assembleResponse(`${RESPONSE_MARKERS.claim} Keiyaku Fulfilled (Claim)`, `Merged '${result.deletedBranch}' into '${result.mergedInto}'${result.commit ? ` [${result.commit}]` : ''}. Deleted feature branch.${draftPathMessage}`, [diffSection].filter((section) => section !== null), infoLines);
     return {
         content: [{ type: "text", text }],
         structuredContent: buildSuccessStructuredContent(resultData),
     };
 }
-export function buildCloseDropResponse(result, input) {
+export function buildCloseDropResponse(result, _input) {
     const { status: _status, ...resultData } = result;
     const droppedChanges = result.droppedChanges ?? [];
     const warningSection = buildSection("Warning", formatList("Dropped Local Changes", droppedChanges, { maxItems: 40, maxItemChars: 400 }));
@@ -151,7 +169,8 @@ export function buildCloseDropResponse(result, input) {
         ...formatMaybe(BRANCH_LABEL, result.currentBranch, 200),
         ...formatMaybe("Base Branch", result.baseBranch, 200),
     ];
-    const text = assembleResponse(`${RESPONSE_MARKERS.forfeit} Keiyaku Forfeited (Forfeit)`, `Deleted '${result.deletedBranch}'. Switched back to '${result.baseBranch}'.${result.archiveTag ? ` Archived at '${result.archiveTag}'.` : ""}${droppedChanges.length > 0 ? ` Dropped ${droppedChanges.length} local change(s).` : ''}${result.draftKept ? " Draft 'KEIYAKU.draft.md' kept." : ''}`, [warningSection].filter((section) => section !== null), infoLines);
+    const draftPathMessage = result.draftPath ? ` Draft kept at '${result.draftPath}'.` : "";
+    const text = assembleResponse(`${RESPONSE_MARKERS.forfeit} Keiyaku Forfeited (Forfeit)`, `Deleted '${result.deletedBranch}'. Switched back to '${result.baseBranch}'.${result.archiveTag ? ` Archived at '${result.archiveTag}'.` : ""}${droppedChanges.length > 0 ? ` Dropped ${droppedChanges.length} local change(s).` : ''}${draftPathMessage}`, [warningSection].filter((section) => section !== null), infoLines);
     return {
         content: [{ type: "text", text }],
         structuredContent: buildSuccessStructuredContent(resultData),
@@ -167,7 +186,7 @@ export function buildToolErrorResponse(input) {
             error: {
                 code: input.errorCode,
                 message: input.message,
-                suggestion: input.hint,
+                suggestion: input.hints[0] ?? "",
             },
         },
     };
@@ -178,9 +197,8 @@ export function buildToolErrorResponse(input) {
 }
 function buildToolErrorText(input) {
     const errorSection = buildSection("Error", input.message);
-    const hintSection = buildSection("Hint", input.hint);
-    const contextSection = buildSection("Context", input.inputEcho ?? []);
-    return assembleResponse(colorizeErrorStatus(`${RESPONSE_MARKERS.failure} Failed [${input.errorCode}]`), "Request could not be completed.", [errorSection, hintSection, contextSection].filter((section) => section !== null));
+    const hintsSection = buildSection("Hints", formatHints(input.hints, { maxItems: 12, maxItemChars: 400 }));
+    return assembleResponse(colorizeErrorStatus(`${RESPONSE_MARKERS.failure} Failed [${input.errorCode}]`), "Request could not be completed.", [errorSection, hintsSection].filter((section) => section !== null));
 }
 export function buildHelpResponse(input) {
     return {
@@ -189,34 +207,47 @@ export function buildHelpResponse(input) {
     };
 }
 export function buildStatusResponse(result, labels) {
-    const summaryLine = result.active
-        ? `Active keiyaku branch '${result.branch ?? "(unknown)"}'.`
-        : "No active keiyaku branch.";
-    const draftFileInfo = result.protocolFiles.draft.present
-        ? [
-            `present`,
-            `tracked=${result.protocolFiles.draft.tracked ? "yes" : "no"}`,
-            `dirty=${result.protocolFiles.draft.dirty ? "yes" : "no"}`,
-        ].join(", ")
-        : "missing";
-    const infoLines = [
-        `Active: ${result.active ? "yes" : "no"}`,
-        ...formatMaybe("Branch", result.branch, 200),
-        ...formatMaybe("Base Branch", result.baseBranch, 200),
-        `Round: ${result.round}`,
-        `Pending Review: ${result.pendingReview ? "yes" : "no"}`,
-        `${result.protocolFiles.keiyaku.path}: ${result.protocolFiles.keiyaku.present ? "present" : "missing"}`,
-        `${result.protocolFiles.trace.path}: ${result.protocolFiles.trace.present ? "present" : "missing"}`,
-        `${result.protocolFiles.draft.path}: ${draftFileInfo}`,
-        ...formatOperationReadiness(labels.start, result.operationReadiness.start),
-        ...formatOperationReadiness(labels.drive, result.operationReadiness.drive),
-        ...formatOperationReadiness(labels.present, result.operationReadiness.present),
-        ...formatMaybe("Last Round Outcome", result.lastRoundSummary, 400),
-        ...formatList("Hints", result.hints, { maxItems: 12, maxItemChars: 400 }),
+    const blockedItems = {};
+    if (result.blockedByOperation.start.length > 0) {
+        blockedItems[labels.start] = result.blockedByOperation.start;
+    }
+    if (result.blockedByOperation.drive.length > 0) {
+        blockedItems[labels.drive] = result.blockedByOperation.drive;
+    }
+    if (result.blockedByOperation.present.length > 0) {
+        blockedItems[labels.close] = result.blockedByOperation.present;
+    }
+    const summaryLine = result.branch
+        ? `${STATUS_ACTIVE_SUMMARY_PREFIX} — ${result.branch} (round ${result.round})`
+        : STATUS_INACTIVE_SUMMARY;
+    const stateLines = [
+        ...formatMaybe("Keiyaku Preview", result.keiyakuPreview, 400),
+        ...formatMaybe("Last Round Preview", result.lastRoundPreview, 400),
+        ...formatMaybe("Draft Preview", result.draftPreview, 400),
     ];
-    const text = assembleResponse(`${RESPONSE_MARKERS.round} Status`, summaryLine, [], infoLines);
+    const readinessLines = [
+        ...formatBlockedOperation(labels.start, result.blockedByOperation.start),
+        ...formatBlockedOperation(labels.drive, result.blockedByOperation.drive),
+        ...formatBlockedOperation(labels.close, result.blockedByOperation.present),
+    ];
+    const hintLines = formatHints(result.hints, { maxItems: 12, maxItemChars: 400 });
+    const text = assembleResponse(`${RESPONSE_MARKERS.round} Status`, summaryLine, [
+        buildSection(STATUS_KEIYAKU_SECTION_TITLE, stateLines),
+        buildSection(STATUS_BLOCKED_SECTION_TITLE, readinessLines),
+        buildSection(HINTS_SECTION_TITLE, hintLines),
+    ].filter((section) => section !== null));
     return {
         content: [{ type: "text", text }],
-        structuredContent: buildSuccessStructuredContent(result),
+        structuredContent: buildSuccessStructuredContent({
+            active: result.active,
+            round: result.round,
+            baseBranch: result.baseBranch,
+            hints: result.hints,
+            currentKeiyakuBranch: result.branch ?? null,
+            keiyakuPreview: result.keiyakuPreview ?? null,
+            lastRoundPreview: result.lastRoundPreview ?? null,
+            draftPreview: result.draftPreview ?? null,
+            blockedItems,
+        }),
     };
 }

package/build/workflow/response-meta.js

@@ -0,0 +1,15 @@
+import { resolveTermPreset } from "../config/term-presets/index.js";
+import { renderPreset } from "../utils/text-utils.js";
+function renderPresetHints() {
+    const preset = resolveTermPreset();
+    return renderPreset(preset.hints, {
+        start: preset.tools.start.name,
+        drive: preset.tools.drive.name,
+        ask: preset.tools.ask.name,
+        close: preset.tools.close.name,
+        identity: preset.identity,
+    });
+}
+export function resolveWorkflowHints(kind) {
+    return renderPresetHints()[kind];
+}

package/build/workflow/response-renderer.js

@@ -1,4 +1,4 @@
-import { DIFF_OVERVIEW_SECTION_TITLE, SECTION_ICONS } from "../common/response-style.js";
+import { SECTION_ICONS } from "../common/response-style.js";
 const HEADER_MAX_WIDTH = 40;
 const HEADER_DASH = "┈";
 function supportsHeaderColor() {
@@ -50,21 +50,10 @@ export function assembleResponse(status, summary, sections, infoLines = []) {
     if (summaryLine) {
         statusLines.push(`↳ ${summaryLine}`);
     }
-    const normalSections = [];
-    const diffSections = [];
-    for (const section of sections) {
-        if (section.title.trim().toLowerCase() === DIFF_OVERVIEW_SECTION_TITLE.toLowerCase()) {
-            diffSections.push(section);
-        }
-        else {
-            normalSections.push(section);
-        }
-    }
-    const fullSections = [...normalSections];
+    const fullSections = [...sections];
     if (infoLines.length > 0) {
         fullSections.push({ title: "Info", body: infoLines.join("\n") });
     }
-    fullSections.push(...diffSections);
     const renderedSections = fullSections
         .map((section) => {
         const body = section.body.trim();

package/build/workflow/round-summary.js

@@ -1,4 +1,4 @@
-import { parseMarkdownSections } from "../utils/keiyaku-document.js";
+import { parseMarkdownSections } from "../utils/keiyaku-document/index.js";
 export const ROUND_SUMMARY_SECTION_KEYS = [
     "outcome",
     "changes",

package/build/workflow/start.js

@@ -1,18 +1,19 @@
 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 { logInfo, logWarn } from "../utils/logger.js";
 import { FlowError, isFlowError, requireText, wrapFlowError } from "../common/errors.js";
 import * as git from "../utils/git.js";
 import { parseDiffCoordinates } from "../utils/trace.js";
 import { buildStartPrompt } from "./prompts.js";
 import { renderToolRoundSummary } from "./round-summary.js";
-import { assertCleanWorkingTree } from "./contract.js";
+import { assertCleanWorkingTree } from "./keiyaku.js";
 import { runAndRecordRound } from "./round.js";
 import { renderKeiyaku } from "./keiyaku-document-builder.js";
 import { parseAndValidateKeiyakuDraft, } from "./keiyaku-draft.js";
 import { resolveIncrementalDiffMode } from "../config/incremental-diff-mode.js";
 import { readBaseRules } from "./base-rules.js";
+import { resolveWorkflowHints } from "./response-meta.js";
 const INTERNAL_START_DIRTY_ALLOWLIST = [];
 function normalizeOptionalText(value) {
     if (value === undefined)
@@ -289,7 +290,10 @@ export async function startKeiyaku(input) {
                 coordinates = undefined;
             }
         }
-        const diff = await git.getIncrementalDiff(cwd, incrementalDiffMode, coordinates);
+        const diff = await git.getIncrementalDiff(cwd, incrementalDiffMode, {
+            coordinates,
+            maxChars: INCREMENTAL_DIFF_MAX_CHARS,
+        });
         if (resolved.fromFile && resolved.fromFilePath) {
             await fs.unlink(resolved.fromFilePath);
             consumedFromFile = resolved.fromFile;
@@ -310,6 +314,7 @@ export async function startKeiyaku(input) {
             currentBranch: keiyakuBranch,
             baseBranch,
             commit,
+            meta: { hints: resolveWorkflowHints("start") },
         };
     }
     catch (err) {

package/build/workflow/status.js

@@ -2,7 +2,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { KEIYAKU_BRANCH_PREFIX, KEIYAKU_DRAFT_FILE, KEIYAKU_FILE, TRACE_FILE, } from "../common/constants.js";
 import { FlowError } from "../common/errors.js";
-import { parseToAST, renderNodeContent } from "../utils/keiyaku-document.js";
+import { parseToAST, renderNodeContent } from "../utils/keiyaku-document/index.js";
 import * as git from "../utils/git.js";
 import { computeTraceState } from "../utils/trace.js";
 import { parseRoundSummary } from "./round-summary.js";
@@ -16,45 +16,41 @@ function parseRoundSectionNumber(title) {
 function normalizeHeading(value) {
     return value.trim().toLowerCase();
 }
-function unwrapMarkdownFence(content) {
-    const trimmed = content.trim();
-    const fencedMatch = /^```(?:markdown)?\s*\n([\s\S]*?)\n```$/i.exec(trimmed);
-    return fencedMatch ? fencedMatch[1].trim() : trimmed;
-}
-function renderSummarySection(summaryNodes) {
-    if (summaryNodes.length === 0)
+const PREVIEW_SECTION_TITLES = ["goal", "context"];
+const PREVIEW_SECTION_TITLE_SET = new Set(PREVIEW_SECTION_TITLES);
+function renderNodesForPreview(nodes) {
+    if (nodes.length === 0)
         return "";
-    for (const node of summaryNodes) {
-        if (node.type !== "code_block")
-            continue;
-        const body = unwrapMarkdownFence(node.lines.join("\n"));
-        if (body.length > 0) {
-            return body;
+    return nodes
+        .map((node) => {
+        if (node.type === "blockquote") {
+            return node.value.trim();
         }
-    }
-    const rendered = summaryNodes
-        .map((node) => renderNodeContent(node).trim())
-        .filter((node) => node.length > 0)
+        return renderNodeContent(node).trim();
+    })
+        .filter((text) => text.length > 0)
         .join("\n")
         .trim();
-    return unwrapMarkdownFence(rendered);
 }
-function extractRoundRawSummary(roundSection) {
-    let captureSummary = false;
-    const summaryNodes = [];
-    for (const child of roundSection.children) {
+function extractHeadingBody(section, heading) {
+    let capture = false;
+    const captured = [];
+    for (const child of section.children) {
         if (child.type === "heading" && child.level === 3) {
-            if (captureSummary) {
+            if (capture) {
                 break;
             }
-            captureSummary = normalizeHeading(child.text) === "summary";
+            capture = normalizeHeading(child.text) === heading;
             continue;
         }
-        if (!captureSummary)
+        if (!capture)
             continue;
-        summaryNodes.push(child);
+        captured.push(child);
     }
-    const summary = renderSummarySection(summaryNodes);
+    return captured;
+}
+function extractRoundRawSummary(roundSection) {
+    const summary = renderNodesForPreview(extractHeadingBody(roundSection, "summary"));
     return summary.length > 0 ? summary : undefined;
 }
 function extractLastRoundSummary(traceContent) {
@@ -86,9 +82,57 @@ function extractLastRoundSummary(traceContent) {
     }
     return rawSummary;
 }
-async function readTrace(cwd) {
+function extractDocumentPreviewBySections(content, fallbackToDocument) {
+    const ast = parseToAST(content, { allowSections: true });
+    const sectionBodies = new Map();
+    for (const node of ast.children) {
+        if (node.type !== "section" || node.level !== 2)
+            continue;
+        const normalizedTitle = normalizeHeading(node.title);
+        if (!PREVIEW_SECTION_TITLE_SET.has(normalizedTitle))
+            continue;
+        if (sectionBodies.has(normalizedTitle))
+            continue;
+        const body = renderNodesForPreview(node.children);
+        if (body.length === 0)
+            continue;
+        sectionBodies.set(normalizedTitle, body);
+    }
+    const preferredBody = PREVIEW_SECTION_TITLES
+        .map((title) => sectionBodies.get(title))
+        .filter((value) => Boolean(value))
+        .join("\n")
+        .trim();
+    if (preferredBody.length > 0) {
+        return preferredBody;
+    }
+    if (!fallbackToDocument)
+        return undefined;
+    const fullDocument = renderNodeContent(ast).trim();
+    return fullDocument.length > 0 ? fullDocument : undefined;
+}
+function toStatusPreview(text) {
+    if (!text)
+        return undefined;
+    const MAX_LINES = 2;
+    const MAX_LINE_CHARS = 180;
+    const lines = text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    if (lines.length === 0)
+        return undefined;
+    const previewLines = lines
+        .slice(0, MAX_LINES)
+        .map((line) => (line.length > MAX_LINE_CHARS ? `${line.slice(0, MAX_LINE_CHARS - 1)}…` : line));
+    if (lines.length > MAX_LINES) {
+        previewLines.push("…");
+    }
+    return previewLines.join("\n");
+}
+async function readOptionalFile(cwd, fileName) {
     try {
-        return await fs.readFile(path.join(cwd, TRACE_FILE), "utf-8");
+        return await fs.readFile(path.join(cwd, fileName), "utf-8");
     }
     catch (error) {
         if (error?.code === "ENOENT") {
@@ -124,19 +168,35 @@ const STATUS_BLOCKERS = {
     missingBaseMetadata: "Active keiyaku branch is missing base metadata (branch.<keiyaku-branch>.keiyakuBase).",
     missingProtocolFiles: "Active keiyaku branch is missing KEIYAKU.md or KEIYAKU_TRACE.md; restore protocol files before continuing.",
 };
-function buildOperationReadiness(input) {
+function toGitStatusLine(file) {
+    const indexCode = file.index.length > 0 ? file.index : " ";
+    const worktreeCode = file.working_dir.length > 0 ? file.working_dir : " ";
+    return `${indexCode}${worktreeCode} ${file.path}`;
+}
+function formatDirtyWorktreeBlocker(dirtyStatusLines) {
+    if (dirtyStatusLines.length === 0) {
+        return STATUS_BLOCKERS.dirtyWorktree;
+    }
+    const MAX_ITEMS = 5;
+    const shownLines = dirtyStatusLines.slice(0, MAX_ITEMS);
+    const overflowLine = dirtyStatusLines.length > MAX_ITEMS ? [`... (+${dirtyStatusLines.length - MAX_ITEMS} more)`] : [];
+    return [STATUS_BLOCKERS.dirtyWorktree, ...shownLines, ...overflowLine].join("\n");
+}
+function buildBlockedByOperation(input) {
     const startBlockers = [];
     const driveBlockers = [];
     const presentBlockers = [];
     const hasDirtyWorktree = input.dirtyPaths.length > 0;
     const hasBlockingDirtyForRoundOps = input.dirtyPaths.some((dirtyPath) => dirtyPath !== KEIYAKU_DRAFT_FILE);
     const missingProtocolFiles = !input.protocolFiles.keiyaku.present || !input.protocolFiles.trace.present;
+    const startDirtyBlocker = formatDirtyWorktreeBlocker(input.dirtyStatusLines);
+    const roundOpsDirtyBlocker = formatDirtyWorktreeBlocker(input.blockingDirtyStatusLines);
     if (hasDirtyWorktree) {
-        startBlockers.push(STATUS_BLOCKERS.dirtyWorktree);
+        startBlockers.push(startDirtyBlocker);
     }
     if (hasBlockingDirtyForRoundOps) {
-        driveBlockers.push(STATUS_BLOCKERS.dirtyWorktree);
-        presentBlockers.push(STATUS_BLOCKERS.dirtyWorktree);
+        driveBlockers.push(roundOpsDirtyBlocker);
+        presentBlockers.push(roundOpsDirtyBlocker);
     }
     if (input.active) {
         startBlockers.push(STATUS_BLOCKERS.startActiveBranch);
@@ -156,14 +216,10 @@ function buildOperationReadiness(input) {
             startBlockers.push(STATUS_BLOCKERS.startProtocolOutsideActive);
         }
     }
-    const readiness = (blockers) => ({
-        available: blockers.length === 0,
-        blockers,
-    });
     return {
-        start: readiness(startBlockers),
-        drive: readiness(driveBlockers),
-        present: readiness(presentBlockers),
+        start: startBlockers,
+        drive: driveBlockers,
+        present: presentBlockers,
     };
 }
 function buildStatusHints(input) {
@@ -178,12 +234,7 @@ function buildStatusHints(input) {
         if (!input.baseBranch) {
             hints.push("Base branch metadata is missing; set branch.<keiyaku-branch>.keiyakuBase to avoid close-time failures.");
         }
-        if (input.pendingReview) {
-            hints.push("Pending review detected; run the next round to address the latest review feedback.");
-        }
-        else {
-            hints.push("No pending review detected; if criteria are done, proceed to close with CLAIM.");
-        }
+        hints.push("Run another round with drive, or close with CLAIM when criteria and rules checks are complete.");
     }
     else if (input.localKeiyakuBranches.length > 0) {
         hints.push(`No active keiyaku branch; checkout one to resume: ${formatBranchCandidates(input.localKeiyakuBranches)}.`);
@@ -209,7 +260,12 @@ export async function readKeiyakuStatus(input) {
         isPresentFile(cwd, TRACE_FILE),
         isPresentFile(cwd, KEIYAKU_DRAFT_FILE),
     ]);
-    const dirtyPaths = await git.getDirtyPaths(cwd);
+    const dirtyFiles = await git.getDirtyFiles(cwd);
+    const dirtyPaths = Array.from(new Set(dirtyFiles.map((file) => file.path)));
+    const dirtyStatusLines = dirtyFiles.map((file) => toGitStatusLine(file));
+    const blockingDirtyStatusLines = dirtyFiles
+        .filter((file) => file.path !== KEIYAKU_DRAFT_FILE)
+        .map((file) => toGitStatusLine(file));
     const draftDirty = dirtyPaths.includes(KEIYAKU_DRAFT_FILE);
     const draftTracked = draftPresent ? await git.isPathTracked(cwd, KEIYAKU_DRAFT_FILE) : undefined;
     const protocolFiles = {
@@ -223,34 +279,46 @@ export async function readKeiyakuStatus(input) {
     };
     const currentBranch = await git.getCurrentBranch(cwd);
     if (!currentBranch.startsWith(KEIYAKU_BRANCH_PREFIX)) {
+        const [keiyakuContent, draftContent] = await Promise.all([
+            readOptionalFile(cwd, KEIYAKU_FILE),
+            readOptionalFile(cwd, KEIYAKU_DRAFT_FILE),
+        ]);
         const localKeiyakuBranches = await git.listLocalKeiyakuBranches(cwd);
-        const operationReadiness = buildOperationReadiness({
+        const blockedByOperation = buildBlockedByOperation({
             active: false,
             dirtyPaths,
+            dirtyStatusLines,
+            blockingDirtyStatusLines,
             protocolFiles,
         });
         return {
             active: false,
             round: 0,
-            pendingReview: false,
-            protocolFiles,
-            operationReadiness,
+            keiyakuPreview: toStatusPreview(keiyakuContent ? extractDocumentPreviewBySections(keiyakuContent, false) : undefined),
+            draftPreview: toStatusPreview(draftContent ? extractDocumentPreviewBySections(draftContent, true) : undefined),
+            blockedByOperation,
             hints: buildStatusHints({
                 active: false,
-                pendingReview: false,
                 protocolFiles,
                 localKeiyakuBranches,
             }),
         };
     }
-    const traceContent = await readTrace(cwd);
+    const [traceContent, keiyakuContent, draftContent] = await Promise.all([
+        readOptionalFile(cwd, TRACE_FILE),
+        readOptionalFile(cwd, KEIYAKU_FILE),
+        readOptionalFile(cwd, KEIYAKU_DRAFT_FILE),
+    ]);
     const traceState = traceContent ? computeTraceState(traceContent) : { maxRound: 0, pendingReviewRound: null };
     const baseBranch = await git.getKeiyakuBase(cwd, currentBranch);
-    const lastRoundSummary = traceContent ? extractLastRoundSummary(traceContent) : undefined;
-    const pendingReview = traceState.pendingReviewRound !== null;
-    const operationReadiness = buildOperationReadiness({
+    const keiyakuPreview = toStatusPreview(keiyakuContent ? extractDocumentPreviewBySections(keiyakuContent, false) : undefined);
+    const lastRoundPreview = toStatusPreview(traceContent ? extractLastRoundSummary(traceContent) : undefined);
+    const draftPreview = toStatusPreview(draftContent ? extractDocumentPreviewBySections(draftContent, true) : undefined);
+    const blockedByOperation = buildBlockedByOperation({
         active: true,
         dirtyPaths,
+        dirtyStatusLines,
+        blockingDirtyStatusLines,
         baseBranch: baseBranch ?? undefined,
         protocolFiles,
     });
@@ -259,13 +327,12 @@ export async function readKeiyakuStatus(input) {
         branch: currentBranch,
         baseBranch: baseBranch ?? undefined,
         round: traceState.maxRound,
-        pendingReview,
-        lastRoundSummary,
-        protocolFiles,
-        operationReadiness,
+        keiyakuPreview,
+        lastRoundPreview,
+        draftPreview,
+        blockedByOperation,
         hints: buildStatusHints({
             active: true,
-            pendingReview,
             baseBranch: baseBranch ?? undefined,
             protocolFiles,
             localKeiyakuBranches: [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "0.1.47",
+  "version": "0.1.49",
   "description": "MCP server for running iterative keiyaku workflows with Codex subagents.",
   "license": "MIT",
   "type": "module",