@astrosheep/keiyaku 0.1.14 → 0.1.15

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

@@ -31,7 +31,7 @@ export function createCloseHandler() {
                     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",
                 });
@@ -51,7 +51,7 @@ 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",
             });

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/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(),
 });
@@ -25,11 +26,11 @@ 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),
+    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(),
 });