knit-mcp 0.6.0

package/dist/tools-VHBH4PPR.js

@@ -0,0 +1,2041 @@
+import {
+  appendSession,
+  getRecentSessions,
+  installAgentsForProject,
+  pruneSessionsByAge,
+  searchSessions,
+  sessionCount
+} from "./chunk-TH5QPD5E.js";
+import {
+  scanProject
+} from "./chunk-LW6NOFHF.js";
+import {
+  appendGlobalLearning,
+  buildGlobalLearning,
+  getRecentGlobalLearnings,
+  searchGlobalLearnings
+} from "./chunk-FEOG4WTP.js";
+import {
+  addEntry,
+  getFalsePositives,
+  getKBSummary,
+  queryByDomains,
+  recordCacheHit,
+  saveKnowledgeBase
+} from "./chunk-BAUQEFYY.js";
+import {
+  canonicalRepoRoot,
+  classificationMarkerPath,
+  knowledgebasePath,
+  learningsDir,
+  projectDataDir,
+  protocolConfigPath,
+  sessionsLogPath,
+  teamsPath,
+  worktreesRegistryPath
+} from "./chunk-YI37OAJ7.js";
+
+// src/mcp/handlers.ts
+import { writeFileSync as writeFileSync4, readFileSync as readFileSync4, readdirSync, existsSync as existsSync4 } from "fs";
+import { join as join2 } from "path";
+import { statSync as statSync2 } from "fs";
+
+// src/generators/workflow-protocol.ts
+function getWorkflowSection(phase, ctx = {}) {
+  const normalized = phase.toLowerCase().trim();
+  const fn = SECTIONS[normalized];
+  return fn ? fn(ctx) : null;
+}
+function listWorkflowSections() {
+  return [
+    { name: "overview", description: "What the protocol is and how to navigate it." },
+    { name: "tier", description: "The four tiers (Inquiry / Trivial / Standard / Complex) as a decision aid." },
+    { name: "phases", description: "The 6-phase protocol overview + routing per tier." },
+    { name: "research", description: "Phase 1 \u2014 gather context, name affected files + domains." },
+    { name: "ideate", description: "Phase 2 (Complex only) \u2014 propose \u22652 approaches with trade-offs." },
+    { name: "plan", description: "Phase 3 (Complex only) \u2014 file-level plan + plan mode rules." },
+    { name: "execute", description: "Phase 4 \u2014 write the code. TDD for features, repro-first for bugs." },
+    { name: "optimize", description: "Phase 5 \u2014 parallel review agents with role briefings." },
+    { name: "review", description: "Phase 6 \u2014 gates pass before commit." },
+    { name: "tdd", description: "RED \u2192 GREEN \u2192 REFACTOR cycle in detail." },
+    { name: "learn", description: "Quality-gated LEARN \u2014 when to record, when to skip." },
+    { name: "handoff", description: "Session handoff when context degrades." },
+    { name: "ship", description: "Commit format + PR flow + production checklist." },
+    { name: "tools", description: "Knit MCP tools reference \u2014 what each is for." }
+  ];
+}
+var SECTIONS = {
+  overview,
+  tier,
+  phases,
+  research,
+  ideate,
+  plan,
+  execute,
+  optimize,
+  review,
+  tdd,
+  learn,
+  handoff,
+  ship,
+  tools
+};
+function overview(_) {
+  return `# Engram workflow \u2014 overview
+
+This protocol is a decision aid. Read once, follow loosely, escalate when something doesn't fit. The principle: engram gives you data; you make the calls.
+
+**Navigation:** call \`knit_get_workflow({phase})\` with any of:
+- \`overview\` (this) \xB7 \`tier\` \xB7 \`phases\`
+- \`research\` \xB7 \`ideate\` \xB7 \`plan\` \xB7 \`execute\` \xB7 \`optimize\` \xB7 \`review\`
+- \`tdd\` \xB7 \`learn\` \xB7 \`handoff\` \xB7 \`ship\` \xB7 \`tools\`
+
+Start of every session: call \`knit_load_session\` first. It returns prior sessions, learnings, false positives, project knowledge in one round trip.
+
+When in doubt: under-classify. Easier to escalate mid-task than to downgrade.`;
+}
+function tier(_) {
+  return `# Tier classification \u2014 you decide, engram informs
+
+Four tiers. You read the user's message and decide. No regex, no auto-rules.
+
+| Tier | Smell | What you do |
+|------|-------|-------------|
+| **Inquiry** | Read-only. "What", "where", "audit", "explain", "status". | Just answer. No phases, no LEARN unless something durable surfaced. |
+| **Trivial** | Single obvious change (typo, version bump, one-line fix). | EXECUTE \u2192 verify \u2192 done. |
+| **Standard** | Bug fix, single-file feature, single domain. | RESEARCH \u2192 EXECUTE \u2192 OPTIMIZE \u2192 REVIEW. |
+| **Complex** | Cross-domain, touches types/auth/money, high-fanout file, new feature with unclear shape, **or a single user request that will span more than one commit / PR**. | Full 6 phases. Auto-enter plan mode on RESEARCH. |
+
+Signals to consult before classifying (call any of these):
+- \`knit_find_fanout\` \u2014 is the file central?
+- \`knit_search_learnings\` \u2014 have we done this before?
+- \`knit_query_dependents\` \u2014 what depends on what I'd touch?
+- \`knit_search_sessions\` \u2014 did a past session tackle something similar?
+
+**Multi-commit arcs.** If a single user request will span more than one commit or PR, the *arc* is Complex even if individual commits inside it are Standard or Trivial. Enter plan mode at the start of the arc.`;
+}
+function phases(_) {
+  return `# The 6-phase protocol
+
+\`\`\`
+RESEARCH \u2192 IDEATE \u2192 PLAN \u2192 EXECUTE \u2192 OPTIMIZE \u2192 REVIEW
+    \u2191                                              |
+    \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 LEARN \u2190\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+\`\`\`
+
+Routing by tier:
+
+| Tier | Phases |
+|------|--------|
+| Inquiry | (none \u2014 just answer) |
+| Trivial | EXECUTE \u2192 verify |
+| Standard | RESEARCH \u2192 EXECUTE \u2192 OPTIMIZE \u2192 REVIEW |
+| Complex | RESEARCH \u2192 IDEATE \u2192 PLAN \u2192 EXECUTE \u2192 OPTIMIZE \u2192 REVIEW |
+
+Each phase has one quality gate. Don't move on until it passes. Call \`knit_get_workflow({phase})\` for the depth on any phase.`;
+}
+function research(_) {
+  return `# RESEARCH (Standard + Complex)
+
+Goal: understand what you're touching before you touch it.
+
+**Standard tasks:** read the affected files directly. Check cross-domain ripple via \`knit_query_dependents\`. Pull relevant past sessions via \`knit_search_sessions\` if the area has history.
+
+**Complex tasks:** spawn \`code-explorer\` agents per affected domain in parallel. Each scout reports complexity + risks. Use \`knit_find_fanout\` to spot universal-contract files.
+
+**Gate:** can you name every file and domain that will be touched? If no, read more. If yes, proceed.
+
+**Avoid:** speculative file reads. Avoid reading every file in the import graph "just in case." Read what the change demands, then stop.`;
+}
+function ideate(_) {
+  return `# IDEATE (Complex only)
+
+Goal: surface at least 2 approaches with trade-offs before committing to one.
+
+1. Launch domain heads in parallel. Each head proposes an approach for its domain + risks.
+2. Synthesize into 2+ distinct options. Make them genuinely different \u2014 same approach with two coats of paint isn't IDEATE.
+3. Present options with trade-offs (complexity / risk / reversibility / scope).
+
+**Gate:** user picks an approach.
+
+For Standard, skip IDEATE \u2014 pick the obvious approach and state it out loud. User can override.`;
+}
+function plan(_) {
+  return `# PLAN (Complex only \u2014 auto plan mode)
+
+**Plan mode auto-fires by phase, not by user keyword.** You enter plan mode when you decide to enter RESEARCH or PLAN. The user doesn't need to say "plan."
+
+- **Inquiry / Trivial** \u2192 never plan mode.
+- **Standard** \u2192 rarely; only if RESEARCH reveals unexpected complexity.
+- **Complex** \u2192 plan mode opens at the start of RESEARCH. Stay in plan mode through IDEATE and PLAN. User's approval is required to **exit** plan mode (before EXECUTE).
+
+What to produce in PLAN:
+1. File-level: exact files to create / modify / delete.
+2. Ordering: which domain goes first, what's sequential vs parallel.
+3. Test plan: how to verify the work end-to-end.
+4. Risk note: what could break + rollback path.
+
+**Gate:** user says "go" / "approved" / "do it." After approval, exit plan mode and execute.`;
+}
+function execute(ctx) {
+  const buildHint = ctx.buildCommands?.typecheck ? `
+
+Milestone check (every ~5 edits): run \`${ctx.buildCommands.typecheck}\` \u2014 still green?` : "";
+  return `# EXECUTE
+
+Follow the approved plan strictly. No scope creep \u2014 surprises go into LEARN, not into the diff.
+
+**New features:** TDD when applicable (see \`knit_get_workflow({phase: "tdd"})\`). Failing test \u2192 minimum impl \u2192 refactor.
+
+**Bug fixes:** reproduce first. Write the failing test that captures the bug. Fix. Run full suite. No regressions.
+
+**Cross-domain changes:** follow the cross-domain ripple rules from RESEARCH. If a type contract changes, all downstream domains get notified.${buildHint}
+
+**Avoid:**
+- Adding error handling for cases that can't happen.
+- Adding comments that explain WHAT (well-named code already does that).
+- Backwards-compat shims when the code can just change.
+- Half-finished implementations. Either it works end-to-end or it doesn't ship.`;
+}
+function optimize(_) {
+  return `# OPTIMIZE (Standard + Complex)
+
+Spawn review agents in parallel. Standard: 1\u20132 agents. Complex: as many as affected domains.
+
+**Role briefing replaces frozen Domain Context Objects.** Each spawned agent gets a short briefing, not a 3K-token DCO. The agent has MCP access and pulls depth on demand.
+
+Briefing template:
+> You are a {role} for files X, Y, Z. Task: {one sentence}.
+> Project brain available: \`knit_query_dependents\`, \`knit_get_false_positives\`, \`knit_search_learnings\`, \`knit_search_sessions\`. Call them if you need depth.
+> Report findings as: severity / file / line / issue / suggestion.
+
+Before passing false positives \u2014 filter to those whose file paths overlap the agent's task. Don't dump all entries; pass the 3 that apply.
+
+Findings sorted CRITICAL / HIGH / MEDIUM / LOW.
+
+**Gate:** zero CRITICAL findings. All HIGH addressed (fixed or explicitly deferred with reason).`;
+}
+function review(ctx) {
+  const gates = [];
+  if (ctx.buildCommands?.typecheck) gates.push(`- \`${ctx.buildCommands.typecheck}\``);
+  if (ctx.buildCommands?.lint) gates.push(`- \`${ctx.buildCommands.lint}\``);
+  if (ctx.buildCommands?.test) gates.push(`- \`${ctx.buildCommands.test}\``);
+  if (ctx.buildCommands?.build) gates.push(`- \`${ctx.buildCommands.build}\``);
+  const gatesBlock = gates.length > 0 ? `
+
+Gates for this project:
+${gates.join("\n")}` : "";
+  return `# REVIEW (Standard + Complex)
+
+**Layer 1 \u2014 automated gates.** typecheck + lint + test + build all green. If anything fails: fix, re-run.${gatesBlock}
+
+**Layer 2 \u2014 functional verification.** If browser QA tools are available and the task touches UI or API, navigate the change end-to-end. Take screenshots as proof. If unavailable, note "browser verification skipped" and continue.
+
+**Layer 3 \u2014 ship readiness (Complex + PR only):**
+- Plan-vs-done diff: anything missed?
+- Regression check: did existing functionality break?
+- Confidence signal: "ready to ship" only when ALL layers pass.`;
+}
+function tdd(_) {
+  return `# TDD workflow
+
+**New feature:**
+1. RED \u2014 write a test that describes the expected behavior. Run tests. New test MUST fail. If it passes, it isn't testing anything new.
+2. GREEN \u2014 write the simplest code that makes the test pass. No extras, no optimization, no cleanup.
+3. REFACTOR \u2014 clean up. Extract helpers, improve naming, kill duplication. Run tests after EVERY change.
+4. VERIFY COVERAGE \u2014 does the new code have tests? Are edge cases covered?
+
+**Bug fix:**
+1. REPRODUCE \u2014 find the exact input that triggers the bug.
+2. WRITE FAILING TEST \u2014 captures the bug.
+3. FIX \u2014 minimum change to make the test pass.
+4. VERIFY \u2014 full test suite, no regressions.
+
+**When NOT to TDD:**
+- Trivial-tier work (typo, config, version bump).
+- Doc updates.
+- Behavior-preserving refactors (run existing tests).`;
+}
+function learn(_) {
+  return `# LEARN \u2014 opportunistic, not mandatory
+
+**Default: don't record a learning.** Most tasks produce no durable insight.
+
+Record one only when **all** are true:
+- A non-obvious fact emerged (the kind future-you would forget by next month).
+- The lesson generalizes to a hypothetical future task.
+- You can name a specific tag where someone would search for it.
+
+Quality check before \`knit_record_learning\`:
+> If session N+1 searched for this tag, would this entry save them time?
+
+If no \u2014 don't write. Manufactured learnings hurt the hit rate by burying real ones.
+
+If a task finishes with no learning recorded \u2014 that's correct, not a failure.
+
+**Sessions vs learnings.** Two different tools:
+- \`knit_record_learning\` \u2014 durable, reusable insight (Stripe webhook signature rules).
+- \`knit_save_session_summary\` \u2014 what this session accomplished (refactored auth middleware). Opt-in, narrative.
+
+Use both. They serve different searches.`;
+}
+function handoff(_) {
+  return `# Session handoff
+
+When context degrades \u2014 circular debugging, repeated failures, post-compaction confusion \u2014 call \`knit_save_handoff\` with:
+
+- **goal** \u2014 what we're trying to accomplish
+- **current_state** \u2014 where we are right now
+- **files_in_flight** \u2014 what's been modified
+- **what_changed** \u2014 commits and edits since session start
+- **failed_attempts** *(mandatory)* \u2014 what was tried and why it failed. This is the load-bearing field that prevents the next session from repeating mistakes.
+- **decisions_made** \u2014 choices and their reasoning
+- **next_step** \u2014 the ONE most important thing to do next
+
+Then tell the user to start a fresh session. The next session's \`knit_load_session\` will surface the handoff first.
+
+**Never auto-handoff.** Try compacting context first. Handoff is for genuinely stuck.`;
+}
+function ship(ctx) {
+  const gates = [];
+  if (ctx.buildCommands?.typecheck) gates.push(ctx.buildCommands.typecheck);
+  if (ctx.buildCommands?.lint) gates.push(ctx.buildCommands.lint);
+  if (ctx.buildCommands?.test) gates.push(ctx.buildCommands.test);
+  if (ctx.buildCommands?.build) gates.push(ctx.buildCommands.build);
+  const gatesLine = gates.length > 0 ? `
+
+Pre-commit (all must pass): \`${gates.join(" && ")}\`` : "";
+  return `# Commit & ship${gatesLine}
+
+**Commit format:**
+\`\`\`
+<type>: <description>
+
+<optional body \u2014 what and why, not how>
+\`\`\`
+Types: \`feat\`, \`fix\`, \`refactor\`, \`docs\`, \`test\`, \`chore\`, \`perf\`.
+
+**PR flow:**
+1. Atomic commits \u2014 one concern per commit.
+2. Push to feature branch.
+3. PR with 1\u20133 bullet summary + test plan.
+4. Squash merge to main, delete branch.
+
+**Production checklist** (only when shipping to prod, not every PR):
+- No secrets in code or git history (\`git log -p --all -S "sk-"\`).
+- \`.env\` in \`.gitignore\`; \`.env.example\` exists with placeholders.
+- All user input validated at system boundaries.
+- Build succeeds clean: \`rm -rf node_modules && npm ci && npm run build\`.
+- Auth on protected routes; rate limiting on auth/submission endpoints.
+- Verify production loads post-deploy. Check error monitoring.`;
+}
+function tools(_) {
+  return `# Knit MCP tools \u2014 reference
+
+**Read the brain** (cheap, instant, no side effects):
+| Tool | Use when |
+|------|----------|
+| \`knit_load_session\` | First call every session. Returns last sessions, handoff, learnings, false positives. |
+| \`knit_query_imports\` | Before editing \u2014 what depends on this file? |
+| \`knit_query_dependents\` | What does this file need to work? |
+| \`knit_query_exports\` | Find a function without opening the file. |
+| \`knit_query_tests\` | Is this tested? Or: list all untested files. |
+| \`knit_find_fanout\` | High-risk files \u2014 change carefully. |
+| \`knit_search_learnings\` | Did we solve this before? |
+| \`knit_search_sessions\` | Did a past session work in this area? |
+| \`knit_get_false_positives\` | Filter known non-issues out of review prompts. |
+| \`knit_brain_status\` | Brain health + hit-rate + token-accounting. |
+| \`knit_get_workflow\` | Fetch protocol depth for a specific phase. |
+
+**Update the brain** (only when there's real signal):
+| Tool | Use when |
+|------|----------|
+| \`knit_classify_task\` | At task start. Returns tier + phases. |
+| \`knit_build_context\` | Get cross-domain ripple + pitfalls for the current task. |
+| \`knit_record_learning\` | A non-obvious, reusable insight surfaced (pass the quality check first). |
+| \`knit_record_false_positive\` | Review agent flagged a non-issue. |
+| \`knit_save_session_summary\` | Session accomplished something a future session would search for. |
+| \`knit_save_handoff\` | Context degrading \u2014 save state for next session. |
+| \`knit_setup_project\` | First-time project setup for non-code domains (legal, research, marketing). |
+
+**Team orchestration** (for parallel review boards):
+| Tool | Use when |
+|------|----------|
+| \`knit_get_teams\` | Get auto-detected or custom teams. |
+| \`knit_define_team\` | Create a custom team. |
+| \`knit_start_team_review\` | Start a parallel review board. |
+| \`knit_post_team_findings\` | Each team posts to the shared board. |
+| \`knit_get_board_summary\` | Cross-team findings, severity-gated. |`;
+}
+
+// src/engine/worktrees.ts
+import { execSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from "fs";
+import { dirname, basename, resolve, join } from "path";
+var EMPTY_REGISTRY = { version: 1, worktrees: [] };
+function spawnWorktree(rootPath, teamName, taskDescription) {
+  const repoRoot = canonicalRepoRoot(rootPath);
+  const slug = slugify(teamName);
+  const ts = Date.now();
+  const branch = `engram/team-${slug}-${ts}`;
+  const worktreePath = resolve(dirname(repoRoot), `${basename(repoRoot)}-knit-${slug}-${ts}`);
+  if (existsSync(worktreePath)) {
+    throw new Error(`Worktree path already exists: ${worktreePath}`);
+  }
+  const registry = loadRegistry(rootPath);
+  const existing = registry.worktrees.find(
+    (w) => w.teamSlug === slug && w.status === "active"
+  );
+  if (existing) {
+    throw new Error(
+      `Team "${teamName}" already has an active worktree at ${existing.path}. Finalize it before spawning a new one.`
+    );
+  }
+  try {
+    execSync(
+      `git worktree add -b ${shellQuote(branch)} ${shellQuote(worktreePath)}`,
+      { cwd: repoRoot, stdio: "pipe" }
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`git worktree add failed: ${msg}`);
+  }
+  const record = {
+    teamName,
+    teamSlug: slug,
+    path: worktreePath,
+    branch,
+    taskDescription,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "active"
+  };
+  registry.worktrees.push(record);
+  saveRegistry(rootPath, registry);
+  return record;
+}
+function listWorktrees(rootPath, includeFinalized = false) {
+  const registry = loadRegistry(rootPath);
+  for (const wt of registry.worktrees) {
+    if (wt.status === "active" && !existsSync(wt.path)) {
+      wt.status = "discarded";
+    }
+  }
+  saveRegistry(rootPath, registry);
+  return includeFinalized ? registry.worktrees : registry.worktrees.filter((w) => w.status === "active");
+}
+function finalizeWorktree(rootPath, teamSlugOrName, action) {
+  const registry = loadRegistry(rootPath);
+  const slug = slugify(teamSlugOrName);
+  const record = registry.worktrees.find(
+    (w) => w.status === "active" && (w.teamSlug === slug || w.teamName === teamSlugOrName)
+  );
+  if (!record) {
+    throw new Error(`No active worktree found for team "${teamSlugOrName}".`);
+  }
+  const repoRoot = canonicalRepoRoot(rootPath);
+  if (action === "discard") {
+    try {
+      execSync(`git worktree remove --force ${shellQuote(record.path)}`, { cwd: repoRoot, stdio: "pipe" });
+    } catch {
+    }
+    try {
+      execSync(`git branch -D ${shellQuote(record.branch)}`, { cwd: repoRoot, stdio: "pipe" });
+    } catch {
+    }
+    record.status = "discarded";
+    saveRegistry(rootPath, registry);
+    return { status: "discarded", worktree: record };
+  }
+  try {
+    execSync(`git merge --no-ff ${shellQuote(record.branch)}`, { cwd: repoRoot, stdio: "pipe" });
+  } catch (err) {
+    let conflictFiles = [];
+    try {
+      const out = execSync("git diff --name-only --diff-filter=U", { cwd: repoRoot, encoding: "utf-8" });
+      conflictFiles = out.split("\n").map((s) => s.trim()).filter(Boolean);
+    } catch {
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      status: "conflict",
+      worktree: record,
+      conflictFiles,
+      message: `Merge conflict. Resolve in ${repoRoot}, then call knit_finalize_worktree again with action='merge' to retry, or 'discard' to throw away. ${msg}`
+    };
+  }
+  try {
+    execSync(`git worktree remove ${shellQuote(record.path)}`, { cwd: repoRoot, stdio: "pipe" });
+  } catch {
+  }
+  try {
+    execSync(`git branch -d ${shellQuote(record.branch)}`, { cwd: repoRoot, stdio: "pipe" });
+  } catch {
+  }
+  record.status = "merged";
+  saveRegistry(rootPath, registry);
+  return { status: "merged", worktree: record };
+}
+function loadRegistry(rootPath) {
+  const path = worktreesRegistryPath(rootPath);
+  if (!existsSync(path)) return { ...EMPTY_REGISTRY, worktrees: [] };
+  try {
+    const data = JSON.parse(readFileSync(path, "utf-8"));
+    if (data && data.version === 1 && Array.isArray(data.worktrees)) {
+      return data;
+    }
+  } catch {
+  }
+  return { ...EMPTY_REGISTRY, worktrees: [] };
+}
+function saveRegistry(rootPath, registry) {
+  const path = worktreesRegistryPath(rootPath);
+  mkdirSync(projectDataDir(rootPath), { recursive: true });
+  const tmp = `${path}.tmp.${process.pid}.${Date.now()}`;
+  writeFileSync(tmp, JSON.stringify(registry, null, 2), "utf-8");
+  renameSync(tmp, path);
+}
+function slugify(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function shellQuote(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+
+// src/engine/reflect.ts
+function reflect(kb) {
+  const patterns = [];
+  const localEntries = kb.entries.map((e) => ({ ...e, _origin: "local" }));
+  let entries = localEntries;
+  if (kb.entries.length < 3) {
+    try {
+      const globals = getRecentGlobalLearnings(200);
+      const globalEntries = globals.map((g) => globalToKBEntry(g));
+      entries = [...localEntries, ...globalEntries];
+    } catch {
+      entries = localEntries;
+    }
+  }
+  if (entries.length < 3) return patterns;
+  const successes = entries.filter((e) => e.outcome === "success");
+  const successTagCounts = countTags(successes);
+  for (const [tag, count] of Object.entries(successTagCounts)) {
+    if (count >= 3) {
+      const relevant = successes.filter((e) => e.tags.includes(tag));
+      patterns.push({
+        id: `success-${tag}`,
+        type: "success-pattern",
+        description: `Consistent success in ${tag} domain (${count} successes)`,
+        confidence: Math.min(count * 2, 10),
+        evidence: relevant.slice(-3).map((e) => e.summary),
+        domains: [tag],
+        lastSeen: relevant[relevant.length - 1].date,
+        occurrences: count,
+        source: classifyOrigin(relevant)
+      });
+    }
+  }
+  const failures = entries.filter((e) => e.outcome === "failure");
+  const failureTagCounts = countTags(failures);
+  for (const [tag, count] of Object.entries(failureTagCounts)) {
+    if (count >= 2) {
+      const relevant = failures.filter((e) => e.tags.includes(tag));
+      patterns.push({
+        id: `failure-${tag}`,
+        type: "failure-pattern",
+        description: `Repeated failures in ${tag} (${count} times). Common lesson: ${relevant[relevant.length - 1].lesson}`,
+        confidence: Math.min(count * 3, 10),
+        evidence: relevant.map((e) => e.summary),
+        domains: [tag],
+        lastSeen: relevant[relevant.length - 1].date,
+        occurrences: count,
+        source: classifyOrigin(relevant)
+      });
+    }
+  }
+  const tagPairs = findTagPairs(entries);
+  for (const [pair, count] of tagPairs) {
+    if (count >= 3) {
+      const [tag1, tag2] = pair.split("+");
+      const supporting = entries.filter((e) => e.tags.includes(tag1) && e.tags.includes(tag2));
+      patterns.push({
+        id: `cooccur-${pair}`,
+        type: "co-occurrence",
+        description: `${tag1} and ${tag2} frequently appear together (${count} times) \u2014 changes in one likely affect the other`,
+        confidence: Math.min(count * 2, 10),
+        evidence: [],
+        domains: [tag1, tag2],
+        lastSeen: entries[entries.length - 1].date,
+        occurrences: count,
+        source: classifyOrigin(supporting)
+      });
+    }
+  }
+  const accessed = entries.filter((e) => e.accessCount >= 3);
+  for (const entry of accessed) {
+    patterns.push({
+      id: `insight-${entry.id}`,
+      type: "domain-insight",
+      description: `High-value insight (accessed ${entry.accessCount}x): ${entry.lesson}`,
+      confidence: Math.min(entry.accessCount, 10),
+      evidence: [entry.summary],
+      domains: entry.tags,
+      lastSeen: entry.lastAccessed || entry.date,
+      occurrences: entry.accessCount,
+      source: entry._origin
+    });
+  }
+  return patterns.sort((a, b) => b.confidence - a.confidence);
+}
+function globalToKBEntry(g) {
+  return {
+    id: `global:${g.id}`,
+    date: g.date,
+    summary: g.summary,
+    domains: g.tags,
+    approach: "",
+    outcome: g.outcome ?? "success",
+    lesson: g.lesson,
+    tags: g.tags,
+    accessCount: 0,
+    lastAccessed: null,
+    _origin: "global"
+  };
+}
+function classifyOrigin(supporting) {
+  let local = false;
+  let global = false;
+  for (const e of supporting) {
+    if (e._origin === "local") local = true;
+    else global = true;
+    if (local && global) return "mixed";
+  }
+  if (local && global) return "mixed";
+  return local ? "local" : "global";
+}
+function getAdaptiveSuggestions(kb, taskDomains) {
+  const suggestions = [];
+  const patterns = reflect(kb);
+  for (const pattern of patterns) {
+    const overlap = pattern.domains.some(
+      (d) => taskDomains.some((td) => td.toLowerCase().includes(d.replace("#", "").toLowerCase()) || d.replace("#", "").toLowerCase().includes(td.toLowerCase()))
+    );
+    if (!overlap) continue;
+    if (pattern.type === "failure-pattern") {
+      suggestions.push({
+        trigger: `Working in ${pattern.domains.join(", ")} domain`,
+        action: `Be careful \u2014 this area has failed ${pattern.occurrences} times before`,
+        reason: pattern.description,
+        confidence: pattern.confidence
+      });
+    }
+    if (pattern.type === "co-occurrence") {
+      suggestions.push({
+        trigger: `Touching ${pattern.domains[0]}`,
+        action: `Also check ${pattern.domains[1]} \u2014 they always change together`,
+        reason: `${pattern.occurrences} past changes affected both`,
+        confidence: pattern.confidence
+      });
+    }
+    if (pattern.type === "domain-insight" && pattern.confidence >= 5) {
+      suggestions.push({
+        trigger: `Working in ${pattern.domains.join(", ")}`,
+        action: pattern.description.replace(/^High-value insight.*: /, ""),
+        reason: `Validated ${pattern.occurrences} times across sessions`,
+        confidence: pattern.confidence
+      });
+    }
+  }
+  return suggestions.slice(0, 5);
+}
+function countTags(entries) {
+  const counts = {};
+  for (const entry of entries) {
+    for (const tag of entry.tags) {
+      counts[tag] = (counts[tag] || 0) + 1;
+    }
+  }
+  return counts;
+}
+function findTagPairs(entries) {
+  const pairs = {};
+  for (const entry of entries) {
+    const tags = entry.tags.filter((t) => t.startsWith("#"));
+    for (let i = 0; i < tags.length; i++) {
+      for (let j = i + 1; j < tags.length; j++) {
+        const pair = [tags[i], tags[j]].sort().join("+");
+        pairs[pair] = (pairs[pair] || 0) + 1;
+      }
+    }
+  }
+  return Object.entries(pairs).sort((a, b) => b[1] - a[1]);
+}
+
+// src/engine/teams.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, statSync, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+function buildDefaultTeams(domains) {
+  return domains.map((domain) => domainToTeam(domain));
+}
+function domainToTeam(domain) {
+  const teamMap = {
+    "UI": {
+      role: "Frontend Engineering",
+      focus: "User interface, components, accessibility, responsive design, state management",
+      reviewChecklist: [
+        "Components render correctly with all props",
+        "Accessibility: keyboard navigation, screen readers, ARIA labels",
+        "Responsive: works at 320px, 768px, 1024px, 1440px",
+        "Loading and error states handled",
+        "No layout shifts from dynamic content",
+        "Design system compliance"
+      ]
+    },
+    "API & Security": {
+      role: "Backend & Security Engineering",
+      focus: "API endpoints, authentication, authorization, input validation, rate limiting",
+      reviewChecklist: [
+        "All endpoints validate input (Zod/Joi/etc)",
+        "Authentication required on protected routes",
+        "Authorization checks (user can only access own resources)",
+        "Rate limiting on auth and submission endpoints",
+        "No SQL injection (parameterized queries)",
+        "No XSS (sanitized output)",
+        "Error responses don't leak internal details",
+        "CORS configured correctly"
+      ]
+    },
+    "Business Logic": {
+      role: "Core Logic Engineering",
+      focus: "Types, validations, calculations, data transformations, business rules",
+      reviewChecklist: [
+        "Type contracts are correct and complete",
+        "Calculations produce correct results for edge cases",
+        "Validation schemas match API expectations",
+        "No silent failures in data transformations",
+        "Immutable data patterns where applicable"
+      ]
+    },
+    "Infrastructure": {
+      role: "Infrastructure & Platform Engineering",
+      focus: "Database, email, webhooks, middleware, external integrations, deployment",
+      reviewChecklist: [
+        "Database migrations are safe and reversible",
+        "Queries are efficient (no N+1, proper indexes)",
+        "External API calls have timeouts and retries",
+        "Email/webhook payloads are correct",
+        "Environment variables documented",
+        "Docker/deployment configs are secure"
+      ]
+    },
+    "Quality Assurance": {
+      role: "QA & Testing",
+      focus: "Test coverage, test quality, build stability, regression detection",
+      reviewChecklist: [
+        "New code has tests (80%+ coverage target)",
+        "Tests are deterministic (no flaky tests)",
+        "Edge cases covered (empty, null, large inputs)",
+        "Integration tests for critical paths",
+        "Build passes in clean environment"
+      ]
+    }
+  };
+  const defaults = teamMap[domain.name] || {
+    role: `${domain.name} Engineering`,
+    focus: domain.description,
+    reviewChecklist: ["Code quality review", "Test coverage", "Error handling"]
+  };
+  return {
+    name: domain.name,
+    role: defaults.role || domain.name,
+    focus: defaults.focus || domain.description,
+    agents: domain.agents,
+    filePatterns: domain.filePatterns,
+    reviewChecklist: defaults.reviewChecklist || []
+  };
+}
+function generateTeamPrompt(team, taskDescription, domainContext, otherTeamFindings) {
+  let prompt = `You are the **${team.name} Team** (${team.role}).
+
+**Your focus:** ${team.focus}
+
+**Task:** ${taskDescription}
+
+**Files in your domain:** ${team.filePatterns.join(", ")}
+
+**Your review checklist:**
+${team.reviewChecklist.map((item) => `- [ ] ${item}`).join("\n")}
+
+**Domain Context:**
+${JSON.stringify(domainContext, null, 2)}
+`;
+  if (otherTeamFindings.length > 0) {
+    prompt += `
+**Findings from other teams (react to these if they affect your domain):**
+`;
+    for (const finding of otherTeamFindings) {
+      prompt += `- [${finding.severity}] ${finding.team}: ${finding.description} (${finding.file})
+`;
+    }
+  }
+  prompt += `
+**Report format:** For each finding, provide:
+- Severity: CRITICAL / HIGH / MEDIUM / LOW
+- File: which file
+- Description: what's wrong
+- Recommendation: specific fix
+
+Only report findings you've VERIFIED against the actual code. Do not hallucinate issues.`;
+  return prompt;
+}
+var boards = /* @__PURE__ */ new Map();
+var latestBoardId = null;
+function startTeamBoard(taskId, taskDescription, teams) {
+  const board = {
+    taskId,
+    taskDescription,
+    teams,
+    findings: [],
+    status: Object.fromEntries(teams.map((t) => [t, "pending"])),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  boards.set(taskId, board);
+  latestBoardId = taskId;
+  if (boards.size > 10) {
+    const oldest = boards.keys().next().value;
+    if (oldest) boards.delete(oldest);
+  }
+  return board;
+}
+function getTeamBoard(taskId) {
+  if (taskId) return boards.get(taskId) || null;
+  if (latestBoardId) return boards.get(latestBoardId) || null;
+  return null;
+}
+function markTeamWorking(teamName, taskId) {
+  const board = getTeamBoard(taskId);
+  if (board) board.status[teamName] = "working";
+}
+function postTeamFindings(teamName, findings, taskId) {
+  const board = getTeamBoard(taskId);
+  if (!board) return;
+  board.findings.push(...findings);
+  board.status[teamName] = "done";
+}
+function getOtherTeamFindings(excludeTeam, taskId) {
+  const board = getTeamBoard(taskId);
+  if (!board) return [];
+  return board.findings.filter((f) => f.team !== excludeTeam);
+}
+function allTeamsDone(taskId) {
+  const board = getTeamBoard(taskId);
+  if (!board) return false;
+  return Object.values(board.status).every((s) => s === "done");
+}
+function getBoardSummary(taskId) {
+  const board = getTeamBoard(taskId);
+  if (!board) {
+    return { total: 0, critical: 0, high: 0, medium: 0, low: 0, byTeam: {}, allDone: false };
+  }
+  const findings = board.findings;
+  const byTeam = {};
+  for (const f of findings) {
+    byTeam[f.team] = (byTeam[f.team] || 0) + 1;
+  }
+  return {
+    total: findings.length,
+    critical: findings.filter((f) => f.severity === "CRITICAL").length,
+    high: findings.filter((f) => f.severity === "HIGH").length,
+    medium: findings.filter((f) => f.severity === "MEDIUM").length,
+    low: findings.filter((f) => f.severity === "LOW").length,
+    byTeam,
+    allDone: allTeamsDone(taskId)
+  };
+}
+function loadCustomTeams(rootPath) {
+  const teamsFile = teamsPath(rootPath);
+  if (!existsSync2(teamsFile)) return null;
+  try {
+    const stat = statSync(teamsFile);
+    if (stat.size > 10 * 1024 * 1024) return null;
+    const teams = JSON.parse(readFileSync2(teamsFile, "utf-8"));
+    if (!Array.isArray(teams)) return null;
+    return teams;
+  } catch {
+    return null;
+  }
+}
+function saveCustomTeams(rootPath, teams) {
+  const teamsFile = teamsPath(rootPath);
+  const dir = dirname2(teamsFile);
+  if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
+  writeFileSync2(teamsFile, JSON.stringify(teams, null, 2), "utf-8");
+}
+
+// src/engine/protocol-guard.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3 } from "path";
+var VALID_LEVELS = ["off", "warn", "block"];
+function isValidStrictness(level) {
+  return VALID_LEVELS.includes(level);
+}
+function readProtocolConfig(rootPath) {
+  const path = protocolConfigPath(rootPath);
+  if (!existsSync3(path)) {
+    return { level: "warn", updatedAt: (/* @__PURE__ */ new Date(0)).toISOString() };
+  }
+  try {
+    const parsed = JSON.parse(readFileSync3(path, "utf-8"));
+    const level = parsed.level && isValidStrictness(parsed.level) ? parsed.level : "warn";
+    const updatedAt = typeof parsed.updatedAt === "string" ? parsed.updatedAt : (/* @__PURE__ */ new Date(0)).toISOString();
+    return { level, updatedAt };
+  } catch {
+    return { level: "warn", updatedAt: (/* @__PURE__ */ new Date(0)).toISOString() };
+  }
+}
+function writeProtocolConfig(rootPath, level) {
+  const path = protocolConfigPath(rootPath);
+  mkdirSync3(dirname3(path), { recursive: true });
+  const config = { level, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  writeFileSync3(path, JSON.stringify(config, null, 2), "utf-8");
+  return config;
+}
+function writeClassificationMarker(rootPath, marker) {
+  const path = classificationMarkerPath(rootPath);
+  mkdirSync3(dirname3(path), { recursive: true });
+  writeFileSync3(path, JSON.stringify(marker, null, 2), "utf-8");
+}
+
+// src/mcp/handlers.ts
+function detectDomainsFromFiles(files) {
+  const domains = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    if (file.includes("api/") || file.includes("auth")) domains.add("API & Security");
+    if (file.includes("components/") || file.includes(".tsx")) domains.add("UI");
+    if (file.includes("lib/") || file.includes("utils") || file.includes("types")) domains.add("Business Logic");
+    if (file.includes("db") || file.includes("email") || file.includes("middleware")) domains.add("Infrastructure");
+    if (file.includes("test")) domains.add("QA");
+  }
+  return domains;
+}
+var VALID_SEVERITIES = /* @__PURE__ */ new Set(["CRITICAL", "HIGH", "MEDIUM", "LOW"]);
+function handleQueryImports(params, brain) {
+  const filePath = params.file_path;
+  const importers = brain.reverseDeps[filePath] || [];
+  const risk = importers.length >= 5 ? "HIGH" : importers.length >= 3 ? "MEDIUM" : "LOW";
+  return JSON.stringify({
+    file: filePath,
+    imported_by: importers,
+    count: importers.length,
+    risk,
+    instruction: importers.length >= 3 ? `This file has ${importers.length} dependents. Changes here will ripple. Update/test these files after editing: ${importers.slice(0, 5).join(", ")}` : "Low risk \u2014 few dependents."
+  });
+}
+function handleQueryDependents(params, brain) {
+  const filePath = params.file_path;
+  const deps = brain.knowledge.importGraph[filePath] || [];
+  return JSON.stringify({ file: filePath, depends_on: deps, count: deps.length });
+}
+function handleQueryExports(params, brain) {
+  const filePath = params.file_path;
+  const exports = brain.knowledge.exports[filePath] || [];
+  return JSON.stringify({
+    file: filePath,
+    exports: exports.map((e) => ({ name: e.name, kind: e.kind, line: e.line })),
+    count: exports.length
+  });
+}
+function handleQueryTests(params, brain) {
+  if (params.filter === "untested") {
+    const untested = brain.knowledge.testMap.untested;
+    return JSON.stringify({
+      untested_files: untested,
+      count: untested.length,
+      instruction: untested.length > 0 ? `${untested.length} files have no tests. Write tests for these before shipping.` : "All files have test coverage."
+    });
+  }
+  if (params.file_path) {
+    const tests = brain.knowledge.testMap.tested[params.file_path] || [];
+    return JSON.stringify({
+      file: params.file_path,
+      tested_by: tests,
+      has_tests: tests.length > 0,
+      instruction: tests.length > 0 ? `Tested by: ${tests.join(", ")}` : "NO TESTS. Write tests for this file before making changes."
+    });
+  }
+  return JSON.stringify({
+    tested_files: Object.keys(brain.knowledge.testMap.tested).length,
+    untested_files: brain.knowledge.testMap.untested.length,
+    test_files: brain.knowledge.testMap.testFiles.length
+  });
+}
+function handleFindFanout(params, brain) {
+  const minImporters = parseInt(params.min_importers || "3") || 3;
+  const fanout = [];
+  for (const [file, importers] of Object.entries(brain.reverseDeps)) {
+    if (importers.length >= minImporters) {
+      fanout.push({ file, importers: importers.length, imported_by: importers });
+    }
+  }
+  fanout.sort((a, b) => b.importers - a.importers);
+  return JSON.stringify({ high_fanout_files: fanout, count: fanout.length });
+}
+function handleSearchLearnings(params, brain) {
+  const domains = (params.domains || "").split(",").map((d) => d.trim()).filter(Boolean);
+  if (domains.length === 0) return JSON.stringify({ error: "domains parameter is required", query: [], results: [], count: 0 });
+  const results = queryByDomains(brain.knowledgeBase, domains);
+  if (results.length > 0) recordCacheHit(brain.knowledgeBase);
+  const hasFailures = results.some((r) => r.outcome === "failure");
+  return JSON.stringify({
+    query: domains,
+    results: results.map((r) => ({
+      summary: r.summary,
+      lesson: r.lesson,
+      outcome: r.outcome,
+      date: r.date,
+      tags: r.tags,
+      access_count: r.accessCount
+    })),
+    count: results.length,
+    instruction: results.length > 0 ? hasFailures ? `Found ${results.length} past learnings including FAILURES. Read the lessons carefully \u2014 avoid repeating past mistakes.` : `Found ${results.length} past learnings. Apply these lessons to your current task.` : "No past learnings for these domains. This is new territory \u2014 be thorough and record what you learn."
+  });
+}
+function handleGetFalsePositives(_params, brain) {
+  const fps = getFalsePositives(brain.knowledgeBase);
+  return JSON.stringify({
+    false_positives: fps.map((fp) => ({ summary: fp.summary, lesson: fp.lesson, date: fp.date })),
+    count: fps.length,
+    instruction: "Include these in review agent prompts as DO NOT FLAG items."
+  });
+}
+function handleBrainStatus(_params, brain) {
+  const summary = getKBSummary(brain.knowledgeBase);
+  const claudeMdBytes = (() => {
+    try {
+      return statSync2(join2(brain.rootPath, "CLAUDE.md")).size;
+    } catch {
+      return 0;
+    }
+  })();
+  const totalSessions = sessionCount(brain.rootPath);
+  const hitRate = summary.totalEntries > 0 ? Math.round(summary.accessedEntries / summary.totalEntries * 100) : 0;
+  return JSON.stringify({
+    ...summary,
+    knowledge_index: {
+      files_indexed: brain.knowledge.summary.totalFiles,
+      total_lines: brain.knowledge.summary.totalLines,
+      import_edges: Object.keys(brain.knowledge.importGraph).length,
+      exports_mapped: Object.keys(brain.knowledge.exports).length
+    },
+    token_accounting: {
+      claude_md_bytes: claudeMdBytes,
+      claude_md_kb: Math.round(claudeMdBytes / 1024 * 10) / 10,
+      session_count: totalSessions,
+      learnings_hit_rate_pct: hitRate,
+      note: claudeMdBytes > 3e4 ? "CLAUDE.md is large \u2014 consider trimming. Tax exceeds typical savings." : hitRate < 20 && summary.totalEntries > 10 ? "Low hit rate \u2014 many learnings unused. Consider pruning stale entries." : "Healthy."
+    },
+    cache_age_ms: Date.now() - brain.loadedAt,
+    instruction: "Brain is ready. Next: call knit_classify_task with the files you plan to touch to get your tier and phases."
+  });
+}
+function handleClassifyTask(params, brain) {
+  const rawFiles = (params.files_to_touch || "").split(",").map((f) => f.trim()).filter(Boolean);
+  const files = rawFiles.filter((f) => f !== "unknown");
+  const description = (params.description || "").toLowerCase();
+  const domains = detectDomainsFromFiles(files);
+  const crossDomainRipple = [];
+  for (const file of files) {
+    const importers = brain.reverseDeps[file] || [];
+    if (importers.length >= 3) crossDomainRipple.push(`${file} is high-fanout (${importers.length} dependents)`);
+  }
+  const isTypes = files.some((f) => f.includes("types") || f.includes("schema"));
+  const isAuth = files.some((f) => f.includes("auth") || f.includes("security"));
+  const isNewProject = files.length === 0 || rawFiles.includes("unknown");
+  const descriptionIsComplex = description.includes("architect") || description.includes("build from scratch") || description.includes("new project") || description.includes("system") || description.length > 100;
+  const tier2 = isNewProject ? descriptionIsComplex ? "complex" : "standard" : domains.size >= 3 || isTypes || isAuth || files.length > 3 ? "complex" : domains.size >= 2 || files.length > 1 ? "standard" : "trivial";
+  const phases2 = tier2 === "complex" ? ["RESEARCH", "IDEATE", "PLAN", "EXECUTE", "OPTIMIZE", "REVIEW", "LEARN"] : tier2 === "standard" ? ["RESEARCH", "EXECUTE", "OPTIMIZE", "REVIEW", "LEARN"] : ["EXECUTE", "VERIFY", "LEARN"];
+  const instruction = tier2 === "complex" ? "ENTER PLAN MODE NOW. Call EnterPlanMode tool immediately. Do NOT start coding without a plan. This task touches 3+ domains and requires RESEARCH \u2192 IDEATE \u2192 PLAN \u2192 EXECUTE \u2192 OPTIMIZE \u2192 REVIEW \u2192 LEARN." : tier2 === "standard" ? "Follow phases: RESEARCH \u2192 EXECUTE \u2192 OPTIMIZE \u2192 REVIEW \u2192 LEARN. No plan mode needed but do research first." : "Simple task. EXECUTE \u2192 VERIFY \u2192 LEARN. Do it directly, then record what you learned.";
+  try {
+    writeClassificationMarker(brain.rootPath, {
+      turnId: `${Date.now()}-${process.pid}`,
+      classifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      tier: tier2,
+      files
+    });
+  } catch {
+  }
+  return JSON.stringify({
+    tier: tier2,
+    affected_domains: [...domains],
+    phases: phases2,
+    files_count: files.length,
+    cross_domain_ripple: crossDomainRipple,
+    auto_plan_mode: tier2 === "complex",
+    instruction,
+    reasoning: tier2 === "complex" ? `Complex: ${domains.size} domains affected${isTypes ? ", touches shared types" : ""}${isAuth ? ", security-sensitive" : ""}` : tier2 === "standard" ? `Standard: ${domains.size} domain(s), ${files.length} file(s)` : `Trivial: 1 domain, simple change`
+  });
+}
+function handleSetProtocolStrictness(params, brain) {
+  const level = (params.level || "").trim().toLowerCase();
+  if (!isValidStrictness(level)) {
+    return JSON.stringify({
+      status: "error",
+      error: `Invalid level: "${params.level}". Must be one of: off, warn, block.`
+    });
+  }
+  const config = writeProtocolConfig(brain.rootPath, level);
+  return JSON.stringify({
+    status: "set",
+    level: config.level,
+    updated_at: config.updatedAt,
+    applies_to: "next-tool-call",
+    note: level === "block" ? "PreToolUse hook will now HARD BLOCK Edit/Write without knit_classify_task first." : level === "warn" ? "PreToolUse hook will print a reminder but not block." : "Protocol Guard disabled. No checks on Edit/Write."
+  });
+}
+function handleGetProtocolStrictness(_params, brain) {
+  const config = readProtocolConfig(brain.rootPath);
+  return JSON.stringify({ level: config.level, updated_at: config.updatedAt });
+}
+function handleBuildContext(params, brain) {
+  const files = (params.files_to_touch || "").split(",").map((f) => f.trim()).filter(Boolean);
+  const affectedDomains = detectDomainsFromFiles(files);
+  const knownPitfalls = [];
+  const ripple = [];
+  for (const file of files) {
+    const importers = brain.reverseDeps[file] || [];
+    if (importers.length > 0) ripple.push(`${file} is imported by: ${importers.join(", ")}`);
+  }
+  const domainTags = [...affectedDomains].map((d) => d.toLowerCase().replace(/[^a-z]/g, ""));
+  const learnings = queryByDomains(brain.knowledgeBase, domainTags);
+  for (const l of learnings) knownPitfalls.push(`${l.summary}: ${l.lesson}`);
+  const fps = getFalsePositives(brain.knowledgeBase);
+  return JSON.stringify({
+    domain_context: {
+      affected_domains: [...affectedDomains],
+      files_to_touch: files,
+      cross_domain_ripple: ripple,
+      known_pitfalls: knownPitfalls,
+      false_positives: fps.map((fp) => `${fp.summary}: ${fp.lesson}`)
+    },
+    instruction: "Pass this entire object to every agent prompt in EXECUTE, OPTIMIZE, and REVIEW phases."
+  });
+}
+function handleRecordLearning(params, brain) {
+  if (!params.summary?.trim() && !params.lesson?.trim()) {
+    return JSON.stringify({ error: "summary and lesson are required \u2014 cannot record empty learning" });
+  }
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const entry = {
+    date,
+    summary: params.summary || "Untitled learning",
+    domains: (params.domains || "general").split(",").map((d) => d.trim()),
+    approach: params.approach || "",
+    outcome: ["success", "partial", "failure"].includes(params.outcome) ? params.outcome : "success",
+    lesson: params.lesson || "",
+    tags: (params.tags || "").split(/\s+/).filter((t) => t.startsWith("#"))
+  };
+  addEntry(brain.knowledgeBase, entry);
+  saveKnowledgeBase(knowledgebasePath(brain.rootPath), brain.knowledgeBase);
+  const learnDir = learningsDir(brain.rootPath);
+  const mdFiles = existsSync4(learnDir) ? readdirSync(learnDir).filter((f) => f.endsWith(".md") && f !== "sessions.md") : [];
+  if (mdFiles.length > 0) {
+    const mdPath = join2(learnDir, mdFiles[0]);
+    const mdEntry = `
+## ${date} ${entry.summary}
+**Domain(s):** ${entry.domains.join(", ")}
+**Approach:** ${entry.approach}
+**Outcome:** ${entry.outcome}
+**Lesson:** ${entry.lesson}
+**Tags:** ${entry.tags.join(" ")}
+`;
+    const existing = readFileSync4(mdPath, "utf-8");
+    writeFileSync4(mdPath, existing + mdEntry, "utf-8");
+  }
+  return JSON.stringify({
+    status: "recorded",
+    entry: { date, summary: entry.summary, tags: entry.tags },
+    kb_total: brain.knowledgeBase.entries.length,
+    instruction: "Learning recorded. You may now report task as complete."
+  });
+}
+function handleRecordFalsePositive(params, brain) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const entry = {
+    date,
+    summary: params.summary || "Untitled FP",
+    domains: ["General"],
+    approach: "Verified manually",
+    outcome: "success",
+    lesson: params.reason || "Confirmed non-issue",
+    tags: [...(params.tags || "").split(/\s+/).filter((t) => t.startsWith("#")), "#false-positive"]
+  };
+  addEntry(brain.knowledgeBase, entry);
+  saveKnowledgeBase(knowledgebasePath(brain.rootPath), brain.knowledgeBase);
+  return JSON.stringify({
+    status: "recorded",
+    summary: entry.summary,
+    total_false_positives: getFalsePositives(brain.knowledgeBase).length,
+    instruction: "This will be included in future agent prompts as a DO NOT FLAG item."
+  });
+}
+function handleSaveHandoff(params, brain) {
+  const handoffPath = join2(brain.rootPath, "handoff.md");
+  const content = `# Session Handoff
+
+**Goal:** ${params.goal || "Not specified"}
+
+**Current State:** ${params.current_state || "Not specified"}
+
+**Files in Flight:** ${params.files_in_flight || "None"}
+
+**What Changed:** ${params.what_changed || "Nothing"}
+
+**Failed Attempts:**
+${params.failed_attempts || "None documented"}
+
+**Decisions Made:** ${params.decisions_made || "None"}
+
+**Next Step:** ${params.next_step || "Not specified"}
+
+---
+*Saved: ${(/* @__PURE__ */ new Date()).toISOString()}*
+`;
+  writeFileSync4(handoffPath, content, "utf-8");
+  return JSON.stringify({ status: "saved", path: "handoff.md", instruction: "Next session will read handoff.md first." });
+}
+function handleSetupProject(params, brain) {
+  const description = params.description || "";
+  const projectType = params.project_type || "auto";
+  const domainNames = params.domains ? params.domains.split(",").map((d) => d.trim()) : inferDomainsFromDescription(description, projectType);
+  const teamRoles = params.team_roles ? params.team_roles.split(",").map((r) => r.trim()) : domainNames;
+  const teams = domainNames.map((domain, i) => ({
+    name: domain.charAt(0).toUpperCase() + domain.slice(1).replace(/-/g, " "),
+    role: `${teamRoles[i] || domain} specialist`,
+    focus: `${domain} domain for: ${description.slice(0, 200)}`,
+    agents: ["code-reviewer"],
+    // generic — the PROMPT is what matters, not the agent type
+    filePatterns: ["**/*"],
+    reviewChecklist: [`Review ${domain} quality`, `Check ${domain} completeness`, `Verify ${domain} accuracy`]
+  }));
+  saveCustomTeams(brain.rootPath, teams);
+  addEntry(brain.knowledgeBase, {
+    date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    summary: `Project setup: ${description.slice(0, 100)}`,
+    domains: domainNames,
+    approach: `Project type: ${projectType}. Domains: ${domainNames.join(", ")}`,
+    outcome: "success",
+    lesson: `This is a ${projectType} project. Key domains: ${domainNames.join(", ")}`,
+    tags: ["#project-setup", ...domainNames.map((d) => `#${d.toLowerCase().replace(/\s+/g, "-")}`)]
+  });
+  saveKnowledgeBase(knowledgebasePath(brain.rootPath), brain.knowledgeBase);
+  return JSON.stringify({
+    status: "configured",
+    project_type: projectType,
+    domains: domainNames,
+    teams_created: teams.length,
+    teams: teams.map((t) => ({ name: t.name, role: t.role })),
+    instruction: `Project configured with ${teams.length} teams. Use knit_start_team_review to run parallel team analysis. Use knit_classify_task to classify tasks before starting.`
+  });
+}
+var DOMAIN_TEMPLATES = {
+  // Code (handled by scanner, these are fallbacks)
+  code: ["frontend", "backend", "database", "testing", "devops"],
+  // Business
+  startup: ["market-research", "business-model", "financial-projections", "competitive-analysis", "pitch-preparation"],
+  marketing: ["market-research", "content-strategy", "campaign-creation", "analytics", "optimization"],
+  sales: ["prospecting", "outreach", "pipeline-management", "deal-analysis", "forecasting"],
+  // Research & Analysis
+  research: ["literature-review", "data-collection", "analysis", "synthesis", "reporting"],
+  finance: ["market-analysis", "risk-assessment", "portfolio-strategy", "compliance", "reporting"],
+  "data-science": ["data-collection", "data-cleaning", "feature-engineering", "model-training", "evaluation"],
+  // Creative
+  writing: ["research", "outlining", "drafting", "editing", "publishing"],
+  journalism: ["source-management", "investigation", "fact-checking", "writing", "editorial-review"],
+  music: ["songwriting", "arrangement", "production", "mixing-mastering", "distribution"],
+  video: ["pre-production", "scripting", "filming", "editing", "distribution"],
+  // Design & Product
+  design: ["user-research", "information-architecture", "visual-design", "prototyping", "usability-testing"],
+  product: ["discovery", "requirements", "design", "development", "launch"],
+  gamedev: ["game-design", "level-design", "art-assets", "programming", "playtesting"],
+  // Technical
+  devops: ["inventory", "migration-planning", "implementation", "security-review", "monitoring"],
+  security: ["threat-modeling", "vulnerability-assessment", "penetration-testing", "remediation", "compliance"],
+  architecture: ["requirements-analysis", "system-design", "component-design", "integration", "documentation"],
+  // Domain-specific
+  legal: ["document-review", "risk-identification", "compliance-check", "contract-analysis", "recommendations"],
+  medical: ["data-collection", "clinical-analysis", "safety-review", "statistical-analysis", "reporting"],
+  education: ["curriculum-design", "content-creation", "assessment-design", "review", "delivery"],
+  realestate: ["market-research", "property-valuation", "financial-analysis", "risk-assessment", "recommendations"],
+  hr: ["job-analysis", "candidate-sourcing", "screening", "interview-assessment", "onboarding"],
+  consulting: ["discovery", "analysis", "strategy", "recommendations", "implementation-planning"]
+};
+function inferDomainsFromDescription(description, projectType) {
+  if (DOMAIN_TEMPLATES[projectType]) {
+    return DOMAIN_TEMPLATES[projectType];
+  }
+  const desc = description.toLowerCase();
+  const typeScores = [];
+  for (const [type, domains] of Object.entries(DOMAIN_TEMPLATES)) {
+    let score = 0;
+    if (desc.includes(type.replace("-", " "))) score += 10;
+    if (desc.includes(type)) score += 10;
+    for (const domain of domains) {
+      const keywords = domain.replace(/-/g, " ").split(" ");
+      for (const kw of keywords) {
+        if (kw.length > 3 && desc.includes(kw)) score += 2;
+      }
+    }
+    if (score > 0) typeScores.push([type, score]);
+  }
+  typeScores.sort((a, b) => b[1] - a[1]);
+  if (typeScores.length > 0 && typeScores[0][1] >= 4) {
+    return DOMAIN_TEMPLATES[typeScores[0][0]];
+  }
+  return ["planning", "research", "execution", "review", "delivery"];
+}
+function handleGetTeams(_params, brain) {
+  const custom = loadCustomTeams(brain.rootPath);
+  if (custom) return JSON.stringify({ source: "custom", teams: custom, count: custom.length });
+  const scan = scanProject(brain.rootPath);
+  const defaults = buildDefaultTeams(scan.domains);
+  return JSON.stringify({ source: "auto-detected", teams: defaults, count: defaults.length });
+}
+function handleDefineTeam(params, brain) {
+  const existing = loadCustomTeams(brain.rootPath) || [];
+  const newTeam = {
+    name: params.name,
+    role: params.role,
+    focus: params.focus,
+    agents: (params.agents || "code-reviewer").split(",").map((a) => a.trim()),
+    filePatterns: (params.file_patterns || "src/**").split(",").map((p) => p.trim()),
+    reviewChecklist: (params.checklist || "").split("|").map((c) => c.trim()).filter(Boolean)
+  };
+  const idx = existing.findIndex((t) => t.name === newTeam.name);
+  if (idx >= 0) existing[idx] = newTeam;
+  else existing.push(newTeam);
+  saveCustomTeams(brain.rootPath, existing);
+  return JSON.stringify({ status: "saved", team: newTeam, total_teams: existing.length });
+}
+function handleStartTeamReview(params, brain) {
+  const teamNames = params.teams === "all" || !params.teams ? (loadCustomTeams(brain.rootPath) || buildDefaultTeams([])).map((t) => t.name) : params.teams.split(",").map((t) => t.trim());
+  const board = startTeamBoard(`review-${Date.now()}`, params.task_description, teamNames);
+  return JSON.stringify({
+    status: "started",
+    board_id: board.taskId,
+    teams: teamNames,
+    instruction: `Launch ${teamNames.length} agents IN PARALLEL. For each team, call knit_get_team_prompt, then spawn an Agent. After each returns, call knit_post_team_findings. Finally, call knit_get_board_summary.`
+  });
+}
+function handleGetTeamPrompt(params, brain) {
+  const teams = loadCustomTeams(brain.rootPath) || buildDefaultTeams([
+    { name: params.team_name, description: "", filePatterns: ["src/**"], agents: ["code-reviewer"] }
+  ]);
+  const team = teams.find((t) => t.name === params.team_name);
+  if (!team) return JSON.stringify({ error: `Team "${params.team_name}" not found` });
+  markTeamWorking(params.team_name);
+  const files = (params.files_to_review || "").split(",").map((f) => f.trim()).filter(Boolean);
+  const domainContext = {
+    files_to_review: files.length > 0 ? files : team.filePatterns,
+    knowledge_summary: {
+      total_files: brain.knowledge.summary.totalFiles,
+      high_fanout: brain.knowledge.summary.highFanoutFiles,
+      untested: brain.knowledge.summary.untestedFiles
+    }
+  };
+  const otherFindings = getOtherTeamFindings(params.team_name);
+  const prompt = generateTeamPrompt(team, getTeamBoard()?.taskDescription || "", domainContext, otherFindings);
+  return JSON.stringify({ team: team.name, prompt, agents_to_use: team.agents, instruction: "Spawn an Agent with this prompt." });
+}
+function handlePostTeamFindings(params, _brain) {
+  let findings;
+  try {
+    const raw = JSON.parse(params.findings || "[]");
+    findings = raw.map((f) => ({
+      team: params.team_name,
+      severity: VALID_SEVERITIES.has(String(f.severity).toUpperCase()) ? String(f.severity).toUpperCase() : "MEDIUM",
+      file: f.file || "unknown",
+      description: f.description || "",
+      recommendation: f.recommendation || "",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+  } catch {
+    findings = [{
+      team: params.team_name,
+      severity: "LOW",
+      file: "unknown",
+      description: params.findings || "No structured findings",
+      recommendation: "",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }];
+  }
+  postTeamFindings(params.team_name, findings);
+  const summary = getBoardSummary();
+  return JSON.stringify({
+    status: "posted",
+    team: params.team_name,
+    findings_count: findings.length,
+    board_summary: summary,
+    all_done: summary.allDone
+  });
+}
+function handleGetBoardSummary(_params, _brain) {
+  const board = getTeamBoard();
+  if (!board) return JSON.stringify({ error: "No active review board. Call knit_start_team_review first." });
+  const summary = getBoardSummary();
+  const criticals = board.findings.filter((f) => f.severity === "CRITICAL");
+  const highs = board.findings.filter((f) => f.severity === "HIGH");
+  return JSON.stringify({
+    task: board.taskDescription,
+    ...summary,
+    team_status: board.status,
+    critical_findings: criticals.map((f) => `[${f.team}] ${f.file}: ${f.description}`),
+    high_findings: highs.map((f) => `[${f.team}] ${f.file}: ${f.description}`),
+    gate: summary.critical > 0 ? "BLOCKED \u2014 fix CRITICAL findings before proceeding" : summary.high > 0 ? "WARNING \u2014 HIGH findings should be addressed" : "PASSED \u2014 no blocking findings"
+  });
+}
+function handleReflect(_params, brain) {
+  const patterns = reflect(brain.knowledgeBase);
+  if (patterns.length === 0) {
+    return JSON.stringify({
+      patterns: [],
+      message: "Not enough data yet. Record more learnings (minimum 3) for patterns to emerge. Also try knit_search_global_learnings for cross-project patterns."
+    });
+  }
+  return JSON.stringify({
+    patterns: patterns.slice(0, 10).map((p) => ({
+      type: p.type,
+      description: p.description,
+      confidence: p.confidence,
+      occurrences: p.occurrences,
+      domains: p.domains
+    })),
+    total_patterns: patterns.length,
+    insight: patterns[0].confidence >= 7 ? `Strongest pattern: ${patterns[0].description}` : "Patterns are forming but not yet high-confidence. Keep recording learnings."
+  });
+}
+function handleGetSuggestions(params, brain) {
+  const domains = (params.domains || "").split(",").map((d) => d.trim()).filter(Boolean);
+  if (domains.length === 0) {
+    return JSON.stringify({ error: "domains parameter required", suggestions: [] });
+  }
+  const suggestions = getAdaptiveSuggestions(brain.knowledgeBase, domains);
+  if (suggestions.length === 0) {
+    return JSON.stringify({
+      suggestions: [],
+      message: `No patterns yet for domains: ${domains.join(", ")}. Try knit_search_global_learnings for cross-project insights.`
+    });
+  }
+  return JSON.stringify({
+    domains_queried: domains,
+    suggestions,
+    message: `${suggestions.length} adaptive suggestions based on past patterns in these domains.`
+  });
+}
+function handleRecordGlobalLearning(params, brain) {
+  const summary = (params.summary || "").slice(0, 500);
+  const lesson = (params.lesson || "").slice(0, 2e3);
+  const tags = (params.tags || "").split(/\s+/).filter((t) => t.startsWith("#"));
+  const outcomeRaw = (params.outcome || "").toLowerCase();
+  const outcome = ["success", "partial", "failure"].includes(outcomeRaw) ? outcomeRaw : void 0;
+  if (!summary || !lesson || tags.length === 0) {
+    return JSON.stringify({ error: "summary, lesson, and tags are all required" });
+  }
+  const entry = buildGlobalLearning(brain.rootPath, { summary, lesson, tags, outcome });
+  appendGlobalLearning(entry);
+  return JSON.stringify({
+    status: "saved",
+    id: entry.id,
+    project: entry.projectName,
+    instruction: "Cross-project learning saved. Future knit_search_global_learnings calls from any project will find it."
+  });
+}
+function handleSearchGlobalLearnings(params, _brain) {
+  const query = (params.query || "").trim();
+  const limit = Math.max(1, Math.min(50, parseInt(params.limit || "10", 10) || 10));
+  if (!query) {
+    return JSON.stringify({ error: "query is required", results: [] });
+  }
+  const matches = searchGlobalLearnings(query, limit);
+  return JSON.stringify({
+    query,
+    count: matches.length,
+    results: matches.map((m) => ({
+      id: m.id,
+      date: m.date,
+      from_project: m.projectName,
+      summary: m.summary,
+      lesson: m.lesson,
+      tags: m.tags,
+      outcome: m.outcome
+    })),
+    instruction: matches.length === 0 ? "No cross-project matches. This area might be new across all your projects." : `Found ${matches.length} cross-project learning(s). Review before duplicating work.`
+  });
+}
+function handleLoadSession(_params, brain) {
+  const root = brain.rootPath;
+  const sessionsFile = sessionsLogPath(root);
+  let lastSession = null;
+  if (existsSync4(sessionsFile)) {
+    const content = readFileSync4(sessionsFile, "utf-8");
+    const sessions = content.split(/^## Session/m).slice(1);
+    if (sessions.length > 0) {
+      const last = sessions[sessions.length - 1].trim();
+      lastSession = last.slice(0, 300);
+    }
+  }
+  const handoffPath = join2(root, "handoff.md");
+  let handoff2 = null;
+  if (existsSync4(handoffPath)) {
+    handoff2 = readFileSync4(handoffPath, "utf-8").slice(0, 2e3);
+  }
+  const topLearnings = brain.knowledgeBase.entries.filter((e) => e.accessCount > 0).sort((a, b) => b.accessCount - a.accessCount).slice(0, 5).map((e) => ({ summary: e.summary, lesson: e.lesson, tags: e.tags, accessed: e.accessCount }));
+  const fps = brain.knowledgeBase.entries.filter((e) => e.tags.includes("#false-positive")).map((e) => ({ summary: e.summary, lesson: e.lesson }));
+  const teamsFile = teamsPath(root);
+  let teams = [];
+  if (existsSync4(teamsFile)) {
+    try {
+      const t = JSON.parse(readFileSync4(teamsFile, "utf-8"));
+      teams = t.map((team) => team.name);
+    } catch {
+    }
+  }
+  const knowledge = {
+    files: brain.knowledge.summary.totalFiles,
+    imports: Object.keys(brain.knowledge.importGraph).length,
+    high_fanout: brain.knowledge.summary.highFanoutFiles,
+    untested: brain.knowledge.summary.untestedFiles.slice(0, 5)
+  };
+  const metrics = {
+    total_sessions: brain.knowledgeBase.metrics.totalSessions,
+    total_learnings: brain.knowledgeBase.entries.length,
+    cache_hits: brain.knowledgeBase.metrics.cacheHits
+  };
+  const recentSessions = getRecentSessions(root, 3).map((s) => ({
+    date: s.date,
+    branch: s.branch ?? null,
+    summary: s.summary ?? "",
+    tags: s.tags ?? [],
+    outcome: s.outcome
+  }));
+  const patterns = reflect(brain.knowledgeBase).slice(0, 3).map((p) => ({ type: p.type, description: p.description, confidence: p.confidence }));
+  return JSON.stringify({
+    session_context: {
+      last_session: lastSession,
+      handoff: handoff2,
+      has_unfinished_work: handoff2 !== null
+    },
+    intelligence: {
+      top_learnings: topLearnings,
+      false_positives: fps,
+      patterns
+    },
+    project: {
+      knowledge,
+      teams,
+      metrics,
+      recent_sessions: recentSessions
+    },
+    instruction: handoff2 ? "UNFINISHED WORK DETECTED. Read the handoff above \u2014 pick up where the last session left off. Do NOT start fresh." : topLearnings.length > 0 ? `Session loaded. ${topLearnings.length} key learnings available. ${fps.length} false positives to suppress. Call knit_classify_task to begin.` : recentSessions.length > 0 ? `Session loaded. ${recentSessions.length} recent sessions on file. Call knit_classify_task to begin.` : "Fresh brain \u2014 no past learnings yet. Call knit_classify_task to begin your first task."
+  });
+}
+function handleSaveSessionSummary(params, brain) {
+  const validOutcomes = ["shipped", "wip", "failed", "unknown"];
+  const outcomeRaw = params.outcome || "unknown";
+  const outcome = validOutcomes.includes(outcomeRaw) ? outcomeRaw : "unknown";
+  const entry = {
+    id: `${Date.now()}-agent`,
+    date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    summary: (params.summary || "").slice(0, 500),
+    tags: (params.tags || "").split(/\s+/).filter((t) => t.startsWith("#")),
+    outcome,
+    filesTouched: params.files_touched ? params.files_touched.split(",").map((f) => f.trim()).filter(Boolean) : void 0,
+    domainsTouched: params.domains ? params.domains.split(",").map((d) => d.trim()).filter(Boolean) : void 0
+  };
+  appendSession(brain.rootPath, entry);
+  return JSON.stringify({
+    status: "saved",
+    id: entry.id,
+    summary: entry.summary,
+    instruction: "Session summary recorded. Future knit_search_sessions calls can find this."
+  });
+}
+function handleGetWorkflow(params, brain) {
+  const phase = (params.phase || "").trim().toLowerCase();
+  if (!phase) {
+    return JSON.stringify({
+      sections: listWorkflowSections(),
+      instruction: "Call knit_get_workflow with one of the section names to fetch its content."
+    });
+  }
+  const buildCommands = {
+    typecheck: brain.config.stack.typecheckCommand ?? void 0,
+    lint: brain.config.stack.lintCommand ?? void 0,
+    test: brain.config.stack.testFramework ? `${brain.config.packageManager === "unknown" ? "npm" : brain.config.packageManager} test` : void 0,
+    build: brain.config.stack.buildCommand ?? void 0
+  };
+  const content = getWorkflowSection(phase, { buildCommands });
+  if (content === null) {
+    return JSON.stringify({
+      error: `Unknown phase: "${phase}".`,
+      available: listWorkflowSections().map((s) => s.name)
+    });
+  }
+  return JSON.stringify({
+    phase,
+    content,
+    instruction: "Apply this section to the current task. For another phase, call knit_get_workflow again with that phase name."
+  });
+}
+function handleInstallAgent(params, brain) {
+  const name = (params.name || "").trim();
+  const refresh = (params.refresh || "").toLowerCase() === "true";
+  if (!name) return JSON.stringify({ error: "name is required" });
+  installAgentsForProject(
+    brain.rootPath,
+    brain.config,
+    brain.knowledge,
+    brain.knowledgeBase,
+    { only: [name], refresh }
+  ).catch((err) => {
+    process.stderr.write(`[knit] handleInstallAgent background error for ${name}: ${err?.message ?? err}
+`);
+  });
+  return JSON.stringify({
+    status: "queued",
+    agent: name,
+    target: `<project>/.claude/agents/knit-${name}.md`,
+    instruction: "Install started in background. File will be ready within a few seconds. If it fails, see stderr \u2014 engram does not throw from this handler."
+  });
+}
+function handleSpawnTeamWorktree(params, brain) {
+  const teamName = (params.team_name || "").trim();
+  const taskDescription = (params.task_description || "").trim();
+  if (!teamName) {
+    return JSON.stringify({ error: "team_name is required" });
+  }
+  if (!taskDescription) {
+    return JSON.stringify({ error: "task_description is required" });
+  }
+  try {
+    const record = spawnWorktree(brain.rootPath, teamName, taskDescription);
+    return JSON.stringify({
+      status: "spawned",
+      team_name: record.teamName,
+      team_slug: record.teamSlug,
+      path: record.path,
+      branch: record.branch,
+      task_description: record.taskDescription,
+      instruction: `Worktree ready at ${record.path}. Pass this path to the team's agents. They should cd there and make their changes on branch ${record.branch}. When done, call knit_finalize_team_worktree with action="merge".`
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return JSON.stringify({ error: msg });
+  }
+}
+function handleListTeamWorktrees(params, brain) {
+  const includeFinalized = (params.include_finalized || "").toLowerCase() === "true";
+  const records = listWorktrees(brain.rootPath, includeFinalized);
+  return JSON.stringify({
+    count: records.length,
+    worktrees: records.map((w) => ({
+      team_name: w.teamName,
+      team_slug: w.teamSlug,
+      path: w.path,
+      branch: w.branch,
+      task_description: w.taskDescription,
+      created_at: w.createdAt,
+      status: w.status
+    }))
+  });
+}
+function handleFinalizeTeamWorktree(params, brain) {
+  const teamName = (params.team_name || "").trim();
+  const action = (params.action || "").trim().toLowerCase();
+  if (!teamName) {
+    return JSON.stringify({ error: "team_name is required" });
+  }
+  if (action !== "merge" && action !== "discard") {
+    return JSON.stringify({ error: 'action must be "merge" or "discard"' });
+  }
+  try {
+    const result = finalizeWorktree(brain.rootPath, teamName, action);
+    return JSON.stringify({
+      status: result.status,
+      team_name: result.worktree.teamName,
+      branch: result.worktree.branch,
+      conflict_files: result.conflictFiles,
+      message: result.message,
+      instruction: result.status === "merged" ? `Worktree merged and removed. Branch ${result.worktree.branch} deleted.` : result.status === "discarded" ? `Worktree discarded. Branch ${result.worktree.branch} deleted; changes lost.` : `Merge conflict on ${result.conflictFiles?.length ?? 0} file(s). Resolve in the main repo, then call this tool again with action="merge" to retry, or "discard" to throw away.`
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return JSON.stringify({ error: msg });
+  }
+}
+function handleSearchSessions(params, brain) {
+  const query = params.query || "";
+  const limit = Math.max(1, Math.min(50, parseInt(params.limit || "10", 10) || 10));
+  if (!query.trim()) {
+    return JSON.stringify({ error: "query is required", results: [] });
+  }
+  const matches = searchSessions(brain.rootPath, query, limit);
+  return JSON.stringify({
+    query,
+    count: matches.length,
+    results: matches.map((s) => ({
+      id: s.id,
+      date: s.date,
+      branch: s.branch ?? null,
+      summary: s.summary ?? "",
+      tags: s.tags ?? [],
+      outcome: s.outcome,
+      files_modified: s.filesModified ?? (s.filesTouched?.length ?? 0)
+    })),
+    instruction: matches.length === 0 ? "No matching sessions. This might be the first time we tackle this area." : `Found ${matches.length} matching past session(s). Review summaries before duplicating prior work.`
+  });
+}
+function handlePruneSessions(params, brain) {
+  const raw = parseInt(params.max_age_days || "90", 10);
+  const maxAgeDays = Number.isFinite(raw) && raw > 0 ? Math.min(raw, 36500) : 90;
+  try {
+    const { kept, pruned } = pruneSessionsByAge(brain.rootPath, maxAgeDays);
+    return JSON.stringify({
+      status: "ok",
+      kept,
+      pruned,
+      max_age_days: maxAgeDays,
+      instruction: pruned === 0 ? `No sessions older than ${maxAgeDays} days. Nothing to prune.` : `Pruned ${pruned} session(s) older than ${maxAgeDays} days. ${kept} kept.`
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return JSON.stringify({ status: "error", error: msg });
+  }
+}
+
+// src/mcp/tools.ts
+function getToolDefinitions() {
+  return [
+    // ── Query (read the brain) ───────────────────────────────────
+    {
+      name: "knit_query_imports",
+      description: "Who imports this file? Returns the reverse dependency list \u2014 call before editing to know the blast radius.",
+      inputSchema: { type: "object", properties: { file_path: { type: "string", description: "Relative file path." } }, required: ["file_path"] }
+    },
+    {
+      name: "knit_query_dependents",
+      description: "What does this file import? Returns the file's own dependencies.",
+      inputSchema: { type: "object", properties: { file_path: { type: "string", description: "Relative file path." } }, required: ["file_path"] }
+    },
+    {
+      name: "knit_query_exports",
+      description: "What does this file expose? Functions, classes, interfaces, types, constants.",
+      inputSchema: { type: "object", properties: { file_path: { type: "string", description: "Relative file path." } }, required: ["file_path"] }
+    },
+    {
+      name: "knit_query_tests",
+      description: 'Is this file tested? Or pass filter="untested" to list all untested files.',
+      inputSchema: { type: "object", properties: { file_path: { type: "string", description: "Relative file path (optional)." }, filter: { type: "string", description: '"untested" to list all untested files.' } } }
+    },
+    {
+      name: "knit_find_fanout",
+      description: "High-fanout files \u2014 imported by many others. These are the contracts; change carefully.",
+      inputSchema: { type: "object", properties: { min_importers: { type: "string", description: "Minimum importers to qualify (default: 3)." } } }
+    },
+    {
+      name: "knit_search_learnings",
+      description: "Search past learnings by domain tag. Returns prior lessons and mistakes to avoid.",
+      inputSchema: { type: "object", properties: { domains: { type: "string", description: "Comma-separated domain tags." } }, required: ["domains"] }
+    },
+    {
+      name: "knit_get_false_positives",
+      description: "Confirmed non-issues. Pass to review agents so they don't re-flag them.",
+      inputSchema: { type: "object", properties: {} }
+    },
+    {
+      name: "knit_brain_status",
+      description: "Brain health + token-accounting: learnings, hit rate, CLAUDE.md size, session count.",
+      inputSchema: { type: "object", properties: {} }
+    },
+    // ── Update (write to the brain) ──────────────────────────────
+    {
+      name: "knit_classify_task",
+      description: "Call first on every task. Classifies tier (trivial/standard/complex), returns phases + domains + auto plan mode flag. Also triggers project auto-init.",
+      inputSchema: { type: "object", properties: { files_to_touch: { type: "string", description: 'Comma-separated files, or "unknown" for new projects.' }, description: { type: "string", description: "Brief task description." } }, required: ["files_to_touch"] }
+    },
+    {
+      name: "knit_build_context",
+      description: "Build a context object for the current task: domains, ripple effects, pitfalls, false positives.",
+      inputSchema: { type: "object", properties: { files_to_touch: { type: "string", description: "Comma-separated files." } }, required: ["files_to_touch"] }
+    },
+    {
+      name: "knit_record_learning",
+      description: "Record a non-obvious, reusable insight. Quality check first: would session N+1 searching this tag be glad it exists? If no, skip.",
+      inputSchema: { type: "object", properties: { summary: { type: "string", description: "One-line summary." }, domains: { type: "string", description: "Comma-separated domains." }, approach: { type: "string", description: "What approach was taken." }, outcome: { type: "string", description: "success | partial | failure." }, lesson: { type: "string", description: "What to repeat or avoid." }, tags: { type: "string", description: 'Space-separated tags (e.g. "#api #auth").' } }, required: ["summary", "lesson", "tags"] }
+    },
+    {
+      name: "knit_record_false_positive",
+      description: "Mark a finding as a confirmed non-issue so future review agents stop re-flagging it.",
+      inputSchema: { type: "object", properties: { summary: { type: "string", description: "What was flagged." }, reason: { type: "string", description: "Why it's not a real issue." }, tags: { type: "string", description: "Domain tags." } }, required: ["summary", "reason"] }
+    },
+    {
+      name: "knit_save_handoff",
+      description: "Save state for the next session when context degrades. failed_attempts is the load-bearing field.",
+      inputSchema: { type: "object", properties: { goal: { type: "string", description: "What we're trying to accomplish." }, current_state: { type: "string", description: "Where we are now." }, files_in_flight: { type: "string", description: "Files being modified." }, what_changed: { type: "string", description: "Commits and edits." }, failed_attempts: { type: "string", description: "What was tried and why it failed." }, decisions_made: { type: "string", description: "Important choices." }, next_step: { type: "string", description: "ONE most important next thing." } }, required: ["goal", "current_state", "failed_attempts", "next_step"] }
+    },
+    {
+      name: "knit_setup_project",
+      description: "Describe a project (especially non-code: research, legal, marketing). Generates domain-specific teams.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          project_type: { type: "string", description: "code | research | analysis | writing | design | custom." },
+          description: { type: "string", description: "What the project does." },
+          domains: { type: "string", description: "Comma-separated domains." },
+          team_roles: { type: "string", description: "Comma-separated team roles." }
+        },
+        required: ["description"]
+      }
+    },
+    // ── Teams (parallel review board) ────────────────────────────
+    {
+      name: "knit_get_teams",
+      description: "List agent teams configured for this project.",
+      inputSchema: { type: "object", properties: {} }
+    },
+    {
+      name: "knit_define_team",
+      description: "Create or update a custom agent team.",
+      inputSchema: { type: "object", properties: { name: { type: "string", description: "Team name." }, role: { type: "string", description: "Team role." }, focus: { type: "string", description: "Team focus area." }, agents: { type: "string", description: "Comma-separated agent types." }, file_patterns: { type: "string", description: "Comma-separated globs." }, checklist: { type: "string", description: "Pipe-separated review items." } }, required: ["name", "role", "focus"] }
+    },
+    {
+      name: "knit_start_team_review",
+      description: "Start a parallel team review with a shared findings board.",
+      inputSchema: { type: "object", properties: { task_description: { type: "string", description: "What the teams review." }, teams: { type: "string", description: 'Comma-separated team names or "all".' } }, required: ["task_description"] }
+    },
+    {
+      name: "knit_get_team_prompt",
+      description: "Get the prompt for a team, including other teams' findings.",
+      inputSchema: { type: "object", properties: { team_name: { type: "string", description: "Team name." }, files_to_review: { type: "string", description: "Comma-separated files." } }, required: ["team_name"] }
+    },
+    {
+      name: "knit_post_team_findings",
+      description: "Post a team's findings to the shared board.",
+      inputSchema: { type: "object", properties: { team_name: { type: "string", description: "Team posting." }, findings: { type: "string", description: "JSON array of findings." } }, required: ["team_name", "findings"] }
+    },
+    {
+      name: "knit_get_board_summary",
+      description: "Cross-team findings, severity-gated.",
+      inputSchema: { type: "object", properties: {} }
+    },
+    // ── Session memory ───────────────────────────────────────────
+    {
+      name: "knit_load_session",
+      description: "Call at session start. Returns last sessions, handoff, top learnings, false positives, teams, project knowledge in one round trip.",
+      inputSchema: { type: "object", properties: {} }
+    },
+    {
+      name: "knit_save_session_summary",
+      description: "Opt-in. Record a narrative summary if this session accomplished something a future session would search for. Quality check first.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          summary: { type: "string", description: "One-line summary." },
+          tags: { type: "string", description: 'Space-separated tags like "#auth #refactor".' },
+          outcome: { type: "string", description: "shipped | wip | failed | unknown." },
+          files_touched: { type: "string", description: "Comma-separated files (optional)." },
+          domains: { type: "string", description: "Comma-separated domains (optional)." }
+        },
+        required: ["summary", "tags", "outcome"]
+      }
+    },
+    {
+      name: "knit_prune_sessions",
+      description: "Prune entries older than max_age_days (default 90) from this project's sessions.jsonl. Atomic rewrite. Also runs automatically on auto-init.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          max_age_days: { type: "string", description: "Maximum age in days (default 90)." }
+        }
+      }
+    },
+    {
+      name: "knit_search_sessions",
+      description: "Search past sessions by free text over summary + tags + branch. Check before duplicating prior work.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Free text or tag." },
+          limit: { type: "string", description: "Max results (default 10)." }
+        },
+        required: ["query"]
+      }
+    },
+    // ── Workflow on demand ───────────────────────────────────────
+    {
+      name: "knit_get_workflow",
+      description: "Fetch protocol depth for one phase. Sections: overview, tier, phases, research, ideate, plan, execute, optimize, review, tdd, learn, handoff, ship, tools. Omit phase to list all.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          phase: { type: "string", description: "Section name. Omit to list all." }
+        }
+      }
+    },
+    // ── Parallel team worktrees ──────────────────────────────────
+    {
+      name: "knit_spawn_team_worktree",
+      description: "Create a git worktree for a team. Multiple agents within the team can work in parallel inside it without colliding with other teams.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          team_name: { type: "string", description: 'Team display name (e.g., "UI", "API & Security").' },
+          task_description: { type: "string", description: "What this team is doing." }
+        },
+        required: ["team_name", "task_description"]
+      }
+    },
+    {
+      name: "knit_list_team_worktrees",
+      description: "List active team worktrees. Pass include_finalized=true for full history.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          include_finalized: { type: "string", description: '"true" for full history (default: active only).' }
+        }
+      }
+    },
+    // ── Cross-project learnings (Model C — global pool) ─────────
+    {
+      name: "knit_record_global_learning",
+      description: "Opt-in. Record a learning to the cross-project pool when the insight generalizes beyond this project (e.g., Stripe webhook signature rules). Per-project knit_record_learning stays primary.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          summary: { type: "string", description: "One-line summary." },
+          lesson: { type: "string", description: "Generalizable lesson." },
+          tags: { type: "string", description: "Space-separated tags." },
+          outcome: { type: "string", description: "success | partial | failure (optional)." }
+        },
+        required: ["summary", "lesson", "tags"]
+      }
+    },
+    {
+      name: "knit_search_global_learnings",
+      description: "Search the cross-project learnings pool. Use to check whether a similar lesson has been recorded in any project on this machine.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Free text or tag." },
+          limit: { type: "string", description: "Max results (default 10)." }
+        },
+        required: ["query"]
+      }
+    },
+    // ── Pattern reflection (now backed by Model C, useful with ≥3 entries) ──
+    {
+      name: "knit_reflect",
+      description: "Detect patterns across recorded learnings (per-project + global pool). Returns recurring themes, repeated failures, domain co-occurrences. Needs \u22653 learnings to surface anything meaningful.",
+      inputSchema: { type: "object", properties: {} }
+    },
+    {
+      name: "knit_get_suggestions",
+      description: 'Adaptive suggestions for the current task based on past patterns in given domains. "Based on history, watch out for X."',
+      inputSchema: { type: "object", properties: { domains: { type: "string", description: "Comma-separated domains for this task." } }, required: ["domains"] }
+    },
+    {
+      name: "knit_install_agent",
+      description: "Install or refresh one subagent. Writes <project>/.claude/agents/knit-<name>.md, personalized with project context. Use mid-session if a team needs an agent that isn't on disk yet.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: 'Agent name (e.g., "typescript-pro", "security-engineer").' },
+          refresh: { type: "string", description: '"true" to force re-fetch even if cached.' }
+        },
+        required: ["name"]
+      }
+    },
+    {
+      name: "knit_finalize_team_worktree",
+      description: "Merge or discard a team's worktree. Merge surfaces conflict files without destroying the worktree on failure.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          team_name: { type: "string", description: "Team name or slug." },
+          action: { type: "string", description: '"merge" or "discard".' }
+        },
+        required: ["team_name", "action"]
+      }
+    },
+    // ── Protocol Guard ───────────────────────────────────────────
+    {
+      name: "knit_set_protocol_strictness",
+      description: "Set Protocol Guard strictness for this project. off = no checks. warn = reminder only (default). block = hard-fail Edit/Write without prior knit_classify_task.",
+      inputSchema: { type: "object", properties: { level: { type: "string", description: "One of: off | warn | block." } }, required: ["level"] }
+    },
+    {
+      name: "knit_get_protocol_strictness",
+      description: "Read current Protocol Guard strictness level for this project.",
+      inputSchema: { type: "object", properties: {} }
+    }
+  ];
+}
+var handlers = {
+  knit_query_imports: handleQueryImports,
+  knit_query_dependents: handleQueryDependents,
+  knit_query_exports: handleQueryExports,
+  knit_query_tests: handleQueryTests,
+  knit_find_fanout: handleFindFanout,
+  knit_search_learnings: handleSearchLearnings,
+  knit_get_false_positives: handleGetFalsePositives,
+  knit_brain_status: handleBrainStatus,
+  knit_classify_task: handleClassifyTask,
+  knit_build_context: handleBuildContext,
+  knit_record_learning: handleRecordLearning,
+  knit_record_false_positive: handleRecordFalsePositive,
+  knit_save_handoff: handleSaveHandoff,
+  knit_setup_project: handleSetupProject,
+  knit_get_teams: handleGetTeams,
+  knit_define_team: handleDefineTeam,
+  knit_start_team_review: handleStartTeamReview,
+  knit_get_team_prompt: handleGetTeamPrompt,
+  knit_post_team_findings: handlePostTeamFindings,
+  knit_get_board_summary: handleGetBoardSummary,
+  knit_load_session: handleLoadSession,
+  knit_save_session_summary: handleSaveSessionSummary,
+  knit_search_sessions: handleSearchSessions,
+  knit_prune_sessions: handlePruneSessions,
+  knit_get_workflow: handleGetWorkflow,
+  knit_spawn_team_worktree: handleSpawnTeamWorktree,
+  knit_list_team_worktrees: handleListTeamWorktrees,
+  knit_finalize_team_worktree: handleFinalizeTeamWorktree,
+  knit_record_global_learning: handleRecordGlobalLearning,
+  knit_search_global_learnings: handleSearchGlobalLearnings,
+  knit_reflect: handleReflect,
+  knit_get_suggestions: handleGetSuggestions,
+  knit_install_agent: handleInstallAgent,
+  knit_set_protocol_strictness: handleSetProtocolStrictness,
+  knit_get_protocol_strictness: handleGetProtocolStrictness
+};
+function handleToolCall(toolName, params, brain) {
+  if (params.file_path) {
+    const decoded = decodeURIComponent(params.file_path).replace(/\\/g, "/");
+    if (decoded.includes("..") || decoded.startsWith("/") || decoded.includes("\0")) {
+      return JSON.stringify({ error: "Invalid file path \u2014 no traversal or absolute paths allowed" });
+    }
+    params.file_path = decoded;
+  }
+  for (const key of ["summary", "description", "lesson", "reason", "goal", "current_state", "next_step", "files_in_flight", "what_changed", "failed_attempts", "decisions_made", "task_description", "approach", "tags", "team_name", "name", "role", "focus", "file_patterns", "checklist", "domains", "team_roles", "project_type"]) {
+    if (params[key]) {
+      params[key] = params[key].slice(0, 5e3).replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, "");
+    }
+  }
+  const handler = handlers[toolName];
+  if (!handler) {
+    return JSON.stringify({ error: `Unknown tool: ${toolName}` });
+  }
+  return handler(params, brain);
+}
+export {
+  getToolDefinitions,
+  handleToolCall
+};