@astrosheep/keiyaku 0.1.14 → 0.1.16

package/build/common/constants.js

@@ -1,3 +1,5 @@
 export const KEIYAKU_FILE = "KEIYAKU.md";
+export const KEIYAKU_DRAFT_FILE = "KEIYAKU.draft.md";
+export const KEIYAKU_DRAFT_NEW_FILE = "KEIYAKU.draft.new.md";
 export const TRACE_FILE = "KEIYAKU_TRACE.md";
 export const ROUND_SUBAGENTS = ["agent-a", "agent-b", "agent-c"];

package/build/common/errors.js

@@ -62,6 +62,14 @@ function hintForFlowCode(code, message) {
             return "Title cannot be converted to a valid branch token for `keiyaku/<title>`.";
         case "UNKNOWN_SUBAGENT":
             return unknownSubagentHint();
+        case "FROM_FILE_NOT_FOUND":
+            return "The path in `from_file` does not exist. Use an existing file path (absolute or relative to `cwd`).";
+        case "INVALID_KEIYAKU_DRAFT":
+            return "Invalid draft/input. Provide `title`, `goal`, `context`, and non-empty `criteria` (or include them in `from_file` with proper section headers).";
+        case "KEIYAKU_FILE_EXISTS":
+            return `\`${preset.tools.start.name}\` requires a clean slate. Remove existing \`KEIYAKU.md\` before starting.`;
+        case "DRAFT_FILE_EXISTS":
+            return `Existing \`KEIYAKU.draft.md\` detected. Use it via \`from_file\` or delete it before starting.`;
     }
 }
 const MESSAGE_HINT_PATTERNS = [
@@ -93,6 +101,10 @@ const MESSAGE_HINT_PATTERNS = [
     { code: "ROUND_SUBAGENT_FAILED", patterns: ["failed during subagent execution"] },
     { code: "INVALID_BRANCH_TITLE", patterns: ["cannot be converted to a valid branch name"] },
     { code: "UNKNOWN_SUBAGENT", patterns: ["Unknown subagent"] },
+    { code: "FROM_FILE_NOT_FOUND", patterns: ["from_file path does not exist"] },
+    { code: "INVALID_KEIYAKU_DRAFT", patterns: ["invalid keiyaku draft"] },
+    { code: "KEIYAKU_FILE_EXISTS", patterns: ["pre-flight failed: KEIYAKU.md already exists"] },
+    { code: "DRAFT_FILE_EXISTS", patterns: ["pre-flight failed: KEIYAKU.draft.md exists but from_file does not target it"] },
 ];
 function inferFlowCodeFromMessage(message) {
     for (const entry of MESSAGE_HINT_PATTERNS) {

package/build/config/term-presets.js

@@ -7,13 +7,13 @@ export const DEFAULT_AVAILABLE_NAMES = [
 export const DEFAULT_SUBAGENT_NAME = 'A-tier';
 const DEFAULT_VERDICT_CONFIG = {
     thresholds: {
-        precise: 5,
-        minimal: 4,
-        isolated: 4,
-        idiomatic: 3,
-        cohesive: 4,
+        precise: 10,
+        minimal: 8,
+        isolated: 8,
+        idiomatic: 6,
+        cohesive: 8,
     },
-    minTotalScore: 20,
+    minTotalScore: 40,
 };
 export const DEFAULT_PRESET = {
     id: 'default',
@@ -57,12 +57,13 @@ export const DEFAULT_PRESET = {
             title: 'Sign Keiyaku',
             description: 'Initialize a Keiyaku (Contract). Bind a Servant to a dedicated workspace (branch).\nYou are the Architect; they are the Instrument. Define the Goal and Scope clearly.\nThe contract isolates their existence until the objective is met.\nCall ONCE to seal the bond.\n\nFlow: ${start} → [${drive} x N] → ${close}',
             args: {
-                title: 'REQUIRED. A concise codename for this hunt.',
-                goal: 'REQUIRED. The Kill Condition. State exactly what success looks like for the servant to achieve.',
-                directive: 'Optional First Step. Use to leash the servant to a specific starting point (e.g., "Analyze the code first"). If omitted, the Servant will attempt the Goal directly.',
-                context: 'REQUIRED. Mission Intel. The complete knowledge base for the servant: current vs. expected behavior, relevant file paths, error logs, and any critical background info.',
-                constraints: 'REQUIRED. Non-negotiable Rules. Architectural and stylistic boundaries the servant must obey.',
-                criteria: 'REQUIRED. Acceptance Criteria. Verifiable checks to prove the servant has finished the job.',
+                from_file: "Optional markdown draft path. Loads `# title` + required sections from file (relative to cwd unless absolute).",
+                title: 'Required unless provided via `from_file`. A concise codename for this hunt.',
+                goal: 'Required unless provided via `from_file`. The Kill Condition for this mission.',
+                directive: 'Optional First Step. Overrides `## Directive` from `from_file` when both are provided.',
+                context: 'Required unless provided via `from_file`. Mission intel: behavior gap, key files, logs, and critical background.',
+                constraints: 'Optional. Non-negotiable rules as a list of strings. If omitted, the draft value (if any) is used.',
+                criteria: 'Required unless provided via `from_file`. Verifiable checks proving completion.',
                 name: 'Optional ${identity} profile to execute this mission. Available: ${available_names}.',
                 cwd: "Optional repository path. Defaults to the server's current working directory.",
             },
@@ -103,11 +104,11 @@ export const DEFAULT_PRESET = {
                 petition: 'REQUIRED. CLAIM declares fulfillment; FORFEIT concedes failure.\nREQUIRES AN ACTIVE KEIYAKU (started via ${start}).\nIf any score wavers, do not claim—return to ${drive}.',
                 criteriaChecks: 'REQUIRED. For CLAIM: evidence that each criterion is met. For FORFEIT: honest account of what remains unfinished.',
                 constraintsChecks: 'REQUIRED. For CLAIM: evidence that each constraint stayed compliant. For FORFEIT: list known violations or unresolved risk.',
-                score_precise: 'REQUIRED (0-5). Architectural placement. 5 = exact layer, exact boundary, zero misplacement.',
-                score_minimal: 'REQUIRED (0-5). Economy of change. 5 = no avoidable lines, no speculative edits, no hidden bloat.',
-                score_isolated: 'REQUIRED (0-5). Surgical containment. 5 = zero unrelated files, zero opportunistic cleanup, zero collateral.',
-                score_idiomatic: 'REQUIRED (0-5). Native fluency. 5 = naming, structure, style indistinguishable from the codebase.',
-                score_cohesive: 'REQUIRED (0-5). Single responsibility. 5 = each unit does one thing, boundaries intact.',
+                score_precise: 'REQUIRED (0-10). Architectural placement. 10 = exact layer, exact boundary, zero misplacement.',
+                score_minimal: 'REQUIRED (0-10). Economy of change. 10 = no avoidable lines, no speculative edits, no hidden bloat.',
+                score_isolated: 'REQUIRED (0-10). Surgical containment. 10 = zero unrelated files, zero opportunistic cleanup, zero collateral.',
+                score_idiomatic: 'REQUIRED (0-10). Native fluency. 10 = naming, structure, style indistinguishable from the codebase.',
+                score_cohesive: 'REQUIRED (0-10). Single responsibility. 10 = each unit does one thing, boundaries intact.',
                 oath: 'Required for CLAIM. Your binding word. The Contract holds you to it.\nVerbatim: ${oath_text}',
                 cwd: "Optional repository path. Defaults to the server's current working directory.",
             },
@@ -158,12 +159,13 @@ export const POCKET_PRESET = {
             title: 'I Choose You!',
             description: 'Initialize the Battle Phase. Send a Critter (Servant) into a dedicated Arena (branch).\nYou are the Trainer; they are the Fighter. Define the Victory Condition (Goal) clearly.\nThe battle continues in this Arena until the Badge is won.\nCall ONCE to start the encounter.\n\nFlow: ${start} → [${drive} x N] → ${close}',
             args: {
-                title: 'REQUIRED. Battle card title for this encounter.',
-                goal: 'REQUIRED. Victory condition. Define exactly what winning this battle means.',
-                directive: 'Optional Turn 1 strategy. Use to focus on the opening move.',
-                context: 'REQUIRED. Battle background: key code paths, symptoms, logs, and repro clues.',
-                constraints: 'REQUIRED. Battle rules that cannot be broken while fighting.',
-                criteria: 'REQUIRED. Gym badges for completion: concrete checks proving victory.',
+                from_file: 'Optional battle plan markdown path with title + sections.',
+                title: 'Required unless provided via `from_file`. Battle card title for this encounter.',
+                goal: 'Required unless provided via `from_file`. Victory condition for this battle.',
+                directive: 'Optional Turn 1 strategy (overrides draft directive).',
+                context: 'Required unless provided via `from_file`. Battle background and repro clues.',
+                constraints: 'Optional battle rules as a list of strings. Uses draft constraints if omitted.',
+                criteria: 'Required unless provided via `from_file`. Concrete checks proving victory.',
                 name: 'Optional ${identity} to send into battle. Available: ${available_names}.',
                 cwd: 'Optional battlefield path (repository root). Defaults to current arena.',
             },
@@ -198,11 +200,11 @@ export const POCKET_PRESET = {
                 petition: 'REQUIRED. CLAIM seeks Badge; FORFEIT forfeits the match.\nREQUIRES AN ACTIVE BATTLE (started via ${start}).\nIf stats are low, continue with ${drive}.',
                 criteriaChecks: 'REQUIRED. Badge-by-badge proof for CLAIM, or reason for Forfeit.',
                 constraintsChecks: 'REQUIRED. Rule-by-rule proof that constraints were respected, or known breaks when forfeiting.',
-                score_precise: 'REQUIRED score (0-5). 5 means a Critical Hit: exact layer, exact target, zero meaningful misplacement.',
-                score_minimal: 'REQUIRED score (0-5). 5 means Max Efficiency: no wasted PP, no extra motion.',
-                score_isolated: 'REQUIRED score (0-5). 5 means 1v1 Focus: zero side-quests, zero unrelated damage.',
-                score_idiomatic: "REQUIRED score (0-5). 5 means STAB (Same Type Attack Bonus): perfectly matches the codebase style.",
-                score_cohesive: 'REQUIRED score (0-5). 5 means Team Synergy: action serves one purpose with clean boundaries.',
+                score_precise: 'REQUIRED score (0-10). 10 means a Critical Hit: exact layer, exact target, zero meaningful misplacement.',
+                score_minimal: 'REQUIRED score (0-10). 10 means Max Efficiency: no wasted PP, no extra motion.',
+                score_isolated: 'REQUIRED score (0-10). 10 means 1v1 Focus: zero side-quests, zero unrelated damage.',
+                score_idiomatic: "REQUIRED score (0-10). 10 means STAB (Same Type Attack Bonus): perfectly matches the codebase style.",
+                score_cohesive: 'REQUIRED score (0-10). 10 means Team Synergy: action serves one purpose with clean boundaries.',
                 oath: "Trainer's Honor Code. Required for CLAIM. Verbatim: ${oath_text}",
                 cwd: 'Optional battlefield path (repository root). Defaults to current arena.',
             },
@@ -253,12 +255,13 @@ export const MISCHIEF_PRESET = {
             title: 'Oi!',
             description: "Initiate Grand Scheme. Summon a Minion to the Lair (branch).\nYou are the Mastermind; they are the Henchman. Define the Conquest (Goal) with dominance.\nThe minion is bound to this Lair until the plot is realized.\nCall ONCE to start the machine.\n\nFlow: ${start} → [${drive} x N] → ${close}",
             args: {
-                title: 'REQUIRED. Operation codename for your grand scheme.',
-                goal: 'REQUIRED. The conquest objective. Define the exact end-state your minion must deliver.',
-                directive: 'Optional first-order command. Point them in the right direction.',
-                context: 'REQUIRED. Briefing dossier: relevant file paths, current failures, logs, and repro clues.',
-                constraints: 'REQUIRED. Absolute decrees. Architectural and stylistic limits your minion must obey.',
-                criteria: 'REQUIRED. Triumph conditions that can be verified without debate.',
+                from_file: 'Optional scheme markdown path with title + sectioned objectives.',
+                title: 'Required unless provided via `from_file`. Operation codename.',
+                goal: 'Required unless provided via `from_file`. Conquest objective and end-state.',
+                directive: 'Optional first-order command (overrides draft directive).',
+                context: 'Required unless provided via `from_file`. Briefing dossier and technical clues.',
+                constraints: 'Optional decrees as a list of strings. Uses draft constraints when omitted.',
+                criteria: 'Required unless provided via `from_file`. Verifiable triumph conditions.',
                 name: 'Optional ${identity} to command this operation. Available: ${available_names}.',
                 cwd: 'Optional lair path (repository root). Defaults to current command chamber.',
             },
@@ -293,11 +296,11 @@ export const MISCHIEF_PRESET = {
                 petition: 'REQUIRED. CLAIM demands rule; FORFEIT admits defeat.\nREQUIRES AN ACTIVE SCHEME (started via ${start}).\nIf the plan is weak, improve it with ${drive}.',
                 criteriaChecks: 'REQUIRED. Proof of conquest for CLAIM, or reason for self-destruct.',
                 constraintsChecks: 'REQUIRED. Constraint-by-constraint compliance proof for CLAIM, or confession of violations for FORFEIT.',
-                score_precise: 'REQUIRED (0-5). Architectural placement. 5 = exact layer, exact boundary, zero misplacement.',
-                score_minimal: 'REQUIRED (0-5). Economy of change. 5 = no avoidable lines, no speculative edits, no hidden bloat.',
-                score_isolated: 'REQUIRED (0-5). Surgical containment. 5 = zero unrelated files, zero opportunistic cleanup, zero collateral.',
-                score_idiomatic: 'REQUIRED (0-5). Native fluency. 5 = naming, structure, style indistinguishable from the codebase.',
-                score_cohesive: 'REQUIRED (0-5). Single responsibility. 5 = each unit does one thing, boundaries intact.',
+                score_precise: 'REQUIRED (0-10). Architectural placement. 10 = exact layer, exact boundary, zero misplacement.',
+                score_minimal: 'REQUIRED (0-10). Economy of change. 10 = no avoidable lines, no speculative edits, no hidden bloat.',
+                score_isolated: 'REQUIRED (0-10). Surgical containment. 10 = zero unrelated files, zero opportunistic cleanup, zero collateral.',
+                score_idiomatic: 'REQUIRED (0-10). Native fluency. 10 = naming, structure, style indistinguishable from the codebase.',
+                score_cohesive: 'REQUIRED (0-10). Single responsibility. 10 = each unit does one thing, boundaries intact.',
                 oath: "Mastermind's Vow. Required for CLAIM. Verbatim: ${oath_text}",
                 cwd: 'Optional lair path (repository root). Defaults to current command chamber.',
             },

package/build/handlers/close.js

@@ -2,48 +2,53 @@ import { appendDebugLog } from "../utils/debug-log.js";
 import { presentWork } from "../workflow/present.js";
 import { buildCloseDoneResponse, buildCloseDropResponse, } from "../workflow/response-builders.js";
 import { resolveTermPreset } from "../config/term-presets.js";
+import { closeToolSchema } from "../types/tooling.js";
 import { handleToolError } from "./shared.js";
 export function createCloseHandler() {
-    return async ({ petition, criteriaChecks, constraintsChecks, score_precise, score_minimal, score_isolated, score_idiomatic, score_cohesive, oath, cwd, }, extra) => {
-        const workingDir = cwd || process.cwd();
-        const criteriaCheckParts = criteriaChecks;
-        const constraintsCheckParts = constraintsChecks ?? [];
+    return async (args, extra) => {
+        let petition = "UNKNOWN";
+        let workingDir = process.cwd();
+        let criteriaCheckParts = [];
+        let constraintsCheckParts = [];
+        let oath;
+        let scoreLine;
         try {
+            const input = closeToolSchema.parse(args);
+            petition = input.petition;
+            workingDir = input.cwd || process.cwd();
+            if (input.petition === "CLAIM") {
+                criteriaCheckParts = input.criteriaChecks;
+                constraintsCheckParts = input.constraintsChecks;
+                oath = input.oath;
+                scoreLine = `Scores: precise=${input.score_precise} minimal=${input.score_minimal} isolated=${input.score_isolated} idiomatic=${input.score_idiomatic} cohesive=${input.score_cohesive}`;
+            }
             appendDebugLog(`tool close start petition=${petition} cwd=${workingDir} criteriaChecks=${criteriaCheckParts.length} constraintsChecks=${constraintsCheckParts.length}`, {
                 cwd: workingDir,
                 section: "script",
             });
             const outcome = await presentWork({
+                ...input,
                 cwd: workingDir,
-                petition,
-                criteriaChecks: criteriaCheckParts,
-                constraintsChecks: constraintsCheckParts,
-                score_precise,
-                score_minimal,
-                score_isolated,
-                score_idiomatic,
-                score_cohesive,
-                oath,
                 signal: extra.signal,
             });
-            if (petition === "CLAIM") {
-                if (!("result" in outcome) || outcome.result !== "done") {
+            if (input.petition === "CLAIM") {
+                if (!("result" in outcome) || outcome.result !== "merged") {
                     throw new Error("Unexpected CLAIM outcome shape");
                 }
                 const finalOutcome = outcome;
-                appendDebugLog(`tool close CLAIM success branch=${finalOutcome.branch} base=${finalOutcome.baseBranch}`, {
+                appendDebugLog(`tool close CLAIM success branch=${finalOutcome.currentBranch} base=${finalOutcome.baseBranch}`, {
                     cwd: workingDir,
                     section: "script",
                 });
                 return buildCloseDoneResponse(finalOutcome, {
                     criteriaChecks: criteriaCheckParts,
                     constraintsChecks: constraintsCheckParts,
-                    score_precise,
-                    score_minimal,
-                    score_isolated,
-                    score_idiomatic,
-                    score_cohesive,
-                    oath,
+                    score_precise: input.score_precise,
+                    score_minimal: input.score_minimal,
+                    score_isolated: input.score_isolated,
+                    score_idiomatic: input.score_idiomatic,
+                    score_cohesive: input.score_cohesive,
+                    oath: input.oath,
                     cwd: workingDir,
                 });
             }
@@ -51,19 +56,11 @@ export function createCloseHandler() {
                 throw new Error("Unexpected FORFEIT outcome shape");
             }
             const finalOutcome = outcome;
-            appendDebugLog(`tool close FORFEIT success branch=${finalOutcome.branch} base=${finalOutcome.baseBranch}`, {
+            appendDebugLog(`tool close FORFEIT success branch=${finalOutcome.currentBranch} base=${finalOutcome.baseBranch}`, {
                 cwd: workingDir,
                 section: "script",
             });
             return buildCloseDropResponse(finalOutcome, {
-                criteriaChecks: criteriaCheckParts,
-                constraintsChecks: constraintsCheckParts,
-                score_precise,
-                score_minimal,
-                score_isolated,
-                score_idiomatic,
-                score_cohesive,
-                oath,
                 cwd: workingDir,
             });
         }
@@ -78,8 +75,8 @@ export function createCloseHandler() {
                     `Petition: ${petition}`,
                     `Criteria checks (${criteriaCheckParts.length}): ${criteriaCheckParts.join("; ")}`,
                     `Constraints checks (${constraintsCheckParts.length}): ${constraintsCheckParts.join("; ")}`,
-                    `Scores: precise=${score_precise} minimal=${score_minimal} isolated=${score_isolated} idiomatic=${score_idiomatic} cohesive=${score_cohesive}`,
-                    ...(oath ? [`Oath: ${oath}`] : []),
+                    ...(scoreLine ? [scoreLine] : []),
+                    ...(petition === "CLAIM" && oath ? [`Oath: ${oath}`] : []),
                     `Path: ${workingDir}`,
                 ],
             });

package/build/handlers/help.js

@@ -5,9 +5,14 @@ export function createHelpHandler(preset) {
             "# Keiyaku System Help",
             "",
             "## Core Files (.keiyaku/)",
-            "These files define the 'Law' of the project. **CRITICAL**: Use Markdown level 2 headers (## header).",
+            "These files define the 'Law' and configuration of the project.",
             "",
             "- **base-constraints.md**: Mandatory architectural boundaries and coding standards.",
+            "  - **Purpose**: Global constraints injected into every mission.",
+            "  - **Logic**: The system prioritize extracting all list items (`-` or `*`) as individual constraints.",
+            "  - **Formatting**: Use lists for constraints. You can use H3+ headers (`###`) for organization, but they are stripped if the section contains lists.",
+            "  - **Strict Rule**: DO NOT use H1 (`#`) or H2 (`##`) within constraints or as content if they aren't meant to be item separators, as they will trigger validation errors.",
+            "- **settings.json**: Local configuration for the Keiyaku environment.",
             "",
             preset.usageGuide,
             "",

package/build/handlers/start.js

@@ -1,35 +1,48 @@
 import { appendDebugLog } from "../utils/debug-log.js";
-import { summonServant } from "../workflow/summon.js";
+import { startKeiyaku } from "../workflow/start.js";
 import { buildKeiyakuSuccessResponse, } from "../workflow/response-builders.js";
 import { resolveTermPreset } from "../config/term-presets.js";
 import { handleToolError } from "./shared.js";
+function normalizeOptionalArg(value) {
+    if (value === undefined)
+        return undefined;
+    return value.trim().length > 0 ? value : undefined;
+}
 export function createStartHandler() {
-    return async ({ title, goal, directive, context, constraints, criteria, name, cwd }, extra) => {
+    return async ({ from_file, title, goal, directive, context, constraints, criteria, name, cwd }, extra) => {
         const workingDir = cwd || process.cwd();
+        const normalizedFromFile = normalizeOptionalArg(from_file);
         try {
             appendDebugLog(`tool start cwd=${workingDir}`, { cwd: workingDir, section: "script" });
-            const result = await summonServant({
-                cwd: workingDir,
-                title,
-                goal,
-                directive,
-                context,
-                criteria,
-                constraints,
-                name,
-                signal: extra.signal,
-            });
-            appendDebugLog(`tool start success branch=${result.branch} base=${result.baseBranch} round=${result.round}`, {
+            const result = normalizedFromFile
+                ? await startKeiyaku({
+                    cwd: workingDir,
+                    from_file: normalizedFromFile,
+                    title: normalizeOptionalArg(title),
+                    goal: normalizeOptionalArg(goal),
+                    directive: normalizeOptionalArg(directive),
+                    context: normalizeOptionalArg(context),
+                    constraints,
+                    criteria,
+                    name,
+                    signal: extra.signal,
+                })
+                : await startKeiyaku({
+                    cwd: workingDir,
+                    title: title ?? "",
+                    goal: goal ?? "",
+                    directive: normalizeOptionalArg(directive),
+                    context: context ?? "",
+                    constraints,
+                    criteria: criteria ?? [],
+                    name,
+                    signal: extra.signal,
+                });
+            appendDebugLog(`tool start success branch=${result.currentBranch} base=${result.baseBranch} round=${result.round}`, {
                 cwd: workingDir,
                 section: "script",
             });
             return buildKeiyakuSuccessResponse(result, {
-                title,
-                goal,
-                directive,
-                context,
-                constraints,
-                criteria,
                 name,
                 cwd: workingDir,
             });
@@ -42,12 +55,13 @@ export function createStartHandler() {
                 cwd: workingDir,
                 logLabel: "tool start",
                 inputEcho: [
-                    `Title: ${title}`,
-                    `Goal: ${goal}`,
+                    ...(normalizedFromFile ? [`From file: ${normalizedFromFile}`] : []),
+                    ...(title ? [`Title: ${title}`] : []),
+                    ...(goal ? [`Goal: ${goal}`] : []),
                     ...(directive ? [`Directive: ${directive}`] : []),
-                    `Criteria (${criteria.length}): ${criteria.join("; ")}`,
+                    ...(criteria ? [`Criteria (${criteria.length}): ${criteria.join("; ")}`] : []),
                     ...(context ? [`Context: ${context}`] : []),
-                    ...(constraints ? [`Constraints: ${constraints}`] : []),
+                    ...(constraints ? [`Constraints (${constraints.length}): ${constraints.join("; ")}`] : []),
                     ...(name ? [`${preset.identity}: ${name}`] : []),
                     `Path: ${workingDir}`,
                 ],

package/build/index.js

@@ -41,9 +41,7 @@ function registerTools(server) {
     const askPreset = renderedPreset.tools.ask;
     const closePreset = renderedPreset.tools.close;
     const helpPreset = renderedPreset.tools.help;
-    const dynamicCloseSchema = applyArgumentDescriptions(closeToolSchema, {
-        ...closePreset.args,
-    });
+    const dynamicCloseSchema = closeToolSchema;
     const dynamicStartSchema = applyArgumentDescriptions(startToolSchema, {
         ...startPreset.args,
     });

package/build/types/tooling.js

@@ -1,11 +1,12 @@
 import { z } from "zod";
 export const startToolSchema = z.object({
-    title: z.string(),
-    goal: z.string(),
+    from_file: z.string().optional(),
+    title: z.string().optional(),
+    goal: z.string().optional(),
     directive: z.string().optional(),
-    context: z.string(),
-    constraints: z.string(),
-    criteria: z.array(z.string().trim().min(1)).min(1),
+    context: z.string().optional(),
+    constraints: z.array(z.string().trim().min(1)).min(1).optional(),
+    criteria: z.array(z.string().trim().min(1)).min(1).optional(),
     name: z.string().optional(),
     cwd: z.string().optional(),
 });
@@ -21,16 +22,22 @@ export const askToolSchema = z.object({
     name: z.string().optional(),
     cwd: z.string().optional(),
 });
-export const closeToolSchema = z.object({
-    petition: z.enum(["CLAIM", "FORFEIT"]),
-    criteriaChecks: z.array(z.string().trim().min(1)).min(1),
-    constraintsChecks: z.array(z.string().trim().min(1)).min(1),
-    score_precise: z.number().min(0).max(5),
-    score_minimal: z.number().min(0).max(5),
-    score_isolated: z.number().min(0).max(5),
-    score_idiomatic: z.number().min(0).max(5),
-    score_cohesive: z.number().min(0).max(5),
-    oath: z.string().optional(),
-    cwd: z.string().optional(),
-});
+export const closeToolSchema = z.discriminatedUnion("petition", [
+    z.object({
+        petition: z.literal("CLAIM"),
+        criteriaChecks: z.array(z.string().trim().min(1)).min(1),
+        constraintsChecks: z.array(z.string().trim().min(1)).min(1),
+        score_precise: z.number().min(0).max(10),
+        score_minimal: z.number().min(0).max(10),
+        score_isolated: z.number().min(0).max(10),
+        score_idiomatic: z.number().min(0).max(10),
+        score_cohesive: z.number().min(0).max(10),
+        oath: z.string().optional(),
+        cwd: z.string().optional(),
+    }),
+    z.object({
+        petition: z.literal("FORFEIT"),
+        cwd: z.string().optional(),
+    }),
+]);
 export const helpToolSchema = z.object({});

package/build/utils/git-ops.js

@@ -265,6 +265,16 @@ export async function getKeiyakuBase(cwd, branchName) {
         return null;
     }
 }
+export async function getLatestCommitHash(cwd) {
+    const git = createGit(cwd);
+    try {
+        const hash = await git.revparse(["--short", "HEAD"]);
+        return hash.trim();
+    }
+    catch (err) {
+        throw wrapGitError("rev-parse --short HEAD", err, cwd);
+    }
+}
 export async function clearKeiyakuBase(cwd, branchName) {
     const git = createGit(cwd);
     try {