continuous-improvement 3.0.0 → 3.8.0

package/bin/mcp-server.mjs

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-
 /**
  * continuous-improvement MCP Server
  *
@@ -11,533 +10,877 @@
  *   node bin/mcp-server.mjs --mode expert    # all tools
  *   node bin/mcp-server.mjs --mode beginner  # explicit beginner
  */
-
-import { existsSync, readFileSync, readdirSync, writeFileSync, mkdirSync } from "node:fs";
-import { join, basename } from "node:path";
-import { homedir } from "node:os";
 import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
 import { createInterface } from "node:readline";
-
-// ---------------------------------------------------------------------------
-// Config
-// ---------------------------------------------------------------------------
-const VERSION = "3.0.0";
-const INSTINCTS_DIR = join(homedir(), ".claude", "instincts");
+import { fileURLToPath } from "node:url";
+import { createHash } from "node:crypto";
+import { PACKAGE_NAME, VERSION, getToolDefinitions, isPluginMode, } from "../lib/plugin-metadata.mjs";
+function getHomeDir() {
+    return process.env.HOME || process.env.USERPROFILE || homedir();
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function getString(value, fallback = "") {
+    return typeof value === "string" ? value : fallback;
+}
+function getNumber(value, fallback = 0) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function getBoolean(value, fallback = false) {
+    return typeof value === "boolean" ? value : fallback;
+}
+function toInstinct(value) {
+    const record = asRecord(value);
+    if (!record) {
+        return null;
+    }
+    const id = getString(record.id);
+    const trigger = getString(record.trigger);
+    const body = getString(record.body);
+    if (!id || !trigger || !body) {
+        return null;
+    }
+    let confidence = getNumber(record.confidence, 0.6);
+    // Validate confidence bounds (0.0 - 0.9)
+    confidence = Math.max(0, Math.min(0.9, confidence));
+    const scopeValue = getString(record.scope);
+    const scope = scopeValue === "global" || scopeValue === "project"
+        ? scopeValue
+        : undefined;
+    return {
+        id,
+        trigger,
+        body,
+        confidence,
+        domain: getString(record.domain) || undefined,
+        source: getString(record.source) || undefined,
+        scope,
+        project_id: getString(record.project_id) || undefined,
+        created: getString(record.created) || undefined,
+        last_seen: getString(record.last_seen) || undefined,
+        observation_count: typeof record.observation_count === "number" ? record.observation_count : undefined,
+    };
+}
+const REPO_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
+const INSTINCTS_DIR = join(getHomeDir(), ".claude", "instincts");
 const GLOBAL_DIR = join(INSTINCTS_DIR, "global");
-
+const PACKS_DIR = join(REPO_ROOT, "instinct-packs");
+const PLANNING_TEMPLATES_DIR = join(REPO_ROOT, "templates", "planning-with-files");
+const DEFAULT_PLANNING_PHASES = ["Research", "Plan", "Execute", "Verify", "Reflect"];
+const PLANNING_FILES = {
+    taskPlan: "task_plan.md",
+    findings: "findings.md",
+    progress: "progress.md",
+};
 const args = process.argv.slice(2);
-const modeIdx = args.indexOf("--mode");
-const MODE = modeIdx !== -1 && args[modeIdx + 1] ? args[modeIdx + 1] : "beginner";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
+const modeIndex = args.indexOf("--mode");
+const requestedMode = args[modeIndex + 1];
+const MODE = isPluginMode(requestedMode) ? requestedMode : "beginner";
 function getProjectHash() {
-  try {
-    const root = execSync("git rev-parse --show-toplevel 2>/dev/null", { encoding: "utf8" }).trim();
-    const hash = execSync(`printf '%s' "${root}" | sha256sum | cut -c1-12`, {
-      encoding: "utf8",
-      shell: "/bin/bash",
-    }).trim();
-    return { root, hash, name: basename(root) };
-  } catch {
-    return { root: "global", hash: "global", name: "global" };
-  }
-}
-
+    try {
+        const root = execSync("git rev-parse --show-toplevel 2>/dev/null", { encoding: "utf8" }).trim();
+        const hash = createHash("sha256").update(root).digest("hex").slice(0, 12);
+        return { root, hash, name: basename(root) };
+    }
+    catch {
+        return { root: "global", hash: "global", name: "global" };
+    }
+}
 function readInstincts(projectHash) {
-  const instincts = [];
-  const dirs = [GLOBAL_DIR];
-  if (projectHash !== "global") {
-    dirs.push(join(INSTINCTS_DIR, projectHash));
-  }
-
-  for (const dir of dirs) {
-    if (!existsSync(dir)) continue;
-    for (const file of readdirSync(dir)) {
-      if (!file.endsWith(".yaml")) continue;
-      try {
-        const content = readFileSync(join(dir, file), "utf8");
-        const parsed = parseYamlInstinct(content);
-        if (parsed) instincts.push(parsed);
-      } catch {
-        // skip malformed files
-      }
+    const instincts = [];
+    const dirs = [GLOBAL_DIR];
+    if (projectHash !== "global") {
+        dirs.push(join(INSTINCTS_DIR, projectHash));
+    }
+    for (const dir of dirs) {
+        if (!existsSync(dir)) {
+            continue;
+        }
+        for (const file of readdirSync(dir)) {
+            if (!file.endsWith(".yaml")) {
+                continue;
+            }
+            try {
+                const parsed = parseYamlInstinct(readFileSync(join(dir, file), "utf8"));
+                if (parsed) {
+                    instincts.push(parsed);
+                }
+            }
+            catch {
+                // skip malformed files
+            }
+        }
     }
-  }
-  return instincts;
+    return instincts;
 }
-
 function parseYamlInstinct(content) {
-  const lines = content.split("\n");
-  const meta = {};
-  let body = "";
-  let inBody = false;
-
-  for (const line of lines) {
-    if (line.trim() === "---" && Object.keys(meta).length > 0) {
-      inBody = true;
-      continue;
+    const lines = content.split("\n");
+    const meta = {};
+    let body = "";
+    let inBody = false;
+    for (const line of lines) {
+        if (line.trim() === "---" && Object.keys(meta).length > 0) {
+            inBody = true;
+            continue;
+        }
+        if (inBody) {
+            body += `${line}\n`;
+            continue;
+        }
+        const match = line.match(/^(\w[\w_-]*):\s*(.+)/);
+        if (!match) {
+            continue;
+        }
+        const rawValue = match[2].trim().replace(/^["']|["']$/g, "");
+        const value = rawValue !== "" && !Number.isNaN(Number(rawValue))
+            ? Number(rawValue)
+            : rawValue;
+        meta[match[1]] = value;
     }
-    if (inBody) {
-      body += line + "\n";
-    } else {
-      const match = line.match(/^(\w[\w_-]*):\s*(.+)/);
-      if (match) {
-        let val = match[2].trim().replace(/^["']|["']$/g, "");
-        if (!isNaN(val) && val !== "") val = parseFloat(val);
-        meta[match[1]] = val;
-      }
+    if (typeof meta.id !== "string" || typeof meta.trigger !== "string") {
+        return null;
     }
-  }
-
-  if (!meta.id) return null;
-  return { ...meta, body: body.trim() };
+    return {
+        id: meta.id,
+        trigger: meta.trigger,
+        body: body.trim(),
+        confidence: typeof meta.confidence === "number" ? meta.confidence : 0.6,
+        domain: typeof meta.domain === "string" ? meta.domain : undefined,
+        source: typeof meta.source === "string" ? meta.source : undefined,
+        scope: meta.scope === "global" || meta.scope === "project" ? meta.scope : undefined,
+        project_id: typeof meta.project_id === "string" ? meta.project_id : undefined,
+        created: typeof meta.created === "string" ? meta.created : undefined,
+        last_seen: typeof meta.last_seen === "string" ? meta.last_seen : undefined,
+        observation_count: typeof meta.observation_count === "number" ? meta.observation_count : undefined,
+    };
 }
-
 function countObservations(projectHash) {
-  const obsFile = join(INSTINCTS_DIR, projectHash, "observations.jsonl");
-  if (!existsSync(obsFile)) return 0;
-  try {
-    const content = readFileSync(obsFile, "utf8");
-    return content.split("\n").filter((l) => l.trim()).length;
-  } catch {
-    return 0;
-  }
-}
-
+    const observationsFile = join(INSTINCTS_DIR, projectHash, "observations.jsonl");
+    if (!existsSync(observationsFile)) {
+        return 0;
+    }
+    try {
+        const content = readFileSync(observationsFile, "utf8");
+        return content.split("\n").filter((line) => line.trim().length > 0).length;
+    }
+    catch {
+        return 0;
+    }
+}
 function getRecentObservations(projectHash, limit = 50) {
-  const obsFile = join(INSTINCTS_DIR, projectHash, "observations.jsonl");
-  if (!existsSync(obsFile)) return [];
-  try {
-    const lines = readFileSync(obsFile, "utf8").split("\n").filter((l) => l.trim());
-    return lines.slice(-limit).map((l) => {
-      try { return JSON.parse(l); } catch { return null; }
-    }).filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-
+    const observationsFile = join(INSTINCTS_DIR, projectHash, "observations.jsonl");
+    if (!existsSync(observationsFile)) {
+        return [];
+    }
+    try {
+        const lines = readFileSync(observationsFile, "utf8")
+            .split("\n")
+            .filter((line) => line.trim().length > 0);
+        return lines.slice(-limit).flatMap((line) => {
+            try {
+                return [JSON.parse(line)];
+            }
+            catch {
+                return [];
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+}
 function detectLevel(projectHash) {
-  const obsCount = countObservations(projectHash);
-  const instincts = readInstincts(projectHash);
-  const hasHighConfidence = instincts.some((i) => i.confidence >= 0.7);
-  const hasMidConfidence = instincts.some((i) => i.confidence >= 0.5 && i.confidence < 0.7);
-
-  if (hasHighConfidence) return "AUTO-APPLY";
-  if (hasMidConfidence) return "SUGGEST";
-  if (obsCount >= 20 || instincts.length > 0) return "ANALYZE";
-  return "CAPTURE";
-}
-
+    const observationCount = countObservations(projectHash);
+    const instincts = readInstincts(projectHash);
+    const hasHighConfidence = instincts.some((instinct) => instinct.confidence >= 0.7);
+    const hasMidConfidence = instincts.some((instinct) => instinct.confidence >= 0.5 && instinct.confidence < 0.7);
+    if (hasHighConfidence) {
+        return "AUTO-APPLY";
+    }
+    if (hasMidConfidence) {
+        return "SUGGEST";
+    }
+    if (observationCount >= 20 || instincts.length > 0) {
+        return "ANALYZE";
+    }
+    return "CAPTURE";
+}
 function writeInstinct(projectHash, instinct) {
-  const dir = instinct.scope === "global" ? GLOBAL_DIR : join(INSTINCTS_DIR, projectHash);
-  mkdirSync(dir, { recursive: true });
-
-  const yaml = [
-    `id: ${instinct.id}`,
-    `trigger: "${instinct.trigger}"`,
-    `confidence: ${instinct.confidence}`,
-    `domain: ${instinct.domain || "workflow"}`,
-    `source: ${instinct.source || "manual"}`,
-    `scope: ${instinct.scope || "project"}`,
-    `project_id: ${projectHash}`,
-    `created: "${new Date().toISOString().split("T")[0]}"`,
-    `last_seen: "${new Date().toISOString().split("T")[0]}"`,
-    `observation_count: ${instinct.observation_count || 1}`,
-    "---",
-    instinct.body,
-  ].join("\n");
-
-  writeFileSync(join(dir, `${instinct.id}.yaml`), yaml + "\n");
-}
-
+    const scope = instinct.scope === "global" ? "global" : "project";
+    const dir = scope === "global" ? GLOBAL_DIR : join(INSTINCTS_DIR, projectHash);
+    mkdirSync(dir, { recursive: true });
+    const today = new Date().toISOString().split("T")[0];
+    const yaml = [
+        `id: ${instinct.id}`,
+        `trigger: "${instinct.trigger}"`,
+        `confidence: ${instinct.confidence}`,
+        `domain: ${instinct.domain || "workflow"}`,
+        `source: ${instinct.source || "manual"}`,
+        `scope: ${scope}`,
+        `project_id: ${projectHash}`,
+        `created: "${instinct.created || today}"`,
+        `last_seen: "${instinct.last_seen || today}"`,
+        `observation_count: ${instinct.observation_count || 1}`,
+        "---",
+        instinct.body,
+    ].join("\n");
+    writeFileSync(join(dir, `${instinct.id}.yaml`), `${yaml}\n`);
+}
 function updateInstinctConfidence(projectHash, instinctId, delta) {
-  const instincts = readInstincts(projectHash);
-  const instinct = instincts.find((i) => i.id === instinctId);
-  if (!instinct) return null;
-
-  const newConf = Math.max(0, Math.min(0.9, (instinct.confidence || 0.5) + delta));
-  instinct.confidence = Math.round(newConf * 100) / 100;
-  instinct.last_seen = new Date().toISOString().split("T")[0];
-  writeInstinct(projectHash, instinct);
-  return instinct;
-}
-
-// ---------------------------------------------------------------------------
-// MCP Protocol (JSON-RPC over stdio, no SDK dependency)
-// ---------------------------------------------------------------------------
-
-const BEGINNER_TOOLS = [
-  {
-    name: "ci_status",
-    description: "Show current level, instinct count, and observation count for this project. Good starting point to see what the system has learned.",
-    inputSchema: { type: "object", properties: {}, required: [] },
-  },
-  {
-    name: "ci_instincts",
-    description: "List all learned instincts for this project with their confidence levels and behaviors.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        min_confidence: { type: "number", description: "Minimum confidence to show (default: 0)", default: 0 },
-      },
-      required: [],
-    },
-  },
-  {
-    name: "ci_reflect",
-    description: "Generate a structured reflection for the current session. Provide a summary of what you worked on.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        summary: { type: "string", description: "Brief summary of what was done this session" },
-      },
-      required: ["summary"],
-    },
-  },
-];
-
-const EXPERT_TOOLS = [
-  {
-    name: "ci_reinforce",
-    description: "Accept or reject an instinct suggestion. Adjusts confidence: +0.15 for accept, -0.1 for reject.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        instinct_id: { type: "string", description: "The instinct ID to reinforce" },
-        accepted: { type: "boolean", description: "true = accept (+0.15), false = reject (-0.1)" },
-      },
-      required: ["instinct_id", "accepted"],
-    },
-  },
-  {
-    name: "ci_create_instinct",
-    description: "Manually create a new instinct with a trigger, body, and starting confidence.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        id: { type: "string", description: "Unique instinct ID (kebab-case)" },
-        trigger: { type: "string", description: "When this instinct applies" },
-        body: { type: "string", description: "The behavior to follow" },
-        confidence: { type: "number", description: "Starting confidence 0.0-0.9 (default: 0.6)", default: 0.6 },
-        domain: { type: "string", description: "Domain: workflow|tooling|testing|patterns|code-style", default: "workflow" },
-        scope: { type: "string", description: "Scope: project|global", default: "project" },
-      },
-      required: ["id", "trigger", "body"],
-    },
-  },
-  {
-    name: "ci_observations",
-    description: "View recent tool call observations captured by hooks.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        limit: { type: "number", description: "Number of recent observations to return (default: 20)", default: 20 },
-      },
-      required: [],
-    },
-  },
-  {
-    name: "ci_export",
-    description: "Export all instincts as a JSON array for sharing or backup.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        scope: { type: "string", description: "Which instincts: project|global|all (default: all)", default: "all" },
-      },
-      required: [],
-    },
-  },
-  {
-    name: "ci_import",
-    description: "Import instincts from a JSON array. Skips duplicates by ID.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        instincts_json: { type: "string", description: "JSON array of instinct objects to import" },
-        scope: { type: "string", description: "Import to: project|global (default: project)", default: "project" },
-      },
-      required: ["instincts_json"],
-    },
-  },
-];
-
-function getAllTools() {
-  if (MODE === "expert") return [...BEGINNER_TOOLS, ...EXPERT_TOOLS];
-  return BEGINNER_TOOLS;
-}
-
-// ---------------------------------------------------------------------------
-// Tool handlers
-// ---------------------------------------------------------------------------
-
-function handleTool(name, params) {
-  const project = getProjectHash();
-
-  switch (name) {
-    case "ci_status": {
-      const level = detectLevel(project.hash);
-      const obsCount = countObservations(project.hash);
-      const instincts = readInstincts(project.hash);
-      const byConfidence = {
-        silent: instincts.filter((i) => i.confidence < 0.5).length,
-        suggest: instincts.filter((i) => i.confidence >= 0.5 && i.confidence < 0.7).length,
-        autoApply: instincts.filter((i) => i.confidence >= 0.7).length,
-      };
-
-      return text([
-        `## continuous-improvement Status`,
-        ``,
-        `**Project:** ${project.name}`,
-        `**Level:** ${level}`,
-        `**Observations:** ${obsCount}`,
-        `**Instincts:** ${instincts.length} total`,
-        `  - Silent (< 0.5): ${byConfidence.silent}`,
-        `  - Suggest (0.5-0.69): ${byConfidence.suggest}`,
-        `  - Auto-apply (0.7+): ${byConfidence.autoApply}`,
-        ``,
-        `**Mode:** ${MODE}`,
-        level === "CAPTURE" ? `\n_Keep working — hooks are capturing. Analysis begins at 20 observations._` : "",
-      ].join("\n"));
+    const instincts = readInstincts(projectHash);
+    const instinct = instincts.find((candidate) => candidate.id === instinctId);
+    if (!instinct) {
+        return null;
     }
-
-    case "ci_instincts": {
-      const minConf = params.min_confidence || 0;
-      const instincts = readInstincts(project.hash).filter((i) => i.confidence >= minConf);
-
-      if (instincts.length === 0) return text("No instincts found. Keep working — the system learns from your sessions.");
-
-      const lines = instincts
-        .sort((a, b) => b.confidence - a.confidence)
-        .map((i) => {
-          const behavior = i.confidence >= 0.7 ? "AUTO-APPLY" : i.confidence >= 0.5 ? "SUGGEST" : "silent";
-          return `- **${i.id}** (${i.confidence}) [${behavior}]\n  Trigger: ${i.trigger}\n  ${i.body}`;
-        });
-
-      return text(`## Instincts for ${project.name}\n\n${lines.join("\n\n")}`);
+    const newConfidence = Math.max(0, Math.min(0.9, instinct.confidence + delta));
+    instinct.confidence = Math.round(newConfidence * 100) / 100;
+    instinct.last_seen = new Date().toISOString().split("T")[0];
+    writeInstinct(projectHash, instinct);
+    return instinct;
+}
+function getWorkspaceRoot() {
+    try {
+        const root = execSync("git rev-parse --show-toplevel 2>/dev/null", { encoding: "utf8" }).trim();
+        return root || process.cwd();
     }
-
-    case "ci_reflect": {
-      const summary = params.summary || "No summary provided";
-      const reflection = [
-        `## Reflection — ${new Date().toISOString().split("T")[0]}`,
-        ``,
-        `**Session summary:** ${summary}`,
-        ``,
-        `Use this template to reflect:`,
-        `- **What worked:**`,
-        `- **What failed:**`,
-        `- **What I'd do differently:**`,
-        `- **Rule to add:** (becomes an instinct at 0.6 confidence)`,
-      ].join("\n");
-
-      return text(reflection);
+    catch {
+        return process.cwd();
     }
-
-    case "ci_reinforce": {
-      if (MODE !== "expert") return error("ci_reinforce requires expert mode. Start server with --mode expert");
-      const delta = params.accepted ? 0.15 : -0.1;
-      const updated = updateInstinctConfidence(project.hash, params.instinct_id, delta);
-      if (!updated) return error(`Instinct "${params.instinct_id}" not found`);
-      return text(`${params.accepted ? "Accepted" : "Rejected"} **${updated.id}** — confidence now ${updated.confidence}`);
+}
+function readPlanningTemplate(fileName, fallback) {
+    const templatePath = join(PLANNING_TEMPLATES_DIR, fileName);
+    if (!existsSync(templatePath)) {
+        return fallback;
     }
-
-    case "ci_create_instinct": {
-      if (MODE !== "expert") return error("ci_create_instinct requires expert mode");
-      writeInstinct(project.hash, {
-        id: params.id,
-        trigger: params.trigger,
-        body: params.body,
-        confidence: params.confidence || 0.6,
-        domain: params.domain || "workflow",
-        source: "manual",
-        scope: params.scope || "project",
-        observation_count: 1,
-      });
-      return text(`Created instinct **${params.id}** with confidence ${params.confidence || 0.6}`);
+    try {
+        return readFileSync(templatePath, "utf8");
     }
-
-    case "ci_observations": {
-      if (MODE !== "expert") return error("ci_observations requires expert mode");
-      const limit = params.limit || 20;
-      const obs = getRecentObservations(project.hash, limit);
-      if (obs.length === 0) return text("No observations yet. Hooks capture tool calls automatically.");
-      const lines = obs.map((o) => `[${o.ts}] ${o.event} — ${o.tool}`);
-      return text(`## Recent Observations (${obs.length})\n\n${lines.join("\n")}`);
+    catch {
+        return fallback;
     }
-
-    case "ci_export": {
-      if (MODE !== "expert") return error("ci_export requires expert mode");
-      const scope = params.scope || "all";
-      let instincts = readInstincts(project.hash);
-      if (scope === "project") instincts = instincts.filter((i) => i.scope === "project");
-      if (scope === "global") instincts = instincts.filter((i) => i.scope === "global");
-      return text(JSON.stringify(instincts, null, 2));
+}
+function replaceTemplateToken(template, token, value) {
+    return template.split(`{{${token}}}`).join(value);
+}
+function getToday() {
+    return new Date().toISOString().split("T")[0];
+}
+function normalizePhases(value) {
+    if (!Array.isArray(value)) {
+        return [...DEFAULT_PLANNING_PHASES];
     }
-
-    case "ci_import": {
-      if (MODE !== "expert") return error("ci_import requires expert mode");
-      let toImport;
-      try {
-        toImport = JSON.parse(params.instincts_json);
-      } catch {
-        return error("Invalid JSON. Provide a JSON array of instinct objects.");
-      }
-      if (!Array.isArray(toImport)) return error("Expected a JSON array");
-
-      const existing = readInstincts(project.hash);
-      const existingIds = new Set(existing.map((i) => i.id));
-      let imported = 0;
-
-      for (const inst of toImport) {
-        if (!inst.id || !inst.trigger || !inst.body) continue;
-        if (existingIds.has(inst.id)) continue;
-        writeInstinct(project.hash, {
-          ...inst,
-          scope: params.scope || inst.scope || "project",
-          source: "imported",
-        });
-        imported++;
-      }
-
-      return text(`Imported ${imported} instincts (${toImport.length - imported} skipped as duplicates)`);
+    const phases = value
+        .map((phase) => typeof phase === "string" ? phase.trim() : "")
+        .filter((phase) => phase.length > 0);
+    return phases.length > 0 ? phases : [...DEFAULT_PLANNING_PHASES];
+}
+function formatPhaseChecklist(phases) {
+    return phases.map((phase) => `- [ ] ${phase}`).join("\n");
+}
+function renderTaskPlan(goal, phases) {
+    const fallback = `# Task Plan
+
+## Goal
+{{goal}}
+
+## Status
+{{status}}
+
+## Phases
+{{phases}}
+
+## Key Questions
+- [ ] What existing implementation or context should be reviewed first?
+- [ ] What constraints or risks need validation before execution?
+- [ ] What verification proves the task is complete?
+
+## Decisions Made
+- None yet.
+
+## Errors Encountered
+| Error | Attempt | Resolution |
+| --- | --- | --- |
+| None yet | - | - |
+`;
+    let template = readPlanningTemplate(PLANNING_FILES.taskPlan, fallback);
+    template = replaceTemplateToken(template, "goal", goal);
+    template = replaceTemplateToken(template, "status", "Not started");
+    template = replaceTemplateToken(template, "phases", formatPhaseChecklist(phases));
+    template = replaceTemplateToken(template, "date", getToday());
+    return template.endsWith("\n") ? template : `${template}\n`;
+}
+function renderFindings() {
+    const fallback = `# Findings
+
+## Research Notes
+- Created on {{date}}.
+- Record source links, code references, and synthesized findings here.
+
+## Sources
+- Add links and short summaries here.
+`;
+    let template = readPlanningTemplate(PLANNING_FILES.findings, fallback);
+    template = replaceTemplateToken(template, "date", getToday());
+    return template.endsWith("\n") ? template : `${template}\n`;
+}
+function renderProgress() {
+    const fallback = `# Progress
+
+## Session Log
+- {{date}}: Initialized planning files.
+
+## Verification Notes
+- Record commands, tests, outputs, and checkpoints here.
+`;
+    let template = readPlanningTemplate(PLANNING_FILES.progress, fallback);
+    template = replaceTemplateToken(template, "date", getToday());
+    return template.endsWith("\n") ? template : `${template}\n`;
+}
+function writePlanningFile(filePath, content, force) {
+    const alreadyExists = existsSync(filePath);
+    if (alreadyExists && !force) {
+        return "preserved";
+    }
+    writeFileSync(filePath, content);
+    return alreadyExists ? "overwritten" : "created";
+}
+function getMarkdownSection(content, heading) {
+    const lines = content.split(/\r?\n/);
+    const sectionLines = [];
+    let inSection = false;
+    for (const line of lines) {
+        if (line.startsWith("## ")) {
+            if (inSection) {
+                break;
+            }
+            inSection = line.trim() === `## ${heading}`;
+            continue;
+        }
+        if (inSection) {
+            sectionLines.push(line);
+        }
+    }
+    return sectionLines.join("\n").trim();
+}
+function parseTaskPlan(content) {
+    const checkedPhases = [];
+    const uncheckedPhases = [];
+    for (const line of content.split(/\r?\n/)) {
+        const match = line.match(/^- \[([ xX])\] (.+)$/);
+        if (!match) {
+            continue;
+        }
+        const phase = match[2].trim();
+        if (match[1].toLowerCase() === "x") {
+            checkedPhases.push(phase);
+        }
+        else {
+            uncheckedPhases.push(phase);
+        }
+    }
+    const inlineStatus = content.match(/^\*\*Status:\*\*\s*(.+)$/m) ?? content.match(/^Status:\s*(.+)$/m);
+    const statusFromSection = getMarkdownSection(content, "Status")
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find(Boolean);
+    return {
+        status: inlineStatus?.[1]?.trim() || statusFromSection || "Unknown",
+        checkedPhases,
+        uncheckedPhases,
+    };
+}
+function hasMeaningfulContent(content, placeholders) {
+    return content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .filter((line) => !line.startsWith("#"))
+        .filter((line) => !/^[-|: ]+$/.test(line))
+        .some((line) => line !== "- None yet." &&
+        line !== "| None yet | - | - |" &&
+        !placeholders.some((placeholder) => line.includes(placeholder)));
+}
+function getAllTools() {
+    return getToolDefinitions(MODE);
+}
+function text(value) {
+    return { content: [{ type: "text", text: value }] };
+}
+function error(value) {
+    return { content: [{ type: "text", text: value }], isError: true };
+}
+function handleTool(name, params) {
+    const project = getProjectHash();
+    switch (name) {
+        case "ci_status": {
+            const level = detectLevel(project.hash);
+            const observationCount = countObservations(project.hash);
+            const instincts = readInstincts(project.hash);
+            const byConfidence = {
+                silent: instincts.filter((instinct) => instinct.confidence < 0.5).length,
+                suggest: instincts.filter((instinct) => instinct.confidence >= 0.5 && instinct.confidence < 0.7).length,
+                autoApply: instincts.filter((instinct) => instinct.confidence >= 0.7).length,
+            };
+            return text([
+                "## continuous-improvement Status",
+                "",
+                `**Project:** ${project.name}`,
+                `**Level:** ${level}`,
+                `**Observations:** ${observationCount}`,
+                `**Instincts:** ${instincts.length} total`,
+                `  - Silent (< 0.5): ${byConfidence.silent}`,
+                `  - Suggest (0.5-0.69): ${byConfidence.suggest}`,
+                `  - Auto-apply (0.7+): ${byConfidence.autoApply}`,
+                "",
+                `**Mode:** ${MODE}`,
+                level === "CAPTURE" ? "\n_Keep working — hooks are capturing. Analysis begins at 20 observations._" : "",
+            ].join("\n"));
+        }
+        case "ci_instincts": {
+            const minConfidence = getNumber(params.min_confidence, 0);
+            const instincts = readInstincts(project.hash).filter((instinct) => instinct.confidence >= minConfidence);
+            if (instincts.length === 0) {
+                return text("No instincts found. Keep working — the system learns from your sessions.");
+            }
+            const lines = instincts
+                .sort((left, right) => right.confidence - left.confidence)
+                .map((instinct) => {
+                const behavior = instinct.confidence >= 0.7
+                    ? "AUTO-APPLY"
+                    : instinct.confidence >= 0.5
+                        ? "SUGGEST"
+                        : "silent";
+                return `- **${instinct.id}** (${instinct.confidence}) [${behavior}]\n  Trigger: ${instinct.trigger}\n  ${instinct.body}`;
+            });
+            return text(`## Instincts for ${project.name}\n\n${lines.join("\n\n")}`);
+        }
+        case "ci_reflect": {
+            const summary = getString(params.summary, "No summary provided");
+            const reflection = [
+                `## Reflection — ${new Date().toISOString().split("T")[0]}`,
+                "",
+                `**Session summary:** ${summary}`,
+                "",
+                "Use this template to reflect:",
+                "- **What worked:**",
+                "- **What failed:**",
+                "- **What I'd do differently:**",
+                "- **Rule to add:** (becomes an instinct at 0.6 confidence)",
+                "- **Iteration — Next best recommendations (ranked, top 3):**",
+                "  1. <primary — strongest next core-development move>",
+                "  2. <alternative — different angle>",
+                "  3. <alternative — smaller or larger scope>",
+                "  (or just `1. None — goal met, stop.` if the original goal is fully resolved)",
+            ].join("\n");
+            return text(reflection);
+        }
+        case "ci_reinforce": {
+            if (MODE !== "expert") {
+                return error("ci_reinforce requires expert mode. Start server with --mode expert");
+            }
+            const instinctId = getString(params.instinct_id);
+            const delta = getBoolean(params.accepted) ? 0.15 : -0.1;
+            const updated = updateInstinctConfidence(project.hash, instinctId, delta);
+            if (!updated) {
+                return error(`Instinct "${instinctId}" not found`);
+            }
+            return text(`${getBoolean(params.accepted) ? "Accepted" : "Rejected"} **${updated.id}** — confidence now ${updated.confidence}`);
+        }
+        case "ci_create_instinct": {
+            if (MODE !== "expert") {
+                return error("ci_create_instinct requires expert mode");
+            }
+            const scope = getString(params.scope) === "global" ? "global" : "project";
+            const instinct = {
+                id: getString(params.id),
+                trigger: getString(params.trigger),
+                body: getString(params.body),
+                confidence: getNumber(params.confidence, 0.6),
+                domain: getString(params.domain, "workflow"),
+                source: "manual",
+                scope,
+                observation_count: 1,
+            };
+            writeInstinct(project.hash, instinct);
+            return text(`Created instinct **${instinct.id}** with confidence ${instinct.confidence}`);
+        }
+        case "ci_observations": {
+            if (MODE !== "expert") {
+                return error("ci_observations requires expert mode");
+            }
+            const limit = getNumber(params.limit, 20);
+            const observations = getRecentObservations(project.hash, limit);
+            if (observations.length === 0) {
+                return text("No observations yet. Hooks capture tool calls automatically.");
+            }
+            const lines = observations.map((observation) => `[${observation.ts}] ${observation.event} — ${observation.tool}`);
+            return text(`## Recent Observations (${observations.length})\n\n${lines.join("\n")}`);
+        }
+        case "ci_export": {
+            if (MODE !== "expert") {
+                return error("ci_export requires expert mode");
+            }
+            const scope = getString(params.scope, "all");
+            let instincts = readInstincts(project.hash);
+            if (scope === "project") {
+                instincts = instincts.filter((instinct) => instinct.scope === "project");
+            }
+            if (scope === "global") {
+                instincts = instincts.filter((instinct) => instinct.scope === "global");
+            }
+            return text(JSON.stringify(instincts, null, 2));
+        }
+        case "ci_import": {
+            if (MODE !== "expert") {
+                return error("ci_import requires expert mode");
+            }
+            const rawJson = getString(params.instincts_json);
+            let parsed;
+            try {
+                parsed = JSON.parse(rawJson);
+            }
+            catch {
+                return error("Invalid JSON. Provide a JSON array of instinct objects.");
+            }
+            if (!Array.isArray(parsed)) {
+                return error("Expected a JSON array");
+            }
+            const scope = getString(params.scope, "project") === "global" ? "global" : "project";
+            const existing = readInstincts(project.hash);
+            const existingIds = new Set(existing.map((instinct) => instinct.id));
+            let imported = 0;
+            for (const candidate of parsed) {
+                const instinct = toInstinct(candidate);
+                if (!instinct || existingIds.has(instinct.id)) {
+                    continue;
+                }
+                instinct.scope = instinct.scope || scope;
+                instinct.source = "imported";
+                writeInstinct(project.hash, instinct);
+                imported++;
+            }
+            return text(`Imported ${imported} instincts (${parsed.length - imported} skipped as duplicates)`);
+        }
+        case "ci_plan_init": {
+            if (MODE !== "expert") {
+                return error("ci_plan_init requires expert mode");
+            }
+            const goal = getString(params.goal).trim();
+            if (!goal) {
+                return error("goal is required");
+            }
+            const phases = normalizePhases(params.phases);
+            const force = getBoolean(params.force, false);
+            const workspaceRoot = getWorkspaceRoot();
+            const taskPlanStatus = writePlanningFile(join(workspaceRoot, PLANNING_FILES.taskPlan), renderTaskPlan(goal, phases), force);
+            const findingsStatus = writePlanningFile(join(workspaceRoot, PLANNING_FILES.findings), renderFindings(), force);
+            const progressStatus = writePlanningFile(join(workspaceRoot, PLANNING_FILES.progress), renderProgress(), force);
+            return text([
+                "## Planning-With-Files Initialized",
+                "",
+                `**Project root:** ${workspaceRoot}`,
+                `**Goal:** ${goal}`,
+                `**Force overwrite:** ${force ? "yes" : "no"}`,
+                "",
+                "**Files:**",
+                `- ${PLANNING_FILES.taskPlan}: ${taskPlanStatus}`,
+                `- ${PLANNING_FILES.findings}: ${findingsStatus}`,
+                `- ${PLANNING_FILES.progress}: ${progressStatus}`,
+                "",
+                "**Phases:**",
+                ...phases.map((phase) => `- [ ] ${phase}`),
+            ].join("\n"));
+        }
+        case "ci_plan_status": {
+            if (MODE !== "expert") {
+                return error("ci_plan_status requires expert mode");
+            }
+            const workspaceRoot = getWorkspaceRoot();
+            const includeContents = getBoolean(params.include_contents, false);
+            const taskPlanPath = join(workspaceRoot, PLANNING_FILES.taskPlan);
+            const findingsPath = join(workspaceRoot, PLANNING_FILES.findings);
+            const progressPath = join(workspaceRoot, PLANNING_FILES.progress);
+            const taskPlanExists = existsSync(taskPlanPath);
+            const findingsExists = existsSync(findingsPath);
+            const progressExists = existsSync(progressPath);
+            if (!taskPlanExists && !findingsExists && !progressExists) {
+                return text(`No planning files found in ${workspaceRoot}. Run ci_plan_init or /planning-with-files to create ${PLANNING_FILES.taskPlan}, ${PLANNING_FILES.findings}, and ${PLANNING_FILES.progress}.`);
+            }
+            const taskPlanContent = taskPlanExists ? readFileSync(taskPlanPath, "utf8") : "";
+            const findingsContent = findingsExists ? readFileSync(findingsPath, "utf8") : "";
+            const progressContent = progressExists ? readFileSync(progressPath, "utf8") : "";
+            const summary = taskPlanExists
+                ? parseTaskPlan(taskPlanContent)
+                : { status: "No task plan yet", checkedPhases: [], uncheckedPhases: [] };
+            const findingsState = findingsExists
+                ? hasMeaningfulContent(findingsContent, [
+                    "Created on",
+                    "Record source links, code references, and synthesized findings here.",
+                    "Add links and short summaries here.",
+                ])
+                    ? "has notes"
+                    : "template only"
+                : "missing";
+            const progressState = progressExists
+                ? hasMeaningfulContent(progressContent, [
+                    "Initialized planning files.",
+                    "Record commands, tests, outputs, and checkpoints here.",
+                ])
+                    ? "has entries"
+                    : "template only"
+                : "missing";
+            const lines = [
+                "## Planning-With-Files Status",
+                "",
+                `**Project root:** ${workspaceRoot}`,
+                "",
+                "**Files:**",
+                `- ${PLANNING_FILES.taskPlan}: ${taskPlanExists ? "present" : "missing"}`,
+                `- ${PLANNING_FILES.findings}: ${findingsExists ? "present" : "missing"} (${findingsState})`,
+                `- ${PLANNING_FILES.progress}: ${progressExists ? "present" : "missing"} (${progressState})`,
+                "",
+                `**Status:** ${summary.status}`,
+                `**Completed phases:** ${summary.checkedPhases.length}/${summary.checkedPhases.length + summary.uncheckedPhases.length}`,
+                `**Checked phases:** ${summary.checkedPhases.length > 0 ? summary.checkedPhases.join(", ") : "(none)"}`,
+                `**Remaining phases:** ${summary.uncheckedPhases.length > 0 ? summary.uncheckedPhases.join(", ") : "(none)"}`,
+            ];
+            if (includeContents) {
+                const filesToInclude = [
+                    [PLANNING_FILES.taskPlan, taskPlanContent],
+                    [PLANNING_FILES.findings, findingsContent],
+                    [PLANNING_FILES.progress, progressContent],
+                ];
+                for (const [fileName, content] of filesToInclude) {
+                    if (!content) {
+                        continue;
+                    }
+                    lines.push("", `## ${fileName}`, "```md", content.trimEnd(), "```");
+                }
+            }
+            return text(lines.join("\n"));
+        }
+        case "ci_dashboard": {
+            if (MODE !== "expert") {
+                return error("ci_dashboard requires expert mode");
+            }
+            const level = detectLevel(project.hash);
+            const observationCount = countObservations(project.hash);
+            const instincts = readInstincts(project.hash);
+            const byConfidence = {
+                auto: instincts.filter((instinct) => instinct.confidence >= 0.7),
+                suggest: instincts.filter((instinct) => instinct.confidence >= 0.5 && instinct.confidence < 0.7),
+                silent: instincts.filter((instinct) => instinct.confidence < 0.5),
+            };
+            const globalCount = instincts.filter((instinct) => instinct.scope === "global").length;
+            const projectCount = instincts.length - globalCount;
+            const today = Date.now();
+            const stale = instincts.filter((instinct) => {
+                if (!instinct.last_seen) {
+                    return false;
+                }
+                const diff = (today - new Date(instinct.last_seen).getTime()) / (1000 * 60 * 60 * 24);
+                return diff > 30;
+            });
+            const autoBar = "█".repeat(Math.min(10, byConfidence.auto.length)) + "░".repeat(Math.max(0, 10 - byConfidence.auto.length));
+            const suggestBar = "█".repeat(Math.min(10, byConfidence.suggest.length)) + "░".repeat(Math.max(0, 10 - byConfidence.suggest.length));
+            const silentBar = "█".repeat(Math.min(10, byConfidence.silent.length)) + "░".repeat(Math.max(0, 10 - byConfidence.silent.length));
+            const top5 = instincts
+                .sort((left, right) => right.confidence - left.confidence)
+                .slice(0, 5)
+                .map((instinct) => `  ${"█".repeat(Math.round(instinct.confidence * 10)) + "░".repeat(10 - Math.round(instinct.confidence * 10))} ${instinct.confidence.toFixed(2)} ${instinct.id}`)
+                .join("\n");
+            let packInfo = "";
+            if (existsSync(PACKS_DIR)) {
+                const packs = readdirSync(PACKS_DIR)
+                    .filter((file) => file.endsWith(".json"))
+                    .map((file) => file.replace(".json", ""));
+                packInfo = `\n  Available packs: ${packs.join(", ")}`;
+            }
+            return text([
+                "╔══════════════════════════════════════════════════════════════╗",
+                "║              continuous-improvement Dashboard                ║",
+                "╠══════════════════════════════════════════════════════════════╣",
+                "║                                                              ║",
+                `║  Project: ${project.name.padEnd(20)} Level: ${level.padEnd(12)}   ║`,
+                `║  Sessions: ~${String(Math.floor(observationCount / 10)).padEnd(17)} Mode: ${MODE.padEnd(13)}  ║`,
+                "║                                                              ║",
+                "║  ┌─ Observations ────────────────────────────────────────┐   ║",
+                `║  │  Total: ${String(observationCount).padEnd(48)} │   ║`,
+                "║  └───────────────────────────────────────────────────────┘   ║",
+                "║                                                              ║",
+                "║  ┌─ Instincts ───────────────────────────────────────────┐   ║",
+                `║  │  Total: ${String(instincts.length).padEnd(48)} │   ║`,
+                `║  │  ${autoBar} Auto-apply (0.7+): ${String(byConfidence.auto.length).padEnd(20)} │   ║`,
+                `║  │  ${suggestBar} Suggest (0.5-0.69): ${String(byConfidence.suggest.length).padEnd(19)} │   ║`,
+                `║  │  ${silentBar} Silent (< 0.5): ${String(byConfidence.silent.length).padEnd(23)} │   ║`,
+                `║  │  Global: ${String(globalCount).padEnd(10)} Project: ${String(projectCount).padEnd(28)} │   ║`,
+                "║  └───────────────────────────────────────────────────────┘   ║",
+                "║                                                              ║",
+                instincts.length > 0
+                    ? [
+                        "║  ┌─ Top Instincts ───────────────────────────────────────┐   ║",
+                        ...top5.split("\n").map((line) => `║  │${line.padEnd(56)}│   ║`),
+                        "║  └───────────────────────────────────────────────────────┘   ║",
+                    ].join("\n")
+                    : "",
+                "║                                                              ║",
+                "║  ┌─ Health ──────────────────────────────────────────────┐   ║",
+                `║  │  Stale (30+ days): ${String(stale.length).padEnd(38)} │   ║`,
+                "║  └───────────────────────────────────────────────────────┘   ║",
+                packInfo ? `║${packInfo.padEnd(63)}║` : "",
+                "║                                                              ║",
+                "╚══════════════════════════════════════════════════════════════╝",
+            ].filter(Boolean).join("\n"));
+        }
+        case "ci_load_pack": {
+            if (MODE !== "expert") {
+                return error("ci_load_pack requires expert mode");
+            }
+            const packName = getString(params.pack);
+            const packPath = join(PACKS_DIR, `${packName}.json`);
+            if (!existsSync(packPath)) {
+                const available = existsSync(PACKS_DIR)
+                    ? readdirSync(PACKS_DIR)
+                        .filter((file) => file.endsWith(".json"))
+                        .map((file) => file.replace(".json", ""))
+                    : [];
+                return error(`Unknown pack: ${packName}. Available: ${available.join(", ")}`);
+            }
+            const packInstincts = JSON.parse(readFileSync(packPath, "utf8"));
+            const existing = readInstincts(project.hash);
+            const existingIds = new Set(existing.map((instinct) => instinct.id));
+            let loaded = 0;
+            for (const candidate of packInstincts) {
+                const instinct = toInstinct(candidate);
+                if (!instinct || existingIds.has(instinct.id)) {
+                    continue;
+                }
+                instinct.source = `pack-${packName}`;
+                instinct.scope = "project";
+                instinct.observation_count = 0;
+                writeInstinct(project.hash, instinct);
+                loaded++;
+            }
+            return text(`Loaded ${loaded}/${packInstincts.length} instincts from **${packName}** pack (${packInstincts.length - loaded} already existed)`);
+        }
+        default:
+            return error(`Unknown tool: ${name}`);
     }
-
-    default:
-      return error(`Unknown tool: ${name}`);
-  }
-}
-
-function text(t) {
-  return { content: [{ type: "text", text: t }] };
-}
-
-function error(t) {
-  return { content: [{ type: "text", text: t }], isError: true };
-}
-
-// ---------------------------------------------------------------------------
-// JSON-RPC stdio transport (zero dependencies)
-// ---------------------------------------------------------------------------
-
+}
 const rl = createInterface({ input: process.stdin, terminal: false });
 let buffer = "";
-
 rl.on("line", (line) => {
-  buffer += line;
-  try {
-    const msg = JSON.parse(buffer);
-    buffer = "";
-    handleMessage(msg);
-  } catch {
-    // incomplete JSON, keep buffering
-  }
-});
-
-function send(response) {
-  const json = JSON.stringify(response);
-  process.stdout.write(`Content-Length: ${Buffer.byteLength(json)}\r\n\r\n${json}`);
-}
-
-function handleMessage(msg) {
-  const { id, method, params } = msg;
-
-  switch (method) {
-    case "initialize":
-      send({
-        jsonrpc: "2.0",
-        id,
-        result: {
-          protocolVersion: "2024-11-05",
-          capabilities: {
-            tools: { listChanged: false },
-            resources: { subscribe: false, listChanged: false },
-          },
-          serverInfo: {
-            name: "continuous-improvement",
-            version: VERSION,
-          },
-        },
-      });
-      break;
-
-    case "notifications/initialized":
-      // no response needed
-      break;
-
-    case "tools/list":
-      send({
-        jsonrpc: "2.0",
-        id,
-        result: { tools: getAllTools() },
-      });
-      break;
-
-    case "tools/call": {
-      const result = handleTool(params.name, params.arguments || {});
-      send({ jsonrpc: "2.0", id, result });
-      break;
+    buffer += line;
+    try {
+        const message = JSON.parse(buffer);
+        buffer = "";
+        handleMessage(message);
     }
-
-    case "resources/list": {
-      const project = getProjectHash();
-      const resources = [
-        {
-          uri: `instincts://project/${project.hash}`,
-          name: `${project.name} instincts`,
-          description: `Learned instincts for ${project.name}`,
-          mimeType: "application/json",
-        },
-        {
-          uri: "instincts://global",
-          name: "Global instincts",
-          description: "Cross-project instincts",
-          mimeType: "application/json",
-        },
-      ];
-      send({ jsonrpc: "2.0", id, result: { resources } });
-      break;
+    catch {
+        // incomplete JSON, keep buffering
     }
-
-    case "resources/read": {
-      const uri = params.uri;
-      const project = getProjectHash();
-      let instincts;
-
-      if (uri === "instincts://global") {
-        instincts = readInstincts("global").filter((i) => i.scope === "global");
-      } else {
-        instincts = readInstincts(project.hash);
-      }
-
-      send({
-        jsonrpc: "2.0",
-        id,
-        result: {
-          contents: [
-            {
-              uri,
-              text: JSON.stringify(instincts, null, 2),
-              mimeType: "application/json",
-            },
-          ],
-        },
-      });
-      break;
+});
+function send(response) {
+    const json = JSON.stringify(response);
+    process.stdout.write(`Content-Length: ${Buffer.byteLength(json)}\r\n\r\n${json}`);
+}
+function handleMessage(message) {
+    const id = message.id;
+    const method = message.method;
+    const params = asRecord(message.params) ?? {};
+    switch (method) {
+        case "initialize":
+            send({
+                jsonrpc: "2.0",
+                id,
+                result: {
+                    protocolVersion: "2024-11-05",
+                    capabilities: {
+                        tools: { listChanged: false },
+                        resources: { subscribe: false, listChanged: false },
+                    },
+                    serverInfo: {
+                        name: PACKAGE_NAME,
+                        version: VERSION,
+                    },
+                },
+            });
+            break;
+        case "notifications/initialized":
+            break;
+        case "tools/list":
+            send({
+                jsonrpc: "2.0",
+                id,
+                result: { tools: getAllTools() },
+            });
+            break;
+        case "tools/call": {
+            const toolName = getString(params.name);
+            const toolArgs = asRecord(params.arguments) ?? {};
+            const result = handleTool(toolName, toolArgs);
+            send({ jsonrpc: "2.0", id, result });
+            break;
+        }
+        case "resources/list": {
+            const project = getProjectHash();
+            send({
+                jsonrpc: "2.0",
+                id,
+                result: {
+                    resources: [
+                        {
+                            uri: `instincts://project/${project.hash}`,
+                            name: `${project.name} instincts`,
+                            description: `Learned instincts for ${project.name}`,
+                            mimeType: "application/json",
+                        },
+                        {
+                            uri: "instincts://global",
+                            name: "Global instincts",
+                            description: "Cross-project instincts",
+                            mimeType: "application/json",
+                        },
+                    ],
+                },
+            });
+            break;
+        }
+        case "resources/read": {
+            const uri = getString(params.uri);
+            const project = getProjectHash();
+            const instincts = uri === "instincts://global"
+                ? readInstincts("global").filter((instinct) => instinct.scope === "global")
+                : readInstincts(project.hash);
+            send({
+                jsonrpc: "2.0",
+                id,
+                result: {
+                    contents: [
+                        {
+                            uri,
+                            text: JSON.stringify(instincts, null, 2),
+                            mimeType: "application/json",
+                        },
+                    ],
+                },
+            });
+            break;
+        }
+        default:
+            if (id !== undefined) {
+                send({
+                    jsonrpc: "2.0",
+                    id,
+                    error: { code: -32601, message: `Method not found: ${method}` },
+                });
+            }
     }
-
-    default:
-      if (id) {
-        send({
-          jsonrpc: "2.0",
-          id,
-          error: { code: -32601, message: `Method not found: ${method}` },
-        });
-      }
-  }
 }
-
-console.error(`continuous-improvement MCP server v${VERSION} started (mode: ${MODE})`);
+console.error(`${PACKAGE_NAME} MCP server v${VERSION} started (mode: ${MODE})`);