@a-company/paradigm 1.5.0

package/dist/dist-NHJQVVUW.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+import {
+  PREFIX_TO_TYPE,
+  SYMBOL_PREFIXES,
+  addConnection,
+  addPremiseNode,
+  aggregateFromDirectory,
+  aggregateFromPremise,
+  buildSymbolIndex,
+  createEmptyPremiseFile,
+  createSnapshot,
+  createSymbolIndex,
+  createSymbolString,
+  getAllSymbols,
+  getAllTags,
+  getAutocompleteSuggestions,
+  getDefaultPremiseContent,
+  getReferencesFrom,
+  getReferencesTo,
+  getSymbol,
+  getSymbolById,
+  getSymbolCounts,
+  getSymbolsBySource,
+  getSymbolsByTag,
+  getSymbolsByType,
+  isValidSymbol,
+  parsePremiseContent,
+  parsePremiseFile,
+  parseSymbol,
+  searchSymbols,
+  serializePremiseFile,
+  updateNodePosition
+} from "./chunk-5C4SGQKH.js";
+import "./chunk-PW2EXJQT.js";
+import "./chunk-IRKUEJVW.js";
+import "./chunk-MO4EEYFW.js";
+export {
+  PREFIX_TO_TYPE,
+  SYMBOL_PREFIXES,
+  addConnection,
+  addPremiseNode,
+  aggregateFromDirectory,
+  aggregateFromPremise,
+  buildSymbolIndex,
+  createEmptyPremiseFile,
+  createSnapshot,
+  createSymbolIndex,
+  createSymbolString,
+  getAllSymbols,
+  getAllTags,
+  getAutocompleteSuggestions,
+  getDefaultPremiseContent,
+  getReferencesFrom,
+  getReferencesTo,
+  getSymbol,
+  getSymbolById,
+  getSymbolCounts,
+  getSymbolsBySource,
+  getSymbolsByTag,
+  getSymbolsByType,
+  isValidSymbol,
+  parsePremiseContent,
+  parsePremiseFile,
+  parseSymbol,
+  searchSymbols,
+  serializePremiseFile,
+  updateNodePosition
+};

package/dist/dist-ZEMSQV74.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import {
+  findGateFiles,
+  formatValidationResult,
+  getDefaultGateConfig,
+  parseGateConfig,
+  parseGateFile,
+  serializeGateConfig,
+  validateGateConfig
+} from "./chunk-IRKUEJVW.js";
+import "./chunk-MO4EEYFW.js";
+export {
+  findGateFiles,
+  formatValidationResult,
+  getDefaultGateConfig,
+  parseGateConfig,
+  parseGateFile,
+  serializeGateConfig,
+  validateGateConfig
+};

package/dist/doctor-6Y6L6HEB.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import {
+  doctorCommand
+} from "./chunk-753RICFF.js";
+import "./chunk-YDNKXH4Z.js";
+import "./chunk-4NCFWYGG.js";
+import "./chunk-YO6DVTL7.js";
+import "./chunk-MO4EEYFW.js";
+export {
+  doctorCommand
+};

package/dist/echo-VYZW3OTT.js

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+import {
+  log
+} from "./chunk-4NCFWYGG.js";
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/echo.ts
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+var ECHOES_TEMPLATE = `# Echoes - Error to Symbol Mapping
+# When errors occur, they echo back to their source symbol.
+# Run \`paradigm echo ERROR_CODE\` to look up context.
+
+version: "1.0"
+
+errors:
+  # Example error mapping
+  AUTH_REQUIRED:
+    symbol: "^authenticated"
+    location: "src/middleware/auth.ts"
+    ripple:
+      - "@checkout"
+      - "@profile"
+      - "@settings"
+    resolution: "Ensure user token is passed in request headers"
+
+  # Add your error mappings below
+  # ERROR_CODE:
+  #   symbol: "^portal-name"       # or signal: "!signal-name"
+  #   location: "path/to/file.ts"
+  #   ripple:
+  #     - "@feature1"
+  #     - "@feature2"
+  #   resolution: "How to fix this error"
+`;
+function parseEchoes(content) {
+  const data = {
+    version: "1.0",
+    errors: {}
+  };
+  const lines = content.split("\n");
+  let currentError = null;
+  let currentEntry = {};
+  let inRipple = false;
+  for (const line of lines) {
+    if (line.trim().startsWith("#") || line.trim() === "") continue;
+    const versionMatch = line.match(/^version:\s*"?([^"]+)"?/);
+    if (versionMatch) {
+      data.version = versionMatch[1];
+      continue;
+    }
+    if (line.match(/^errors:\s*$/)) continue;
+    const errorKeyMatch = line.match(/^  ([A-Z_][A-Z0-9_]*):\s*$/);
+    if (errorKeyMatch) {
+      if (currentError && Object.keys(currentEntry).length > 0) {
+        data.errors[currentError] = currentEntry;
+      }
+      currentError = errorKeyMatch[1];
+      currentEntry = {};
+      inRipple = false;
+      continue;
+    }
+    if (currentError) {
+      const symbolMatch = line.match(/^\s{4}symbol:\s*"?([^"]+)"?/);
+      if (symbolMatch) {
+        currentEntry.symbol = symbolMatch[1];
+        inRipple = false;
+        continue;
+      }
+      const signalMatch = line.match(/^\s{4}signal:\s*"?([^"]+)"?/);
+      if (signalMatch) {
+        currentEntry.signal = signalMatch[1];
+        inRipple = false;
+        continue;
+      }
+      const locationMatch = line.match(/^\s{4}location:\s*"?([^"]+)"?/);
+      if (locationMatch) {
+        currentEntry.location = locationMatch[1];
+        inRipple = false;
+        continue;
+      }
+      const resolutionMatch = line.match(/^\s{4}resolution:\s*"?([^"]+)"?/);
+      if (resolutionMatch) {
+        currentEntry.resolution = resolutionMatch[1];
+        inRipple = false;
+        continue;
+      }
+      if (line.match(/^\s{4}ripple:\s*$/)) {
+        currentEntry.ripple = [];
+        inRipple = true;
+        continue;
+      }
+      if (inRipple) {
+        const rippleMatch = line.match(/^\s{6}-\s*"?([^"]+)"?/);
+        if (rippleMatch) {
+          if (!currentEntry.ripple) currentEntry.ripple = [];
+          currentEntry.ripple.push(rippleMatch[1]);
+          continue;
+        }
+      }
+    }
+  }
+  if (currentError && Object.keys(currentEntry).length > 0) {
+    data.errors[currentError] = currentEntry;
+  }
+  return data;
+}
+async function echoCommand(errorCode, targetPath, options = {}) {
+  const cwd = process.cwd();
+  const absolutePath = targetPath ? path.resolve(cwd, targetPath) : cwd;
+  const echoesPath = path.join(absolutePath, ".paradigm", "echoes.yaml");
+  log.command("echo").debug("Looking up error code", { errorCode });
+  if (!fs.existsSync(echoesPath)) {
+    if (options.json) {
+      console.log(JSON.stringify({ found: false, error: "No echoes.yaml found" }, null, 2));
+      return;
+    }
+    log.command("echo").warn("No echoes.yaml found");
+    console.log(chalk.yellow("\n\u{1F4E2} No echoes.yaml found.\n"));
+    console.log(chalk.gray("  Run `paradigm echo --init` to create one.\n"));
+    return;
+  }
+  const content = fs.readFileSync(echoesPath, "utf8");
+  const data = parseEchoes(content);
+  log.component("echoes-parser").debug("Echoes file parsed", { count: Object.keys(data.errors).length });
+  const entry = data.errors[errorCode.toUpperCase()];
+  if (!entry) {
+    log.command("echo").warn("Error code not found", { errorCode });
+    if (options.json) {
+      console.log(JSON.stringify({
+        found: false,
+        errorCode: errorCode.toUpperCase(),
+        available: Object.keys(data.errors)
+      }, null, 2));
+      return;
+    }
+    console.log(chalk.yellow(`
+\u{1F4E2} No echo found for: ${errorCode}
+`));
+    const available = Object.keys(data.errors);
+    if (available.length > 0) {
+      console.log(chalk.gray("  Available error codes:"));
+      for (const code of available.slice(0, 10)) {
+        const e = data.errors[code];
+        const symbolInfo = e.symbol || e.signal || "";
+        console.log(chalk.gray(`    ${code} \u2192 ${symbolInfo}`));
+      }
+      if (available.length > 10) {
+        console.log(chalk.gray(`    ... and ${available.length - 10} more`));
+      }
+    }
+    console.log("");
+    return;
+  }
+  log.command("echo").success("Error code found", { errorCode, hasSymbol: !!entry.symbol, hasResolution: !!entry.resolution });
+  if (options.json) {
+    console.log(JSON.stringify({
+      found: true,
+      errorCode: errorCode.toUpperCase(),
+      ...entry
+    }, null, 2));
+    return;
+  }
+  console.log(chalk.blue(`
+\u{1F4E2} Echo: ${chalk.cyan(errorCode)}
+`));
+  console.log(chalk.gray("\u2500".repeat(50)));
+  if (entry.symbol) {
+    console.log(`  Symbol:     ${chalk.red(entry.symbol)}`);
+  }
+  if (entry.signal) {
+    console.log(`  Signal:     ${chalk.yellow(entry.signal)}`);
+  }
+  if (entry.location) {
+    console.log(`  Location:   ${chalk.gray(entry.location)}`);
+  }
+  if (entry.ripple && entry.ripple.length > 0) {
+    console.log(`  Ripple:     ${entry.ripple.map((r) => {
+      if (r.startsWith("@")) return chalk.blue(r);
+      if (r.startsWith("#")) return chalk.green(r);
+      if (r.startsWith("^")) return chalk.red(r);
+      return chalk.gray(r);
+    }).join(", ")}`);
+  }
+  console.log("");
+  if (entry.resolution) {
+    console.log(chalk.white("Resolution:"));
+    console.log(chalk.gray("\u2500".repeat(50)));
+    console.log(chalk.green(`  ${entry.resolution}`));
+    console.log("");
+  }
+  console.log(chalk.gray("Tip: Run `paradigm ripple " + (entry.symbol || entry.signal || "") + "` for full impact analysis.\n"));
+}
+async function echoInitCommand(targetPath, options = {}) {
+  const cwd = process.cwd();
+  const absolutePath = targetPath ? path.resolve(cwd, targetPath) : cwd;
+  const paradigmDir = path.join(absolutePath, ".paradigm");
+  const echoesPath = path.join(paradigmDir, "echoes.yaml");
+  if (!fs.existsSync(paradigmDir)) {
+    fs.mkdirSync(paradigmDir, { recursive: true });
+  }
+  if (fs.existsSync(echoesPath) && !options.quiet) {
+    console.log(chalk.yellow("\n\u26A0\uFE0F  echoes.yaml already exists.\n"));
+    console.log(chalk.gray(`  Path: ${echoesPath}
+`));
+    return;
+  }
+  fs.writeFileSync(echoesPath, ECHOES_TEMPLATE, "utf8");
+  if (!options.quiet) {
+    console.log(chalk.green("\n\u2713 Created .paradigm/echoes.yaml\n"));
+    console.log(chalk.gray("  Edit this file to add error-to-symbol mappings."));
+    console.log(chalk.gray("  Then use `paradigm echo ERROR_CODE` to look them up.\n"));
+  }
+}
+async function echoListCommand(targetPath, _options = {}) {
+  const cwd = process.cwd();
+  const absolutePath = targetPath ? path.resolve(cwd, targetPath) : cwd;
+  const echoesPath = path.join(absolutePath, ".paradigm", "echoes.yaml");
+  if (!fs.existsSync(echoesPath)) {
+    console.log(chalk.yellow("\n\u{1F4E2} No echoes.yaml found.\n"));
+    console.log(chalk.gray("  Run `paradigm echo --init` to create one.\n"));
+    return;
+  }
+  const content = fs.readFileSync(echoesPath, "utf8");
+  const data = parseEchoes(content);
+  console.log(chalk.blue("\n\u{1F4E2} All Echoes\n"));
+  console.log(chalk.gray("\u2500".repeat(50)));
+  const codes = Object.keys(data.errors);
+  if (codes.length === 0) {
+    console.log(chalk.gray("  No error mappings defined yet.\n"));
+    return;
+  }
+  for (const code of codes) {
+    const entry = data.errors[code];
+    const symbol = entry.symbol || entry.signal || "";
+    const location = entry.location ? chalk.gray(` @ ${entry.location}`) : "";
+    console.log(`  ${chalk.cyan(code.padEnd(20))} \u2192 ${symbol}${location}`);
+  }
+  console.log(chalk.gray(`
+  Total: ${codes.length} error mappings
+`));
+}
+export {
+  echoCommand,
+  echoInitCommand,
+  echoListCommand
+};

package/dist/export-R4FJ5NOH.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import {
+  AuditLogger
+} from "./chunk-PBHIFAL4.js";
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/team/export.ts
+import * as path from "path";
+import chalk from "chalk";
+async function teamExportCommand(targetPath, options) {
+  const rootDir = targetPath ? path.resolve(targetPath) : process.cwd();
+  let from;
+  let to;
+  if (options.from) {
+    from = new Date(options.from);
+  }
+  if (options.to) {
+    to = new Date(options.to);
+  }
+  const auditLogger = new AuditLogger(rootDir);
+  const format = options.format || "json";
+  let output;
+  if (format === "csv") {
+    output = auditLogger.exportToCsv({ from, to });
+  } else {
+    output = auditLogger.exportToJson({ from, to });
+  }
+  if (options.output) {
+    const fs = await import("fs");
+    fs.writeFileSync(options.output, output);
+    console.log(chalk.green(`\u2713 Exported to ${options.output}`));
+  } else {
+    console.log(output);
+  }
+}
+export {
+  teamExportCommand
+};

package/dist/history-EVO3L6SC.js

@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/history/index.ts
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import * as yaml from "js-yaml";
+var HISTORY_DIR = ".paradigm/history";
+async function historyShowCommand(symbol, options = {}) {
+  const rootDir = process.cwd();
+  const historyPath = path.join(rootDir, HISTORY_DIR);
+  if (!fs.existsSync(historyPath)) {
+    console.log(chalk.yellow("No history directory found."));
+    console.log(chalk.gray(`Run \`paradigm history init\` to create .paradigm/history/`));
+    return;
+  }
+  const index = loadYaml(path.join(historyPath, "index.yaml"));
+  const entries = loadLog(path.join(historyPath, "log.jsonl"));
+  if (options.json) {
+    if (symbol) {
+      const symbolData = index?.by_symbol?.[symbol];
+      const symbolEntries = entries.filter((e) => e.symbols.includes(symbol));
+      console.log(JSON.stringify({ symbol, summary: symbolData, entries: symbolEntries }, null, 2));
+    } else {
+      console.log(JSON.stringify({ index, entries: entries.slice(-(options.limit || 20)) }, null, 2));
+    }
+    return;
+  }
+  console.log(chalk.magenta("\n  History\n"));
+  if (symbol) {
+    const summary = index?.by_symbol?.[symbol];
+    const symbolEntries = entries.filter((e) => e.symbols.includes(symbol)).slice(-(options.limit || 10));
+    console.log(chalk.cyan(`  Symbol: ${symbol}
+`));
+    if (summary) {
+      const fragilityColor = summary.fragility === "critical" || summary.fragility === "high" ? chalk.red : summary.fragility === "medium" ? chalk.yellow : chalk.green;
+      console.log(chalk.white("  Summary:"));
+      console.log(chalk.gray(`    Total changes: ${summary.total_changes}`));
+      console.log(chalk.gray(`    Last modified: ${summary.last_modified}`));
+      console.log(chalk.gray(`    Stability: ${(summary.stability_score * 100).toFixed(0)}%`));
+      console.log(fragilityColor(`    Fragility: ${summary.fragility}`));
+      console.log();
+    }
+    if (symbolEntries.length > 0) {
+      console.log(chalk.white("  Recent changes:"));
+      symbolEntries.forEach((e) => {
+        const typeColor = e.type === "rollback" ? chalk.red : e.type === "validate" ? e.result === "pass" ? chalk.green : chalk.red : chalk.blue;
+        console.log(
+          typeColor(`    [${e.type}] ${e.description || e.id}`) + chalk.gray(` - ${e.author.id} @ ${e.ts.split("T")[0]}`)
+        );
+      });
+    }
+    return;
+  }
+  const symbols = Object.keys(index?.by_symbol || {});
+  console.log(chalk.white(`  Tracked symbols: ${symbols.length}`));
+  console.log(chalk.white(`  Total entries: ${entries.length}`));
+  console.log();
+  const fragile = index?.fragile_symbols || [];
+  if (fragile.length > 0) {
+    console.log(chalk.red("  Fragile symbols:"));
+    fragile.slice(0, 5).forEach((f) => {
+      console.log(chalk.gray(`    [${f.fragility}] ${f.symbol}`));
+    });
+    console.log();
+  }
+  const recent = entries.slice(-10);
+  if (recent.length > 0) {
+    console.log(chalk.white("  Recent entries:"));
+    recent.reverse().forEach((e) => {
+      const typeColor = e.type === "rollback" ? chalk.red : e.type === "validate" ? e.result === "pass" ? chalk.green : chalk.red : chalk.blue;
+      console.log(
+        typeColor(`    [${e.type}] ${e.symbols.join(", ")}`) + chalk.gray(` - ${e.ts.split("T")[0]}`)
+      );
+    });
+  }
+}
+async function historyInitCommand(options = {}) {
+  const rootDir = process.cwd();
+  const historyPath = path.join(rootDir, HISTORY_DIR);
+  if (fs.existsSync(historyPath) && !options.force) {
+    console.log(chalk.yellow("History directory already exists."));
+    console.log(chalk.gray("Use --force to reinitialize"));
+    return;
+  }
+  fs.mkdirSync(historyPath, { recursive: true });
+  fs.writeFileSync(path.join(historyPath, "log.jsonl"), "");
+  const index = {
+    version: "1.0",
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    by_symbol: {},
+    co_changes: [],
+    fragile_symbols: []
+  };
+  fs.writeFileSync(path.join(historyPath, "index.yaml"), yaml.dump(index, { lineWidth: -1 }));
+  const validation = {
+    version: "1.0",
+    total_validations: 0,
+    pass_rate: 0,
+    by_symbol: {}
+  };
+  fs.writeFileSync(path.join(historyPath, "validation.yaml"), yaml.dump(validation, { lineWidth: -1 }));
+  console.log(chalk.green("History directory initialized!"));
+  console.log(chalk.gray(`  ${historyPath}/`));
+  console.log(chalk.gray("    log.jsonl"));
+  console.log(chalk.gray("    index.yaml"));
+  console.log(chalk.gray("    validation.yaml"));
+}
+async function historyFragileCommand(options = {}) {
+  const rootDir = process.cwd();
+  const indexPath = path.join(rootDir, HISTORY_DIR, "index.yaml");
+  if (!fs.existsSync(indexPath)) {
+    console.log(chalk.yellow("No history index found."));
+    console.log(chalk.gray("Run `paradigm history reindex` to generate"));
+    return;
+  }
+  const index = loadYaml(indexPath);
+  const fragile = index?.fragile_symbols || [];
+  if (options.json) {
+    console.log(JSON.stringify({ fragile }, null, 2));
+    return;
+  }
+  console.log(chalk.magenta("\n  Fragile Symbols\n"));
+  if (fragile.length === 0) {
+    console.log(chalk.green("  No fragile symbols detected!"));
+    return;
+  }
+  fragile.forEach((f) => {
+    const color = f.fragility === "critical" ? chalk.red : chalk.yellow;
+    console.log(color(`  [${f.fragility}] ${f.symbol}`));
+    console.log(chalk.gray(`    ${f.reason}`));
+  });
+  console.log();
+  console.log(chalk.gray("  Recommendation: Add extra test coverage before modifying these symbols"));
+}
+async function historyReindexCommand() {
+  const rootDir = process.cwd();
+  const historyPath = path.join(rootDir, HISTORY_DIR);
+  const logPath = path.join(historyPath, "log.jsonl");
+  if (!fs.existsSync(logPath)) {
+    console.log(chalk.yellow("No history log found."));
+    return;
+  }
+  const entries = loadLog(logPath);
+  const index = buildIndex(entries);
+  const indexPath = path.join(historyPath, "index.yaml");
+  fs.writeFileSync(indexPath, yaml.dump(index, { lineWidth: -1 }));
+  console.log(chalk.green("History index regenerated!"));
+  console.log(chalk.gray(`  Symbols: ${Object.keys(index.by_symbol).length}`));
+  console.log(chalk.gray(`  Entries: ${entries.length}`));
+  console.log(chalk.gray(`  Fragile: ${index.fragile_symbols.length}`));
+}
+async function historyRecordCommand(options) {
+  const rootDir = process.cwd();
+  const logPath = path.join(rootDir, HISTORY_DIR, "log.jsonl");
+  fs.mkdirSync(path.join(rootDir, HISTORY_DIR), { recursive: true });
+  let count = 1;
+  if (fs.existsSync(logPath)) {
+    const content = fs.readFileSync(logPath, "utf8");
+    count = content.split("\n").filter((l) => l.trim()).length + 1;
+  }
+  const entry = {
+    id: `h${String(count).padStart(4, "0")}`,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    type: options.type,
+    symbols: options.symbols.split(",").map((s) => s.trim()),
+    author: { type: "human", id: process.env.USER || "unknown" },
+    description: options.description,
+    intent: options.intent,
+    commit: options.commit,
+    reason: options.reason
+  };
+  fs.appendFileSync(logPath, JSON.stringify(entry) + "\n");
+  console.log(chalk.green(`Entry ${entry.id} recorded!`));
+}
+async function historyValidateCommand(options) {
+  const rootDir = process.cwd();
+  const logPath = path.join(rootDir, HISTORY_DIR, "log.jsonl");
+  fs.mkdirSync(path.join(rootDir, HISTORY_DIR), { recursive: true });
+  let count = 1;
+  if (fs.existsSync(logPath)) {
+    const content = fs.readFileSync(logPath, "utf8");
+    count = content.split("\n").filter((l) => l.trim()).length + 1;
+  }
+  const entry = {
+    id: `h${String(count).padStart(4, "0")}`,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    type: "validate",
+    symbols: [],
+    author: { type: "agent", id: "cli" },
+    ref: options.ref,
+    result: options.result,
+    tests: options.passed !== void 0 ? { passed: options.passed, failed: options.failed || 0 } : void 0
+  };
+  fs.appendFileSync(logPath, JSON.stringify(entry) + "\n");
+  console.log(chalk.green(`Validation ${entry.id} recorded: ${options.result}`));
+}
+function loadYaml(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    return yaml.load(content);
+  } catch {
+    return null;
+  }
+}
+function loadLog(logPath) {
+  if (!fs.existsSync(logPath)) return [];
+  const content = fs.readFileSync(logPath, "utf8");
+  return content.split("\n").filter((l) => l.trim()).map((l) => {
+    try {
+      return JSON.parse(l);
+    } catch {
+      return null;
+    }
+  }).filter(Boolean);
+}
+function buildIndex(entries) {
+  const bySymbol = {};
+  const symbolChanges = {};
+  for (const entry of entries) {
+    for (const symbol of entry.symbols) {
+      if (!symbolChanges[symbol]) symbolChanges[symbol] = [];
+      symbolChanges[symbol].push(entry);
+    }
+  }
+  for (const [symbol, changes] of Object.entries(symbolChanges)) {
+    const sorted = changes.sort((a, b) => new Date(b.ts).getTime() - new Date(a.ts).getTime());
+    const rollbacks = changes.filter((c) => c.type === "rollback").length;
+    const failures = changes.filter((c) => c.type === "validate" && c.result === "fail").length;
+    const total = changes.length;
+    const stabilityScore = Math.max(0, 1 - (rollbacks * 0.2 + failures * 0.1) / Math.max(1, total / 10));
+    let fragility = "low";
+    if (stabilityScore < 0.5) fragility = "critical";
+    else if (stabilityScore < 0.7) fragility = "high";
+    else if (stabilityScore < 0.85) fragility = "medium";
+    const humanContributors = /* @__PURE__ */ new Set();
+    const agentContributors = /* @__PURE__ */ new Set();
+    for (const change of changes) {
+      if (change.author.type === "human") humanContributors.add(change.author.id);
+      else agentContributors.add(change.author.id);
+    }
+    bySymbol[symbol] = {
+      symbol,
+      total_changes: total,
+      last_modified: sorted[0]?.ts || (/* @__PURE__ */ new Date()).toISOString(),
+      stability_score: stabilityScore,
+      fragility,
+      recent: sorted.slice(0, 5),
+      contributors: {
+        human: Array.from(humanContributors),
+        agent: Array.from(agentContributors)
+      }
+    };
+  }
+  const fragileSymbols = Object.values(bySymbol).filter((s) => s.fragility === "high" || s.fragility === "critical").map((s) => ({
+    symbol: s.symbol,
+    fragility: s.fragility,
+    reason: `Stability score: ${(s.stability_score * 100).toFixed(0)}%`
+  }));
+  return {
+    version: "1.0",
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    by_symbol: bySymbol,
+    co_changes: [],
+    fragile_symbols: fragileSymbols
+  };
+}
+export {
+  historyFragileCommand,
+  historyInitCommand,
+  historyRecordCommand,
+  historyReindexCommand,
+  historyShowCommand,
+  historyValidateCommand
+};

package/dist/hooks-MBWE4ILT.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import {
+  hooksInstallCommand,
+  hooksStatusCommand,
+  hooksUninstallCommand
+} from "./chunk-2M6OSOIG.js";
+import "./chunk-MO4EEYFW.js";
+export {
+  hooksInstallCommand,
+  hooksStatusCommand,
+  hooksUninstallCommand
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }