@a-company/paradigm 3.23.2 → 3.24.0

package/dist/mcp.js

@@ -2026,7 +2026,7 @@ function registerResources(server, getContext2) {
 
 // ../paradigm-mcp/src/tools/index.ts
 import * as os3 from "os";
-import * as path26 from "path";
+import * as path28 from "path";
 import {
   ListToolsRequestSchema,
   CallToolRequestSchema
@@ -2790,7 +2790,7 @@ function navigateExplore(config, target, rootDir) {
   }
   if (result.paths.length === 0) {
     const areaSymbols = Object.entries(config.symbols).filter(
-      ([sym, path27]) => sym.toLowerCase().includes(targetLower) || path27.toLowerCase().includes(targetLower)
+      ([sym, path29]) => sym.toLowerCase().includes(targetLower) || path29.toLowerCase().includes(targetLower)
     ).slice(0, 10);
     result.paths = [...new Set(areaSymbols.map(([, p]) => p))];
     result.symbols = areaSymbols.map(([s]) => s);
@@ -11288,8 +11288,8 @@ function generateRunId() {
 var TEMPLATE_REGEX = /\{\{([^}]+)\}\}/g;
 function interpolate(value, scope) {
   if (typeof value === "string") {
-    return value.replace(TEMPLATE_REGEX, (_match, path27) => {
-      const resolved = resolvePath(path27.trim(), scope);
+    return value.replace(TEMPLATE_REGEX, (_match, path29) => {
+      const resolved = resolvePath(path29.trim(), scope);
       return resolved !== void 0 ? String(resolved) : _match;
     });
   }
@@ -11322,8 +11322,8 @@ function resolvePath(dotPath, scope) {
       return void 0;
   }
 }
-function deepGet(obj, path27) {
-  const parts = path27.split(/[.\[\]]+/).filter(Boolean);
+function deepGet(obj, path29) {
+  const parts = path29.split(/[.\[\]]+/).filter(Boolean);
   let current = obj;
   for (const part of parts) {
     if (current == null || typeof current !== "object") return void 0;
@@ -11559,11 +11559,11 @@ async function runPersonaObject(rootDir, persona, options) {
 }
 async function runChain(rootDir, chainId, options) {
   const start = Date.now();
-  const fs23 = await import("fs");
-  const path27 = await import("path");
-  const yaml14 = await import("js-yaml");
-  const chainPath = path27.join(rootDir, ".paradigm", "personas", "chains", `${chainId}.yaml`);
-  if (!fs23.existsSync(chainPath)) {
+  const fs25 = await import("fs");
+  const path29 = await import("path");
+  const yaml15 = await import("js-yaml");
+  const chainPath = path29.join(rootDir, ".paradigm", "personas", "chains", `${chainId}.yaml`);
+  if (!fs25.existsSync(chainPath)) {
     return {
       chain_id: chainId,
       status: "error",
@@ -11572,7 +11572,7 @@ async function runChain(rootDir, chainId, options) {
       duration_ms: Date.now() - start
     };
   }
-  const chain = yaml14.load(fs23.readFileSync(chainPath, "utf8"));
+  const chain = yaml15.load(fs25.readFileSync(chainPath, "utf8"));
   let permutation;
   if (options.permutation && chain.permutations) {
     permutation = chain.permutations.find((p) => p.id === options.permutation);
@@ -11676,8 +11676,8 @@ function validateInterpolation(persona) {
     const serialized = JSON.stringify(step);
     const templates = serialized.match(TEMPLATE_REGEX) || [];
     for (const template of templates) {
-      const path27 = template.replace("{{", "").replace("}}", "").trim();
-      const [namespace, ...rest] = path27.split(".");
+      const path29 = template.replace("{{", "").replace("}}", "").trim();
+      const [namespace, ...rest] = path29.split(".");
       const key = rest.join(".");
       switch (namespace) {
         case "fixtures":
@@ -12939,8 +12939,811 @@ function buildGraphState(rootDir, symbolFilter, groups, links, graphName = "Gene
   };
 }
 
-// ../paradigm-mcp/src/tools/fallback-grep.ts
+// ../paradigm-mcp/src/tools/heatmap.ts
+import * as fs23 from "fs";
 import * as path25 from "path";
+var HEAT_MAP_FILE = ".paradigm/heat-map.json";
+var CONFIDENCE_DECAY_RATE = 0.05;
+function getHeatmapToolsList() {
+  return [
+    {
+      name: "paradigm_heatmap_query",
+      description: "Query the adaptive heat map for historically relevant symbols given keywords. Returns associations sorted by confidence.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          keywords: {
+            type: "array",
+            items: { type: "string" },
+            description: "Keywords to search for in the heat map"
+          }
+        },
+        required: ["keywords"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_heatmap_record",
+      description: "Record a query-to-symbol association in the adaptive heat map. Use positive signal to reinforce, negative to correct.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          keywords: {
+            type: "array",
+            items: { type: "string" },
+            description: "Keywords that relate to the symbols"
+          },
+          symbols: {
+            type: "array",
+            items: { type: "string" },
+            description: "Symbol IDs (with prefix) that are relevant"
+          },
+          aspects: {
+            type: "array",
+            items: { type: "string" },
+            description: "Aspect IDs that are relevant (optional)"
+          },
+          context: {
+            type: "string",
+            description: "Why this association exists"
+          },
+          signal: {
+            type: "string",
+            enum: ["positive", "negative"],
+            description: "Positive reinforces, negative reduces confidence"
+          },
+          correction: {
+            type: "string",
+            description: "Explanation if correcting a wrong association"
+          }
+        },
+        required: ["keywords", "symbols", "signal"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_heatmap_stats",
+      description: "Show heat map statistics \u2014 total associations, hot/cold keywords, top symbols, session count.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    }
+  ];
+}
+function loadHeatMap(projectDir2) {
+  const filePath = path25.join(projectDir2, HEAT_MAP_FILE);
+  if (!fs23.existsSync(filePath)) {
+    return {
+      version: "1.0",
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      sessionCount: 0,
+      associations: []
+    };
+  }
+  return JSON.parse(fs23.readFileSync(filePath, "utf8"));
+}
+function saveHeatMap(projectDir2, heatMap) {
+  const filePath = path25.join(projectDir2, HEAT_MAP_FILE);
+  const dir = path25.dirname(filePath);
+  if (!fs23.existsSync(dir)) fs23.mkdirSync(dir, { recursive: true });
+  heatMap.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  fs23.writeFileSync(filePath, JSON.stringify(heatMap, null, 2), "utf8");
+}
+async function handleHeatmapQuery(args, projectDir2) {
+  const heatMap = loadHeatMap(projectDir2);
+  const now = Date.now();
+  for (const assoc of heatMap.associations) {
+    const daysSinceHit = (now - new Date(assoc.lastHit).getTime()) / (1e3 * 60 * 60 * 24);
+    const decayPeriods = Math.floor(daysSinceHit / 30);
+    if (decayPeriods > 0) {
+      assoc.confidence = Math.max(
+        0.01,
+        assoc.confidence * Math.pow(1 - CONFIDENCE_DECAY_RATE, decayPeriods)
+      );
+    }
+  }
+  const queryKeywords = args.keywords.map((k) => k.toLowerCase());
+  const matches = heatMap.associations.filter(
+    (a) => a.keywords.some(
+      (k) => queryKeywords.some((qk) => k.includes(qk) || qk.includes(k))
+    )
+  ).sort((a, b) => b.confidence - a.confidence).slice(0, 10);
+  return JSON.stringify({
+    matches,
+    totalAssociations: heatMap.associations.length
+  });
+}
+async function handleHeatmapRecord(args, projectDir2) {
+  const heatMap = loadHeatMap(projectDir2);
+  const queryKeywords = args.keywords.map((k) => k.toLowerCase());
+  const existing = heatMap.associations.find(
+    (a) => a.keywords.some((k) => queryKeywords.includes(k))
+  );
+  if (args.signal === "positive") {
+    if (existing) {
+      existing.confidence = Math.min(1, existing.confidence + 0.05);
+      existing.hitCount += 1;
+      existing.lastHit = (/* @__PURE__ */ new Date()).toISOString();
+      for (const s of args.symbols) {
+        if (!existing.symbols.includes(s)) existing.symbols.push(s);
+      }
+      if (args.aspects) {
+        if (!existing.aspects) existing.aspects = [];
+        for (const a of args.aspects) {
+          if (!existing.aspects.includes(a)) existing.aspects.push(a);
+        }
+      }
+      for (const k of queryKeywords) {
+        if (!existing.keywords.includes(k)) existing.keywords.push(k);
+      }
+    } else {
+      heatMap.associations.push({
+        keywords: queryKeywords,
+        symbols: args.symbols,
+        aspects: args.aspects,
+        confidence: 0.5,
+        hitCount: 1,
+        lastHit: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  } else {
+    if (existing) {
+      existing.confidence = Math.max(0.01, existing.confidence - 0.15);
+      if (args.correction) {
+        for (const s of args.symbols) {
+          const idx = existing.symbols.indexOf(s);
+          if (idx >= 0) existing.symbols.splice(idx, 1);
+        }
+      }
+    }
+  }
+  saveHeatMap(projectDir2, heatMap);
+  return JSON.stringify({
+    recorded: true,
+    totalAssociations: heatMap.associations.length
+  });
+}
+async function handleHeatmapStats(projectDir2) {
+  const heatMap = loadHeatMap(projectDir2);
+  const sorted = [...heatMap.associations].sort(
+    (a, b) => b.confidence - a.confidence
+  );
+  const hot = sorted.filter((a) => a.confidence > 0.7);
+  const cold = sorted.filter((a) => a.confidence < 0.3);
+  return JSON.stringify({
+    totalAssociations: heatMap.associations.length,
+    sessionCount: heatMap.sessionCount,
+    lastUpdated: heatMap.lastUpdated,
+    hotAssociations: hot.slice(0, 5).map((a) => ({
+      keywords: a.keywords,
+      confidence: a.confidence,
+      hitCount: a.hitCount
+    })),
+    coldAssociations: cold.slice(0, 5).map((a) => ({
+      keywords: a.keywords,
+      confidence: a.confidence,
+      hitCount: a.hitCount
+    })),
+    topSymbols: getTopSymbols(heatMap)
+  });
+}
+function getTopSymbols(heatMap) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const a of heatMap.associations) {
+    for (const s of a.symbols) {
+      counts.set(s, (counts.get(s) || 0) + a.hitCount);
+    }
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10).map(([symbol, mentions]) => ({ symbol, mentions }));
+}
+async function handleHeatmapTool(name, args, ctx) {
+  switch (name) {
+    case "paradigm_heatmap_query": {
+      const text = await handleHeatmapQuery(
+        args,
+        ctx.rootDir
+      );
+      trackToolCall(text.length, name);
+      return { handled: true, text };
+    }
+    case "paradigm_heatmap_record": {
+      const text = await handleHeatmapRecord(
+        args,
+        ctx.rootDir
+      );
+      trackToolCall(text.length, name);
+      return { handled: true, text };
+    }
+    case "paradigm_heatmap_stats": {
+      const text = await handleHeatmapStats(ctx.rootDir);
+      trackToolCall(text.length, name);
+      return { handled: true, text };
+    }
+    default:
+      return { handled: false, text: "" };
+  }
+}
+
+// ../paradigm-mcp/src/tools/pipeline.ts
+import * as fs24 from "fs";
+import * as path26 from "path";
+import * as yaml14 from "js-yaml";
+var STAGE_ORDER = ["specify", "plan", "task", "implement", "validate"];
+var PIPELINE_DIR = ".paradigm/pipeline";
+var DEFAULT_TEMPLATES = {
+  "add-feature": {
+    gates: { specify: "manual", plan: "manual", task: "auto", implement: "sentinel", validate: "sentinel" },
+    description: "Standard feature addition with manual spec/plan review"
+  },
+  "bug-fix": {
+    gates: { specify: "auto", plan: "auto", task: "auto", implement: "sentinel", validate: "sentinel" },
+    description: "Quick bug fix with automated gates except validation"
+  },
+  "security-change": {
+    gates: { specify: "manual", plan: "manual", task: "manual", implement: "manual", validate: "manual" },
+    description: "Security-sensitive change with all-manual gates"
+  },
+  "refactor": {
+    gates: { specify: "auto", plan: "manual", task: "auto", implement: "sentinel", validate: "sentinel" },
+    description: "Code refactoring with manual plan review"
+  }
+};
+function slugify2(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function loadPipeline(projectDir2, feature) {
+  const slug = slugify2(feature);
+  const filePath = path26.join(projectDir2, PIPELINE_DIR, `${slug}.yaml`);
+  if (!fs24.existsSync(filePath)) return null;
+  return yaml14.load(fs24.readFileSync(filePath, "utf8"));
+}
+function savePipeline(projectDir2, pipeline) {
+  const slug = slugify2(pipeline.feature);
+  const dir = path26.join(projectDir2, PIPELINE_DIR);
+  if (!fs24.existsSync(dir)) fs24.mkdirSync(dir, { recursive: true });
+  const filePath = path26.join(dir, `${slug}.yaml`);
+  fs24.writeFileSync(filePath, yaml14.dump(pipeline, { lineWidth: 120 }), "utf8");
+  return filePath;
+}
+function listPipelines(projectDir2) {
+  const dir = path26.join(projectDir2, PIPELINE_DIR);
+  if (!fs24.existsSync(dir)) return [];
+  return fs24.readdirSync(dir).filter((f) => f.endsWith(".yaml") && !f.startsWith("completed")).map((f) => {
+    try {
+      return yaml14.load(fs24.readFileSync(path26.join(dir, f), "utf8"));
+    } catch {
+      return null;
+    }
+  }).filter(Boolean);
+}
+function createPipeline(feature, gateConfig, template) {
+  const stages = {
+    specify: { status: "pending" },
+    plan: { status: "pending" },
+    task: { status: "pending" },
+    implement: { status: "pending" },
+    validate: { status: "pending" }
+  };
+  stages.specify.status = "in-progress";
+  return {
+    version: "1.0",
+    feature: slugify2(feature),
+    created: (/* @__PURE__ */ new Date()).toISOString(),
+    current_stage: "specify",
+    gate_config: gateConfig,
+    template,
+    stages
+  };
+}
+function getNextStage(current) {
+  const idx = STAGE_ORDER.indexOf(current);
+  return idx < STAGE_ORDER.length - 1 ? STAGE_ORDER[idx + 1] : null;
+}
+function archivePipeline(projectDir2, pipeline) {
+  const slug = slugify2(pipeline.feature);
+  const completedDir = path26.join(projectDir2, PIPELINE_DIR, "completed");
+  if (!fs24.existsSync(completedDir)) fs24.mkdirSync(completedDir, { recursive: true });
+  const destPath = path26.join(completedDir, `${slug}.yaml`);
+  fs24.writeFileSync(destPath, yaml14.dump(pipeline, { lineWidth: 120 }), "utf8");
+  const activePath = path26.join(projectDir2, PIPELINE_DIR, `${slug}.yaml`);
+  if (fs24.existsSync(activePath)) fs24.unlinkSync(activePath);
+}
+function getPipelineToolsList() {
+  return [
+    {
+      name: "paradigm_pipeline_start",
+      description: "Create a new spec pipeline for a feature. Uses templates (add-feature, bug-fix, security-change, refactor) or custom gate config. Returns pipeline state. ~200 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          feature: {
+            type: "string",
+            description: "Feature name or description (will be slugified)"
+          },
+          template: {
+            type: "string",
+            enum: ["add-feature", "bug-fix", "security-change", "refactor"],
+            description: "Pipeline template (default: add-feature)"
+          },
+          gates: {
+            type: "object",
+            properties: {
+              specify: { type: "string", enum: ["auto", "manual", "sentinel"] },
+              plan: { type: "string", enum: ["auto", "manual", "sentinel"] },
+              task: { type: "string", enum: ["auto", "manual", "sentinel"] },
+              implement: { type: "string", enum: ["auto", "manual", "sentinel"] },
+              validate: { type: "string", enum: ["auto", "manual", "sentinel"] }
+            },
+            description: "Custom gate config (overrides template)"
+          }
+        },
+        required: ["feature"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_pipeline_status",
+      description: "Get pipeline status \u2014 current stage, progress, gate config. Pass feature name for specific pipeline, or omit for all active pipelines. ~200 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          feature: {
+            type: "string",
+            description: "Feature name (omit to list all active pipelines)"
+          }
+        }
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_pipeline_advance",
+      description: "Advance pipeline past the current gate. Marks current stage as approved and moves to the next stage. ~150 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          feature: {
+            type: "string",
+            description: "Feature name"
+          },
+          approved_by: {
+            type: "string",
+            description: "Who approved this gate (default: agent)"
+          }
+        },
+        required: ["feature"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_pipeline_configure",
+      description: "Change gate modes on an active pipeline. Use to escalate or relax gates during development. ~150 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          feature: {
+            type: "string",
+            description: "Feature name"
+          },
+          updates: {
+            type: "object",
+            properties: {
+              specify: { type: "string", enum: ["auto", "manual", "sentinel"] },
+              plan: { type: "string", enum: ["auto", "manual", "sentinel"] },
+              task: { type: "string", enum: ["auto", "manual", "sentinel"] },
+              implement: { type: "string", enum: ["auto", "manual", "sentinel"] },
+              validate: { type: "string", enum: ["auto", "manual", "sentinel"] }
+            },
+            description: "Stage-to-gate-mode updates"
+          },
+          reason: {
+            type: "string",
+            description: "Reason for the configuration change"
+          }
+        },
+        required: ["feature", "updates", "reason"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_pipeline_escalate",
+      description: "Flag a pipeline stage for user input. Use when a gate requires a decision the agent cannot make autonomously. ~200 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          feature: {
+            type: "string",
+            description: "Feature name"
+          },
+          stage: {
+            type: "string",
+            enum: ["specify", "plan", "task", "implement", "validate"],
+            description: "Stage to escalate"
+          },
+          question: {
+            type: "string",
+            description: "Question for the user"
+          },
+          options: {
+            type: "array",
+            items: { type: "string" },
+            description: "Available options for the user"
+          },
+          context: {
+            type: "object",
+            description: "Additional context for the decision"
+          }
+        },
+        required: ["feature", "stage", "question", "options"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_pipeline_abort",
+      description: "Cancel and archive an active pipeline. Use when a feature is abandoned or no longer needed. ~100 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          feature: {
+            type: "string",
+            description: "Feature name"
+          }
+        },
+        required: ["feature"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true
+      }
+    },
+    {
+      name: "paradigm_pipeline_list",
+      description: "List all active pipelines with current stages and progress. ~150 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    }
+  ];
+}
+async function handlePipelineTool(name, args, ctx) {
+  switch (name) {
+    case "paradigm_pipeline_start": {
+      const feature = args.feature;
+      const templateName = args.template || "add-feature";
+      const customGates = args.gates;
+      let gateConfig;
+      if (customGates) {
+        gateConfig = {
+          specify: customGates.specify || "manual",
+          plan: customGates.plan || "manual",
+          task: customGates.task || "auto",
+          implement: customGates.implement || "sentinel",
+          validate: customGates.validate || "sentinel"
+        };
+      } else {
+        const tmpl = DEFAULT_TEMPLATES[templateName];
+        if (!tmpl) {
+          return {
+            handled: true,
+            text: JSON.stringify({
+              error: `Unknown template: ${templateName}`,
+              available: Object.keys(DEFAULT_TEMPLATES)
+            })
+          };
+        }
+        gateConfig = tmpl.gates;
+      }
+      const pipeline = createPipeline(feature, gateConfig, templateName);
+      const filePath = savePipeline(ctx.rootDir, pipeline);
+      return {
+        handled: true,
+        text: JSON.stringify(
+          {
+            created: true,
+            feature: pipeline.feature,
+            template: templateName,
+            file: filePath,
+            current_stage: pipeline.current_stage,
+            gate_config: pipeline.gate_config,
+            stages: pipeline.stages,
+            hint: `Pipeline '${pipeline.feature}' started at 'specify' stage. Create your spec, then call paradigm_pipeline_advance to move to 'plan'.`
+          },
+          null,
+          2
+        )
+      };
+    }
+    case "paradigm_pipeline_status": {
+      const feature = args.feature;
+      if (feature) {
+        const pipeline = loadPipeline(ctx.rootDir, feature);
+        if (!pipeline) {
+          return {
+            handled: true,
+            text: JSON.stringify({ error: `Pipeline not found: ${feature}` })
+          };
+        }
+        const completedStages = STAGE_ORDER.filter(
+          (s) => pipeline.stages[s].status === "approved"
+        ).length;
+        return {
+          handled: true,
+          text: JSON.stringify(
+            {
+              feature: pipeline.feature,
+              created: pipeline.created,
+              template: pipeline.template,
+              current_stage: pipeline.current_stage,
+              progress: `${completedStages}/${STAGE_ORDER.length}`,
+              gate_config: pipeline.gate_config,
+              stages: pipeline.stages
+            },
+            null,
+            2
+          )
+        };
+      }
+      const pipelines = listPipelines(ctx.rootDir);
+      if (pipelines.length === 0) {
+        return {
+          handled: true,
+          text: JSON.stringify({
+            count: 0,
+            message: "No active pipelines. Use paradigm_pipeline_start to create one."
+          })
+        };
+      }
+      return {
+        handled: true,
+        text: JSON.stringify(
+          {
+            count: pipelines.length,
+            pipelines: pipelines.map((p) => {
+              const completed = STAGE_ORDER.filter(
+                (s) => p.stages[s].status === "approved"
+              ).length;
+              return {
+                feature: p.feature,
+                current_stage: p.current_stage,
+                progress: `${completed}/${STAGE_ORDER.length}`,
+                template: p.template,
+                created: p.created
+              };
+            })
+          },
+          null,
+          2
+        )
+      };
+    }
+    case "paradigm_pipeline_advance": {
+      const feature = args.feature;
+      const approvedBy = args.approved_by || "agent";
+      const pipeline = loadPipeline(ctx.rootDir, feature);
+      if (!pipeline) {
+        return {
+          handled: true,
+          text: JSON.stringify({ error: `Pipeline not found: ${feature}` })
+        };
+      }
+      const current = pipeline.current_stage;
+      const gateMode = pipeline.gate_config[current];
+      const next = getNextStage(current);
+      pipeline.stages[current].status = "approved";
+      pipeline.stages[current].approved_by = approvedBy;
+      pipeline.stages[current].approved_at = (/* @__PURE__ */ new Date()).toISOString();
+      if (gateMode === "auto") {
+        pipeline.stages[current].auto_passed_at = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      if (next) {
+        pipeline.current_stage = next;
+        pipeline.stages[next].status = "in-progress";
+        savePipeline(ctx.rootDir, pipeline);
+        return {
+          handled: true,
+          text: JSON.stringify(
+            {
+              advanced: true,
+              from: current,
+              to: next,
+              gate_mode: gateMode,
+              approved_by: approvedBy,
+              pipeline: {
+                feature: pipeline.feature,
+                current_stage: pipeline.current_stage,
+                stages: pipeline.stages
+              }
+            },
+            null,
+            2
+          )
+        };
+      }
+      savePipeline(ctx.rootDir, pipeline);
+      archivePipeline(ctx.rootDir, pipeline);
+      return {
+        handled: true,
+        text: JSON.stringify(
+          {
+            completed: true,
+            feature: pipeline.feature,
+            message: `Pipeline '${pipeline.feature}' completed and archived.`,
+            stages: pipeline.stages
+          },
+          null,
+          2
+        )
+      };
+    }
+    case "paradigm_pipeline_configure": {
+      const feature = args.feature;
+      const updates = args.updates;
+      const reason = args.reason;
+      const pipeline = loadPipeline(ctx.rootDir, feature);
+      if (!pipeline) {
+        return {
+          handled: true,
+          text: JSON.stringify({ error: `Pipeline not found: ${feature}` })
+        };
+      }
+      const changes = [];
+      for (const [stage, mode] of Object.entries(updates)) {
+        if (STAGE_ORDER.includes(stage) && ["auto", "manual", "sentinel"].includes(mode)) {
+          const old = pipeline.gate_config[stage];
+          pipeline.gate_config[stage] = mode;
+          changes.push({ stage, from: old, to: mode });
+        }
+      }
+      if (changes.length === 0) {
+        return {
+          handled: true,
+          text: JSON.stringify({
+            error: "No valid gate updates provided",
+            valid_stages: STAGE_ORDER,
+            valid_modes: ["auto", "manual", "sentinel"]
+          })
+        };
+      }
+      savePipeline(ctx.rootDir, pipeline);
+      return {
+        handled: true,
+        text: JSON.stringify(
+          {
+            configured: true,
+            feature: pipeline.feature,
+            changes,
+            reason,
+            gate_config: pipeline.gate_config
+          },
+          null,
+          2
+        )
+      };
+    }
+    case "paradigm_pipeline_escalate": {
+      const feature = args.feature;
+      const stage = args.stage;
+      const question = args.question;
+      const options = args.options;
+      const context2 = args.context;
+      const pipeline = loadPipeline(ctx.rootDir, feature);
+      if (!pipeline) {
+        return {
+          handled: true,
+          text: JSON.stringify({ error: `Pipeline not found: ${feature}` })
+        };
+      }
+      pipeline.stages[stage].status = "blocked";
+      pipeline.stages[stage].block_reason = question;
+      savePipeline(ctx.rootDir, pipeline);
+      return {
+        handled: true,
+        text: JSON.stringify(
+          {
+            escalated: true,
+            feature: pipeline.feature,
+            stage,
+            question,
+            options,
+            context: context2 || {},
+            current_gate: pipeline.gate_config[stage],
+            instruction: "This pipeline stage requires user input. Present the question and options to the user, then use paradigm_pipeline_advance or paradigm_pipeline_configure based on their response."
+          },
+          null,
+          2
+        )
+      };
+    }
+    case "paradigm_pipeline_abort": {
+      const feature = args.feature;
+      const pipeline = loadPipeline(ctx.rootDir, feature);
+      if (!pipeline) {
+        return {
+          handled: true,
+          text: JSON.stringify({ error: `Pipeline not found: ${feature}` })
+        };
+      }
+      archivePipeline(ctx.rootDir, pipeline);
+      return {
+        handled: true,
+        text: JSON.stringify({
+          aborted: true,
+          feature: pipeline.feature,
+          message: `Pipeline '${pipeline.feature}' aborted and archived.`
+        })
+      };
+    }
+    case "paradigm_pipeline_list": {
+      const pipelines = listPipelines(ctx.rootDir);
+      if (pipelines.length === 0) {
+        return {
+          handled: true,
+          text: JSON.stringify({
+            count: 0,
+            message: "No active pipelines."
+          })
+        };
+      }
+      return {
+        handled: true,
+        text: JSON.stringify(
+          {
+            count: pipelines.length,
+            pipelines: pipelines.map((p) => {
+              const completed = STAGE_ORDER.filter(
+                (s) => p.stages[s].status === "approved"
+              ).length;
+              return {
+                feature: p.feature,
+                current_stage: p.current_stage,
+                progress: `${completed}/${STAGE_ORDER.length}`,
+                template: p.template,
+                created: p.created
+              };
+            })
+          },
+          null,
+          2
+        )
+      };
+    }
+    default:
+      return { handled: false, text: "" };
+  }
+}
+
+// ../paradigm-mcp/src/tools/fallback-grep.ts
+import * as path27 from "path";
 import { execSync as execSync5 } from "child_process";
 function grepForReferences(rootDir, symbol, options = {}) {
   const { maxResults = 20 } = options;
@@ -12969,7 +13772,7 @@ function grepForReferences(rootDir, symbol, options = {}) {
     const match = line.match(/^(.+?):(\d+):(.*)$/);
     if (match) {
       const [, filePath, lineNum, content] = match;
-      const relativePath = path25.relative(rootDir, filePath);
+      const relativePath = path27.relative(rootDir, filePath);
       let context2 = "unknown";
       if (relativePath.includes(".purpose") || relativePath.includes("portal.yaml")) {
         context2 = "purpose";
@@ -13234,6 +14037,10 @@ function registerTools(server, getContext2, reloadContext2) {
           ...getProtocolsToolsList(),
           // Graph generation tool
           ...getGraphToolsList(),
+          // Heat map tools
+          ...getHeatmapToolsList(),
+          // Pipeline tools
+          ...getPipelineToolsList(),
           // Plugin update check
           {
             name: "paradigm_plugin_check",
@@ -13867,7 +14674,7 @@ Update command:
             const { rebuildStaticFiles: rebuildStaticFiles2 } = await import("./reindex-CMZARW5K.js");
             const memberResults = [];
             for (const member of ctx.workspace.config.members) {
-              const memberAbsPath = path26.resolve(path26.dirname(ctx.workspace.workspacePath), member.path);
+              const memberAbsPath = path28.resolve(path28.dirname(ctx.workspace.workspacePath), member.path);
               try {
                 const result = await rebuildStaticFiles2(memberAbsPath);
                 memberResults.push({
@@ -14065,6 +14872,23 @@ Update command:
                 };
               }
             }
+            if (name.startsWith("paradigm_heatmap_")) {
+              const result = await handleHeatmapTool(name, args, ctx);
+              if (result.handled) {
+                return {
+                  content: [{ type: "text", text: result.text }]
+                };
+              }
+            }
+            if (name.startsWith("paradigm_pipeline_")) {
+              const result = await handlePipelineTool(name, args, ctx);
+              if (result.handled) {
+                trackToolCall(result.text.length, name);
+                return {
+                  content: [{ type: "text", text: result.text }]
+                };
+              }
+            }
             if (name === "paradigm_reindex") {
               const reload = reloadContext2 || (async () => {
               });