@astrosheep/keiyaku 0.1.76 → 0.1.78

package/build/mcp/server.js

@@ -1,7 +1,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { resolveOath } from "../protocol/oath.js";
-import { amendToolSchema, askToolSchemaBase, attachAskResponsePathValidation, summonToolSchema, driveToolSchema, petitionToolSchema, helpToolSchema, statusToolSchema, } from "../tools/schema.js";
-import { getAvailableNamesForPreset, listTermPresets, resolveTermPreset } from "../config/term-presets/resolver.js";
+import { amendToolSchema, askToolSchema, summonToolSchema, driveToolSchema, petitionToolSchema, helpToolSchema, statusToolSchema, } from "../tools/schema.js";
+import { getAvailableNamesForPreset, resolveTermPreset } from "../config/term-presets/resolver.js";
 import { renderPreset } from "../config/render-template.js";
 import { applyArgumentDescriptions } from "../config/apply-argument-descriptions.js";
 import { createAmendHandler } from "../tools/amend/index.js";
@@ -13,9 +13,6 @@ import { createHelpHandler } from "../tools/help.js";
 import { createStatusHandler } from "../tools/status/index.js";
 function registerTools(server, packageVersion) {
     const preset = resolveTermPreset();
-    const presetIdentities = listTermPresets()
-        .map((item) => `${item.id}=${item.identity}`)
-        .join(", ");
     const availableNames = getAvailableNamesForPreset(preset).join(", ");
     const currentOath = resolveOath();
     const renderedPreset = renderPreset(preset, {
@@ -25,73 +22,68 @@ function registerTools(server, packageVersion) {
         amend: preset.tools.amend.name,
         close: preset.tools.close.name,
         identity: preset.identity,
-        preset_identities: presetIdentities,
         available_names: availableNames,
         oath_text: `'${currentOath}'`,
     });
-    const startPreset = renderedPreset.tools.start;
-    const drivePreset = renderedPreset.tools.drive;
-    const askPreset = renderedPreset.tools.ask;
-    const amendPreset = renderedPreset.tools.amend;
-    const closePreset = renderedPreset.tools.close;
-    const helpPreset = renderedPreset.tools.help;
-    const statusPreset = renderedPreset.tools.status;
-    const dynamicCloseSchema = applyArgumentDescriptions(petitionToolSchema, {
-        ...closePreset.args,
-    });
-    const dynamicStartSchema = applyArgumentDescriptions(summonToolSchema, {
-        ...startPreset.args,
-    });
-    const dynamicDriveSchema = applyArgumentDescriptions(driveToolSchema, {
-        ...drivePreset.args,
-    });
-    const dynamicAskSchema = attachAskResponsePathValidation(applyArgumentDescriptions(askToolSchemaBase, {
-        ...askPreset.args,
-    }));
-    const dynamicAmendSchema = applyArgumentDescriptions(amendToolSchema, {
-        ...amendPreset.args,
-    });
-    const dynamicHelpSchema = applyArgumentDescriptions(helpToolSchema, {
-        ...helpPreset.args,
-    });
-    const dynamicStatusSchema = applyArgumentDescriptions(statusToolSchema, {
-        ...statusPreset.args,
-    });
-    server.registerTool(startPreset.name, {
-        title: startPreset.title,
-        description: startPreset.description,
-        inputSchema: dynamicStartSchema,
-    }, createSummonHandler());
-    server.registerTool(drivePreset.name, {
-        title: drivePreset.title,
-        description: drivePreset.description,
-        inputSchema: dynamicDriveSchema,
-    }, createDriveHandler());
-    server.registerTool(askPreset.name, {
-        title: askPreset.title,
-        description: askPreset.description,
-        inputSchema: dynamicAskSchema,
-    }, createAskHandler());
-    server.registerTool(amendPreset.name, {
-        title: amendPreset.title,
-        description: amendPreset.description,
-        inputSchema: dynamicAmendSchema,
-    }, createAmendHandler());
-    server.registerTool(closePreset.name, {
-        title: closePreset.title,
-        description: closePreset.description,
-        inputSchema: dynamicCloseSchema,
-    }, createPetitionHandler());
-    server.registerTool(helpPreset.name, {
-        title: helpPreset.title,
-        description: helpPreset.description,
-        inputSchema: dynamicHelpSchema,
-    }, createHelpHandler(renderedPreset, packageVersion));
-    server.registerTool(statusPreset.name, {
-        title: statusPreset.title,
-        description: statusPreset.description,
-        inputSchema: dynamicStatusSchema,
-    }, createStatusHandler());
+    const tools = [
+        {
+            key: "start",
+            schema: applyArgumentDescriptions(summonToolSchema, {
+                ...renderedPreset.tools.start.args,
+            }),
+            handler: createSummonHandler(),
+        },
+        {
+            key: "drive",
+            schema: applyArgumentDescriptions(driveToolSchema, {
+                ...renderedPreset.tools.drive.args,
+            }),
+            handler: createDriveHandler(),
+        },
+        {
+            key: "ask",
+            schema: applyArgumentDescriptions(askToolSchema, {
+                ...renderedPreset.tools.ask.args,
+            }),
+            handler: createAskHandler(),
+        },
+        {
+            key: "amend",
+            schema: applyArgumentDescriptions(amendToolSchema, {
+                ...renderedPreset.tools.amend.args,
+            }),
+            handler: createAmendHandler(),
+        },
+        {
+            key: "close",
+            schema: applyArgumentDescriptions(petitionToolSchema, {
+                ...renderedPreset.tools.close.args,
+            }),
+            handler: createPetitionHandler(),
+        },
+        {
+            key: "help",
+            schema: applyArgumentDescriptions(helpToolSchema, {
+                ...renderedPreset.tools.help.args,
+            }),
+            handler: createHelpHandler(renderedPreset, packageVersion),
+        },
+        {
+            key: "status",
+            schema: applyArgumentDescriptions(statusToolSchema, {
+                ...renderedPreset.tools.status.args,
+            }),
+            handler: createStatusHandler(),
+        },
+    ];
+    for (const tool of tools) {
+        const toolPreset = renderedPreset.tools[tool.key];
+        server.registerTool(toolPreset.name, {
+            title: toolPreset.title,
+            description: toolPreset.description,
+            inputSchema: tool.schema,
+        }, tool.handler);
+    }
 }
 export function createServer(packageVersion) {
     const server = new McpServer({

package/build/protocol/draft-artifacts.js

@@ -1,6 +1,7 @@
 import * as fs from "fs/promises";
 import * as path from "path";
 import { DRAFT_ARTIFACT_NOTICE, KEIYAKU_DRAFT_DIR } from "../keiyaku.js";
+import { isErrnoException } from "../errno.js";
 const DRAFT_SLUG_FALLBACK = "keiyaku-draft";
 function normalizeDraftRelativePath(relativePath) {
     return relativePath.split(path.sep).join("/");
@@ -63,7 +64,7 @@ export async function listDraftArtifacts(cwd) {
             .sort((a, b) => b.localeCompare(a));
     }
     catch (error) {
-        if (error?.code === "ENOENT") {
+        if (isErrnoException(error) && error.code === "ENOENT") {
             return [];
         }
         throw error;

package/build/protocol/file-guards.js

@@ -1,6 +1,7 @@
 import * as fs from "fs/promises";
 import * as path from "path";
 import { KEIYAKU_FILE, TRACE_FILE } from "../keiyaku.js";
+import { isErrnoException } from "../errno.js";
 import { FlowError } from "../flow-error.js";
 async function isMissingFile(filePath) {
     try {
@@ -8,7 +9,7 @@ async function isMissingFile(filePath) {
         return false;
     }
     catch (error) {
-        if (error?.code === "ENOENT") {
+        if (isErrnoException(error) && error.code === "ENOENT") {
             return true;
         }
         throw error;

package/build/protocol/markdown/lex.js

@@ -1,3 +1,4 @@
+const FENCE_DELIMITERS = ["`", "~"];
 function countLeadingSpaces(line) {
     let idx = 0;
     while (idx < line.length && line[idx] === " ") {
@@ -6,15 +7,17 @@ function countLeadingSpaces(line) {
     return idx;
 }
 function parseFence(trimmedLine) {
-    if (!trimmedLine.startsWith("```"))
+    const delimiter = FENCE_DELIMITERS.find((candidate) => trimmedLine.startsWith(candidate.repeat(3)));
+    if (!delimiter)
         return null;
     let idx = 0;
-    while (idx < trimmedLine.length && trimmedLine[idx] === "`") {
+    while (idx < trimmedLine.length && trimmedLine[idx] === delimiter) {
         idx += 1;
     }
     if (idx < 3)
         return null;
     return {
+        delimiter,
         length: idx,
         info: trimmedLine.slice(idx).trim(),
     };
@@ -39,6 +42,15 @@ function parseHeader(trimmedLine) {
         return null;
     return { level, text };
 }
+function parseSetextUnderline(trimmedLine) {
+    if (/^=+$/.test(trimmedLine)) {
+        return { level: 1 };
+    }
+    if (/^-+$/.test(trimmedLine)) {
+        return { level: 2 };
+    }
+    return null;
+}
 function parseBlockquote(line) {
     let idx = 0;
     while (idx < line.length && line[idx] === " ") {
@@ -164,17 +176,19 @@ export function isSectionHeaderToken(token) {
     return token.type === "header" && (token.level === 1 || token.level === 2);
 }
 export function isFenceClosingToken(token, fence) {
-    return token.type === "fence" && token.length >= fence.length;
+    return token.type === "fence" && token.delimiter === fence.delimiter && token.length >= fence.length;
 }
 export function lexMarkdown(content) {
     const lines = stripUtf8Bom(content).split(/\r?\n/);
     const tokens = [];
     const frontMatter = consumeLeadingYamlFrontMatter(lines);
     const contentLines = frontMatter.contentLines;
+    let activeFence = null;
     if (frontMatter.token) {
         tokens.push(frontMatter.token);
     }
-    for (const line of contentLines) {
+    for (let index = 0; index < contentLines.length; index += 1) {
+        const line = contentLines[index] ?? "";
         const leadingSpaces = countLeadingSpaces(line);
         if (leadingSpaces <= 3) {
             const trimmedLine = line.trimStart();
@@ -184,21 +198,45 @@ export function lexMarkdown(content) {
                     type: "fence",
                     raw: line,
                     leadingSpaces,
+                    delimiter: fence.delimiter,
                     length: fence.length,
                     info: fence.info,
                 });
+                if (!activeFence) {
+                    activeFence = { delimiter: fence.delimiter, length: fence.length };
+                }
+                else if (activeFence.delimiter === fence.delimiter && fence.length >= activeFence.length) {
+                    activeFence = null;
+                }
                 continue;
             }
-            const header = parseHeader(trimmedLine);
-            if (header) {
-                tokens.push({
-                    type: "header",
-                    raw: line,
-                    leadingSpaces,
-                    level: header.level,
-                    text: header.text,
-                });
-                continue;
+            if (!activeFence) {
+                const header = parseHeader(trimmedLine);
+                if (header) {
+                    tokens.push({
+                        type: "header",
+                        raw: line,
+                        leadingSpaces,
+                        level: header.level,
+                        text: header.text,
+                    });
+                    continue;
+                }
+                const nextLine = contentLines[index + 1];
+                if (trimmedLine.trim().length > 0 && nextLine !== undefined && countLeadingSpaces(nextLine) <= 3) {
+                    const setext = parseSetextUnderline(nextLine.trim());
+                    if (setext) {
+                        tokens.push({
+                            type: "header",
+                            raw: line,
+                            leadingSpaces,
+                            level: setext.level,
+                            text: trimmedLine.trim(),
+                        });
+                        index += 1;
+                        continue;
+                    }
+                }
             }
         }
         const marker = parseListMarker(line);

package/build/protocol/markdown/normalization.js

@@ -1,4 +1,5 @@
-import { parseToAST, renderNodeContent, } from "./index.js";
+import { parseToAST } from "./parser.js";
+import { renderNodeContent } from "./render.js";
 export function computeHeadingDelta(shallowest, minLevel) {
     if (shallowest === null || shallowest >= minLevel) {
         return 0;
@@ -61,7 +62,7 @@ export function renderMarkdownSections(items) {
         // Keiyaku uses H2 as contract section delimiters. Keep payload headings at H3+.
         const normalized = demoteMarkdownHeadings(item, 3);
         const trimmed = normalized.trimStart();
-        if (/^[-*+]\s+/.test(trimmed) || /^\d+\.\s+/.test(trimmed)) {
+        if (/^[-*+]\s+/.test(trimmed) || /^\d+[.)]\s+/.test(trimmed)) {
             return normalized;
         }
         return `- ${normalized}`;

package/build/protocol/markdown/parser.js

@@ -84,7 +84,7 @@ class MarkdownParser {
             throw new KeiyakuParseError("invalid markdown parse state: expected code fence");
         }
         const lines = [opener.raw];
-        const fence = { length: opener.length };
+        const fence = { delimiter: opener.delimiter, length: opener.length };
         while (!this.isEof()) {
             const token = this.consume();
             if (!token)
@@ -192,7 +192,7 @@ class MarkdownParser {
                 break;
             lines.push(consumed.raw);
             if (consumed.type === "fence") {
-                itemFence = { length: consumed.length };
+                itemFence = { delimiter: consumed.delimiter, length: consumed.length };
             }
         }
         const normalizedLines = stripTrailingBlankLines(lines);

package/build/protocol/response-history.js

@@ -1,10 +1,17 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { RESPONSE_ARTIFACT_NOTICE, RESPONSE_HISTORY_DIR } from "../keiyaku.js";
+import { isErrnoException } from "../errno.js";
 import { FlowError, requireText } from "../flow-error.js";
 import { parseToAST } from "./markdown/index.js";
 const RESPONSE_HISTORY_SLUG_MAX_LENGTH = 24;
-const RESUMABLE_RESPONSE_HEADINGS = ["# Ask", "# Summon", "# Drive", "# Review"];
+export const RESPONSE_ARTIFACT_HEADINGS = {
+    ask: "# Ask",
+    summon: "# Summon",
+    drive: "# Drive",
+    review: "# Review",
+};
+const RESUMABLE_RESPONSE_HEADINGS = Object.values(RESPONSE_ARTIFACT_HEADINGS);
 function toTimestampParts(now) {
     const year = String(now.getFullYear());
     const month = String(now.getMonth() + 1).padStart(2, "0");
@@ -12,8 +19,9 @@ function toTimestampParts(now) {
     const hour = String(now.getHours()).padStart(2, "0");
     const minute = String(now.getMinutes()).padStart(2, "0");
     const second = String(now.getSeconds()).padStart(2, "0");
+    const millisecond = String(now.getMilliseconds()).padStart(3, "0");
     return {
-        fileStamp: `${year}${month}${day}-${hour}${minute}${second}`,
+        fileStamp: `${year}${month}${day}-${hour}${minute}${second}${millisecond}`,
         iso: now.toISOString(),
     };
 }
@@ -133,6 +141,28 @@ export async function persistResponseHistory(input) {
     await fs.writeFile(responsePath, markdown, "utf-8");
     return path.relative(input.cwd, responsePath);
 }
+function detectArtifactHeading(document) {
+    const lines = document.split("\n");
+    let index = 0;
+    if (lines[0] === "---") {
+        index = 1;
+        while (index < lines.length && lines[index] !== "---") {
+            index += 1;
+        }
+        if (index === lines.length) {
+            return null;
+        }
+        index += 1;
+    }
+    for (; index < lines.length; index += 1) {
+        const line = lines[index].trim();
+        if (line.length === 0) {
+            continue;
+        }
+        return RESUMABLE_RESPONSE_HEADINGS.find((heading) => heading === line) ?? null;
+    }
+    return null;
+}
 export async function resolveAskResponsePath(input) {
     const responsePath = requireText("responsePath", input.responsePath);
     const resolvedPath = path.isAbsolute(responsePath) ? responsePath : path.resolve(input.cwd, responsePath);
@@ -141,8 +171,7 @@ export async function resolveAskResponsePath(input) {
         document = await fs.readFile(resolvedPath, "utf-8");
     }
     catch (error) {
-        const code = error?.code;
-        if (code === "ENOENT" || code === "EISDIR") {
+        if (isErrnoException(error) && (error.code === "ENOENT" || error.code === "EISDIR")) {
             throw new FlowError("INVALID_RESPONSE_PATH", `Response path file not found: '${responsePath}'.`);
         }
         throw error;
@@ -155,9 +184,19 @@ export async function resolveAskResponsePath(input) {
     if (frontmatter.notice !== RESPONSE_ARTIFACT_NOTICE) {
         throw new FlowError("INVALID_RESPONSE_PATH", `Response path file '${responsePath}' is not a Keiyaku response artifact.`);
     }
-    if (!RESUMABLE_RESPONSE_HEADINGS.some((heading) => new RegExp(`^${heading}\\s*$`, "m").test(document))) {
+    const artifactHeading = detectArtifactHeading(document);
+    if (!artifactHeading) {
         throw new FlowError("INVALID_RESPONSE_PATH", `Response path file '${responsePath}' is not a supported Keiyaku response artifact.`);
     }
+    if (input.allowedTools?.length) {
+        const allowedHeadings = input.allowedTools.map((tool) => RESPONSE_ARTIFACT_HEADINGS[tool]);
+        if (!allowedHeadings.includes(artifactHeading)) {
+            if (input.onArtifactTypeMismatch === "return-null") {
+                return undefined;
+            }
+            throw new FlowError("INVALID_RESPONSE_PATH", `Response path file '${responsePath}' is not a supported ${input.allowedTools.join("/")} response artifact.`);
+        }
+    }
     const sessionId = frontmatter.session_id?.trim();
     if (!sessionId) {
         throw new FlowError("INVALID_RESPONSE_PATH", `Response path file '${responsePath}' does not include 'session_id'; this conversation cannot be resumed.`);

package/build/protocol/status-previews.js

@@ -1,5 +1,4 @@
-import { parseToAST, renderNodeContent } from "./markdown/index.js";
-import { parseRoundSummary } from "../tools/round/report.js";
+import { parseMarkdownSections, parseToAST, renderNodeContent } from "./markdown/index.js";
 const PREVIEW_SECTION_TITLES = ["goal", "context"];
 const PREVIEW_SECTION_TITLE_SET = new Set(PREVIEW_SECTION_TITLES);
 const STATUS_PREVIEW_MAX_LINES = 2;
@@ -49,6 +48,22 @@ function extractRoundRawSummary(roundSection) {
     const summary = renderNodesForPreview(extractHeadingBody(roundSection, "summary"));
     return summary.length > 0 ? summary : undefined;
 }
+function extractOutcomeFromStructuredSummary(rawSummary) {
+    for (const sectionMarkdown of parseMarkdownSections(rawSummary)) {
+        const lines = sectionMarkdown.split(/\r?\n/);
+        const headerLine = lines[0]?.trim();
+        if (!headerLine)
+            continue;
+        const headerMatch = /^#{2,3}\s+(.+?)\s*$/.exec(headerLine);
+        if (!headerMatch)
+            continue;
+        if (normalizeHeading(headerMatch[1]) !== "outcome")
+            continue;
+        const body = lines.slice(1).join("\n").trim();
+        return body.length > 0 ? body : undefined;
+    }
+    return undefined;
+}
 export function extractLastRoundSummary(traceContent) {
     const ast = parseToAST(traceContent, { allowSections: true });
     let lastRoundSection;
@@ -69,12 +84,9 @@ export function extractLastRoundSummary(traceContent) {
     const rawSummary = extractRoundRawSummary(lastRoundSection)?.trim();
     if (!rawSummary)
         return undefined;
-    const parsedSummary = parseRoundSummary(rawSummary);
-    if (parsedSummary.kind === "structured") {
-        const outcomeBody = parsedSummary.sections.outcome?.body.trim();
-        if (outcomeBody) {
-            return outcomeBody;
-        }
+    const outcomeBody = extractOutcomeFromStructuredSummary(rawSummary);
+    if (outcomeBody) {
+        return outcomeBody;
     }
     return rawSummary;
 }

package/build/protocol/summon-draft.js

@@ -1,6 +1,7 @@
 import * as fs from "fs/promises";
 import * as path from "path";
 import { KEIYAKU_DRAFT_DIR } from "../keiyaku.js";
+import { isErrnoException } from "../errno.js";
 import { FlowError, isFlowError, requireText, wrapFlowError } from "../flow-error.js";
 import { resolveTermPreset } from "../config/term-presets/resolver.js";
 import { writeDraftArtifact, listDraftArtifacts } from "./draft-artifacts.js";
@@ -74,7 +75,7 @@ export async function resolveSummonInput(cwd, input) {
         content = await fs.readFile(draftPath, "utf-8");
     }
     catch (error) {
-        if (error?.code === "ENOENT") {
+        if (isErrnoException(error) && error.code === "ENOENT") {
             throw new FlowError("FROM_DRAFT_NOT_FOUND", `from_draft path does not exist: ${fromDraft}`);
         }
         throw error;
@@ -115,7 +116,7 @@ export async function readRollbackDraftSnapshot(cwd, candidatePath) {
         return { relativePath, content };
     }
     catch (error) {
-        if (error?.code === "ENOENT") {
+        if (isErrnoException(error) && error.code === "ENOENT") {
             return null;
         }
         throw error;

package/build/protocol/summon-input.js

@@ -0,0 +1 @@
+export {};

package/build/protocol/trace.js

@@ -187,7 +187,7 @@ export function renderReviewSection(review) {
         `${REVIEW_RESULT_PREFIX} ${review.result}`,
         `${REVIEW_HISTORY_POINTER_PREFIX} ${historyPath}`,
     ];
-    if (findings && review.result === "rejected") {
+    if (findings) {
         lines.push("", findings);
     }
     lines.push("");

package/build/tools/amend/index.js

@@ -1,28 +1,18 @@
-import { appendDebugLog } from "../../telemetry/debug-log.js";
 import { buildAmendResponse } from "../../mcp/responses.js";
-import { handleToolError } from "../../mcp/tool-errors.js";
 import { amendKeiyaku } from "./run.js";
+import { createToolHandler } from "../create-handler.js";
 export function createAmendHandler() {
-    return async ({ amendment, cwd }, _extra) => {
-        const workingDir = cwd || process.cwd();
-        try {
-            appendDebugLog(`tool amend start cwd=${workingDir}`, { cwd: workingDir, section: "script" });
-            const outcome = await amendKeiyaku({
-                cwd: workingDir,
+    return createToolHandler({
+        logLabel: "tool amend",
+        doneLog: (outcome) => `tool amend success branch=${outcome.currentBranch} amendment=${outcome.amendmentNumber}`,
+        async run({ amendment, cwd }) {
+            return amendKeiyaku({
+                cwd,
                 amendment,
             });
-            appendDebugLog(`tool amend success branch=${outcome.currentBranch} amendment=${outcome.amendmentNumber}`, {
-                cwd: workingDir,
-                section: "script",
-            });
+        },
+        buildResponse(outcome) {
             return buildAmendResponse(outcome);
-        }
-        catch (err) {
-            return handleToolError({
-                error: err,
-                cwd: workingDir,
-                logLabel: "tool amend",
-            });
-        }
-    };
+        },
+    });
 }

package/build/tools/ask/index.js

@@ -1,14 +1,13 @@
-import { appendDebugLog } from "../../telemetry/debug-log.js";
 import { runAskAndPersist } from "./persist.js";
 import { buildAskResponse } from "../../mcp/responses.js";
-import { handleToolError } from "../../mcp/tool-errors.js";
+import { createToolHandler } from "../create-handler.js";
 export function createAskHandler() {
-    return async ({ title, request, context, tier, responsePath, cwd }, extra) => {
-        const workingDir = cwd || process.cwd();
-        try {
-            appendDebugLog(`tool ask start cwd=${workingDir}`, { cwd: workingDir, section: "script" });
-            const outcome = await runAskAndPersist({
-                cwd: workingDir,
+    return createToolHandler({
+        logLabel: "tool ask",
+        doneLog: "tool ask success",
+        async run({ title, request, context, tier, responsePath, cwd }, extra) {
+            return runAskAndPersist({
+                cwd,
                 title,
                 request,
                 context,
@@ -16,18 +15,12 @@ export function createAskHandler() {
                 tier,
                 signal: extra.signal,
             });
-            appendDebugLog("tool ask success", { cwd: workingDir, section: "script" });
+        },
+        buildResponse(outcome, { tier }) {
             return buildAskResponse(outcome.result, {
                 tier,
                 responsePath: outcome.responsePath,
             });
-        }
-        catch (err) {
-            return handleToolError({
-                error: err,
-                cwd: workingDir,
-                logLabel: "tool ask",
-            });
-        }
-    };
+        },
+    });
 }