@astrosheep/keiyaku 0.1.76 → 0.1.78

package/build/tools/petition/index.js

@@ -1,9 +1,8 @@
-import { appendDebugLog } from "../../telemetry/debug-log.js";
 import { petitionKeiyaku } from "./run.js";
 import { buildPetitionClaimResponse, buildPetitionForfeitResponse, } from "../../mcp/responses.js";
 import { FlowError } from "../../flow-error.js";
 import { petitionToolSchema } from "../schema.js";
-import { handleToolError } from "../../mcp/tool-errors.js";
+import { createToolHandler } from "../create-handler.js";
 function requireClaimField(value, name) {
     if (value === undefined) {
         throw new FlowError("EMPTY_PARAM", `parameter '${name}' is required when intent=CLAIM`);
@@ -11,23 +10,22 @@ function requireClaimField(value, name) {
     return value;
 }
 export function createPetitionHandler() {
-    return async (args, extra) => {
-        let intent = "UNKNOWN";
-        let workingDir = process.cwd();
-        try {
+    return createToolHandler({
+        logLabel: "tool close",
+        doneLog: (result) => `tool close ${result.intent} success branch=${result.outcome.currentBranch} base=${result.outcome.baseBranch}`,
+        async run(args, extra) {
             const input = petitionToolSchema.parse(args);
-            intent = input.intent;
-            workingDir = input.cwd || process.cwd();
+            const cwd = input.cwd ?? args.cwd;
             let closeInput;
-            let claimInput;
             if (input.intent === "CLAIM") {
+                let claimInput;
                 if (input.dangerouslyBypassGates) {
                     claimInput = {
                         intent: "CLAIM",
                         title: requireClaimField(input.title, "title"),
                         plea: requireClaimField(input.plea, "plea"),
                         dangerouslyBypassGates: true,
-                        cwd: workingDir,
+                        cwd,
                         signal: extra.signal,
                     };
                 }
@@ -41,66 +39,53 @@ export function createPetitionHandler() {
                         containment: requireClaimField(input.containment, "containment"),
                         idiomatic: requireClaimField(input.idiomatic, "idiomatic"),
                         oath: requireClaimField(input.oath, "oath"),
-                        cwd: workingDir,
+                        cwd,
                         signal: extra.signal,
                     };
                 }
                 closeInput = claimInput;
-            }
-            else {
-                if (input.dangerouslyBypassGates) {
-                    throw new FlowError("EMPTY_PARAM", "Parameter 'dangerouslyBypassGates' can only be used when intent=CLAIM.");
-                }
-                closeInput = {
-                    intent: "FORFEIT",
-                    cwd: workingDir,
-                    signal: extra.signal,
+                const outcome = await petitionKeiyaku(closeInput);
+                return {
+                    intent: "CLAIM",
+                    input: claimInput,
+                    outcome,
                 };
             }
-            appendDebugLog(`tool close start intent=${intent} cwd=${workingDir}`, {
-                cwd: workingDir,
-                section: "script",
-            });
-            const outcome = await petitionKeiyaku(closeInput);
-            if (input.intent === "CLAIM") {
-                if (!claimInput) {
-                    throw new FlowError("INTERNAL_STATE", "Unexpected CLAIM input shape");
-                }
-                if (!("result" in outcome) || outcome.result !== "merged") {
+            if (input.dangerouslyBypassGates) {
+                throw new FlowError("EMPTY_PARAM", "Parameter 'dangerouslyBypassGates' can only be used when intent=CLAIM.");
+            }
+            closeInput = {
+                intent: "FORFEIT",
+                cwd,
+                signal: extra.signal,
+            };
+            return {
+                intent: "FORFEIT",
+                outcome: await petitionKeiyaku(closeInput),
+            };
+        },
+        buildResponse(result) {
+            if (result.intent === "CLAIM") {
+                if (!("result" in result.outcome) || result.outcome.result !== "merged") {
                     throw new FlowError("INTERNAL_STATE", "Unexpected CLAIM outcome shape");
                 }
-                const finalOutcome = outcome;
-                appendDebugLog(`tool close CLAIM success branch=${finalOutcome.currentBranch} base=${finalOutcome.baseBranch}`, {
-                    cwd: workingDir,
-                    section: "script",
-                });
+                const finalOutcome = result.outcome;
                 return buildPetitionClaimResponse(finalOutcome, {
-                    title: claimInput.title,
-                    plea: claimInput.plea,
-                    dangerouslyBypassGates: "dangerouslyBypassGates" in claimInput && claimInput.dangerouslyBypassGates === true,
-                    placement: "placement" in claimInput ? claimInput.placement : undefined,
-                    exactness: "exactness" in claimInput ? claimInput.exactness : undefined,
-                    containment: "containment" in claimInput ? claimInput.containment : undefined,
-                    idiomatic: "idiomatic" in claimInput ? claimInput.idiomatic : undefined,
-                    oath: "oath" in claimInput ? claimInput.oath : undefined,
+                    title: result.input.title,
+                    plea: result.input.plea,
+                    dangerouslyBypassGates: "dangerouslyBypassGates" in result.input && result.input.dangerouslyBypassGates === true,
+                    placement: "placement" in result.input ? result.input.placement : undefined,
+                    exactness: "exactness" in result.input ? result.input.exactness : undefined,
+                    containment: "containment" in result.input ? result.input.containment : undefined,
+                    idiomatic: "idiomatic" in result.input ? result.input.idiomatic : undefined,
+                    oath: "oath" in result.input ? result.input.oath : undefined,
                 });
             }
-            if (!("result" in outcome) || outcome.result !== "dropped") {
+            if (!("result" in result.outcome) || result.outcome.result !== "dropped") {
                 throw new FlowError("INTERNAL_STATE", "Unexpected FORFEIT outcome shape");
             }
-            const finalOutcome = outcome;
-            appendDebugLog(`tool close FORFEIT success branch=${finalOutcome.currentBranch} base=${finalOutcome.baseBranch}`, {
-                cwd: workingDir,
-                section: "script",
-            });
+            const finalOutcome = result.outcome;
             return buildPetitionForfeitResponse(finalOutcome, {});
-        }
-        catch (err) {
-            return handleToolError({
-                error: err,
-                cwd: workingDir,
-                logLabel: "tool close",
-            });
-        }
-    };
+        },
+    });
 }

package/build/tools/petition/run.js

@@ -14,6 +14,7 @@ import { claimKeiyaku } from "./claim.js";
 import { forfeitKeiyaku } from "./forfeit.js";
 const VERDICT_DENIED_CODE = "VERDICT_DENIED";
 const DIMENSION_KEY_SET = new Set(CLAIM_DIMENSIONS);
+const REVIEW_AUDIT_COMMIT_MESSAGE = "keiyaku: review audit trail";
 function clampThreshold(value, fallback) {
     if (typeof value !== "number" || !Number.isFinite(value))
         return fallback;
@@ -88,6 +89,16 @@ async function appendDeniedVerdictWithAuditCommit(cwd, titleToken, scores, check
         logWarn(warning, { cwd, section: "script" });
     }
 }
+async function commitPassedReviewAuditTrail(cwd) {
+    try {
+        await addFiles(cwd, [TRACE_FILE]);
+        await commit(cwd, REVIEW_AUDIT_COMMIT_MESSAGE);
+    }
+    catch (error) {
+        const warning = `[CLAIM] Failed to commit passed review audit trail: ${error instanceof Error ? error.message : String(error)}`;
+        logWarn(warning, { cwd, section: "script" });
+    }
+}
 async function loadCloseContext(cwd) {
     const isRepo = await isGitRepo(cwd);
     if (!isRepo) {
@@ -118,6 +129,7 @@ export async function petitionKeiyaku(input) {
         return claimKeiyaku(input, context, {
             resolveClaimGateConfig,
             appendDeniedVerdictWithAuditCommit,
+            commitPassedReviewAuditTrail,
         });
     }
     throw new FlowError("INVALID_CLOSE_INTENT", `unsupported close intent: ${intent}`);

package/build/tools/round/head-guard.js

@@ -0,0 +1,10 @@
+import { FlowError } from "../../flow-error.js";
+import { getLatestCommitHash } from "../../git/staging.js";
+const CONCURRENT_MODIFICATION_CODE = "CONCURRENT_MODIFICATION";
+export async function assertHeadUnchanged(cwd, expectedHead, operation) {
+    const currentHead = await getLatestCommitHash(cwd);
+    if (currentHead === expectedHead) {
+        return;
+    }
+    throw new FlowError(CONCURRENT_MODIFICATION_CODE, `concurrent ${operation} modification detected: repository HEAD changed from ${expectedHead} to ${currentHead} while the ${operation} was running`);
+}

package/build/tools/round/incremental-diff.js

@@ -1,5 +1,6 @@
 import { MAX_DIFF_LINES_PER_FILE, TARGETED_DIFF_WARNING } from "../../git/diff/constants.js";
-import { capTargetedDiffText, filterDiffByCoordinates } from "../../git/diff/filter.js";
+import { filterDiffByCoordinates } from "../../git/diff/filter.js";
+import { truncateTextWithFooter } from "../../git/diff/parsers.js";
 import { readDiff } from "../../git/diff/read.js";
 export async function renderIncrementalDiff({ cwd, range, mode, maxChars, coordinates, }) {
     const statDiff = await readDiff(cwd, range, "stat", { maxChars: maxChars.stat });
@@ -24,5 +25,8 @@ export async function renderIncrementalDiff({ cwd, range, mode, maxChars, coordi
     if (!targetedPatch) {
         return `${statDiff}\n\n${TARGETED_DIFF_WARNING}`;
     }
-    return `${statDiff}\n\n${capTargetedDiffText(targetedPatch, maxChars.targeted)}`;
+    const cappedTargetedPatch = targetedPatch.length <= maxChars.targeted
+        ? targetedPatch
+        : truncateTextWithFooter(targetedPatch, maxChars.targeted, targetedPatch.length - maxChars.targeted);
+    return `${statDiff}\n\n${cappedTargetedPatch}`;
 }

package/build/tools/round/report.js

@@ -28,6 +28,18 @@ const SECTION_TITLE_TO_KEY = {
     "follow ups": "followUps",
     followups: "followUps",
 };
+const SECTION_KEY_TO_TITLE = {
+    outcome: "Outcome",
+    changes: "Changes",
+    testResults: "Test Results",
+    aestheticsGap: "Aesthetics Gap",
+    blindspots: "Blindspots",
+    criteriaCheck: "Criteria Check",
+    rulesCheck: "Rules Check",
+    followUps: "Follow-ups",
+    diffCoordinates: "Diff Coordinates",
+};
+const MISSING_SECTION_WARNING_PREFIX = "> ⚠️ Missing section: ";
 function createEmptySections() {
     return {
         outcome: null,
@@ -77,6 +89,11 @@ function toKnownSection(sectionMarkdown) {
 function shouldRenderSection(key, policy) {
     return policy.allowedSectionKeys.includes(key);
 }
+function renderMissingSectionWarnings(missingSections, policy) {
+    return missingSections
+        .filter((key) => shouldRenderSection(key, policy))
+        .map((key) => `${MISSING_SECTION_WARNING_PREFIX}${SECTION_KEY_TO_TITLE[key]}`);
+}
 export function parseRoundSummary(raw) {
     const sections = parseMarkdownSections(raw);
     if (sections.length === 0) {
@@ -124,10 +141,15 @@ export function renderRoundSummary(roundSummary, policy = TOOL_DEFAULT_POLICY) {
         return [entry.section.markdown.trim()];
     })
         .filter((entry) => entry.length > 0);
-    if (renderedEntries.length === 0) {
+    const missingSectionWarnings = renderMissingSectionWarnings(roundSummary.missingSections, policy);
+    const unknownEntries = roundSummary.entries
+        .flatMap((entry) => (entry.kind === "unknown" ? [entry.markdown.trim()] : []))
+        .filter((entry) => entry.length > 0);
+    const renderedOutput = [...renderedEntries, ...missingSectionWarnings, ...unknownEntries];
+    if (renderedOutput.length === 0) {
         return "";
     }
-    return renderedEntries.join("\n\n").trim();
+    return renderedOutput.join("\n\n").trim();
 }
 export function renderToolRoundSummary(roundSummary) {
     return renderRoundSummary(roundSummary, TOOL_DEFAULT_POLICY);

package/build/tools/round/run.js

@@ -127,6 +127,9 @@ export async function runAndRecordRound(cwd, titleToken, round, prompt, options)
         const 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.";
+        if (options.beforePersist) {
+            await options.beforePersist();
+        }
         if (options.beforeRoundWrite) {
             await options.beforeRoundWrite();
         }
@@ -137,6 +140,9 @@ export async function runAndRecordRound(cwd, titleToken, round, prompt, options)
             hints: buildSubagentFailureHints(err),
         });
     }
+    if (options.beforePersist) {
+        await options.beforePersist();
+    }
     if (options.beforeRoundWrite) {
         await options.beforeRoundWrite();
     }

package/build/tools/round/worktree.js

@@ -1,6 +1,6 @@
 import { formatArtifactDirectories, KEIYAKU_ARTIFACT_DIRS } from "../../keiyaku.js";
 import { FlowError } from "../../flow-error.js";
-import { getDirtyFiles, renderDirtyFileStatusLine } from "../../git/worktree.js";
+import { DIRTY_FILE_CATEGORY, getDirtyFiles, renderDirtyFileStatusLine } from "../../git/worktree.js";
 import * as path from "path";
 const DIRTY_WORKTREE_LIST_LIMIT = 10;
 const KEIYAKU_ARTIFACT_DIR_PREFIX = ".keiyaku/";
@@ -39,8 +39,12 @@ export function filterDirtyFilesByAllowlist(cwd, dirtyFiles, ignorePatterns) {
     });
     return { dirtyFiles: filteredDirtyFiles, ignoredPaths };
 }
+export function filterBlockingDirtyFiles(dirtyFiles) {
+    return dirtyFiles.filter((file) => file.category !== DIRTY_FILE_CATEGORY.untracked);
+}
 export async function assertCleanWorkingTree(cwd, ignorePatterns) {
-    const { dirtyFiles } = filterDirtyFilesByAllowlist(cwd, await getDirtyFiles(cwd), ignorePatterns);
+    const blockingDirtyFiles = filterBlockingDirtyFiles(await getDirtyFiles(cwd));
+    const { dirtyFiles } = filterDirtyFilesByAllowlist(cwd, blockingDirtyFiles, ignorePatterns);
     if (dirtyFiles.length > 0) {
         const hasDirtyKeiyakuArtifacts = dirtyFiles.some((file) => normalizePathForDirtyMatch(cwd, file.path).startsWith(KEIYAKU_ARTIFACT_DIR_PREFIX));
         const shown = dirtyFiles.slice(0, DIRTY_WORKTREE_LIST_LIMIT);

package/build/tools/status/index.js

@@ -1,34 +1,21 @@
-import { appendDebugLog } from "../../telemetry/debug-log.js";
 import { resolveTermPreset } from "../../config/term-presets/resolver.js";
 import { readKeiyakuStatus } from "./read.js";
 import { buildStatusResponse } from "../../mcp/responses.js";
-import { handleToolError } from "../../mcp/tool-errors.js";
+import { createToolHandler } from "../create-handler.js";
 export function createStatusHandler() {
-    return async ({ cwd }, _extra) => {
-        const workingDir = cwd || process.cwd();
-        const preset = resolveTermPreset();
-        try {
-            appendDebugLog(`tool status start cwd=${workingDir}`, {
-                cwd: workingDir,
-                section: "script",
-            });
-            const outcome = await readKeiyakuStatus({ cwd: workingDir });
-            appendDebugLog(`tool status success active=${outcome.active} round=${outcome.round}`, {
-                cwd: workingDir,
-                section: "script",
-            });
+    return createToolHandler({
+        logLabel: "tool status",
+        doneLog: (outcome) => `tool status success active=${outcome.active} round=${outcome.round}`,
+        async run({ cwd }) {
+            return readKeiyakuStatus({ cwd });
+        },
+        buildResponse(outcome) {
+            const preset = resolveTermPreset();
             return buildStatusResponse(outcome, {
                 start: preset.tools.start.name,
                 drive: preset.tools.drive.name,
                 close: preset.tools.close.name,
             });
-        }
-        catch (err) {
-            return handleToolError({
-                error: err,
-                cwd: workingDir,
-                logLabel: "tool status",
-            });
-        }
-    };
+        },
+    });
 }

package/build/tools/status/read.js

@@ -1,13 +1,14 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { formatArtifactDirectories, KEIYAKU_ARTIFACT_DIRS, KEIYAKU_BRANCH_PREFIX, KEIYAKU_DRAFT_DIR, KEIYAKU_FILE, TRACE_FILE, } from "../../keiyaku.js";
+import { isErrnoException } from "../../errno.js";
 import { FlowError } from "../../flow-error.js";
 import { resolveTermPreset } from "../../config/term-presets/resolver.js";
 import { getCurrentBranch, isGitRepo, listLocalKeiyakuBranches } from "../../git/branches.js";
 import { getKeiyakuBase } from "../../git/keiyaku-state.js";
 import { getDirtyFiles, getUntrackedFiles, isPathTracked, renderDirtyFileStatusLine } from "../../git/worktree.js";
 import { computeTraceState } from "../../protocol/trace.js";
-import { filterDirtyFilesByAllowlist } from "../round/worktree.js";
+import { filterBlockingDirtyFiles, filterDirtyFilesByAllowlist } from "../round/worktree.js";
 import { isDraftArtifactPath, readLatestDraftArtifact } from "../../protocol/draft-artifacts.js";
 import { extractDocumentPreviewBySections, extractLastRoundSummary, toStatusPreview } from "../../protocol/status-previews.js";
 const STATUS_BRANCH_CANDIDATE_LIMIT = 3;
@@ -17,7 +18,7 @@ async function readOptionalFile(cwd, fileName) {
         return await fs.readFile(path.join(cwd, fileName), "utf-8");
     }
     catch (error) {
-        if (error?.code === "ENOENT") {
+        if (isErrnoException(error) && error.code === "ENOENT") {
             return null;
         }
         throw error;
@@ -29,7 +30,7 @@ async function isPresentFile(cwd, fileName) {
         return stats.isFile();
     }
     catch (error) {
-        if (error?.code === "ENOENT") {
+        if (isErrnoException(error) && error.code === "ENOENT") {
             return false;
         }
         throw error;
@@ -170,7 +171,8 @@ export async function readKeiyakuStatus(input) {
     const [dirtyFiles, untrackedPaths] = await Promise.all([getDirtyFiles(cwd), getUntrackedFiles(cwd)]);
     const rawDirtyPaths = Array.from(new Set(dirtyFiles.map((file) => file.path)));
     const rawArtifactPaths = Array.from(new Set([...rawDirtyPaths, ...untrackedPaths]));
-    const startBlockingDirtyFiles = filterDirtyFilesByAllowlist(cwd, dirtyFiles, []).dirtyFiles;
+    const blockingDirtyFiles = filterBlockingDirtyFiles(dirtyFiles);
+    const startBlockingDirtyFiles = filterDirtyFilesByAllowlist(cwd, blockingDirtyFiles, []).dirtyFiles;
     const roundBlockingDirtyFiles = filterDirtyFilesByAllowlist(cwd, startBlockingDirtyFiles, []).dirtyFiles;
     const dirtyPaths = Array.from(new Set(startBlockingDirtyFiles.map((file) => file.path)));
     const dirtyStatusLines = startBlockingDirtyFiles.map((file) => renderDirtyFileStatusLine(file));

package/build/tools/summon/index.js

@@ -1,23 +1,22 @@
-import { appendDebugLog } from "../../telemetry/debug-log.js";
 import { summonKeiyaku } from "./run.js";
 import { buildSummonSuccessResponse, } from "../../mcp/responses.js";
-import { handleToolError } from "../../mcp/tool-errors.js";
+import { createToolHandler } from "../create-handler.js";
 function normalizeOptionalArg(value) {
     if (value === undefined)
         return undefined;
     return value.trim().length > 0 ? value : undefined;
 }
 export function createSummonHandler() {
-    return async ({ from_draft, draft_only, title, goal, context, rules, criteria, cwd }, extra) => {
-        const workingDir = cwd || process.cwd();
-        const normalizedFromDraft = normalizeOptionalArg(from_draft);
-        const parsedCriteria = normalizeOptionalArg(criteria);
-        const parsedRules = normalizeOptionalArg(rules);
-        try {
-            appendDebugLog(`tool start cwd=${workingDir}`, { cwd: workingDir, section: "script" });
-            const result = normalizedFromDraft
-                ? await summonKeiyaku({
-                    cwd: workingDir,
+    return createToolHandler({
+        logLabel: "tool start",
+        doneLog: (result) => `tool start success branch=${result.currentBranch} base=${result.baseBranch} round=${result.round}`,
+        async run({ from_draft, draft_only, title, goal, context, rules, criteria, cwd }, extra) {
+            const normalizedFromDraft = normalizeOptionalArg(from_draft);
+            const parsedCriteria = normalizeOptionalArg(criteria);
+            const parsedRules = normalizeOptionalArg(rules);
+            return normalizedFromDraft
+                ? summonKeiyaku({
+                    cwd,
                     from_draft: normalizedFromDraft,
                     draft_only,
                     title: normalizeOptionalArg(title),
@@ -27,8 +26,8 @@ export function createSummonHandler() {
                     criteria: parsedCriteria,
                     signal: extra.signal,
                 })
-                : await summonKeiyaku({
-                    cwd: workingDir,
+                : summonKeiyaku({
+                    cwd,
                     draft_only,
                     title: title ?? "",
                     goal: goal ?? "",
@@ -37,18 +36,9 @@ export function createSummonHandler() {
                     criteria: parsedCriteria ?? "",
                     signal: extra.signal,
                 });
-            appendDebugLog(`tool start success branch=${result.currentBranch} base=${result.baseBranch} round=${result.round}`, {
-                cwd: workingDir,
-                section: "script",
-            });
+        },
+        buildResponse(result) {
             return buildSummonSuccessResponse(result);
-        }
-        catch (err) {
-            return handleToolError({
-                error: err,
-                cwd: workingDir,
-                logLabel: "tool start",
-            });
-        }
-    };
+        },
+    });
 }

package/build/tools/summon/run.js

@@ -1,6 +1,7 @@
 import * as fs from "fs/promises";
 import * as path from "path";
 import { KEIYAKU_BRANCH_PREFIX, KEIYAKU_FILE, TRACE_FILE, } from "../../keiyaku.js";
+import { isErrnoException } from "../../errno.js";
 import { logInfo, logWarn } from "../../telemetry/logger.js";
 import { FlowError } from "../../flow-error.js";
 import { assertValidBranchName, checkoutBranch, createAndCheckoutBranch, deleteBranch, getCurrentBranch, hasLocalBranch, isGitRepo, listLocalKeiyakuBranches } from "../../git/branches.js";
@@ -30,7 +31,7 @@ async function fileExists(filePath) {
         return true;
     }
     catch (error) {
-        if (error?.code === "ENOENT") {
+        if (isErrnoException(error) && error.code === "ENOENT") {
             return false;
         }
         throw error;
@@ -101,10 +102,28 @@ async function initKeiyakuBranch(cwd, resolved, keiyakuContent) {
 }
 async function finalizeSummonKeiyaku(input, resolved, setup, baseRules) {
     const { cwd } = input;
-    const { branchToken, baseBranch, commit, existingBranches, keiyakuBranch } = setup;
+    const { branchToken, baseBranch, existingBranches, keiyakuBranch } = setup;
     const identity = selectSubagent().displayName;
     const summary = SUMMON_READY_SUMMARY;
     const diff = SUMMON_READY_DIFF;
+    let commit = setup.commit;
+    let consumedFromDraft;
+    if (resolved.fromDraft && resolved.fromDraftPath) {
+        const trackedFromDraftPath = resolveGitRelativePath(cwd, resolved.fromDraftPath);
+        const shouldCommitDeletion = trackedFromDraftPath !== null && (await isPathTracked(cwd, trackedFromDraftPath));
+        await fs.unlink(resolved.fromDraftPath);
+        if (shouldCommitDeletion && trackedFromDraftPath) {
+            await addFiles(cwd, trackedFromDraftPath);
+            await commitChanges(cwd, `keiyaku(${branchToken}): ${SUMMON_CONSUME_FROM_DRAFT_COMMIT_SUFFIX}`);
+            commit = await getLatestCommitHash(cwd);
+        }
+        consumedFromDraft = resolved.fromDraft;
+        logInfo(`[keiyaku] Consumed from_draft and deleted source draft: ${resolved.fromDraft}`, {
+            cwd,
+            section: "script",
+            progressOnly: true,
+        });
+    }
     let responsePath;
     try {
         responsePath = await persistResponseHistory({
@@ -128,22 +147,6 @@ async function finalizeSummonKeiyaku(input, resolved, setup, baseRules) {
             section: "script",
         });
     }
-    let consumedFromDraft;
-    if (resolved.fromDraft && resolved.fromDraftPath) {
-        const trackedFromDraftPath = resolveGitRelativePath(cwd, resolved.fromDraftPath);
-        const shouldCommitDeletion = trackedFromDraftPath !== null && (await isPathTracked(cwd, trackedFromDraftPath));
-        await fs.unlink(resolved.fromDraftPath);
-        if (shouldCommitDeletion && trackedFromDraftPath) {
-            await addFiles(cwd, trackedFromDraftPath);
-            await commitChanges(cwd, `keiyaku(${branchToken}): ${SUMMON_CONSUME_FROM_DRAFT_COMMIT_SUFFIX}`);
-        }
-        consumedFromDraft = resolved.fromDraft;
-        logInfo(`[keiyaku] Consumed from_draft and deleted source draft: ${resolved.fromDraft}`, {
-            cwd,
-            section: "script",
-            progressOnly: true,
-        });
-    }
     return {
         status: "success",
         round: 0,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "0.1.76",
+  "version": "0.1.78",
   "description": "MCP server for running iterative keiyaku workflows with Codex subagents.",
   "license": "MIT",
   "type": "module",
@@ -39,14 +39,14 @@
     "release": "npm version patch && npm publish"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "*",
+    "@modelcontextprotocol/sdk": "1.26.0",
     "@openai/codex-sdk": "^0.113.0",
     "simple-git": "^3.21.0",
-    "zod": "*"
+    "zod": "4.3.6"
   },
   "devDependencies": {
-    "@types/node": "*",
-    "tsx": "*",
-    "typescript": "*"
+    "@types/node": "25.2.2",
+    "tsx": "4.21.0",
+    "typescript": "5.9.3"
   }
 }

package/build/git/diff/stat.js

@@ -1,9 +0,0 @@
-import { truncateTextWithFooter } from "./parsers.js";
-export function renderStatDiffPreviewText(output, maxChars) {
-    const trimmed = output.trim();
-    if (!trimmed)
-        return "No diff.";
-    if (trimmed.length <= maxChars)
-        return trimmed;
-    return truncateTextWithFooter(trimmed, maxChars, trimmed.length - maxChars);
-}