@a-company/paradigm 3.0.3 → 3.1.2

package/dist/triage-TBIWJA6R.js

@@ -0,0 +1,671 @@
+#!/usr/bin/env node
+import {
+  PatternImporter,
+  PatternMatcher,
+  PatternSuggester,
+  StatsCalculator,
+  TimelineBuilder,
+  loadAllSeedPatterns
+} from "./chunk-4LGLU2LO.js";
+import {
+  SentinelStorage
+} from "./chunk-VZ7CXFRZ.js";
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/triage/index.ts
+import chalk2 from "chalk";
+import ora from "ora";
+
+// src/commands/triage/utils/format.ts
+import chalk from "chalk";
+function formatHeader() {
+  return `
+${chalk.cyan("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557")}
+${chalk.cyan("\u2551")}                    ${chalk.bold.white("PARADIGM SENTINEL TRIAGE")}                      ${chalk.cyan("\u2551")}
+${chalk.cyan("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D")}
+`;
+}
+function formatSummaryBar(stats) {
+  return `${chalk.cyan("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557")}
+${chalk.cyan("\u2551")}  Open: ${chalk.yellow(String(stats.open).padEnd(4))} \u2502  Investigating: ${chalk.blue(String(stats.investigating).padEnd(3))} \u2502  Resolved: ${chalk.green(String(stats.resolved).padEnd(4))} \u2502  Today: ${chalk.magenta(`+${stats.today}`)}   ${chalk.cyan("\u2551")}
+${chalk.cyan("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D")}
+`;
+}
+function formatIncident(incident, matches) {
+  const lines = [];
+  const statusColor = getStatusColor(incident.status);
+  lines.push(
+    chalk.gray("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510")
+  );
+  lines.push(
+    chalk.gray("\u2502 ") + chalk.bold(`[${incident.id}] `) + statusColor(incident.status.toUpperCase().padEnd(12)) + chalk.gray(incident.timestamp.substring(0, 19).replace("T", " ").padStart(19)) + chalk.gray(" \u2502")
+  );
+  lines.push(
+    chalk.gray("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524")
+  );
+  lines.push(chalk.gray("\u2502 ") + chalk.red("Error: ") + truncate(incident.error.message, 55) + chalk.gray(" \u2502"));
+  lines.push(chalk.gray("\u2502") + " ".repeat(65) + chalk.gray("\u2502"));
+  lines.push(chalk.gray("\u2502 ") + chalk.cyan("Symbolic Context:") + " ".repeat(47) + chalk.gray("\u2502"));
+  const symbols = formatSymbols(incident.symbols);
+  for (const sym of symbols) {
+    lines.push(chalk.gray("\u2502   ") + sym.padEnd(61) + chalk.gray(" \u2502"));
+  }
+  lines.push(chalk.gray("\u2502") + " ".repeat(65) + chalk.gray("\u2502"));
+  const envLine = `Environment: ${chalk.yellow(incident.environment)}  \u2502  Service: ${chalk.yellow(incident.service || "N/A")}  \u2502  v${incident.version || "N/A"}`;
+  lines.push(chalk.gray("\u2502 ") + envLine.substring(0, 63).padEnd(63) + chalk.gray(" \u2502"));
+  if (matches && matches.length > 0) {
+    lines.push(chalk.gray("\u2502") + " ".repeat(65) + chalk.gray("\u2502"));
+    lines.push(
+      chalk.gray("\u2502 \u250C\u2500 ") + chalk.cyan("Matched Patterns") + chalk.gray(" \u2500".repeat(22) + "\u2510 \u2502")
+    );
+    for (let i = 0; i < Math.min(matches.length, 3); i++) {
+      const match = matches[i];
+      const icon = i === 0 ? chalk.yellow("\u2605") : chalk.gray("\u25CB");
+      const conf = `${match.confidence}% confidence`;
+      lines.push(
+        chalk.gray("\u2502 \u2502 ") + icon + " " + chalk.bold(truncate(match.pattern.id, 30).padEnd(30)) + chalk.gray(conf.padStart(15)) + chalk.gray("    \u2502 \u2502")
+      );
+      lines.push(
+        chalk.gray("\u2502 \u2502   ") + chalk.italic(truncate(match.pattern.description, 45).padEnd(45)) + chalk.gray("     \u2502 \u2502")
+      );
+      lines.push(
+        chalk.gray("\u2502 \u2502   Strategy: ") + chalk.cyan(match.pattern.resolution.strategy.padEnd(40)) + chalk.gray("     \u2502 \u2502")
+      );
+      if (i < Math.min(matches.length, 3) - 1) {
+        lines.push(chalk.gray("\u2502 \u2502") + " ".repeat(59) + chalk.gray("\u2502 \u2502"));
+      }
+    }
+    lines.push(
+      chalk.gray("\u2502 \u2514") + "\u2500".repeat(59) + chalk.gray("\u2518 \u2502")
+    );
+  }
+  lines.push(chalk.gray("\u2502") + " ".repeat(65) + chalk.gray("\u2502"));
+  lines.push(chalk.gray("\u2502 ") + chalk.dim("Actions:") + " ".repeat(56) + chalk.gray("\u2502"));
+  lines.push(
+    chalk.gray("\u2502   ") + chalk.dim(`paradigm triage resolve ${incident.id}`) + " ".repeat(35 - incident.id.length) + chalk.gray("\u2502")
+  );
+  lines.push(
+    chalk.gray("\u2502   ") + chalk.dim(`paradigm triage show ${incident.id} --timeline`) + " ".repeat(28 - incident.id.length) + chalk.gray("\u2502")
+  );
+  lines.push(
+    chalk.gray("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518")
+  );
+  return lines.join("\n");
+}
+function formatIncidentCompact(incident) {
+  const statusColor = getStatusColor(incident.status);
+  const status = statusColor(incident.status.substring(0, 4).toUpperCase().padEnd(4));
+  const timestamp = incident.timestamp.substring(5, 16).replace("T", " ");
+  const error = truncate(incident.error.message, 40);
+  const symbols = Object.values(incident.symbols).filter(Boolean).join(" ");
+  return `${chalk.bold(incident.id)} ${status} ${chalk.gray(timestamp)} ${error}
+    ${chalk.cyan(truncate(symbols, 60))}`;
+}
+function formatPattern(pattern) {
+  const lines = [];
+  lines.push(chalk.bold.cyan(`Pattern: ${pattern.id}`));
+  lines.push(chalk.white(`  Name: ${pattern.name}`));
+  lines.push(chalk.gray(`  Description: ${pattern.description}`));
+  lines.push("");
+  lines.push(chalk.yellow("  Matching Criteria:"));
+  if (pattern.pattern.symbols) {
+    for (const [key, value] of Object.entries(pattern.pattern.symbols)) {
+      if (value) {
+        const v = Array.isArray(value) ? value.join(", ") : value;
+        lines.push(`    ${chalk.cyan(key)}: ${v}`);
+      }
+    }
+  }
+  if (pattern.pattern.errorContains) {
+    lines.push(
+      `    ${chalk.cyan("errorContains")}: ${pattern.pattern.errorContains.join(", ")}`
+    );
+  }
+  if (pattern.pattern.missingSignals) {
+    lines.push(
+      `    ${chalk.cyan("missingSignals")}: ${pattern.pattern.missingSignals.join(", ")}`
+    );
+  }
+  lines.push("");
+  lines.push(chalk.green("  Resolution:"));
+  lines.push(`    ${chalk.white(pattern.resolution.description)}`);
+  lines.push(
+    `    Strategy: ${chalk.cyan(pattern.resolution.strategy)}  Priority: ${getPriorityColor(pattern.resolution.priority)(pattern.resolution.priority)}`
+  );
+  if (pattern.resolution.codeHint) {
+    lines.push(`    ${chalk.dim("Hint: " + pattern.resolution.codeHint)}`);
+  }
+  lines.push("");
+  lines.push(chalk.blue("  Confidence:"));
+  lines.push(
+    `    Score: ${getConfidenceColor(pattern.confidence.score)(pattern.confidence.score + "%")}  Matched: ${pattern.confidence.timesMatched}  Resolved: ${pattern.confidence.timesResolved}  Recurred: ${pattern.confidence.timesRecurred}`
+  );
+  lines.push("");
+  lines.push(
+    chalk.gray(
+      `  Source: ${pattern.source}  Tags: ${pattern.tags.join(", ") || "none"}`
+    )
+  );
+  return lines.join("\n");
+}
+function formatPatternCompact(pattern) {
+  const confidence = getConfidenceColor(pattern.confidence.score)(
+    `${pattern.confidence.score}%`
+  );
+  const tags = pattern.tags.slice(0, 3).join(", ");
+  return `${chalk.bold(pattern.id.padEnd(30))} ${confidence.padStart(8)}  ${chalk.gray(pattern.source.padEnd(10))} ${chalk.dim(tags)}
+  ${chalk.white(truncate(pattern.name, 60))}`;
+}
+function formatSymbols(symbols) {
+  const result = [];
+  for (const [key, value] of Object.entries(symbols)) {
+    if (value) {
+      const color = getSymbolColor(key);
+      result.push(`${color(value.padEnd(20))} ${chalk.dim(key)}`);
+    }
+  }
+  return result;
+}
+function getStatusColor(status) {
+  switch (status) {
+    case "open":
+      return chalk.red;
+    case "investigating":
+      return chalk.yellow;
+    case "resolved":
+      return chalk.green;
+    case "wont-fix":
+      return chalk.gray;
+    default:
+      return chalk.white;
+  }
+}
+function getSymbolColor(type) {
+  switch (type) {
+    case "feature":
+      return chalk.magenta;
+    case "component":
+      return chalk.blue;
+    case "flow":
+      return chalk.cyan;
+    case "gate":
+      return chalk.yellow;
+    case "signal":
+      return chalk.green;
+    case "state":
+      return chalk.red;
+    case "integration":
+      return chalk.white;
+    default:
+      return chalk.gray;
+  }
+}
+function getPriorityColor(priority) {
+  switch (priority) {
+    case "critical":
+      return chalk.red.bold;
+    case "high":
+      return chalk.red;
+    case "medium":
+      return chalk.yellow;
+    case "low":
+      return chalk.gray;
+    default:
+      return chalk.white;
+  }
+}
+function getConfidenceColor(score) {
+  if (score >= 80) return chalk.green;
+  if (score >= 60) return chalk.yellow;
+  if (score >= 40) return chalk.red;
+  return chalk.gray;
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.substring(0, maxLen - 3) + "...";
+}
+
+// src/commands/triage/index.ts
+import * as fs from "fs";
+var storage = null;
+function getStorage() {
+  if (!storage) {
+    storage = new SentinelStorage();
+  }
+  return storage;
+}
+async function triageListCommand(options) {
+  const store = getStorage();
+  const matcher = new PatternMatcher(store);
+  const limit = parseInt(options.limit || "10", 10);
+  const status = options.status;
+  const incidents = store.getRecentIncidents({
+    limit,
+    status: status || "all",
+    symbol: options.symbol,
+    environment: options.env,
+    search: options.search,
+    dateFrom: options.from,
+    dateTo: options.to
+  });
+  if (options.json) {
+    const result = incidents.map((i) => ({
+      incident: i,
+      matches: matcher.match(i, { maxResults: 3 })
+    }));
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  const stats = new StatsCalculator(store).getStats(7);
+  const todayStart = /* @__PURE__ */ new Date();
+  todayStart.setHours(0, 0, 0, 0);
+  const todayCount = store.getIncidentCount({
+    dateFrom: todayStart.toISOString()
+  });
+  console.log(formatHeader());
+  console.log(
+    formatSummaryBar({
+      open: stats.incidents.open,
+      investigating: stats.incidents.total - stats.incidents.open - stats.incidents.resolved,
+      resolved: stats.incidents.resolved,
+      today: todayCount
+    })
+  );
+  console.log("");
+  if (incidents.length === 0) {
+    console.log(chalk2.gray("No incidents found."));
+    return;
+  }
+  for (const incident of incidents) {
+    const matches = matcher.match(incident, { maxResults: 3 });
+    console.log(formatIncident(incident, matches));
+    console.log("");
+  }
+}
+async function triageShowCommand(incidentId, options) {
+  const store = getStorage();
+  const matcher = new PatternMatcher(store);
+  const incident = store.getIncident(incidentId);
+  if (!incident) {
+    console.log(chalk2.red(`Incident ${incidentId} not found.`));
+    return;
+  }
+  const matches = matcher.match(incident, { maxResults: 5 });
+  if (options.json) {
+    const result = { incident, matches };
+    if (options.timeline && incident.flowPosition) {
+      const timeline = new TimelineBuilder().build(incident);
+      result.timeline = timeline ? new TimelineBuilder().renderStructured(timeline) : null;
+    }
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(formatIncident(incident, matches));
+  if (options.timeline && incident.flowPosition) {
+    const timeline = new TimelineBuilder().build(incident);
+    if (timeline) {
+      console.log("");
+      console.log(chalk2.cyan.bold("Flow Timeline"));
+      console.log(chalk2.gray("\u2500".repeat(50)));
+      console.log(new TimelineBuilder().renderAscii(timeline));
+    }
+  }
+  if (incident.notes.length > 0) {
+    console.log("");
+    console.log(chalk2.cyan.bold("Notes"));
+    console.log(chalk2.gray("\u2500".repeat(50)));
+    for (const note of incident.notes) {
+      console.log(
+        chalk2.gray(note.timestamp.substring(0, 16)) + " " + (note.author ? chalk2.yellow(note.author + ": ") : "") + note.content
+      );
+    }
+  }
+  if (incident.relatedIncidents.length > 0) {
+    console.log("");
+    console.log(chalk2.cyan.bold("Related Incidents"));
+    console.log(chalk2.gray("\u2500".repeat(50)));
+    console.log("  " + incident.relatedIncidents.join(", "));
+  }
+}
+async function triageResolveCommand(incidentId, options) {
+  const store = getStorage();
+  const incident = store.getIncident(incidentId);
+  if (!incident) {
+    console.log(chalk2.red(`Incident ${incidentId} not found.`));
+    return;
+  }
+  if (incident.status === "resolved" || incident.status === "wont-fix") {
+    console.log(chalk2.yellow(`Incident ${incidentId} is already ${incident.status}.`));
+    return;
+  }
+  if (options.wontFix) {
+    store.updateIncident(incidentId, {
+      status: "wont-fix",
+      resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      resolvedBy: "manual",
+      resolution: {
+        notes: options.notes
+      }
+    });
+    console.log(chalk2.gray(`Incident ${incidentId} marked as won't fix.`));
+    return;
+  }
+  store.recordResolution({
+    incidentId,
+    patternId: options.pattern,
+    commitHash: options.commit,
+    prUrl: options.pr,
+    notes: options.notes
+  });
+  console.log(chalk2.green(`Incident ${incidentId} resolved.`));
+  if (options.pattern) {
+    console.log(chalk2.gray(`  Pattern: ${options.pattern}`));
+  }
+  if (options.commit) {
+    console.log(chalk2.gray(`  Commit: ${options.commit}`));
+  }
+  if (options.pr) {
+    console.log(chalk2.gray(`  PR: ${options.pr}`));
+  }
+}
+async function triageNoteCommand(incidentId, note) {
+  const store = getStorage();
+  const incident = store.getIncident(incidentId);
+  if (!incident) {
+    console.log(chalk2.red(`Incident ${incidentId} not found.`));
+    return;
+  }
+  store.addIncidentNote(incidentId, {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    content: note
+  });
+  console.log(chalk2.green(`Note added to ${incidentId}.`));
+}
+async function triageLinkCommand(incidentId1, incidentId2) {
+  const store = getStorage();
+  const inc1 = store.getIncident(incidentId1);
+  const inc2 = store.getIncident(incidentId2);
+  if (!inc1) {
+    console.log(chalk2.red(`Incident ${incidentId1} not found.`));
+    return;
+  }
+  if (!inc2) {
+    console.log(chalk2.red(`Incident ${incidentId2} not found.`));
+    return;
+  }
+  store.linkIncidents(incidentId1, incidentId2);
+  console.log(chalk2.green(`Linked ${incidentId1} and ${incidentId2}.`));
+}
+async function triagePatternsListCommand(options) {
+  const store = getStorage();
+  const patterns = store.getAllPatterns({
+    source: options.source,
+    minConfidence: options.minConfidence ? parseInt(options.minConfidence, 10) : void 0,
+    includePrivate: true
+  });
+  if (options.json) {
+    console.log(JSON.stringify(patterns, null, 2));
+    return;
+  }
+  console.log(chalk2.cyan.bold("\nFailure Patterns"));
+  console.log(chalk2.gray("\u2500".repeat(70)));
+  if (patterns.length === 0) {
+    console.log(chalk2.gray("No patterns found. Run `paradigm triage patterns seed` to load defaults."));
+    return;
+  }
+  for (const pattern of patterns) {
+    console.log(formatPatternCompact(pattern));
+    console.log("");
+  }
+}
+async function triagePatternsShowCommand(patternId, options) {
+  const store = getStorage();
+  const pattern = store.getPattern(patternId);
+  if (!pattern) {
+    console.log(chalk2.red(`Pattern ${patternId} not found.`));
+    return;
+  }
+  if (options.json) {
+    console.log(JSON.stringify(pattern, null, 2));
+    return;
+  }
+  console.log(formatPattern(pattern));
+}
+async function triagePatternsAddCommand(options) {
+  const store = getStorage();
+  if (options.fromIncident) {
+    const incident = store.getIncident(options.fromIncident);
+    if (!incident) {
+      console.log(chalk2.red(`Incident ${options.fromIncident} not found.`));
+      return;
+    }
+    const suggester = new PatternSuggester(store);
+    const suggested = suggester.suggestFromIncident(incident);
+    console.log(chalk2.cyan("\nSuggested Pattern:"));
+    console.log(JSON.stringify(suggested, null, 2));
+    console.log(
+      chalk2.gray(
+        '\nEdit and add with: paradigm triage patterns add --id <id> --name "..." ...'
+      )
+    );
+    return;
+  }
+  const symbols = {};
+  if (options.symbols) {
+    const pairs = options.symbols.split(",");
+    for (const pair of pairs) {
+      const [key, value] = pair.split(":").map((s) => s.trim());
+      if (key && value) {
+        symbols[key] = value;
+      }
+    }
+  }
+  const input = {
+    id: options.id,
+    name: options.name,
+    description: options.description || "",
+    pattern: {
+      symbols,
+      errorContains: options.errorContains?.split(",").map((s) => s.trim()),
+      missingSignals: options.missingSignals?.split(",").map((s) => s.trim())
+    },
+    resolution: {
+      description: "Resolution TBD",
+      strategy: options.strategy || "fix-code",
+      priority: options.priority || "medium",
+      codeHint: options.codeHint
+    },
+    source: "manual",
+    private: false,
+    tags: options.tags?.split(",").map((s) => s.trim()) || []
+  };
+  store.addPattern(input);
+  console.log(chalk2.green(`Pattern ${options.id} created.`));
+}
+async function triagePatternsDeleteCommand(patternId) {
+  const store = getStorage();
+  const pattern = store.getPattern(patternId);
+  if (!pattern) {
+    console.log(chalk2.red(`Pattern ${patternId} not found.`));
+    return;
+  }
+  store.deletePattern(patternId);
+  console.log(chalk2.green(`Pattern ${patternId} deleted.`));
+}
+async function triagePatternsTestCommand(patternId, options) {
+  const store = getStorage();
+  const matcher = new PatternMatcher(store);
+  const pattern = store.getPattern(patternId);
+  if (!pattern) {
+    console.log(chalk2.red(`Pattern ${patternId} not found.`));
+    return;
+  }
+  const limit = parseInt(options.limit || "100", 10);
+  const result = matcher.testPattern(pattern, limit);
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(chalk2.cyan.bold(`
+Pattern Test: ${patternId}`));
+  console.log(chalk2.gray("\u2500".repeat(50)));
+  console.log(`Would match: ${chalk2.yellow(result.matchCount)} incidents`);
+  console.log(`Average score: ${chalk2.yellow(result.avgScore + "%")}`);
+  if (result.wouldMatch.length > 0) {
+    console.log("");
+    console.log(chalk2.cyan("Sample matches:"));
+    for (const incident of result.wouldMatch.slice(0, 5)) {
+      console.log(formatIncidentCompact(incident));
+    }
+  }
+}
+async function triagePatternsSeedCommand() {
+  const store = getStorage();
+  const spinner = ora("Loading seed patterns...").start();
+  try {
+    const seedData = loadAllSeedPatterns();
+    const result = store.importPatterns(seedData, { overwrite: false });
+    spinner.succeed(
+      `Loaded ${result.imported} patterns (${result.skipped} skipped).`
+    );
+  } catch (error) {
+    spinner.fail(`Failed to load seed patterns: ${error}`);
+  }
+}
+async function triageExportCommand(type, options) {
+  const store = getStorage();
+  let data;
+  let defaultFilename;
+  if (type === "patterns") {
+    data = store.exportPatterns({
+      includePrivate: options.includePrivate
+    });
+    defaultFilename = "sentinel-patterns.json";
+  } else {
+    data = store.exportBackup();
+    defaultFilename = "sentinel-backup.json";
+  }
+  const outputPath = options.output || defaultFilename;
+  fs.writeFileSync(outputPath, JSON.stringify(data, null, 2));
+  console.log(chalk2.green(`Exported to ${outputPath}`));
+}
+async function triageImportCommand(filePath, options) {
+  const store = getStorage();
+  const importer = new PatternImporter();
+  const spinner = ora(`Importing from ${filePath}...`).start();
+  try {
+    const data = importer.loadFromFile(filePath);
+    const result = store.importPatterns(data, {
+      overwrite: options.overwrite
+    });
+    spinner.succeed(
+      `Imported ${result.imported} patterns (${result.skipped} skipped).`
+    );
+  } catch (error) {
+    spinner.fail(`Import failed: ${error}`);
+  }
+}
+async function triageRestoreCommand(filePath) {
+  const store = getStorage();
+  const spinner = ora(`Restoring from ${filePath}...`).start();
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const data = JSON.parse(content);
+    store.importBackup(data);
+    spinner.succeed("Backup restored.");
+  } catch (error) {
+    spinner.fail(`Restore failed: ${error}`);
+  }
+}
+async function triageStatsCommand(options) {
+  const store = getStorage();
+  const calculator = new StatsCalculator(store);
+  let periodDays = 7;
+  if (options.period) {
+    const match = options.period.match(/^(\d+)d$/);
+    if (match) {
+      periodDays = parseInt(match[1], 10);
+    }
+  }
+  if (options.symbol) {
+    const health = calculator.getSymbolHealth(options.symbol);
+    if (options.json) {
+      console.log(JSON.stringify(health, null, 2));
+    } else {
+      console.log(chalk2.cyan.bold(`
+Symbol Health: ${options.symbol}`));
+      console.log(chalk2.gray("\u2500".repeat(50)));
+      console.log(`  Incidents: ${health.incidentCount}`);
+      console.log(`  Avg Time to Resolve: ${health.avgTimeToResolve}m`);
+      console.log("");
+      console.log(chalk2.cyan("  Top Patterns:"));
+      for (const { patternId, count } of health.topPatterns) {
+        console.log(`    ${patternId}: ${count} times`);
+      }
+    }
+    return;
+  }
+  const stats = calculator.getStats(periodDays);
+  if (options.json) {
+    console.log(JSON.stringify(stats, null, 2));
+    return;
+  }
+  console.log(calculator.generateDashboard(periodDays));
+}
+async function triageRecordCommand(options) {
+  const store = getStorage();
+  const matcher = new PatternMatcher(store);
+  const incidentId = store.recordIncident({
+    error: {
+      message: options.error,
+      stack: options.stack
+    },
+    symbols: {
+      feature: options.feature,
+      component: options.component,
+      flow: options.flow,
+      gate: options.gate,
+      signal: options.signal,
+      state: options.state,
+      integration: options.integration
+    },
+    environment: options.env,
+    service: options.service,
+    version: options.version
+  });
+  const incident = store.getIncident(incidentId);
+  const matches = incident ? matcher.match(incident, { maxResults: 3 }) : [];
+  if (options.json) {
+    console.log(JSON.stringify({ incidentId, matches }, null, 2));
+    return;
+  }
+  console.log(chalk2.green(`Recorded incident ${incidentId}`));
+  if (matches.length > 0) {
+    console.log("");
+    console.log(chalk2.cyan("Matched patterns:"));
+    for (const match of matches) {
+      console.log(
+        `  ${chalk2.yellow("\u2605")} ${match.pattern.id} (${match.confidence}% confidence)`
+      );
+      console.log(chalk2.gray(`     ${match.pattern.resolution.description}`));
+    }
+  }
+}
+export {
+  triageExportCommand,
+  triageImportCommand,
+  triageLinkCommand,
+  triageListCommand,
+  triageNoteCommand,
+  triagePatternsAddCommand,
+  triagePatternsDeleteCommand,
+  triagePatternsListCommand,
+  triagePatternsSeedCommand,
+  triagePatternsShowCommand,
+  triagePatternsTestCommand,
+  triageRecordCommand,
+  triageResolveCommand,
+  triageRestoreCommand,
+  triageShowCommand,
+  triageStatsCommand
+};

package/dist/university-content/courses/para-401.json

@@ -6,7 +6,7 @@
     {
       "id": "mcp-tools-overview",
       "title": "MCP Tools Overview",
-      "content": "## MCP Tools Overview\n\nModel Context Protocol (MCP) tools are the primary interface between AI agents and the Paradigm framework. Rather than reading raw files to understand project structure, agents call MCP tools that return structured, token-efficient responses. Understanding the full tool inventory and when to use each tool is fundamental to effective Paradigm orchestration.\n\nParadigm exposes approximately 15 tool modules, organized into four categories:\n\n### Discovery Tools\nThese tools help agents understand the codebase without reading files directly.\n\n- **`paradigm_search`** (~150 tokens) -- Fuzzy search across symbol names, descriptions, and tags. Supports type filtering (component, flow, gate, signal, aspect).\n- **`paradigm_navigate`** (~200 tokens) -- Three intents: `find` (symbol lookup), `explore` (area browsing), `context` (task-based discovery).\n- **`paradigm_ripple`** (~300 tokens) -- Dependency analysis showing what depends on a symbol, 1-5 levels deep.\n- **`paradigm_related`** (~200 tokens) -- All symbols connected to a given symbol, both upstream and downstream.\n\n### Knowledge Tools\nThese tools access the project's institutional memory.\n\n- **`paradigm_wisdom_context`** -- Retrieves preferences, antipatterns, and decisions for specified symbols.\n- **`paradigm_wisdom_record`** -- Captures new antipatterns or architectural decisions.\n- **`paradigm_wisdom_expert`** -- Identifies human experts for symbols or areas.\n- **`paradigm_history_context`** -- Retrieves implementation history for symbols.\n- **`paradigm_history_record`** -- Logs implementation events.\n- **`paradigm_history_fragility`** -- Checks stability scores.\n\n### Validation Tools\nThese tools verify metadata integrity.\n\n- **`paradigm_purpose_validate`** -- Validates `.purpose` files and optionally `portal.yaml`.\n- **`paradigm_flow_validate`** -- Validates flow definitions against the codebase.\n- **`paradigm_aspect_check`** -- Verifies that aspects have valid code anchors.\n\n### Management Tools\nThese tools modify Paradigm metadata.\n\n- **`paradigm_purpose_add_component`**, **`paradigm_purpose_add_signal`**, **`paradigm_purpose_add_flow`**, etc. -- Add symbols to `.purpose` files.\n- **`paradigm_portal_add_gate`**, **`paradigm_portal_add_route`** -- Manage `portal.yaml` gates and routes.\n- **`paradigm_purpose_rename`** -- Rename symbols across all `.purpose` files.\n- **`paradigm_tags`**, **`paradigm_tags_suggest`** -- Manage the tag bank.\n\n### Token Economics\n\nEvery tool call has a token cost. The general principle is that MCP queries are 5-20x cheaper than reading files:\n\n| Operation | Approximate Cost |\n|---|---|\n| `paradigm_status` | ~100 tokens |\n| `paradigm_search` | ~150 tokens |\n| `paradigm_navigate` | ~200 tokens |\n| `paradigm_ripple` | ~300 tokens |\n| Reading a small file | ~500 tokens |\n| Reading a large file | ~2000+ tokens |\n\nThe rule of thumb: **use MCP tools for discovery and knowledge retrieval; use file reads only when you need exact source code for implementation.** An agent that reads 10 files to understand a feature (10,000+ tokens) versus one that calls `paradigm_navigate` with context intent (200 tokens) has a 50x cost difference for the same information.",
+      "content": "## MCP Tools Overview\n\nModel Context Protocol (MCP) tools are the primary interface between AI agents and the Paradigm framework. Rather than reading raw files to understand project structure, agents call MCP tools that return structured, token-efficient responses. Understanding the full tool inventory and when to use each tool is fundamental to effective Paradigm orchestration.\n\nParadigm exposes approximately 15 tool modules, organized into four categories:\n\n### Discovery Tools\nThese tools help agents understand the codebase without reading files directly.\n\n- **`paradigm_search`** (~150 tokens) -- Fuzzy search across symbol names, descriptions, and tags. Supports type filtering (component, flow, gate, signal, aspect).\n- **`paradigm_navigate`** (~200 tokens) -- Three intents: `find` (symbol lookup), `explore` (area browsing), `context` (task-based discovery).\n- **`paradigm_ripple`** (~300 tokens) -- Dependency analysis showing what depends on a symbol, 1-5 levels deep.\n- **`paradigm_related`** (~200 tokens) -- All symbols connected to a given symbol, both upstream and downstream.\n\n### Knowledge Tools\nThese tools access the project's institutional memory.\n\n- **`paradigm_wisdom_context`** -- Retrieves preferences, antipatterns, and decisions for specified symbols.\n- **`paradigm_wisdom_record`** -- Captures new antipatterns or architectural decisions.\n- **`paradigm_wisdom_expert`** -- Identifies human experts for symbols or areas.\n- **`paradigm_history_context`** -- Retrieves implementation history for symbols.\n- **`paradigm_history_record`** -- Logs implementation events.\n- **`paradigm_history_fragility`** -- Checks stability scores.\n\n### Validation Tools\nThese tools verify metadata integrity.\n\n- **`paradigm_purpose_validate`** -- Validates `.purpose` files and optionally `portal.yaml`.\n- **`paradigm_flow_validate`** -- Validates flow definitions against the codebase.\n- **`paradigm_aspect_check`** -- Verifies that aspects have valid code anchors.\n\n### Management Tools\nThese tools modify Paradigm metadata.\n\n- **`paradigm_purpose_add_component`**, **`paradigm_purpose_add_signal`**, **`paradigm_purpose_add_flow`**, etc. -- Add symbols to `.purpose` files.\n- **`paradigm_portal_add_gate`**, **`paradigm_portal_add_route`** -- Manage `portal.yaml` gates and routes.\n- **`paradigm_purpose_rename`** -- Rename symbols across all `.purpose` files.\n- **`paradigm_tags`**, **`paradigm_tags_suggest`** -- Manage the tag bank.\n\n### Token Economics\n\nEvery tool call has a token cost. The general principle is that MCP queries are 5-20x cheaper than reading files:\n\n| Operation | Approximate Cost |\n|---|---|\n| `paradigm_status` | ~100 tokens |\n| `paradigm_search` | ~150 tokens |\n| `paradigm_navigate` | ~200 tokens |\n| `paradigm_ripple` | ~300 tokens |\n| Reading a small file | ~500 tokens |\n| Reading a large file | ~2000+ tokens |\n\nThe rule of thumb: **use MCP tools for discovery and knowledge retrieval; use file reads only when you need exact source code for implementation.** An agent that reads 10 files to understand a feature (10,000+ tokens) versus one that calls `paradigm_navigate` with context intent (200 tokens) has a 50x cost difference for the same information.\n\n### Practice Tools\n\nThese tools manage behavioral discipline and project memory.\n\n**Habits Tools:**\n- **`paradigm_habits_list`** -- List habit definitions with filters (category, trigger, severity, enabled status).\n- **`paradigm_habits_check`** -- Evaluate and record practice compliance. Triggers: `preflight`, `postflight`, `on-stop`, `on-commit`.\n- **`paradigm_habits_status`** -- Practice profile with compliance rates, category breakdowns, trends, and incident correlations.\n- **`paradigm_practice_context`** -- Proactive habit warnings before modifying symbols. Returns relevant habits and recent compliance rates.\n\n**Lore Tools:**\n- **`paradigm_lore_search`** -- Search lore entries by symbol, author, date range, tags, type, and review status.\n- **`paradigm_lore_record`** -- Record new entries (agent sessions, decisions, milestones, incidents, reviews).\n- **`paradigm_lore_get`** -- Fetch a single entry by ID with full detail.\n- **`paradigm_lore_update`** -- Update an existing entry's fields (title, summary, type, symbols, tags, learnings).\n- **`paradigm_lore_delete`** -- Delete an entry by ID. Requires `confirm: true` to prevent accidental deletion.\n- **`paradigm_lore_timeline`** -- Timeline overview with recent entries, hot symbols, and active authors.",
       "keyConcepts": [
         "Four tool categories: discovery, knowledge, validation, management",
         "Token economics of MCP vs file reads",