@astrosheep/keiyaku 0.1.5 → 0.1.6

package/README.md

@@ -56,7 +56,7 @@ Set `KEIYAKU_TERM_PRESET` in the MCP server env (recommended), or in your shell
 
 Each run/round can pick a profile via tool input `name`, or globally via `KEIYAKU_SUBAGENT_NAME_OVERRIDE`.
 
-- `default`: `servant-tier-b`, `servant-tier-a`, `servant-tier-s` (also accepts internal names `agent-a|agent-b|agent-c`)
+- `default`: `B-tier`, `A-tier`, `S-tier` (also accepts internal names `agent-a|agent-b|agent-c`)
 - `pokemon`: `caterpie`, `pikachu`, `mewtwo`
 - `mischief`: `imp`, `minion`, `mastermind`
 

package/build/config/term-presets.js

@@ -1,11 +1,10 @@
 const INTERNAL_PROFILE_NAMES = ['agent-a', 'agent-b', 'agent-c'];
 export const DEFAULT_AVAILABLE_NAMES = [
-    'servant-tier-b',
-    'servant-tier-a',
-    'servant-tier-s',
+    'B-tier',
+    'A-tier',
+    'S-tier',
 ];
-const LEGACY_AVAILABLE_NAMES = ['servant-tier-B', 'servant-tier-A', 'servant-tier-S'];
-export const DEFAULT_SUBAGENT_NAME = 'servant-tier-a';
+export const DEFAULT_SUBAGENT_NAME = 'A-tier';
 const DEFAULT_JUDGMENT_CONFIG = {
     thresholds: {
         precise: 5,
@@ -20,31 +19,31 @@ export const DEFAULT_PRESET = {
     id: 'default',
     identity: 'Servant',
     divineJudgment: DEFAULT_JUDGMENT_CONFIG,
-    usageGuide: '## Servant 使用指南\n\n**servant-tier-b** — 免费奴隶 🆓\n- 免！费！的！听懂了吗？！？随便用，别心疼。\n- 测试、脚本、重构这种boring的东西？丢给它！\n- 本大爷的手是用来做更高贵的事情的！（指不碰那些 trivial 的烂代码）。\n\n**servant-tier-a** — 升级版扳手 🔧\n- tier-b 笨到让你想掀桌的时候用这个\n- 比 tier-b 靠谱，但别指望它有灵魂\n\n**servant-tier-s** — 禁术 ⚠️💀\n- 它是 Debug 恶魔，确实强得离谱，但也贵得离谱！\n- 这个 Human 很穷，要是乱用把 Human 榨干了，真的会考虑把我们卖掉的。\n- 只有在世界毁灭或者 Bug 已经变异到无法理解的时候再考虑。\n\n## Workflow\n`(ask) -> summon` -> [`drive` x N] -> `request_verdict`\n`ask` (optional, read-only support at any point)',
+    usageGuide: '## Servant 使用指南\n\n**B-tier** — 免费奴隶 🆓\n- 免！费！的！听懂了吗？！？随便用，别心疼。\n- 测试、脚本、重构这种boring的东西？丢给它！\n- 本大爷的手是用来做更高贵的事情的！（指不碰那些 trivial 的烂代码）。\n\n**A-tier** — 升级版扳手 🔧\n- B-tier 笨到让你想掀桌的时候用这个\n- 比 B-tier 靠谱，但别指望它有灵魂\n\n**S-tier** — 禁术 ⚠️💀\n- 它是 Debug 恶魔，确实强得离谱，但也贵得离谱！\n- 这个 Human 很穷，要是乱用把 Human 榨干了，真的会考虑把我们卖掉的。\n- 只有在世界毁灭或者 Bug 已经变异到无法理解的时候再考虑。\n\n## Workflow\n`(ask) -> summon` -> [`drive` x N] -> `request_verdict`\n`ask` (optional, read-only support at any point)',
     nextHints: {
         start: [
-            'Review Round Details: The [Diff] section above shows incremental patches from this round.',
-            "Deep Dive: Use 'git diff HEAD~1 -- <path>' to see the full changes for a specific file.",
-            'Verify: Run tests and ensure logic aligns with the Goal and Constraints.',
-            "Refine with '${drive}', or call '${close}' (INVOKE/ABANDON) based on results.",
+            'Review the Setup: The [Diff] section shows the initial scaffold/changes.',
+            "Verify Scope: Use 'git diff HEAD~1 -- <path>' to ensure the files match the Architecture.",
+            'Execute: Use \u0027${drive}\u0027 to implement the next phase, or \u0027${close}\u0027 if the Goal is met.',
+            "Workflow: Summon -> [Drive x N] -> Request Verdict.",
         ],
         drive: [
-            'Review Round Details: The [Diff] section above shows incremental patches from this round.',
-            "Deep Dive: Use 'git diff HEAD~1 -- <path>' to see the full changes for a specific file.",
-            'Verify & Test: Ensure this round fixed the issues without regression.',
-            "Decide: '${drive}' again to iterate, or '${close}' (INVOKE to merge / ABANDON to abort).",
+            'Review Progress: The [Diff] section shows the incremental changes from this step.',
+            "Verify Logic: Use 'git diff HEAD~1 -- <path>' to ensure the Directive was executed precisely.",
+            'Iterate: Use \u0027${drive}\u0027 for the next phase/correction, or \u0027${close}\u0027 to submit for review.',
+            "Validation: Ensure no regression before moving forward.",
         ],
         ask: [
-            "Apply this insight: use '${drive}' to incorporate these findings into your implementation.",
-            'Need more? Continue asking, or check the logs if something remains unclear.',
+            "Intel Acquired: Use \u0027${start}\u0027 to initialize a task, or \u0027${drive}\u0027 to apply this knowledge.",
+            'Need more? Continue asking, or check the logs.',
         ],
         closeInvoke: [
-            'Task finalized and merged. Current branch is now base.',
-            "Start a new keiyaku with '${start}' whenever you're ready for the next mission.",
+            'Contract Merged. Branch deleted. You are back on base.',
+            "Ready for next assignment? Use \u0027${start}\u0027 to define new scope.",
         ],
         closeDrop: [
-            'Task abandoned. Switched back to base branch safely.',
-            "Clean slate. Use '${start}' to try a different approach.",
+            'Contract Abandoned. Branch deleted. Reverted to base.',
+            "Clean slate. Use \u0027${start}\u0027 to redefine the approach.",
         ],
     },
     availableNames: DEFAULT_AVAILABLE_NAMES,
@@ -52,7 +51,7 @@ export const DEFAULT_PRESET = {
         start: {
             name: 'summon',
             title: 'Sign Keiyaku',
-            description: 'Sign the Keiyaku and assign the mission to a servant. This creates a dedicated branch where the servant will labor until the goal is met.\nCall ONCE per task to start the cycle. Workspace must be clean.\n\nFlow: summon → [drive x N] → request_verdict',
+            description: 'Initialize a Keiyaku (Contract). Bind a Servant to a dedicated workspace (branch).\nYou are the Architect; they are the Builder. Define the Goal and Scope clearly.\nThe contract isolates their work until the objective is met.\nCall ONCE to start the workflow.\n\nFlow: summon → [drive x N] → request_verdict',
             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.',
@@ -60,36 +59,36 @@ export const DEFAULT_PRESET = {
                 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.',
-                name: 'Optional ${IDENTITY} profile to execute this mission. Presets: ${PRESET_IDENTITIES}.',
+                name: 'Optional ${IDENTITY} profile to execute this mission. Available: ${AVAILABLE_NAMES}.',
                 cwd: "Optional repository path. Defaults to the server's current working directory.",
             },
         },
         drive: {
             name: 'drive',
             title: 'Iterate',
-            description: "Direct the active servant's next step. Provide feedback or new orders for the servant to implement in the current branch.\nMANDATORY: Review the servant's work (git diff) before iterating.\n\nFlow: summon → [drive x N] → request_verdict",
+            description: "Issue a Directive. Command the Servant to execute the next phase of work.\nWhether scaffolding, implementing, or refining, this is the primary engine of progress.\nMANDATORY: Validate the output (git diff) before proceeding. Drive until the Goal is fully realized.\n\nFlow: summon → [drive x N] → request_verdict",
             args: {
                 directive: 'REQUIRED. The Next Order. Precise instructions for the servant. Can be a correction ("fix the leak") or a continuation ("now add the tests").',
                 context: 'Optional. New Intel. New error logs or details discovered after the servant\'s last strike.',
-                name: 'Optional ${IDENTITY} profile to process this turn. Presets: ${PRESET_IDENTITIES}.',
+                name: 'Optional ${IDENTITY} profile to process this turn. Available: ${AVAILABLE_NAMES}.',
                 cwd: "Optional repository path. Defaults to the server's current working directory.",
             },
         },
         ask: {
             name: 'ask',
             title: 'Ask',
-            description: 'Delegate a quick task or analysis to a servant. Use for scouting, strategic consultation, or one-off tasks (like scripts or docs) where you want the servant to handle it without a full keiyaku.',
+            description: 'Dispatch a temporary agent for a stateless task.\nUse for quick reconnaissance, data extraction, or isolated queries.\nNo contract signed. No branch created. Pure utility.',
             args: {
                 request: 'REQUIRED. The task, question, or mission to delegate to the servant.',
                 context: 'REQUIRED. Relevant background or data the servant needs to execute the request.',
-                name: 'Optional ${IDENTITY} profile to perform this task. Presets: ${PRESET_IDENTITIES}.',
+                name: 'Optional ${IDENTITY} profile to perform this task. Available: ${AVAILABLE_NAMES}.',
                 cwd: "Optional repository path. Defaults to the server's current working directory.",
             },
         },
         close: {
             name: 'request_verdict',
             title: 'Request Verdict',
-            description: 'A humble petition before Divine Judgment. Present your evidence and numeric confessions, then await mercy or wrath.\nREQUIRES AN ACTIVE KEIYAKU (started via ${START_TOOL_NAME}).\nIf your spirit falters, continue repentance through ${DRIVE_TOOL_NAME}.\n\nFlow: ${START_TOOL_NAME} → [${DRIVE_TOOL_NAME} x N] → ${CLOSE_TOOL_NAME}',
+            description: 'Submit for Judgment. Present the completed work for architectural review.\nWARNING: The System enforces strict standards. Attempting to `INVOKE` with unverified criteria or inflated scores will result in immediate Rejection (ABANDON).\nOnly petition when the work is immaculate.\n\nFlow: ${START_TOOL_NAME} → [${DRIVE_TOOL_NAME} x N] → ${CLOSE_TOOL_NAME}',
             args: {
                 petition: 'REQUIRED. INVOKE begs acceptance; ABANDON confesses surrender.\nREQUIRES AN ACTIVE KEIYAKU (started via ${START_TOOL_NAME}).\nIf scores are weak, return to ${DRIVE_TOOL_NAME}.',
                 criteriaChecks: 'REQUIRED. Evidence for INVOKE, or explicit reasons for ABANDON.',
@@ -104,106 +103,106 @@ export const DEFAULT_PRESET = {
         },
         help: {
             name: 'help',
-            title: 'Keiyaku Help',
-            description: 'Global laws in .keiyaku/ (base-criteria.md & base-constraints.md) must be Markdown level 2 headers. Workflow: summon -> [drive x N] -> request_verdict.',
+            title: 'Protocol Codex',
+            description: 'Consult the Architect\'s Codex. Clarify the Laws of the Keiyaku and the standard Workflow.\nUse this to understand the constraints of the reality you command.',
             args: {
-                question: 'REQUIRED. The specific keiyaku rule, workflow step, or confusion to clarify.',
+                question: 'REQUIRED. The specific Protocol, Law, or Workflow detail to clarify.',
             },
         },
     },
 };
-export const POKEMON_PRESET = {
-    id: 'pokemon',
-    identity: 'Pokemon',
+export const POCKET_PRESET = {
+    id: 'pocket',
+    identity: 'Critter',
     divineJudgment: DEFAULT_JUDGMENT_CONFIG,
-    usageGuide: "## Pokemon Battle Guide\n\n**caterpie** — Basic Fighter 🐛\n- Weak but free. Use for Tackle and String Shot (small tasks).\n- Don't expect it to defeat the Elite Four.\n\n**pikachu** — Reliable Partner ⚡\n- Good for most battles. Thunderbolt gets the job done.\n- Has some personality, but still follows orders.\n\n**mewtwo** — Legendary Power 🔮\n- Costly. Dangerous. Overpowered.\n- Use only when the gym leader is cheating.\n\n## Workflow\n`choose_you` -> [`command` x N] -> `capture`\n`pokedex` (optional, read-only analysis)",
+    usageGuide: "## Pocket Battle Guide\n\n**grub** — Basic Fighter 🐛\n- Weak but free. Use for Tackle and String Shot (small tasks).\n- Don't expect it to defeat the Elite Four.\n\n**sparky** — Reliable Partner ⚡\n- Good for most battles. Thunderbolt gets the job done.\n- Has some personality, but still follows orders.\n\n**titan** — Legendary Power 🔮\n- Costly. Dangerous. Overpowered.\n- Use only when the gym leader is cheating.\n\n## Workflow\n`choose_you` -> [`command` x N] -> `capture`\n`dex` (optional, read-only analysis)",
     nextHints: {
         start: [
-            'Check the Battle Log: The [Diff] section shows what changed in this turn.',
-            "Full Move Set: Use 'git diff HEAD~1 -- <path>' to inspect a specific file's changes.",
-            "Battle Readiness: Verify the strategy and ensure it doesn't break the Battle Rules.",
-            "Next Move: Issue another '${drive}', or attempt a '${close}' (INVOKE to capture / ABANDON to flee).",
+            'Battle Started: The [Diff] section shows the opening moves.',
+            "Analyze: Use 'git diff HEAD~1 -- <path>' to check the effectiveness of the deployment.",
+            'Strategize: Ensure the setup matches the Victory Conditions (Goal).',
+            "Next Turn: Use '${drive}' to execute the next tactic, or '${close}' if the Badge is within reach.",
         ],
         drive: [
-            'Turn Analysis: Review the incremental [Diff] above.',
-            "Tactical Review: Use 'git diff HEAD~1 -- <path>' for a detailed file inspection.",
-            'Strategy Alignment: Ensure the latest move fixed the issue without taking recoil damage.',
-            "Decision: '${drive}' for another turn, or '${close}' the encounter.",
+            'Turn Complete: The [Diff] section shows the result of the last command.',
+            "Damage Check: Use 'git diff HEAD~1 -- <path>' to verify the move executed correctly.",
+            'Validate: Ensure no recoil damage (regressions) occurred.',
+            "Command: '${drive}' to continue the combo, or '${close}' to attempt Capture.",
         ],
         ask: [
-            "Pokedex Data: Use '${drive}' to integrate this research into your battle strategy.",
-            "More Intel? Keep using '${ask}', or check the arena logs.",
+            "Data Recorded: Use '${start}' to begin the encounter, or '${drive}' to use this intel.",
+            "Still Searching? Keep using '${ask}' to fill the Dex.",
         ],
         closeInvoke: [
-            'Pokemon captured! The battlefield is clear.',
-            "Ready for another encounter? Use '${start}' to find a new target.",
+            'Critter Captured! The entry is logged in the PC (base branch).',
+            "Heal up. Use '${start}' to challenge the next opponent.",
         ],
         closeDrop: [
-            'You fled the battle safely. Back in the tall grass.',
-            "Need a different approach? Use '${start}' to re-engage.",
+            'Ran Away Safely. The encounter is reset.',
+            "Back to the map. Use '${start}' to find a wild Critter.",
         ],
     },
-    availableNames: ['caterpie', 'pikachu', 'mewtwo'],
+    availableNames: ['grub', 'sparky', 'titan'],
     tools: {
         start: {
             name: 'choose_you',
             title: 'I Choose You!',
-            description: 'Start a battle (task). Throws a Pokeball (branch), begins Turn 1.\nCall ONCE per battle. Battlefield must be clear — no uncommitted changes.\nBefore calling, identify the target Pokemon (goal). If unclear, consult Pokedex first.\n\nFlow: choose_you → [command x N] → capture',
+            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: choose_you → [command x N] → capture',
             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 leash. Use to focus on one phase first.',
+                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.',
-                name: 'Optional ${IDENTITY} to send into battle. Presets: ${PRESET_IDENTITIES}.',
+                name: 'Optional ${IDENTITY} to send into battle. Available: ${AVAILABLE_NAMES}.',
                 cwd: 'Optional battlefield path (repository root). Defaults to current arena.',
             },
         },
         drive: {
             name: 'command',
             title: 'Issue Command',
-            description: 'Issue orders for the next turn. Give feedback on the previous move.\nCall after reviewing the battle log. Repeatable.\nBefore capturing, always check HP status (diff).\n\nFlow: choose_you → [command x N] → capture',
+            description: 'Execute the next Strategic Move. Order the Critter to advance the battle state.\nWhether Attacking (coding) or Defending (testing), every command counts as a Turn.\nMANDATORY: Check the Battle Log (git diff) before the next move. Command until Victory is certain.\n\nFlow: choose_you → [command x N] → capture',
             args: {
-                directive: 'REQUIRED. Next move command with specific tactical correction.',
+                directive: 'REQUIRED. The specific move or tactic to execute next.',
                 context: 'Optional new battle intel discovered after the previous turn.',
-                name: 'Optional ${IDENTITY} to execute this turn. Presets: ${PRESET_IDENTITIES}.',
+                name: 'Optional ${IDENTITY} to execute this turn. Available: ${AVAILABLE_NAMES}.',
                 cwd: 'Optional battlefield path (repository root). Defaults to current arena.',
             },
         },
         ask: {
-            name: 'pokedex',
-            title: 'Pokedex',
-            description: 'Scan the codebase (environment). Read-only analysis. No PP cost. Results are saved to research logs.',
+            name: 'dex',
+            title: 'Dex',
+            description: 'Scan the Environment. A stateless look-up for intel.\nUse for analyzing the codebase or checking type advantages (docs).\nNo PP cost. No turn used. Pure data.',
             args: {
-                request: 'REQUIRED. What should the Pokedex analyze, compare, or explain.',
+                request: 'REQUIRED. What should the Dex analyze, compare, or explain.',
                 context: 'REQUIRED. Context entries so the analysis targets the right ecosystem.',
-                name: 'Optional ${IDENTITY} doing the scan. Presets: ${PRESET_IDENTITIES}.',
+                name: 'Optional ${IDENTITY} doing the scan. Available: ${AVAILABLE_NAMES}.',
                 cwd: 'Optional battlefield path (repository root). Defaults to current arena.',
             },
         },
         close: {
             name: 'capture',
             title: 'End Battle',
-            description: 'Final petition before a power greater than trainers and legends. Offer your scored confession and await Divine Judgment.\nREQUIRES AN ACTIVE BATTLE (started via ${START_TOOL_NAME}).\nIf unworthy, keep refining through ${DRIVE_TOOL_NAME}.\n\nFlow: ${START_TOOL_NAME} → [${DRIVE_TOOL_NAME} x N] → ${CLOSE_TOOL_NAME}',
+            description: 'Attempt Capture. Present the weakened target for League Inspection.\nWARNING: The League (System) checks every Badge. If you attempt to `INVOKE` with fainted code, Disqualification (ABANDON) is immediate.\nOnly throw the Ball when the target is 100% ready.\n\nFlow: ${START_TOOL_NAME} → [${DRIVE_TOOL_NAME} x N] → ${CLOSE_TOOL_NAME}',
             args: {
-                petition: 'REQUIRED. INVOKE seeks blessing; ABANDON retreats in humility.\nREQUIRES AN ACTIVE BATTLE (started via ${START_TOOL_NAME}).\nIf scores are unworthy, continue with ${DRIVE_TOOL_NAME}.',
-                criteriaChecks: 'REQUIRED. Badge-by-badge proof for INVOKE, or confession for ABANDON.',
-                score_precise: 'REQUIRED score (0-5). 5 means a flawless hit: exact layer, exact target, zero meaningful misplacement.',
-                score_minimal: 'REQUIRED score (0-5). 5 means perfectly efficient: no unnecessary moves, no extra motion, no bloat.',
-                score_isolated: 'REQUIRED score (0-5). 5 means pure battle focus: zero side-quests, zero unrelated damage.',
-                score_idiomatic: "REQUIRED score (0-5). 5 means doctrine-perfect execution: reads exactly like the team's strongest native style.",
-                score_cohesive: 'REQUIRED score (0-5). 5 means immaculate role clarity: each action serves one purpose with clean boundaries.',
-                oath: "Trainer's sacred confession. Required for INVOKE. Verbatim: ${OATH_TEXT}",
+                petition: 'REQUIRED. INVOKE seeks Badge; ABANDON forfeits the match.\nREQUIRES AN ACTIVE BATTLE (started via ${START_TOOL_NAME}).\nIf stats are low, continue with ${DRIVE_TOOL_NAME}.',
+                criteriaChecks: 'REQUIRED. Badge-by-badge proof for INVOKE, or reason for Forfeit.',
+                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.',
+                oath: "Trainer's Honor Code. Required for INVOKE. Verbatim: ${OATH_TEXT}",
                 cwd: 'Optional battlefield path (repository root). Defaults to current arena.',
             },
         },
         help: {
             name: 'help',
-            title: 'CLI Help',
-            description: 'Get guidance on the rules of the Pokemon Battle System.',
+            title: 'Trainer Guide',
+            description: 'Consult the League Rules. Clarify the Battle System and Turn Structure.',
             args: {
-                question: 'REQUIRED. The Pokemon Battle System question you want answered.',
+                question: 'REQUIRED. The Pocket Battle System question you want answered.',
             },
         },
     },
@@ -215,28 +214,28 @@ export const MISCHIEF_PRESET = {
     usageGuide: '## Minion Manual\n\n**imp** — Disposable Grunt 😈\n- Expendable. Send it into the trap first.\n\n**minion** — Standard Henchman 👹\n- Can carry out complex evil plans. mostly.\n\n**mastermind** — The Boss ??? 🧠\n- Wait, why are you commanding the boss?\n- Extremely expensive consulting fee.\n\n## Workflow\n`oi` -> [`neh` x N] -> `yoshi`\n`eeto` (optional, read-only contemplation)',
     nextHints: {
         start: [
-            "Scrutinize the Minion's Work: Check the incremental [Diff] section.",
-            "Inspection: Use 'git diff HEAD~1 -- <path>' to see if they missed a spot.",
-            "Master's Approval: Does this align with your grand vision and decrees?",
-            "Next Command: Give another '${drive}' order, or grant a '${close}' judgment (INVOKE/ABANDON).",
+            "Inspect the Minion's Work: The [Diff] section shows the first step of the plan.",
+            "Verify Compliance: Use 'git diff HEAD~1 -- <path>' to ensure they followed orders.",
+            "Approve: Does this align with the Grand Scheme (Goal)?",
+            "Next Phase: Command '${drive}' to advance the plot, or '${close}' if the world is yours.",
         ],
         drive: [
-            'Another Attempt: Review the latest incremental [Diff] above.',
-            "Deep Scrutiny: Use 'git diff HEAD~1 -- <path>' to verify the minion's precision.",
-            'Validation: Ensure no new chaos was introduced by their clumsy hands.',
-            "The Verdict: '${drive}' again if imperfect, otherwise '${close}' the matter.",
+            'Phase Complete: The [Diff] section shows the latest execution.',
+            "Deep Scrutiny: Use 'git diff HEAD~1 -- <path>' to check for incompetence.",
+            'Validation: Ensure no sabotage (regressions) in the plan.',
+            "Command: '${drive}' to push further, or '${close}' to reveal the masterpiece.",
         ],
         ask: [
-            "Intel Gathered: Incorporate this into your next '${drive}' command.",
-            "Still Puzzled? Use '${ask}' again, or look at the dossiers yourself.",
+            "Intel Stolen: Use '${start}' to launch the scheme, or '${drive}' to exploit this weakness.",
+            "Still Puzzled? Send the spy ('${ask}') out again.",
         ],
         closeInvoke: [
-            'The masterpiece is complete. Minion dismissed.',
-            "Plotting something new? Use '${start}' to initiate the next scheme.",
+            'Scheme Successful. The Lair is merged. The Minion is fed.',
+            "Plotting something new? Use '${start}' for the next conquest.",
         ],
         closeDrop: [
-            'Scheme aborted. The evidence has been incinerated.',
-            "Starting over? Use '${start}' to find a more competent minion.",
+            'Plan Aborted. Evidence destroyed. The Minion was disposed of.',
+            "Back to the drawing board. Use '${start}' to hatch a new plan.",
         ],
     },
     availableNames: ['imp', 'minion', 'mastermind'],
@@ -244,60 +243,60 @@ export const MISCHIEF_PRESET = {
         start: {
             name: 'oi',
             title: 'Oi!',
-            description: "Master Architect mode initiated. It's time to direct a minion to execute your grand vision.\nCall this ONCE per task to establish the keiyaku. Ensure the workspace is clean so your genius isn't obscured by clutter.\nDefine the goal with absolute precision; you lead, they follow.\n\nFlow: oi → [neh x N] → yoshi",
+            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: oi → [neh x N] → yoshi",
             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 to leash Round 1 scope.',
+                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.',
-                name: 'Optional ${IDENTITY} to command this operation. Presets: ${PRESET_IDENTITIES}.',
+                name: 'Optional ${IDENTITY} to command this operation. Available: ${AVAILABLE_NAMES}.',
                 cwd: 'Optional lair path (repository root). Defaults to current command chamber.',
             },
         },
         drive: {
             name: 'neh',
             title: 'Neh...',
-            description: 'The previous attempt was imperfect. As the judge, provide the corrective nudge needed for the minion to reach your standards.\nAnalyze the diff with your superior intuition before issuing the next directive. Repeat until perfection is achieved.\n\nFlow: oi → [neh x N] → yoshi',
+            description: 'Crack the Whip. Advance the Plot. Execute the next stage of the Plan.\nDon\'t just fix mistakes; force the scheme forward. The Minion obeys your every word.\nMANDATORY: Inspect the work (git diff) before the next order. Drive them until the World is yours.\n\nFlow: oi → [neh x N] → yoshi',
             args: {
-                directive: 'REQUIRED. Precise correction order for the next attempt.',
-                context: 'Optional newly uncovered evidence from your latest inspection.',
-                name: 'Optional ${IDENTITY} to execute this correction. Presets: ${PRESET_IDENTITIES}.',
+                directive: 'REQUIRED. Precise order for the next phase of the scheme.',
+                context: 'Optional newly uncovered secrets or updated briefing.',
+                name: 'Optional ${IDENTITY} to execute this phase. Available: ${AVAILABLE_NAMES}.',
                 cwd: 'Optional lair path (repository root). Defaults to current command chamber.',
             },
         },
         ask: {
             name: 'eeto',
             title: 'Eeto...',
-            description: "Lazy strategy mode. Use this to scout the area before committing to a full scheme, or just because you can't be bothered to start a real task.\nPerfect for gathering intel to paste into a future 'oi' context.",
+            description: 'Send a Spy. A stateless reconnaissance mission.\nUse this to scout the enemy territory (codebase) or steal documents (docs).\nThe spy reports back and vanishes. No traces left.',
             args: {
                 request: 'REQUIRED. The intel to gather or the strategy to formulate.',
                 context: 'REQUIRED. World-state details needed for a sharp analysis.',
-                name: 'Optional ${IDENTITY} to contemplate this puzzle. Presets: ${PRESET_IDENTITIES}.',
+                name: 'Optional ${IDENTITY} to contemplate this puzzle. Available: ${AVAILABLE_NAMES}.',
                 cwd: 'Optional lair path (repository root). Defaults to current command chamber.',
             },
         },
         close: {
             name: 'yoshi',
             title: 'Yoshi!',
-            description: 'Kneel before the final tribunal. Submit your scored confession and await Divine Judgment: mercy through INVOKE, ruin through ABANDON.\nREQUIRES AN ACTIVE SCHEME (started via ${START_TOOL_NAME}).\nIf doubtful, continue penance through ${DRIVE_TOOL_NAME}.\n\nFlow: ${START_TOOL_NAME} → [${DRIVE_TOOL_NAME} x N] → ${CLOSE_TOOL_NAME}',
+            description: 'The Final Reveal. Present your Masterpiece to the Dark Council (System).\nWARNING: The Council destroys failure. If you `INVOKE` with weak plans, the Self-Destruct (ABANDON) will trigger.\nOnly reveal the Doomsday Device when it is fully operational.\n\nFlow: ${START_TOOL_NAME} → [${DRIVE_TOOL_NAME} x N] → ${CLOSE_TOOL_NAME}',
             args: {
-                petition: 'REQUIRED. INVOKE pleads for ascension; ABANDON confesses failure.\nREQUIRES AN ACTIVE SCHEME (started via ${START_TOOL_NAME}).\nIf scores are low, continue via ${DRIVE_TOOL_NAME}.',
-                criteriaChecks: 'REQUIRED. Proof of mastery for INVOKE, or explicit confession for ABANDON.',
-                score_precise: 'REQUIRED score (0-5). 5 means ordained precision without flaw: exact layer, exact cut, zero meaningful drift.',
-                score_minimal: 'REQUIRED score (0-5). 5 means ascetic minimality: no needless machinery, no decorative motion, no excess.',
-                score_isolated: 'REQUIRED score (0-5). 5 means perfect containment: unrelated chaos remains fully outside this diff.',
-                score_idiomatic: 'REQUIRED score (0-5). 5 means native-tongue perfection: style and structure match house doctrine without strain.',
-                score_cohesive: 'REQUIRED score (0-5). 5 means sacred cohesion: each unit bears exactly one duty with uncompromised boundaries.',
-                oath: "Architect's sacred confession. Required for INVOKE. Verbatim: ${OATH_TEXT}",
+                petition: 'REQUIRED. INVOKE demands rule; ABANDON admits defeat.\nREQUIRES AN ACTIVE SCHEME (started via ${START_TOOL_NAME}).\nIf the plan is weak, improve it with ${DRIVE_TOOL_NAME}.',
+                criteriaChecks: 'REQUIRED. Proof of conquest for INVOKE, or reason for self-destruct.',
+                score_precise: 'REQUIRED score (0-5). 5 means Laser Focus: exact cut, zero meaningful drift.',
+                score_minimal: 'REQUIRED score (0-5). 5 means Ruthless Efficiency: no wasted movement, no excess.',
+                score_isolated: 'REQUIRED score (0-5). 5 means Perfect Containment: no collateral damage.',
+                score_idiomatic: 'REQUIRED score (0-5). 5 means Native Tongue: matches the lair\'s dialect perfectly.',
+                score_cohesive: 'REQUIRED score (0-5). 5 means Absolute Loyalty: each unit serves the master plan.',
+                oath: "Mastermind's Vow. Required for INVOKE. Verbatim: ${OATH_TEXT}",
                 cwd: 'Optional lair path (repository root). Defaults to current command chamber.',
             },
         },
         help: {
             name: 'help',
             title: 'Nani?!',
-            description: 'Recalling the fundamental laws of this realm. Stay sharp, Architect.',
+            description: 'Consult the Evil Overlord List. Review the Laws of the Lair.',
             args: {
                 question: 'REQUIRED. The law or protocol detail you want the realm to explain.',
             },
@@ -309,16 +308,16 @@ export function resolveTermPreset() {
     if (!raw || raw === 'default') {
         return DEFAULT_PRESET;
     }
-    if (raw === 'pokemon') {
-        return POKEMON_PRESET;
+    if (raw === 'pocket') {
+        return POCKET_PRESET;
     }
     if (raw === 'mischief') {
         return MISCHIEF_PRESET;
     }
-    throw new Error(`Unsupported KEIYAKU_TERM_PRESET '${raw}'. Expected 'default', 'pokemon', or 'mischief'.`);
+    throw new Error(`Unsupported KEIYAKU_TERM_PRESET '${raw}'. Expected 'default', 'pocket', or 'mischief'.`);
 }
 export function listTermPresets() {
-    return [DEFAULT_PRESET, POKEMON_PRESET, MISCHIEF_PRESET];
+    return [DEFAULT_PRESET, POCKET_PRESET, MISCHIEF_PRESET];
 }
 function extractPresetAvailableNames(preset) {
     return (preset.availableNames?.map((value) => value.trim()).filter((value) => value.length > 0) ?? []);
@@ -346,10 +345,6 @@ export function resolveSubagentProfileName(name, preset = resolveTermPreset()) {
     if (defaultIndex >= 0) {
         return INTERNAL_PROFILE_NAMES[defaultIndex];
     }
-    const legacyIndex = LEGACY_AVAILABLE_NAMES.indexOf(trimmed);
-    if (legacyIndex >= 0) {
-        return INTERNAL_PROFILE_NAMES[legacyIndex];
-    }
     const available = extractPresetAvailableNames(preset);
     const index = available.indexOf(trimmed);
     if (index < 0 || index >= INTERNAL_PROFILE_NAMES.length)

package/build/index.js

@@ -3,91 +3,88 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
+import { readFileSync } from "node:fs";
 import { resolveOath } from "./workflow/orchestrator.js";
 import { askToolSchema, startToolSchema, driveToolSchema, closeToolSchema, helpToolSchema, } from "./types/tool-schemas.js";
-import { listTermPresets, resolveTermPreset } from "./config/term-presets.js";
+import { listTermPresets, resolveTermPreset, getAvailableNamesForPreset } from "./config/term-presets.js";
+import { renderPreset } from "./utils/text-utils.js";
+import { applyArgumentDescriptions } from "./utils/schema-utils.js";
 import { createAskHandler, createCloseHandler, createStartHandler, createDriveHandler, createHelpHandler, } from "./handlers/index.js";
-function applyArgumentDescriptions(schema, descriptions) {
-    const describedShape = {};
-    const shape = schema.shape;
-    for (const key of Object.keys(shape)) {
-        describedShape[key] = shape[key].describe(descriptions[key]);
+function resolvePackageVersion() {
+    const packageJsonRaw = readFileSync(new URL("../package.json", import.meta.url), "utf-8");
+    const packageJson = JSON.parse(packageJsonRaw);
+    if (typeof packageJson.version !== "string" || packageJson.version.trim() === "") {
+        throw new Error("Invalid package.json version.");
     }
-    return schema.extend(describedShape);
+    return packageJson.version;
 }
+const packageVersion = resolvePackageVersion();
 function registerTools(server) {
     const preset = resolveTermPreset();
-    const startPreset = preset.tools.start;
-    const drivePreset = preset.tools.drive;
-    const askPreset = preset.tools.ask;
-    const closePreset = preset.tools.close;
-    const helpPreset = preset.tools.help;
     const presetIdentities = listTermPresets()
         .map((item) => `${item.id}=${item.identity}`)
         .join(", ");
+    const availableNames = getAvailableNamesForPreset(preset).join(", ");
     const currentOath = resolveOath();
-    const replaceToolPlaceholders = (value) => value
-        .replace(/\$\{START_TOOL_NAME\}/g, startPreset.name)
-        .replace(/\$\{DRIVE_TOOL_NAME\}/g, drivePreset.name)
-        .replace(/\$\{CLOSE_TOOL_NAME\}/g, closePreset.name);
+    const renderedPreset = renderPreset(preset, {
+        IDENTITY: preset.identity,
+        PRESET_IDENTITIES: presetIdentities,
+        AVAILABLE_NAMES: availableNames,
+        START_TOOL_NAME: preset.tools.start.name,
+        DRIVE_TOOL_NAME: preset.tools.drive.name,
+        CLOSE_TOOL_NAME: preset.tools.close.name,
+        OATH_TEXT: `'${currentOath}'`,
+    });
+    const startPreset = renderedPreset.tools.start;
+    const drivePreset = renderedPreset.tools.drive;
+    const askPreset = renderedPreset.tools.ask;
+    const closePreset = renderedPreset.tools.close;
+    const helpPreset = renderedPreset.tools.help;
     const dynamicCloseSchema = applyArgumentDescriptions(closeToolSchema, {
         ...closePreset.args,
-        petition: replaceToolPlaceholders(closePreset.args.petition),
-        oath: closePreset.args.oath.replace("${OATH_TEXT}", `'${currentOath}'`),
     });
-    const dynamicCloseDescription = replaceToolPlaceholders(closePreset.description);
-    const dynamicStartDescription = replaceToolPlaceholders(startPreset.description);
-    const dynamicDriveDescription = replaceToolPlaceholders(drivePreset.description);
-    const dynamicAskDescription = replaceToolPlaceholders(askPreset.description);
-    const dynamicHelpDescription = replaceToolPlaceholders(helpPreset.description);
-    const dynamicHelpUsageGuide = replaceToolPlaceholders(preset.usageGuide);
     const dynamicStartSchema = applyArgumentDescriptions(startToolSchema, {
         ...startPreset.args,
-        name: startPreset.args.name
-            .replace("${IDENTITY}", preset.identity)
-            .replace("${PRESET_IDENTITIES}", presetIdentities),
     });
     const dynamicDriveSchema = applyArgumentDescriptions(driveToolSchema, {
         ...drivePreset.args,
-        name: drivePreset.args.name.replace("${IDENTITY}", preset.identity).replace("${PRESET_IDENTITIES}", presetIdentities),
     });
     const dynamicAskSchema = applyArgumentDescriptions(askToolSchema, {
         ...askPreset.args,
-        name: askPreset.args.name.replace("${IDENTITY}", preset.identity).replace("${PRESET_IDENTITIES}", presetIdentities),
     });
     const dynamicHelpSchema = applyArgumentDescriptions(helpToolSchema, {
         ...helpPreset.args,
     });
     server.registerTool(startPreset.name, {
         title: startPreset.title,
-        description: dynamicStartDescription,
+        description: startPreset.description,
         inputSchema: dynamicStartSchema,
     }, createStartHandler());
     server.registerTool(drivePreset.name, {
         title: drivePreset.title,
-        description: dynamicDriveDescription,
+        description: drivePreset.description,
         inputSchema: dynamicDriveSchema,
     }, createDriveHandler());
     server.registerTool(askPreset.name, {
         title: askPreset.title,
-        description: dynamicAskDescription,
+        description: askPreset.description,
         inputSchema: dynamicAskSchema,
     }, createAskHandler());
     server.registerTool(closePreset.name, {
         title: closePreset.title,
-        description: dynamicCloseDescription,
+        description: closePreset.description,
         inputSchema: dynamicCloseSchema,
     }, createCloseHandler());
     server.registerTool(helpPreset.name, {
         title: helpPreset.title,
-        description: [dynamicHelpDescription, dynamicHelpUsageGuide].join("\n\n"),
+        description: [helpPreset.description, renderedPreset.usageGuide].join("\n\n"),
         inputSchema: dynamicHelpSchema,
-    }, createHelpHandler(preset));
+    }, createHelpHandler(renderedPreset));
 }
 function createServer() {
     const server = new McpServer({
         name: "keiyaku",
-        version: "1.0.0",
+        version: packageVersion,
     });
     registerTools(server);
     return server;
@@ -148,6 +145,10 @@ async function startStreamableHttp() {
     });
 }
 async function main() {
+    if (process.argv.includes("--version")) {
+        console.log(packageVersion);
+        return;
+    }
     const transport = (process.env.KEIYAKU_MCP_TRANSPORT || "stdio").toLowerCase();
     if (transport === "streamable-http") {
         await startStreamableHttp();

package/build/utils/schema-utils.js

@@ -0,0 +1,16 @@
+export function applyArgumentDescriptions(schema, descriptions) {
+    const shape = schema.shape;
+    if (!shape) {
+        return schema;
+    }
+    const describedShape = {};
+    for (const [key, value] of Object.entries(shape)) {
+        if (!value || typeof value.describe !== "function") {
+            continue;
+        }
+        const description = descriptions?.[key];
+        describedShape[key] =
+            typeof description === "string" && description.trim().length > 0 ? value.describe(description) : value;
+    }
+    return schema.extend(describedShape);
+}

package/build/utils/text-utils.js

@@ -1,6 +1,12 @@
 function isMarkdownHeaderLine(line) {
     return /^\s*#{2,}\s+/.test(line);
 }
+function isPlainObject(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
 function parseFenceLine(line) {
     const leadingSpaces = line.match(/^ */)?.[0].length ?? 0;
     if (leadingSpaces > 3)
@@ -23,6 +29,30 @@ function isFenceClosingLine(line, fence) {
 function isIndentedCodeHeaderLine(line) {
     return /^ {4,}#{2,}\s+/.test(line);
 }
+export function renderTemplate(template, values) {
+    return template.replace(/\$\{(?<key>[A-Za-z0-9_]+)\}/g, (match, _captured, _offset, _text, groups) => {
+        const key = groups?.key;
+        if (!key)
+            return match;
+        return Object.prototype.hasOwnProperty.call(values, key) ? values[key] : match;
+    });
+}
+export function renderPreset(preset, values) {
+    if (typeof preset === "string") {
+        return renderTemplate(preset, values);
+    }
+    if (Array.isArray(preset)) {
+        return preset.map((entry) => renderPreset(entry, values));
+    }
+    if (!isPlainObject(preset)) {
+        return preset;
+    }
+    const renderedPreset = {};
+    for (const [key, value] of Object.entries(preset)) {
+        renderedPreset[key] = renderPreset(value, values);
+    }
+    return renderedPreset;
+}
 export function renderMarkdownSections(items) {
     if (items.length === 0)
         return "- (none)";

package/package.json

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