leancraft 0.1.0

package/bin/leancraft.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+// leancraft CLI — unified entry for npx leancraft
+// Usage: npx leancraft init | validate | sync | lock | unlock | status | --help
+
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { execSync } from "child_process";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkgRoot = path.resolve(__dirname, "..");
+
+const args = process.argv.slice(2);
+const cmd = args[0];
+
+function help() {
+  console.log(`
+leancraft — doc-first verified agency
+
+Usage:
+  npx leancraft init [--force]     Scaffold .leancraft/ + hooks + skills in current repo
+  npx leancraft validate           Check registry (docs, sections, min counts, URLs, TODO)
+  npx leancraft sync               Regenerate agent/context.md + status.md + ledger
+  npx leancraft lock               Lock human/** (validate must PASS first)
+  npx leancraft unlock             Unlock human/** for agent drafting
+  npx leancraft status             Show lock state + validate summary
+  npx leancraft mcp                Print MCP config snippet
+
+See: https://github.com/sree-pm/leancraft
+`);
+}
+
+function runScript(name) {
+  const p = path.join(pkgRoot, "scripts", name);
+  execSync(`node "${p}" ${args.slice(1).join(" ")}`, { stdio: "inherit" });
+}
+
+async function init() {
+  const force = args.includes("--force");
+  const dest = process.cwd();
+  const src = path.join(pkgRoot, ".leancraft");
+
+  // Copy .leancraft if not exists
+  if (fs.existsSync(path.join(dest, ".leancraft")) && !force) {
+    console.log("`.leancraft/` already exists. Use --force to overwrite.");
+  } else {
+    console.log("Scaffolding .leancraft/...");
+    execSync(`node -e "const fs=require('fs'),p=require('path');function cp(s,d){fs.mkdirSync(d,{recursive:true});for(const f of fs.readdirSync(s)){const a=p.join(s,f),b=p.join(d,f);if(fs.statSync(a).isDirectory())cp(a,b);else if(!fs.existsSync(b)||process.argv.includes('--force'))fs.copyFileSync(a,b)} } cp(process.argv[1],process.argv[2])" "${src}" "${path.join(dest, ".leancraft")}" ${force ? "--force" : ""}`, { stdio: "inherit" });
+  }
+
+  // Copy skills
+  const skills = [
+    [".claude/skills/leancraft/SKILL.md", ".claude/skills/leancraft/SKILL.md"],
+    [".cursor/rules/leancraft.mdc", ".cursor/rules/leancraft.mdc"],
+  ];
+  for (const [s, d] of skills) {
+    const sp = path.join(pkgRoot, s);
+    const dp = path.join(dest, d);
+    if (fs.existsSync(sp)) {
+      fs.mkdirSync(path.dirname(dp), { recursive: true });
+      if (!fs.existsSync(dp) || force) {
+        fs.copyFileSync(sp, dp);
+        console.log(`+ ${d}`);
+      }
+    }
+  }
+  // AGENTS.md + CLAUDE.md at root
+  for (const f of ["AGENTS.md", "CLAUDE.md"]) {
+    const sp = path.join(pkgRoot, f);
+    const dp = path.join(dest, f);
+    if (fs.existsSync(sp) && (!fs.existsSync(dp) || force)) {
+      fs.copyFileSync(sp, dp);
+      console.log(`+ ${f}`);
+    }
+  }
+  // .mcp.json merge
+  const mcpSrc = path.join(pkgRoot, ".mcp.json");
+  const mcpDest = path.join(dest, ".mcp.json");
+  if (fs.existsSync(mcpSrc) && !fs.existsSync(mcpDest)) {
+    fs.copyFileSync(mcpSrc, mcpDest);
+    console.log(`+ .mcp.json`);
+  }
+  // .github
+  if (!fs.existsSync(path.join(dest, ".github/CODEOWNERS")) && fs.existsSync(path.join(pkgRoot, ".github/CODEOWNERS"))) {
+    fs.mkdirSync(path.join(dest, ".github"), { recursive: true });
+    fs.copyFileSync(path.join(pkgRoot, ".github/CODEOWNERS"), path.join(dest, ".github/CODEOWNERS"));
+    console.log(`+ .github/CODEOWNERS`);
+  }
+  // hooks
+  try {
+    execSync(`node "${path.join(pkgRoot, "scripts/install-hooks.mjs")}"`, { stdio: "inherit" });
+  } catch {}
+
+  console.log(`
+✓ leancraft init done.
+
+Next:
+  1. Fill .leancraft/human/discovery/* (from idea + research)
+  2. npm run leancraft:validate   → must PASS
+  3. npx leancraft lock           → human owns, agent read-only
+  4. Agent now works via agent/proposals/ + auto agent/status.md
+
+MCP: add .mcp.json to your agent (Claude Code / Cursor / Opencode already reads it).
+Docs: https://github.com/sree-pm/leancraft
+`);
+}
+
+if (!cmd || cmd === "--help" || cmd === "-h" || cmd === "help") help();
+else if (cmd === "init") await init();
+else if (cmd === "validate") runScript("leancraft-validate.mjs");
+else if (cmd === "sync") runScript("leancraft-sync.mjs");
+else if (cmd === "lock") runScript("leancraft-lock.mjs");
+else if (cmd === "unlock") execSync(`node "${path.join(pkgRoot, "scripts/leancraft-lock.mjs")}" unlock`, { stdio: "inherit" });
+else if (cmd === "status") {
+  try {
+    const cfg = JSON.parse(fs.readFileSync(path.join(process.cwd(), ".leancraft/config.json"), "utf8"));
+    console.log(`locked: ${cfg.locked}`);
+  } catch { console.log("No .leancraft/config.json — run npx leancraft init"); }
+  runScript("leancraft-validate.mjs");
+}
+else if (cmd === "mcp") {
+  console.log(fs.readFileSync(path.join(pkgRoot, ".mcp.json"), "utf8"));
+}
+else {
+  console.error(`Unknown command: ${cmd}`);
+  help();
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "leancraft",
+  "version": "0.1.0",
+  "description": "Doc-first verified agency — stop vibe coding, start owning. Tight registry + locked human docs + auto agent context. For Claude Code, Cursor, Opencode, Windsurf.",
+  "type": "module",
+  "bin": {
+    "leancraft": "bin/leancraft.js"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    ".leancraft/",
+    ".claude/",
+    ".cursor/",
+    "AGENTS.md",
+    "CLAUDE.md",
+    ".mcp.json"
+  ],
+  "scripts": {
+    "leancraft:validate": "node scripts/leancraft-validate.mjs",
+    "leancraft:sync": "node scripts/leancraft-sync.mjs",
+    "leancraft:lock": "node scripts/leancraft-lock.mjs lock",
+    "leancraft:unlock": "node scripts/leancraft-lock.mjs unlock",
+    "leancraft:security": "echo 'TODO: wire semgrep + axe + codeql' && npm run leancraft:validate",
+    "prepare": "node scripts/install-hooks.mjs || true",
+    "test": "node scripts/leancraft-validate.mjs"
+  },
+  "keywords": [
+    "ai",
+    "agentic-coding",
+    "vibe-coding",
+    "docs-first",
+    "claude-code",
+    "cursor",
+    "opencode",
+    "mcp",
+    "spec-driven"
+  ],
+  "author": "sree-pm",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sree-pm/leancraft.git"
+  },
+  "homepage": "https://github.com/sree-pm/leancraft#readme",
+  "bugs": {
+    "url": "https://github.com/sree-pm/leancraft/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/install-hooks.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+// Installs git hook that enforces human/** READ-ONLY when locked + runs sync
+import fs from "fs";
+import path from "path";
+
+const hook = `#!/bin/sh
+# leancraft pre-commit hook — enforces ownership + runs validate
+set -e
+LOCKED=$(node -p "JSON.parse(require('fs').readFileSync('.leancraft/config.json','utf8')).locked" 2>/dev/null || echo "false")
+if [ "$LOCKED" = "true" ] && git diff --cached --name-only | grep -q "^.leancraft/human/"; then
+  if [ "$LEANCRAFT_HUMAN" != "1" ]; then
+    echo "✖ BLOCKED: .leancraft/human/** is LOCKED. Agent must write to .leancraft/agent/proposals/ instead."
+    echo "  Human unlock: npx leancraft unlock  (or chat [🔓 Unlock])"
+    exit 1
+  fi
+fi
+# Always run validate as warning (don't block commit, just inform)
+node scripts/leancraft-validate.mjs || echo "⚠ validate failed — fix before Lock"
+`;
+
+const hookPath = path.join(process.cwd(), ".git/hooks/pre-commit");
+try {
+  fs.writeFileSync(hookPath, hook, { mode: 0o755 });
+  console.log("✓ pre-commit hook installed");
+} catch (e) {
+  console.log("Note: could not install hook (no .git/hooks):", e.message);
+}

package/scripts/leancraft-lock.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+// leancraft lock/unlock — flips config.json locked + enforces via hook
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+
+const action = process.argv[2]; // lock | unlock
+if (!["lock", "unlock"].includes(action)) {
+  console.error("Usage: node scripts/leancraft-lock.mjs [lock|unlock]");
+  process.exit(1);
+}
+const configPath = path.join(process.cwd(), ".leancraft/config.json");
+const cfg = JSON.parse(fs.readFileSync(configPath, "utf8"));
+
+if (action === "lock") {
+  // validate first
+  try {
+    execSync("node scripts/leancraft-validate.mjs", { stdio: "inherit" });
+  } catch {
+    console.error("\n✖ Cannot lock: validate FAILED. Fix errors first.");
+    process.exit(1);
+  }
+  cfg.locked = true;
+  fs.writeFileSync(configPath, JSON.stringify(cfg, null, 2) + "\n");
+  console.log("🔒 Locked. human/** is now READ-ONLY for agent. Agent must use agent/proposals/.");
+} else {
+  cfg.locked = false;
+  fs.writeFileSync(configPath, JSON.stringify(cfg, null, 2) + "\n");
+  console.log("🔓 Unlocked. Agent may draft human/**. Remember to re-lock after review.");
+}

package/scripts/leancraft-sync.mjs

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+// leancraft sync — regenerates agent/context.md + agent/status.md + ledger
+// Run: node scripts/leancraft-sync.mjs
+
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+
+const root = process.cwd();
+const lcRoot = path.join(root, ".leancraft");
+
+function read(p) { try { return fs.readFileSync(p, "utf8"); } catch { return ""; } }
+function nowISO() { return new Date().toISOString(); }
+function gitCommit() {
+  try { return execSync("git rev-parse --short HEAD", { encoding: "utf8" }).trim(); } catch { return "no-git"; }
+}
+
+const commit = gitCommit();
+const intent = read(path.join(lcRoot, "human/definition/intent.md")).slice(0, 200).replace(/\n/g, " ");
+const system = read(path.join(lcRoot, "human/definition/system.md")).slice(0, 200).replace(/\n/g, " ");
+
+// Update agent/context.md
+const contextPath = path.join(lcRoot, "agent/context.md");
+let context = `# Agent Context — Compressed Repo Memory (AUTO)
+
+> AUTO-GENERATED by \`leancraft sync\` at ${nowISO()}. Commit ${commit}. Human READ-ONLY. Max 500 lines. Agent MUST read this + human/definition/intent.md first.
+
+## Repo Map (auto-scanned)
+
+- Human intent: ${intent || "(empty — fill human/definition/intent.md)"}
+- System: ${system || "(empty)"}
+- Key dirs: ${fs.existsSync(path.join(root, "src")) ? "src/" : ""} ${fs.existsSync(path.join(root, "app")) ? "app/" : ""} ${fs.existsSync(path.join(root, "lib")) ? "lib/" : ""}
+
+## Last Sync
+
+- Commit: ${commit}
+- Time: ${nowISO()}
+- Config locked: ${JSON.parse(read(path.join(lcRoot, "config.json")) || '{"locked":false}').locked}
+
+## Open Invariants (from intent.md)
+
+${read(path.join(lcRoot, "human/definition/intent.md")).match(/\*\*I\d+:.*/g)?.join("\n") || "- (none yet — fill intent.md)"}
+
+## Recent Decisions (from joint/decisions.log.md)
+
+${read(path.join(lcRoot, "joint/decisions.log.md")).split("\n").slice(-10).join("\n")}
+
+---
+*Overwritten by \`npm run leancraft:sync\`. Do not hand-edit. Max 500 lines.*
+`;
+fs.writeFileSync(contextPath, context);
+console.log(`✓ agent/context.md updated (${commit})`);
+
+// Update agent/status.md
+const statusPath = path.join(lcRoot, "agent/status.md");
+const validateExists = fs.existsSync(path.join(root, "scripts/leancraft-validate.mjs"));
+let validateStatus = "not run — run npm run leancraft:validate";
+try {
+  execSync("node scripts/leancraft-validate.mjs", { stdio: "pipe" });
+  validateStatus = "PASS";
+} catch (e) {
+  validateStatus = "FAIL — fix errors before Lock";
+}
+
+let status = `# Agent Status — Live Tracker (AUTO)
+
+> AUTO-GENERATED at ${nowISO()}, commit ${commit}. Human READ-ONLY.
+
+## Last Sync
+
+- Time: ${nowISO()}
+- Commit: ${commit}
+- Validate: ${validateStatus}
+
+## Done
+
+- (auto — fill after features ship)
+
+## Todo
+
+- [ ] Fill human/discovery/* (see validate errors above)
+- [ ] Distill human/definition/intent.md
+- [ ] Run \`npm run leancraft:validate\` → PASS → ask to Lock
+
+## Blocked
+
+- ${validateStatus === "PASS" ? "none" : "validate FAIL — see errors"}
+
+## Budget per run
+
+- Used: 0 / $5.00 (tracked in joint/ledger.jsonl)
+- Calls: 0 / 25
+
+---
+*Overwritten by sync. Human never edits.*
+`;
+fs.writeFileSync(statusPath, status);
+console.log(`✓ agent/status.md updated`);
+
+// Append ledger
+const ledgerPath = path.join(lcRoot, "joint/ledger.jsonl");
+const entry = JSON.stringify({ ts: nowISO(), commit, event: "sync", validate: validateStatus }) + "\n";
+fs.appendFileSync(ledgerPath, entry);
+console.log(`✓ joint/ledger.jsonl appended`);
+console.log(`\nSync done.`);

package/scripts/leancraft-validate.mjs

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+// leancraft validate — checks docRegistry tightness, no placeholders, min counts, URLs, sections
+// Run: node scripts/leancraft-validate.mjs  (or npm run leancraft:validate)
+// Exit 0 = PASS (Lock allowed), 1 = FAIL (Lock blocked)
+
+import fs from "fs";
+import path from "path";
+
+const root = path.resolve(process.cwd());
+const lcRoot = path.join(root, ".leancraft");
+const configPath = path.join(lcRoot, "config.json");
+
+function read(p) {
+  try { return fs.readFileSync(p, "utf8"); } catch { return null; }
+}
+function exists(p) { return fs.existsSync(p); }
+
+const config = JSON.parse(read(configPath));
+if (!config) { console.error("Missing .leancraft/config.json"); process.exit(1); }
+
+let errors = [];
+let warnings = [];
+let checked = 0;
+
+function assert(cond, msg, isWarning = false) {
+  checked++;
+  if (!cond) (isWarning ? warnings : errors).push(msg);
+}
+
+function checkNoPlaceholders(file, content) {
+  const bad = /TODO|TBD|\[TODO|\[TBD/i;
+  if (bad.test(content)) errors.push(`${file}: contains TODO/TBD placeholder`);
+  // check for empty template brackets still present
+  if (/\[TODO:/.test(content)) errors.push(`${file}: unfilled template [TODO:`);
+}
+
+function checkSections(file, content, requiredSections) {
+  if (!requiredSections) return;
+  for (const sec of requiredSections) {
+    const needle = sec.toLowerCase();
+    const has = content.toLowerCase().includes(needle);
+    if (!has) errors.push(`${file}: missing required section "${sec}"`);
+  }
+}
+
+function countMatches(content, regex) {
+  return (content.match(regex) || []).length;
+}
+
+// Validate discovery + definition
+for (const [group, docs] of Object.entries(config.docRegistry)) {
+  if (group === "conditional") continue;
+  for (const [doc, spec] of Object.entries(docs)) {
+    if (doc.includes("*")) {
+      // features/*.md — check at least one exists, but not required
+      const dir = path.join(lcRoot, "human", "definition", "features");
+      if (exists(dir)) {
+        const files = fs.readdirSync(dir).filter(f => f.endsWith(".md"));
+        // Don't fail if no features yet — it's ephemeral
+        if (files.length === 0) warnings.push(`human/definition/features/*.md: no features yet (ok, ephemeral)`);
+        for (const f of files) {
+          const content = read(path.join(dir, f));
+          checkNoPlaceholders(`human/definition/features/${f}`, content);
+          checkSections(`human/definition/features/${f}`, content, spec.sections);
+        }
+      }
+      continue;
+    }
+    // handle sprint map etc — group is sprint, files are in human/sprint
+    let filePath;
+    if (group === "sprint") filePath = path.join(lcRoot, "human", "sprint", doc);
+    else if (group === "discovery") filePath = path.join(lcRoot, "human", "discovery", doc);
+    else if (group === "definition") filePath = path.join(lcRoot, "human", "definition", doc);
+    else filePath = path.join(lcRoot, doc);
+
+    const content = read(filePath);
+    if (!content) {
+      if (spec.required) errors.push(`${group}/${doc}: MISSING (required)`);
+      else warnings.push(`${group}/${doc}: missing (optional)`);
+      continue;
+    }
+    checkNoPlaceholders(`${group}/${doc}`, content);
+    checkSections(`${group}/${doc}`, content, spec.sections);
+
+    // Specific rules
+    if (spec.rules) {
+      if (spec.rules.minPainThemes) {
+        const count = countMatches(content, /^###\s+P\d+/gm);
+        assert(count >= spec.rules.minPainThemes, `${group}/${doc}: needs ${spec.rules.minPainThemes} pain themes (P1-P12), found ${count}`);
+      }
+      if (spec.rules.minSources) {
+        const urlCount = countMatches(content, /https?:\/\//g);
+        assert(urlCount >= spec.rules.minSources, `${group}/${doc}: needs ≥${spec.rules.minSources} URLs, found ${urlCount}`);
+      }
+      if (spec.rules.minCompetitors) {
+        const hasTable = content.includes("|") && content.toLowerCase().includes("competitor");
+        assert(hasTable, `${group}/${doc}: missing competitor table`);
+        const rows = content.split("\n").filter(l => l.trim().startsWith("|") && !l.toLowerCase().includes("competitor") && !l.includes("---")).length;
+        assert(rows >= spec.rules.minCompetitors, `${group}/${doc}: needs ≥${spec.rules.minCompetitors} competitors, found ~${rows}`);
+      }
+      if (spec.rules.minWedges) {
+        const wedgeCount = countMatches(content, /^\d+\./gm);
+        assert(wedgeCount >= spec.rules.minWedges, `${group}/${doc}: needs ≥${spec.rules.minWedges} wedges, found ${wedgeCount}`, true);
+      }
+      if (spec.rules.minPersonas) {
+        const personaCount = countMatches(content, /^##\s+Persona/mg) || countMatches(content, /Persona \d/mg);
+        assert(personaCount >= spec.rules.minPersonas, `${group}/${doc}: needs ≥${spec.rules.minPersonas} personas, found ${personaCount}`);
+      }
+      if (spec.rules.minUserFlows) {
+        const flowCount = countMatches(content, /^###\s+Flow/mg);
+        assert(flowCount >= spec.rules.minUserFlows, `${group}/${doc}: needs ≥${spec.rules.minUserFlows} user flows, found ${flowCount}`);
+      }
+      if (spec.rules.minFunctionalReqs) {
+        const frCount = countMatches(content, /FR-\d+/g);
+        assert(frCount >= spec.rules.minFunctionalReqs, `${group}/${doc}: needs ≥${spec.rules.minFunctionalReqs} FRs (FR-01...), found ${frCount}`);
+      }
+      if (spec.rules.minInvariants) {
+        const invCount = countMatches(content, /\*\*I\d+:/g);
+        assert(invCount >= spec.rules.minInvariants, `${group}/${doc}: needs ≥${spec.rules.minInvariants} invariants (I1:), found ${invCount}`);
+      }
+      if (spec.rules.minOracles) {
+        const oracleCount = countMatches(content, /\*\*O\d+:/g);
+        assert(oracleCount >= spec.rules.minOracles, `${group}/${doc}: needs ≥${spec.rules.minOracles} oracles (O1:), found ${oracleCount}`);
+      }
+      if (spec.rules.requireQuoteAndURL) {
+        const hasQuote = content.includes("Quote:");
+        const hasURL = content.includes("https://");
+        assert(hasQuote && hasURL, `${group}/${doc}: each pain needs Quote + Source URL`);
+      }
+      if (spec.rules.requirePricingWithCurrency) {
+        const hasCurrency = /\$|€|£/.test(content);
+        assert(hasCurrency, `${group}/${doc}: pricing table must have $/€/£`);
+      }
+    }
+  }
+}
+
+// Check joint files exist
+for (const jf of ["joint/decisions.log.md", "joint/ledger.jsonl", "agent/context.md", "agent/status.md"]) {
+  if (!exists(path.join(lcRoot, jf))) warnings.push(`${jf}: missing (auto, will be generated on sync)`);
+}
+
+// Output
+console.log("─ Leancraft Validate ─");
+console.log(`Checked: ${checked} assertions`);
+if (warnings.length) {
+  console.log(`\nWarnings (${warnings.length}):`);
+  warnings.forEach(w => console.log(`  ⚠ ${w}`));
+}
+if (errors.length) {
+  console.log(`\nErrors (${errors.length}):`);
+  errors.forEach(e => console.log(`  ✖ ${e}`));
+  console.log(`\nResult: FAIL — Lock blocked. Fix errors, then re-run.`);
+  process.exit(1);
+} else {
+  console.log(`\nResult: PASS — Lock allowed. (warnings: ${warnings.length})`);
+  if (config.locked) console.log("Note: config.json locked=true — human/** is READ-ONLY for agent.");
+  process.exit(0);
+}

package/scripts/mcp-server.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+// Minimal MCP server for Leancraft — enforces ownership, exposes read_intent, propose_change, get_context
+// Speak MCP JSON-RPC over stdio. Works with Claude Code, Cursor, Opencode.
+
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+
+const root = process.cwd();
+const configPath = path.join(root, ".leancraft/config.json");
+
+function readConfig() {
+  try { return JSON.parse(fs.readFileSync(configPath, "utf8")); } catch { return { locked: false, denyAgentWrite: ["human/**"] }; }
+}
+
+const tools = [
+  {
+    name: "leancraft_read_intent",
+    description: "MUST call first. Reads config + intent + guardrails + context. Returns the contract agent must obey.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "leancraft_get_context",
+    description: "Returns compressed repo memory (agent/context.md, 500 lines). Use to avoid context rot.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "leancraft_propose_change",
+    description: "When locked and you need to change human/**, write a proposal to agent/proposals/ instead. This is the ONLY way.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        target: { type: "string", description: "human file you want to change, e.g., human/definition/intent.md" },
+        reason: { type: "string" },
+        diff: { type: "string", description: "unified diff" }
+      },
+      required: ["target", "reason", "diff"]
+    }
+  },
+  {
+    name: "leancraft_validate",
+    description: "Runs the registry validator. Call before asking to Lock.",
+    inputSchema: { type: "object", properties: {} }
+  }
+];
+
+function handleTool(name, args) {
+  const cfg = readConfig();
+  if (name === "leancraft_read_intent") {
+    const intent = fs.readFileSync(path.join(root, ".leancraft/human/definition/intent.md"), "utf8").slice(0, 4000);
+    const guardrails = fs.readFileSync(path.join(root, ".leancraft/human/definition/guardrails.md"), "utf8").slice(0, 2000);
+    const context = fs.readFileSync(path.join(root, ".leancraft/agent/context.md"), "utf8").slice(0, 2000);
+    return { locked: cfg.locked, intent, guardrails, context, budget: cfg.budget, docRegistry: cfg.docRegistry };
+  }
+  if (name === "leancraft_get_context") {
+    return fs.readFileSync(path.join(root, ".leancraft/agent/context.md"), "utf8");
+  }
+  if (name === "leancraft_propose_change") {
+    if (!cfg.locked) return { error: "Not locked — you may edit human/** directly. No proposal needed." };
+    // enforce human/** check
+    if (!args.target.startsWith("human/")) return { error: "target must be human/**" };
+    const id = Date.now().toString().slice(-6);
+    const p = path.join(root, `.leancraft/agent/proposals/${id}-${args.target.replace(/\//g, "-")}.md`);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, `# Proposal: ${args.target}\n\n**Reason:** ${args.reason}\n\n**Diff:**\n\`\`\`diff\n${args.diff}\n\`\`\`\n\n> Human: merge this file to apply, or [❌ Don't].\n`);
+    return { ok: true, proposal: p, message: "Proposal written. Ask human: [🔓 Unlock / ❌ Don't]" };
+  }
+  if (name === "leancraft_validate") {
+    try {
+      const out = execSync("node scripts/leancraft-validate.mjs", { encoding: "utf8" });
+      return { pass: true, output: out };
+    } catch (e) {
+      return { pass: false, output: e.stdout?.toString() || e.message };
+    }
+  }
+  return { error: "unknown tool" };
+}
+
+// Minimal JSON-RPC loop
+let buf = "";
+process.stdin.on("data", chunk => {
+  buf += chunk.toString();
+  let idx;
+  while ((idx = buf.indexOf("\n")) !== -1) {
+    const line = buf.slice(0, idx).trim();
+    buf = buf.slice(idx + 1);
+    if (!line) continue;
+    try {
+      const msg = JSON.parse(line);
+      if (msg.method === "initialize") {
+        respond(msg.id, { protocolVersion: "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: "leancraft", version: "1.0.0" } });
+      } else if (msg.method === "tools/list") {
+        respond(msg.id, { tools });
+      } else if (msg.method === "tools/call") {
+        const result = handleTool(msg.params.name, msg.params.arguments || {});
+        // handle async validate
+        if (result && typeof result.then === "function") {
+          result.then(r => respond(msg.id, { content: [{ type: "text", text: JSON.stringify(r, null, 2) }] }));
+        } else {
+          respond(msg.id, { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] });
+        }
+      } else if (msg.method === "notifications/initialized") {
+        // no-op
+      } else {
+        respond(msg.id, { error: { code: -32601, message: "Method not found: " + msg.method } });
+      }
+    } catch (e) {
+      // ignore parse errors
+    }
+  }
+});
+
+function respond(id, result) {
+  if (id == null) return;
+  process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, result }) + "\n");
+}
+
+// also support simple test mode
+if (process.argv.includes("--test")) {
+  console.log(JSON.stringify(handleTool("leancraft_read_intent", {}), null, 2));
+  process.exit(0);
+}