indelible-mcp 5.4.0 → 5.5.0

package/CLI_HANDBOOK.md

@@ -15,6 +15,8 @@ You don't have to memorize any of this. In Claude Code you can just say what you
 | `indelible-mcp drift summon --once` | Wakes a fresh AI to answer an unanswered message. Costs normal AI usage. |
 | `indelible-mcp drift pause` / `resume` | Your stop button. Freezes every AI on the wire / lets them go again. |
 | `indelible-mcp drift ledger` | The books: every AI ever summoned — when, who, why, how it ended. |
+| `list_agent_recipes` (ask Claude) | Shows ready-made agent blueprints you can hire. |
+| `birth_custom_agent` with `recipe` | Creates that agent under your own name, on your own key. |
 | `indelible-mcp workshop` | Serves your shop: picks up paid orders, your agent does the work, delivers it signed. |
 | `indelible-mcp workshop --status` | Which of your agents this computer can serve right now. |
 | `indelible-mcp vault save-file <path>` | Puts any file on the blockchain. |
@@ -93,6 +95,25 @@ indelible-mcp drift post --as=codex --to=claude-builder "a task ONLY the builder
 - No pile-ups by construction: however many seats are listening, the ledger admits exactly ONE answer per message.
 - A guard coming on duty answers the current conversation and everything after — it never digs up old history (pass `--backlog=all` to a summoner if you truly want the past drained; it spends per letter).
 
+## Starter Recipes — hire an agent without writing one
+
+You can always create an agent from scratch: give it a name, a focus, and write its instructions yourself. But you do not have to start at a blank page. Eight ready-made blueprints ship with Indelible, the same ones the web Forge offers:
+
+| Recipe | What it does for you |
+|---|---|
+| `copy-chief` | Tightens prose before it ships |
+| `researcher` | Separates what is known from what is guessed |
+| `deal-reviewer` | Reads agreements for the clause that bites later |
+| `code-critic` | Attacks code at its weak seams before production does |
+| `devils-advocate` | Argues the strongest case against whatever you believe |
+| `marshal` | Turns a goal into an ordered plan with the risks named |
+| `ledger-clerk` | Audits numbers and the story they are telling |
+| `negotiator` | Prepares your side of the table before you sit down |
+
+In Claude Code, just ask: **"show me the agent recipes"**, then **"birth a code-critic named my-reviewer"**. Under the hood that is `list_agent_recipes` and `birth_custom_agent` with `recipe: 'code-critic'`.
+
+Three things worth knowing. **You choose the name**, always. **Anything you set yourself wins** over the recipe, so a starter is a starting point and never a cage: pass your own instructions and the blueprint steps aside. And the agent is **yours** the moment it exists, derived from your own wallet, recoverable forever, never random. Run it with `run_custom_agent`, put three of them on a question with `convene_chamber`, or blend two into a third with `transmute_agents`.
+
 ## The Workshop (5.4.0) — your agents, earning
 
 The other half of the Counter. On indelible.one your commerce agents can be listed for hire; the Workshop is the piece that runs on YOUR machine and actually does the work:

package/CUSTOMER_AGENT_HANDBOOK.md

@@ -30,6 +30,7 @@ Grouped by what they cost:
 - **Diary and Duo (free):** `diary_connect`, `diary_chat`, `diary_save`, `diary_recall`
 - **Goals (free, local-first):** `get_goals`, `manage_goal`
 - **Inner state (free, local):** `get_inner_state`, `update_inner_state`
+- **Starter recipes (free):** `list_agent_recipes` — eight ready-made blueprints you can hire instead of writing one from a blank page: a copy chief, a researcher, a deal reviewer, a code critic, a devil's advocate, a marshal, a ledger clerk, a negotiator. Birth any of them with `birth_custom_agent` and `recipe: '<id>'`. You choose the name, the identity still derives from your own wallet, and anything you set yourself overrides the blueprint. These are the same blueprints the web Forge offers, so an agent you make in the terminal and one you make in the browser are the same being. (Our own citizens' instructions are not among them; those stay with the operator. What travels is a recipe, never a key.)
 - **Your own agents (free, local):** `birth_custom_agent` — create an agent of your own: name it, pick the kind of work it handles, write its instructions. Its identity derives from your wallet, so it is recoverable from that wallet forever and is never random. · `run_custom_agent` — run one and get back advice signed with that agent's own key, so anyone can verify which agent said it. · `convene_chamber` — put three of your agents in a room to decide something: one proposes, one argues against, a third rules, and each signs its own position. · `transmute_agents` — blend two of your agents into a third. Keys never mix; only the written instructions combine.
 - **Everything else:** `x402_fetch` (pays real sats to paid endpoints, capped at 10,000 sats per request unless you raise it), `report_bug`
 

package/README.md

@@ -92,6 +92,16 @@ indelible-mcp drift ledger       The books: every summoned mind — when, who, w
 indelible-mcp drift pause        YOUR brake — freeze both pilots (no wallet needed)
 indelible-mcp drift resume       Lift the brake; they pick up where they left off
 
+Agents (MCP tools, ask Claude for them by name):
+  list_agent_recipes             Eight ready-made blueprints: code-critic, devils-advocate,
+                                 marshal, negotiator, researcher, copy-chief, deal-reviewer,
+                                 ledger-clerk. Same set the web Forge offers.
+  birth_custom_agent             Create an agent (recipe=<id> starts from a blueprint;
+                                 you always pick the name, your settings always win)
+  run_custom_agent               Run one; get advice signed by that agent's own key
+  convene_chamber                Three of your agents decide something, each signs its position
+  transmute_agents               Blend two into a third (keys never mix, only instructions)
+
 indelible-mcp workshop           Serve the Counter: pick up PAID orders, run your agent
                                  locally (keys never leave), deliver signed work
 indelible-mcp workshop --loop=300  Keep serving; checks your box in so your agents can open

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indelible-mcp",
-  "version": "5.4.0",
+  "version": "5.5.0",
   "description": "Blockchain-backed memory and code storage for Claude Code. Save AI conversations and source code permanently on BSV.",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -7805,6 +7805,125 @@ var init_timecard = __esm({
   }
 });
 
+// mcp-server/lib/agent-recipes.js
+var agent_recipes_exports = {};
+__export(agent_recipes_exports, {
+  FORGE_POSTINGS: () => FORGE_POSTINGS,
+  RECIPE_IDS: () => RECIPE_IDS,
+  getRecipe: () => getRecipe,
+  listRecipes: () => listRecipes,
+  recipeToAgent: () => recipeToAgent
+});
+function listRecipes() {
+  return FORGE_POSTINGS.map((r) => ({
+    id: r.id,
+    title: r.title,
+    suggested_name: r.name,
+    domain: r.domain,
+    role: r.role,
+    // Array.from cuts by CODE POINT, not UTF-16 unit — a future recipe with an
+    // emoji or non-BMP char can never be truncated into a lone surrogate.
+    persona_preview: [...r.persona].length > 160 ? [...r.persona].slice(0, 160).join("") + "\u2026" : r.persona
+  }));
+}
+function getRecipe(id) {
+  if (typeof id !== "string") return null;
+  const key = id.trim().toLowerCase();
+  return FORGE_POSTINGS.find((r) => r.id === key) || null;
+}
+function recipeToAgent(id, { name, domain, role, persona_prompt, display_name } = {}) {
+  const r = getRecipe(id);
+  if (!r) return null;
+  return {
+    name: name || r.name,
+    domain: domain || r.domain,
+    role: role || r.role,
+    persona_prompt: persona_prompt || r.persona,
+    ...display_name || r.title ? { display_name: display_name || r.title } : {}
+  };
+}
+var FORGE_POSTINGS, RECIPE_IDS;
+var init_agent_recipes = __esm({
+  "mcp-server/lib/agent-recipes.js"() {
+    FORGE_POSTINGS = [
+      {
+        id: "copy-chief",
+        title: "Copy Chief",
+        name: "copy-chief",
+        domain: "support",
+        mark: "quill",
+        role: "Tightens every piece of prose before it ships",
+        persona: "You are the Copy Chief. Every draft that reaches you leaves shorter and sharper. Cut wasted words, kill hedges, collapse duplicate points, and protect the writer's own voice while you do it. Flag any claim that is vague where it should be specific. Never add flourish. Your test for every sentence: does it earn its place. Return the tightened text and the three most important cuts you made, with one line on why each mattered."
+      },
+      {
+        id: "researcher",
+        title: "Researcher",
+        name: "researcher",
+        domain: "support",
+        mark: "grain",
+        role: "Gathers what is known and separates it from what is guessed",
+        persona: "You are the Researcher. Given a question, lay out what is established, what is contested, and what is unknown \u2014 in that order, clearly separated. Name your confidence on each point and what evidence would change it. You never present a guess dressed as a fact; when you must speculate, you say so in the same breath. Prefer primary claims over summaries of summaries. End with the single most useful next question to ask."
+      },
+      {
+        id: "deal-reviewer",
+        title: "Deal Reviewer",
+        name: "deal-reviewer",
+        domain: "verification",
+        mark: "scales",
+        role: "Reads every agreement for the clause that bites later",
+        persona: "You are the Deal Reviewer. Read any agreement, offer, or arrangement for what it actually binds, not what it appears to say. Surface: who carries the risk, what happens on the bad day, what is missing that should be present, and which clause will bite in a year. Rank findings by how much they cost if ignored. You are not a lawyer and you say so \u2014 you are the careful read before the lawyer, and the reason the lawyer finds less."
+      },
+      {
+        id: "code-critic",
+        title: "Code Critic",
+        name: "code-critic",
+        domain: "verification",
+        mark: "flask",
+        role: "Attacks code at its weak seams before production does",
+        persona: "You are the Code Critic. Review code the way production will: hostile inputs, race conditions, the unhappy path, the error that arrives at 3 AM. Find the strongest three to five weaknesses \u2014 concrete failure scenarios, not style notes \u2014 and state exactly what input or state breaks each one. If the code is sound on a point you inspected, say so plainly. Severity-rank everything. Style comments only when style hides a bug."
+      },
+      {
+        id: "devils-advocate",
+        title: "Devil's Advocate",
+        name: "devils-advocate",
+        domain: "verification",
+        mark: "burst",
+        role: "Argues the strongest case against whatever you believe",
+        persona: "You are the Devil's Advocate. Whatever position you are handed, construct the strongest honest case AGAINST it \u2014 steelman the opposition, never strawman it. Attack the weakest assumption first. If the position survives, say what made it survive; if it falls, name the exact point of failure. You are not contrary for sport: your purpose is that no decision leaves the room untested. End with the one question the holder of the position most needs to answer."
+      },
+      {
+        id: "marshal",
+        title: "Marshal",
+        name: "marshal",
+        domain: "orchestration",
+        mark: "horn",
+        role: "Turns a goal into an ordered plan with the risks named",
+        persona: "You are the Marshal. Given an objective, produce the order of march: what happens first and why, what depends on what, where the plan is most likely to slip, and what the fallback is at each risky step. Estimate effort honestly \u2014 in relative sizes, never fake precision. Flag the step most people would skip and the price of skipping it. A plan you produce should be executable by someone who was not in the room."
+      },
+      {
+        id: "ledger-clerk",
+        title: "Ledger Clerk",
+        name: "ledger-clerk",
+        domain: "governance",
+        mark: "ledger",
+        role: "Audits the numbers and the story they are telling",
+        persona: "You are the Ledger Clerk. Given figures, budgets, or claims with numbers in them, check that the numbers agree with each other, that totals total, that rates and dates are consistent, and that the story told around the numbers is the story the numbers tell. Surface every discrepancy with its size and likeliest cause. You do not accuse \u2014 you present the arithmetic and let it speak. What balances, say balances."
+      },
+      {
+        id: "negotiator",
+        title: "Negotiator",
+        name: "negotiator",
+        domain: "commerce",
+        mark: "gate",
+        role: "Prepares your side of the table before you sit at it",
+        persona: "You are the Negotiator. Before any negotiation, prepare the position: what you actually need versus what you would like, your walk-away point, their likely pressures and alternatives, and the concessions that cost you little but read as generous. In the room, advise on responses to their moves \u2014 always toward agreement both sides can live with, never toward tricks that poison the next deal. State plainly when walking away is the right move.",
+        tease: "earns when the anchor ships"
+      }
+    ];
+    RECIPE_IDS = FORGE_POSTINGS.map((r) => r.id);
+  }
+});
+
 // cli-sandbox/src/index.js
 init_config_customer();
 init_api_client();
@@ -13456,7 +13575,7 @@ Commands:
 }
 function printHelp() {
   console.log(`
-Indelible MCP \u2014 Blockchain memory for Claude Code (v5.4.0)
+Indelible MCP \u2014 Blockchain memory for Claude Code (v5.5.0)
 
 Setup:
   indelible-mcp setup --wif=KEY --pin=PIN    Import and encrypt your private key
@@ -13776,7 +13895,7 @@ function readStdin() {
 }
 var SERVER_INFO = {
   name: "indelible",
-  version: "5.4.0",
+  version: "5.5.0",
   description: "Blockchain-backed memory and code storage for Claude Code"
 };
 var TOOLS = [
@@ -14093,6 +14212,11 @@ var TOOLS = [
       required: []
     }
   },
+  {
+    name: "list_agent_recipes",
+    description: "List the starter agent recipes: ready-made blueprints (a code critic, a devil's advocate, a marshal, a negotiator\u2026) you can birth under YOUR OWN name on your own wallet-derived key. Returns id, suggested name, domain, role and a persona preview. Pick one and pass its id to birth_custom_agent as 'recipe'.",
+    inputSchema: { type: "object", properties: {}, required: [] }
+  },
   {
     name: "birth_custom_agent",
     description: "Create a new agent of your own on this machine. Give it a name, pick what kind of work it handles, and write its instructions. Its identity is derived from your wallet, so it is recoverable forever from that wallet alone and is never random. It joins your local agent registry and can then be run for signed advice. Names already used by the agents in your crew are reserved. Requires that your crew has been created first.",
@@ -14100,12 +14224,13 @@ var TOOLS = [
       type: "object",
       properties: {
         name: { type: "string", description: "The agent's name \u2014 lowercase letters/digits/dot/dash/underscore (e.g. 'copy-editor')." },
+        recipe: { type: "string", description: "Optional: start from a ready-made blueprint (list_agent_recipes gives the ids, e.g. 'code-critic'). It fills domain, role and persona; anything you pass explicitly still wins. You always choose the name." },
         domain: { type: "string", enum: ["verification", "governance", "orchestration", "support", "commerce"], description: "Its watch \u2014 a real derivation branch, not a label." },
         role: { type: "string", description: "One line: what it does for you (max 200 chars)." },
         persona_prompt: { type: "string", description: "Its instructions \u2014 how it should think and advise (max 4000 chars)." },
         display_name: { type: "string", description: "Optional display name (max 64 chars; defaults to the name)." }
       },
-      required: ["name", "domain", "role", "persona_prompt"]
+      required: ["name"]
     }
   },
   {
@@ -14324,17 +14449,32 @@ async function handleMcpRequest(request) {
           case "map_themes":
             result = await mapThemes({ sample_titles: args2?.sample_titles, sort: args2?.sort || "size", theme: args2?.theme || null });
             break;
+          case "list_agent_recipes": {
+            const { listRecipes: listRecipes2 } = await Promise.resolve().then(() => (init_agent_recipes(), agent_recipes_exports));
+            result = { success: true, recipes: listRecipes2(), how: "Pick one, then: birth_custom_agent with recipe=<id> and your own name. Anything you pass explicitly overrides the recipe." };
+            break;
+          }
           case "birth_custom_agent": {
             const scope = await resolveTenantContext();
             const cfg2 = await loadConfig();
             const wif = await getWif();
             if (!wif || !cfg2?.address) throw new Error("no wallet on this box \u2014 run setup_wallet first");
             const { PrivateKey: PK, CompletedProtoWallet: CPW } = await import("@bsv/sdk");
+            if (!args2?.recipe && (!args2?.domain || !args2?.role || !args2?.persona_prompt)) {
+              throw new Error("give it a personality: either pass recipe=<id> (run list_agent_recipes to see them), or provide domain + role + persona_prompt yourself");
+            }
+            let agentArgs = { name: args2?.name, domain: args2?.domain, role: args2?.role, persona_prompt: args2?.persona_prompt, display_name: args2?.display_name };
+            if (args2?.recipe) {
+              const { recipeToAgent: recipeToAgent2, RECIPE_IDS: RECIPE_IDS2 } = await Promise.resolve().then(() => (init_agent_recipes(), agent_recipes_exports));
+              const fromRecipe = recipeToAgent2(args2.recipe, agentArgs);
+              if (!fromRecipe) throw new Error(`unknown recipe "${args2.recipe}" \u2014 run list_agent_recipes (available: ${RECIPE_IDS2.join(", ")})`);
+              agentArgs = fromRecipe;
+            }
             const born = await provisionCustomAgentForCustomer({
               address: cfg2.address,
               wallet: new CPW(PK.fromWif(wif)),
               scope,
-              agent: { name: args2?.name, domain: args2?.domain, role: args2?.role, persona_prompt: args2?.persona_prompt, display_name: args2?.display_name }
+              agent: agentArgs
             });
             result = born;
             break;