@triedotdev/mcp 1.0.79 → 1.0.81

package/dist/{chunk-53URTRWH.js → chunk-FW435YKY.js}

@@ -2,13 +2,28 @@ import {
   Executor,
   Triager,
   detectStack,
+  getDiff,
+  getRecentCommits,
   getStagedChanges,
   getUncommittedChanges,
-  getWorkingTreeDiff
-} from "./chunk-LNLLZQWH.js";
+  getWorkingTreeDiff,
+  loadConfig
+} from "./chunk-2BXLPYHR.js";
+import {
+  ContextGraph
+} from "./chunk-B7CLAOEK.js";
+import {
+  scanForVulnerabilities
+} from "./chunk-FCMAQSV7.js";
+import {
+  scanForVibeCodeIssues
+} from "./chunk-SH2JIQLB.js";
 import {
   Trie
 } from "./chunk-6NLHFIYA.js";
+import {
+  storeIssues
+} from "./chunk-WGECLUDQ.js";
 import {
   getWorkingDirectory
 } from "./chunk-CM7EHNQK.js";
@@ -452,390 +467,8 @@ async function getAutonomyConfig(projectPath) {
   return config;
 }
 
-// src/context/graph.ts
-import crypto from "crypto";
-import path2 from "path";
-
-// src/context/store.ts
-import Database from "better-sqlite3";
-import fs from "fs";
-import path from "path";
-var ContextStore = class {
-  db;
-  dbFilePath;
-  constructor(projectPath, dbFilePath) {
-    this.dbFilePath = dbFilePath ?? path.join(projectPath, ".trie", "context.db");
-    this.ensureDirectory();
-    this.db = new Database(this.dbFilePath);
-    this.configure();
-    this.prepareSchema();
-  }
-  get databasePath() {
-    return this.dbFilePath;
-  }
-  addNode(node) {
-    const stmt = this.db.prepare(
-      `INSERT INTO nodes (id, type, data, created_at, updated_at)
-       VALUES (@id, @type, @data, @created_at, @updated_at)`
-    );
-    stmt.run({
-      id: node.id,
-      type: node.type,
-      data: JSON.stringify(node.data),
-      created_at: node.created_at,
-      updated_at: node.updated_at
-    });
-    return node;
-  }
-  upsertNode(node) {
-    const stmt = this.db.prepare(
-      `INSERT INTO nodes (id, type, data, created_at, updated_at)
-       VALUES (@id, @type, @data, @created_at, @updated_at)
-       ON CONFLICT(id) DO UPDATE SET
-         type=excluded.type,
-         data=excluded.data,
-         updated_at=excluded.updated_at`
-    );
-    stmt.run({
-      id: node.id,
-      type: node.type,
-      data: JSON.stringify(node.data),
-      created_at: node.created_at,
-      updated_at: node.updated_at
-    });
-    return node;
-  }
-  getNode(id) {
-    const row = this.db.prepare("SELECT * FROM nodes WHERE id = ?").get(id);
-    return row ? this.mapNodeRow(row) : null;
-  }
-  getNodeByType(type, id) {
-    const row = this.db.prepare("SELECT * FROM nodes WHERE id = ? AND type = ?").get(id, type);
-    return row ? this.mapNodeRow(row) : null;
-  }
-  updateNode(id, updates, updatedAt) {
-    const existing = this.getNode(id);
-    if (!existing) {
-      return null;
-    }
-    const merged = {
-      ...existing,
-      data: { ...existing.data, ...updates },
-      updated_at: updatedAt
-    };
-    this.db.prepare(
-      `UPDATE nodes SET data = @data, updated_at = @updated_at
-         WHERE id = @id`
-    ).run({
-      id,
-      data: JSON.stringify(merged.data),
-      updated_at: merged.updated_at
-    });
-    return merged;
-  }
-  deleteNode(id) {
-    const deleteEdges = this.db.prepare("DELETE FROM edges WHERE from_id = ? OR to_id = ?");
-    const deleteNodeStmt = this.db.prepare("DELETE FROM nodes WHERE id = ?");
-    const transaction = this.db.transaction((nodeId) => {
-      deleteEdges.run(nodeId, nodeId);
-      deleteNodeStmt.run(nodeId);
-    });
-    transaction(id);
-  }
-  listNodes() {
-    const rows = this.db.prepare("SELECT * FROM nodes").all();
-    return rows.map((row) => this.mapNodeRow(row));
-  }
-  findNodesByType(type) {
-    const rows = this.db.prepare("SELECT * FROM nodes WHERE type = ?").all(type);
-    return rows.map((row) => this.mapNodeRow(row));
-  }
-  addEdge(edge) {
-    const stmt = this.db.prepare(
-      `INSERT INTO edges (id, from_id, to_id, type, weight, metadata, created_at)
-       VALUES (@id, @from_id, @to_id, @type, @weight, @metadata, @created_at)`
-    );
-    stmt.run({
-      id: edge.id,
-      from_id: edge.from_id,
-      to_id: edge.to_id,
-      type: edge.type,
-      weight: edge.weight,
-      metadata: JSON.stringify(edge.metadata ?? {}),
-      created_at: edge.created_at
-    });
-    return edge;
-  }
-  upsertEdge(edge) {
-    const stmt = this.db.prepare(
-      `INSERT INTO edges (id, from_id, to_id, type, weight, metadata, created_at)
-       VALUES (@id, @from_id, @to_id, @type, @weight, @metadata, @created_at)
-       ON CONFLICT(id) DO UPDATE SET
-         from_id=excluded.from_id,
-         to_id=excluded.to_id,
-         type=excluded.type,
-         weight=excluded.weight,
-         metadata=excluded.metadata`
-    );
-    stmt.run({
-      id: edge.id,
-      from_id: edge.from_id,
-      to_id: edge.to_id,
-      type: edge.type,
-      weight: edge.weight,
-      metadata: JSON.stringify(edge.metadata ?? {}),
-      created_at: edge.created_at
-    });
-    return edge;
-  }
-  getEdge(id) {
-    const row = this.db.prepare("SELECT * FROM edges WHERE id = ?").get(id);
-    return row ? this.mapEdgeRow(row) : null;
-  }
-  getEdges(nodeId, direction = "both") {
-    let rows;
-    if (direction === "in") {
-      rows = this.db.prepare("SELECT * FROM edges WHERE to_id = ?").all(nodeId);
-    } else if (direction === "out") {
-      rows = this.db.prepare("SELECT * FROM edges WHERE from_id = ?").all(nodeId);
-    } else {
-      rows = this.db.prepare("SELECT * FROM edges WHERE from_id = ? OR to_id = ?").all(nodeId, nodeId);
-    }
-    return rows.map((row) => this.mapEdgeRow(row));
-  }
-  listEdges() {
-    const rows = this.db.prepare("SELECT * FROM edges").all();
-    return rows.map((row) => this.mapEdgeRow(row));
-  }
-  deleteEdge(id) {
-    this.db.prepare("DELETE FROM edges WHERE id = ?").run(id);
-  }
-  close() {
-    this.db.close();
-  }
-  ensureDirectory() {
-    fs.mkdirSync(path.dirname(this.dbFilePath), { recursive: true });
-  }
-  configure() {
-    this.db.pragma("journal_mode = WAL");
-    this.db.pragma("busy_timeout = 5000");
-    this.db.pragma("synchronous = NORMAL");
-  }
-  prepareSchema() {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS nodes (
-        id TEXT PRIMARY KEY,
-        type TEXT NOT NULL,
-        data TEXT NOT NULL,
-        created_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS edges (
-        id TEXT PRIMARY KEY,
-        from_id TEXT NOT NULL,
-        to_id TEXT NOT NULL,
-        type TEXT NOT NULL,
-        weight REAL NOT NULL DEFAULT 1,
-        metadata TEXT DEFAULT '{}',
-        created_at TEXT NOT NULL
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_nodes_type ON nodes(type);
-      CREATE INDEX IF NOT EXISTS idx_edges_from ON edges(from_id);
-      CREATE INDEX IF NOT EXISTS idx_edges_to ON edges(to_id);
-      CREATE INDEX IF NOT EXISTS idx_edges_type ON edges(type);
-    `);
-  }
-  mapNodeRow(row) {
-    return {
-      id: row.id,
-      type: row.type,
-      data: JSON.parse(row.data),
-      created_at: row.created_at,
-      updated_at: row.updated_at
-    };
-  }
-  mapEdgeRow(row) {
-    return {
-      id: row.id,
-      from_id: row.from_id,
-      to_id: row.to_id,
-      type: row.type,
-      weight: row.weight,
-      created_at: row.created_at,
-      metadata: row.metadata ? JSON.parse(row.metadata) : {}
-    };
-  }
-};
-
-// src/context/graph.ts
-var ContextGraph = class {
-  store;
-  projectPath;
-  constructor(projectPath, dbPath, store) {
-    this.projectPath = projectPath;
-    this.store = store ?? new ContextStore(projectPath, dbPath);
-  }
-  get projectRoot() {
-    return this.projectPath;
-  }
-  async addNode(type, data) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const id = this.generateNodeId(type, data);
-    const node = {
-      id,
-      type,
-      data,
-      created_at: now,
-      updated_at: now
-    };
-    this.store.addNode(node);
-    return node;
-  }
-  async getNode(type, id) {
-    return this.store.getNodeByType(type, id);
-  }
-  async updateNode(type, id, updates) {
-    const updated = this.store.updateNode(id, updates, (/* @__PURE__ */ new Date()).toISOString());
-    if (updated && updated.type !== type) {
-      throw new Error(`Type mismatch for node ${id}: expected ${type} but found ${updated.type}`);
-    }
-  }
-  async deleteNode(_type, id) {
-    this.store.deleteNode(id);
-  }
-  async addEdge(fromId, toId, type, metadata = {}, weight = 1) {
-    const edge = {
-      id: crypto.randomUUID(),
-      from_id: fromId,
-      to_id: toId,
-      type,
-      weight,
-      metadata,
-      created_at: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.store.addEdge(edge);
-    return edge;
-  }
-  async getEdges(nodeId, direction = "both") {
-    return this.store.getEdges(nodeId, direction);
-  }
-  async getIncidentsForFile(filePath) {
-    const fileNode = this.findFileNode(filePath);
-    if (!fileNode) return [];
-    const incidents = /* @__PURE__ */ new Map();
-    const affectEdges = this.store.getEdges(fileNode.id, "in").filter((edge) => edge.type === "affects");
-    for (const edge of affectEdges) {
-      const changeId = edge.from_id;
-      const leadEdges = this.store.getEdges(changeId, "out").filter((e) => e.type === "leadTo");
-      const causedByEdges = this.store.getEdges(changeId, "in").filter((e) => e.type === "causedBy");
-      for (const le of leadEdges) {
-        const incident = this.store.getNodeByType("incident", le.to_id);
-        if (incident) incidents.set(incident.id, incident);
-      }
-      for (const ce of causedByEdges) {
-        const incident = this.store.getNodeByType("incident", ce.from_id);
-        if (incident) incidents.set(incident.id, incident);
-      }
-    }
-    return Array.from(incidents.values());
-  }
-  async getPatternsForFile(filePath) {
-    const normalized = this.normalizePath(filePath);
-    const nodes = this.store.findNodesByType("pattern");
-    return nodes.filter(
-      (node) => node.data.appliesTo.some((pattern) => normalized.includes(pattern) || filePath.includes(pattern))
-    );
-  }
-  async getRecentChanges(limit) {
-    const nodes = this.store.findNodesByType("change");
-    return nodes.sort((a, b) => new Date(b.data.timestamp).getTime() - new Date(a.data.timestamp).getTime()).slice(0, limit);
-  }
-  async calculateFileRisk(filePath) {
-    const fileNode = this.findFileNode(filePath);
-    if (!fileNode) return "low";
-    const incidentScore = Math.min(fileNode.data.incidentCount * 2, 6);
-    const changeScore = Math.min(fileNode.data.changeCount, 4);
-    const baseScore = this.riskLevelToScore(fileNode.data.riskLevel);
-    const total = baseScore + incidentScore + changeScore;
-    if (total >= 10) return "critical";
-    if (total >= 7) return "high";
-    if (total >= 4) return "medium";
-    return "low";
-  }
-  async listNodes() {
-    return this.store.listNodes();
-  }
-  async listEdges() {
-    return this.store.listEdges();
-  }
-  async deleteEdge(id) {
-    this.store.deleteEdge(id);
-  }
-  async getSnapshot() {
-    return {
-      nodes: this.store.listNodes(),
-      edges: this.store.listEdges(),
-      exported_at: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  async applySnapshot(snapshot) {
-    for (const node of snapshot.nodes) {
-      const existing = this.store.getNode(node.id);
-      if (!existing || this.isNewer(node.updated_at, existing.updated_at)) {
-        this.store.upsertNode(node);
-      }
-    }
-    for (const edge of snapshot.edges) {
-      const existing = this.store.getEdge(edge.id);
-      if (!existing) {
-        this.store.upsertEdge(edge);
-      }
-    }
-  }
-  generateNodeId(type, data) {
-    if (type === "file") {
-      const fileData = data;
-      return this.normalizePath(fileData.path);
-    }
-    if (type === "change") {
-      const changeData = data;
-      if (changeData.commitHash) {
-        return changeData.commitHash;
-      }
-    }
-    return crypto.randomUUID();
-  }
-  findFileNode(filePath) {
-    const normalized = this.normalizePath(filePath);
-    const nodes = this.store.findNodesByType("file");
-    return nodes.find(
-      (node) => node.id === normalized || this.normalizePath(node.data.path) === normalized || node.data.path === filePath
-    ) ?? null;
-  }
-  normalizePath(filePath) {
-    return path2.resolve(this.projectPath, filePath);
-  }
-  riskLevelToScore(level) {
-    switch (level) {
-      case "critical":
-        return 6;
-      case "high":
-        return 4;
-      case "medium":
-        return 2;
-      default:
-        return 0;
-    }
-  }
-  isNewer(incoming, existing) {
-    return new Date(incoming).getTime() >= new Date(existing).getTime();
-  }
-};
-
 // src/agent/perceive.ts
-import path3 from "path";
+import path from "path";
 
 // src/agent/diff-analyzer.ts
 var RISKY_PATTERNS = [/auth/i, /token/i, /password/i, /secret/i, /validate/i, /sanitize/i];
@@ -939,7 +572,7 @@ async function upsertWorkingChange(graph, files, projectPath) {
   return change.id;
 }
 async function ensureFileNode(graph, filePath, projectPath) {
-  const normalized = path3.resolve(projectPath, filePath);
+  const normalized = path.resolve(projectPath, filePath);
   const existing = await graph.getNode("file", normalized);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   if (existing) {
@@ -952,7 +585,7 @@ async function ensureFileNode(graph, filePath, projectPath) {
   }
   const data = {
     path: filePath,
-    extension: path3.extname(filePath),
+    extension: path.extname(filePath),
     purpose: "",
     riskLevel: "medium",
     whyRisky: null,
@@ -965,7 +598,7 @@ async function ensureFileNode(graph, filePath, projectPath) {
 }
 
 // src/agent/risk-scorer.ts
-import path4 from "path";
+import path2 from "path";
 var BASE_RISK = {
   low: 10,
   medium: 35,
@@ -986,7 +619,7 @@ function levelFromScore(score) {
 }
 async function scoreFile(graph, filePath, matchedPatterns = []) {
   const reasons = [];
-  const normalized = path4.resolve(graph.projectRoot, filePath);
+  const normalized = path2.resolve(graph.projectRoot, filePath);
   const node = await graph.getNode("file", normalized);
   const incidents = await graph.getIncidentsForFile(filePath);
   let score = 10;
@@ -1454,29 +1087,29 @@ function formatFriendlyError(error) {
 }
 
 // src/context/sync.ts
-import fs2 from "fs/promises";
-import path5 from "path";
+import fs from "fs/promises";
+import path3 from "path";
 var DEFAULT_JSON_NAME = "context.json";
 async function exportToJson(graph, targetPath) {
   const snapshot = await graph.getSnapshot();
   const json = JSON.stringify(snapshot, null, 2);
-  const outputPath = targetPath ?? path5.join(graph.projectRoot, ".trie", DEFAULT_JSON_NAME);
-  await fs2.mkdir(path5.dirname(outputPath), { recursive: true });
-  await fs2.writeFile(outputPath, json, "utf8");
+  const outputPath = targetPath ?? path3.join(graph.projectRoot, ".trie", DEFAULT_JSON_NAME);
+  await fs.mkdir(path3.dirname(outputPath), { recursive: true });
+  await fs.writeFile(outputPath, json, "utf8");
   return json;
 }
 async function importFromJson(graph, json, sourcePath) {
-  const payload = json.trim().length > 0 ? json : await fs2.readFile(sourcePath ?? path5.join(graph.projectRoot, ".trie", DEFAULT_JSON_NAME), "utf8");
+  const payload = json.trim().length > 0 ? json : await fs.readFile(sourcePath ?? path3.join(graph.projectRoot, ".trie", DEFAULT_JSON_NAME), "utf8");
   const snapshot = JSON.parse(payload);
   await graph.applySnapshot(snapshot);
 }
 
 // src/context/incident-index.ts
-import path7 from "path";
+import path5 from "path";
 
 // src/context/file-trie.ts
-import fs3 from "fs";
-import path6 from "path";
+import fs2 from "fs";
+import path4 from "path";
 import { performance } from "perf_hooks";
 function normalizePath(filePath) {
   const normalized = filePath.replace(/\\/g, "/");
@@ -1487,9 +1120,9 @@ var FilePathTrie = class {
   persistPath;
   constructor(persistPath) {
     if (persistPath) this.persistPath = persistPath;
-    if (persistPath && fs3.existsSync(persistPath)) {
+    if (persistPath && fs2.existsSync(persistPath)) {
       try {
-        const raw = fs3.readFileSync(persistPath, "utf-8");
+        const raw = fs2.readFileSync(persistPath, "utf-8");
         if (raw.trim().length > 0) {
           const json = JSON.parse(raw);
           this.trie = Trie.fromJSON(json);
@@ -1540,9 +1173,9 @@ var FilePathTrie = class {
       incidentCount: Array.isArray(r.value) ? r.value.length : 0
     })).sort((a, b) => b.incidentCount - a.incidentCount).slice(0, limit);
   }
-  timeLookup(path8) {
+  timeLookup(path7) {
     const start = performance.now();
-    this.getIncidents(path8);
+    this.getIncidents(path7);
     return performance.now() - start;
   }
   toJSON() {
@@ -1555,11 +1188,11 @@ var FilePathTrie = class {
   persist() {
     if (!this.persistPath) return;
     try {
-      const dir = path6.dirname(this.persistPath);
-      if (!fs3.existsSync(dir)) {
-        fs3.mkdirSync(dir, { recursive: true });
+      const dir = path4.dirname(this.persistPath);
+      if (!fs2.existsSync(dir)) {
+        fs2.mkdirSync(dir, { recursive: true });
       }
-      fs3.writeFileSync(this.persistPath, JSON.stringify(this.trie.toJSON()), "utf-8");
+      fs2.writeFileSync(this.persistPath, JSON.stringify(this.trie.toJSON()), "utf-8");
     } catch {
     }
   }
@@ -1574,7 +1207,7 @@ var IncidentIndex = class _IncidentIndex {
     this.graph = graph;
     this.projectRoot = projectRoot;
     this.trie = new FilePathTrie(
-      options?.persistPath ?? path7.join(projectRoot, ".trie", "incident-trie.json")
+      options?.persistPath ?? path5.join(projectRoot, ".trie", "incident-trie.json")
     );
   }
   static async build(graph, projectRoot, options) {
@@ -1627,8 +1260,8 @@ var IncidentIndex = class _IncidentIndex {
     return Array.from(files);
   }
   normalizePath(filePath) {
-    const absolute = path7.isAbsolute(filePath) ? filePath : path7.join(this.projectRoot, filePath);
-    const relative = path7.relative(this.projectRoot, absolute);
+    const absolute = path5.isAbsolute(filePath) ? filePath : path5.join(this.projectRoot, filePath);
+    const relative = path5.relative(this.projectRoot, absolute);
     return relative.replace(/\\/g, "/");
   }
 };
@@ -1767,38 +1400,265 @@ var LearningSystem = class {
   }
 };
 
-// src/tools/feedback.ts
-var TrieFeedbackTool = class {
-  async execute(input) {
-    try {
-      const projectPath = input.directory || getWorkingDirectory(void 0, true);
-      const graph = new ContextGraph(projectPath);
-      const learning = new LearningSystem(graph, projectPath);
-      const decision = await graph.addNode("decision", {
-        context: input.target ?? "unspecified",
-        decision: input.helpful ? "helpful" : "not helpful",
-        reasoning: input.note ?? null,
-        outcome: input.helpful ? "good" : "bad",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+// src/guardian/learning-engine.ts
+import path6 from "path";
+var LearningEngine = class {
+  projectPath;
+  graph;
+  learningSystem;
+  constructor(projectPath, graph) {
+    this.projectPath = projectPath;
+    this.graph = graph || new ContextGraph(projectPath);
+    this.learningSystem = new LearningSystem(this.graph, projectPath);
+  }
+  /**
+   * Unified learning method: Scans history AND processes manual feedback
+   */
+  async learn(options = {}) {
+    const results = [];
+    if (!options.manualFeedback) {
+      const implicitCount = await this.learnFromHistory(options.limit || 20);
+      results.push({ learned: implicitCount, source: "git-history" });
+    }
+    if (options.manualFeedback) {
+      await this.recordManualFeedback(
+        options.manualFeedback.helpful,
+        options.manualFeedback.files,
+        options.manualFeedback.note
+      );
+      results.push({ learned: options.manualFeedback.files.length || 1, source: "manual-feedback" });
+    }
+    return results;
+  }
+  /**
+   * Scan recent commits for implicit failure signals (reverts, fixes)
+   */
+  async learnFromHistory(limit = 20) {
+    const commits = await getRecentCommits(this.projectPath, limit);
+    const issuesToStore = [];
+    for (const commit of commits) {
+      const isRevert = commit.message.toLowerCase().includes("revert") || commit.message.startsWith('Revert "');
+      const isFix = /fix(es|ed)?\s+#\d+/i.test(commit.message) || commit.message.toLowerCase().includes("bugfix");
+      if (isRevert || isFix) {
+        const type = isRevert ? "revert" : "fix";
+        const diff = await getDiff(this.projectPath, commit.hash);
+        const files = this.extractFilesFromDiff(diff);
+        for (const file of files) {
+          const learnedIssues = await this.extractIssuesFromDiff(diff, file, type, commit.message);
+          issuesToStore.push(...learnedIssues);
+        }
+      }
+    }
+    if (issuesToStore.length > 0) {
+      const result = await storeIssues(issuesToStore, path6.basename(this.projectPath), this.projectPath);
+      return result.stored;
+    }
+    return 0;
+  }
+  /**
+   * Record manual feedback (trie ok/bad) and adjust pattern confidence
+   */
+  async recordManualFeedback(helpful, files, note) {
+    const decision = await this.graph.addNode("decision", {
+      context: files.length > 0 ? files[0] : "unspecified",
+      decision: helpful ? "helpful" : "not helpful",
+      reasoning: note ?? null,
+      outcome: helpful ? "good" : "bad",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (files.length > 0) {
+      for (const file of files) {
+        const fileNode = await this.graph.getNode("file", file);
+        if (fileNode) {
+          await this.graph.addEdge(decision.id, fileNode.id, "affects");
+        }
+      }
+      await this.learningSystem.onFeedback(helpful, files);
+    }
+  }
+  extractFilesFromDiff(diff) {
+    const files = /* @__PURE__ */ new Set();
+    const lines = diff.split("\n");
+    for (const line of lines) {
+      if (line.startsWith("+++ b/")) {
+        files.add(line.slice(6));
+      }
+    }
+    return Array.from(files);
+  }
+  async extractIssuesFromDiff(diff, file, type, message) {
+    const issues = [];
+    const badLines = this.getBadLinesFromDiff(diff, file, type);
+    const content = badLines.join("\n");
+    if (!content) return [];
+    const vulnerabilities = await scanForVulnerabilities(content, file);
+    const vibeIssues = await scanForVibeCodeIssues(content, file);
+    const allMatches = [...vulnerabilities, ...vibeIssues];
+    for (const match of allMatches) {
+      issues.push({
+        id: `implicit-${type}-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+        severity: "serious",
+        issue: `Implicit failure detected via ${type}: ${message}. Linked to pattern: ${match.category}`,
+        fix: `Review the ${type} commit and avoid this pattern in ${file}.`,
+        file,
+        confidence: 0.7,
+        autoFixable: false,
+        agent: "implicit-learning",
+        category: match.category
       });
-      if (input.files && input.files.length) {
-        for (const file of input.files) {
-          const fileNode = await graph.getNode("file", file);
-          if (fileNode) {
-            await graph.addEdge(decision.id, fileNode.id, "affects");
+    }
+    if (issues.length === 0) {
+      issues.push({
+        id: `implicit-${type}-${Date.now()}`,
+        severity: "moderate",
+        issue: `Historical ${type} detected: ${message}`,
+        fix: `Review the changes in ${file} from this commit to avoid regression.`,
+        file,
+        confidence: 0.5,
+        autoFixable: false,
+        agent: "implicit-learning"
+      });
+    }
+    return issues;
+  }
+  getBadLinesFromDiff(diff, file, type) {
+    const badLines = [];
+    const lines = diff.split("\n");
+    let inTargetFile = false;
+    for (const line of lines) {
+      if (line.startsWith("+++ b/") || line.startsWith("--- a/")) {
+        inTargetFile = line.includes(file);
+        continue;
+      }
+      if (!inTargetFile) continue;
+      if (type === "fix" && line.startsWith("-") && !line.startsWith("---")) {
+        badLines.push(line.slice(1));
+      } else if (type === "revert" && line.startsWith("+") && !line.startsWith("+++")) {
+        badLines.push(line.slice(1));
+      }
+    }
+    return badLines;
+  }
+};
+
+// src/ingest/linear-ingester.ts
+var LinearIngester = class {
+  projectPath;
+  graph;
+  constructor(projectPath, graph) {
+    this.projectPath = projectPath;
+    this.graph = graph;
+  }
+  async syncTickets() {
+    const apiKey = await this.getApiKey();
+    if (!apiKey) {
+      console.warn('Linear API key not found. Run "trie linear auth <key>" to enable ticket sync.');
+      return;
+    }
+    const tickets = await this.fetchActiveTickets(apiKey);
+    for (const ticket of tickets) {
+      await this.ingestTicket(ticket);
+    }
+  }
+  async getApiKey() {
+    const config = await loadConfig();
+    return config.apiKeys?.linear || process.env.LINEAR_API_KEY || null;
+  }
+  async fetchActiveTickets(apiKey) {
+    const query = `
+      query {
+        issues(filter: { state: { type: { in: ["started", "unstarted"] } } }) {
+          nodes {
+            id
+            identifier
+            title
+            description
+            priority
+            status {
+              name
+            }
+            assignee {
+              name
+            }
+            labels {
+              nodes {
+                name
+              }
+            }
+            createdAt
+            updatedAt
           }
         }
-        await learning.onFeedback(input.helpful, input.files);
       }
-      return {
-        content: [{
-          type: "text",
-          text: input.helpful ? "\u{1F44D} Thanks \u2014 I will prioritize more responses like this." : "\u{1F44E} Understood \u2014 I will adjust future guidance."
-        }]
-      };
-    } catch (error) {
-      const friendly = formatFriendlyError(error);
-      return { content: [{ type: "text", text: friendly.userMessage }] };
+    `;
+    const response = await fetch("https://api.linear.app/graphql", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": apiKey
+      },
+      body: JSON.stringify({ query })
+    });
+    if (!response.ok) {
+      throw new Error(`Linear API error: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.data.issues.nodes;
+  }
+  async ingestTicket(ticket) {
+    const labels = ticket.labels.nodes.map((l) => l.name);
+    const intentVibe = this.extractIntentVibes(ticket.title, ticket.description, labels);
+    const linkedFiles = this.extractLinkedFiles(ticket.description);
+    const data = {
+      ticketId: ticket.identifier,
+      title: ticket.title,
+      description: ticket.description || "",
+      priority: this.mapPriority(ticket.priority),
+      labels,
+      intentVibe,
+      linkedFiles,
+      status: ticket.status.name,
+      assignee: ticket.assignee?.name || null,
+      createdAt: ticket.createdAt,
+      updatedAt: ticket.updatedAt
+    };
+    await this.graph.addNode("linear-ticket", data);
+    for (const file of linkedFiles) {
+      const fileNode = await this.graph.getNode("file", file);
+      if (fileNode) {
+        await this.graph.addEdge(`linear:${ticket.identifier}`, fileNode.id, "relatedTo");
+      }
+    }
+  }
+  extractIntentVibes(title, description, labels) {
+    const vibes = /* @__PURE__ */ new Set();
+    const text = (title + " " + (description || "") + " " + labels.join(" ")).toLowerCase();
+    if (text.includes("performance") || text.includes("slow") || text.includes("optimize")) vibes.add("performance");
+    if (text.includes("security") || text.includes("auth") || text.includes("vulnerability")) vibes.add("security");
+    if (text.includes("refactor") || text.includes("cleanup") || text.includes("debt")) vibes.add("refactor");
+    if (text.includes("feature") || text.includes("new")) vibes.add("feature");
+    if (text.includes("bug") || text.includes("fix") || text.includes("broken")) vibes.add("bug");
+    if (text.includes("breaking") || text.includes("major change")) vibes.add("breaking-change");
+    return Array.from(vibes);
+  }
+  extractLinkedFiles(description) {
+    if (!description) return [];
+    const matches = description.match(/[\\w./_-]+\\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs)/gi);
+    if (!matches) return [];
+    return Array.from(new Set(matches.map((m) => m.replace(/^\.\/+/, ""))));
+  }
+  mapPriority(priority) {
+    switch (priority) {
+      case 1:
+        return "urgent";
+      case 2:
+        return "high";
+      case 3:
+        return "medium";
+      case 4:
+        return "low";
+      default:
+        return "none";
     }
   }
 };
@@ -1809,7 +1669,6 @@ export {
   shouldAutoFix,
   shouldBlockPush,
   getAutonomyConfig,
-  ContextGraph,
   perceiveCurrentChanges,
   reasonAboutChangesHumanReadable,
   loadBootstrapContext,
@@ -1826,6 +1685,7 @@ export {
   exportToJson,
   importFromJson,
   IncidentIndex,
-  TrieFeedbackTool
+  LearningEngine,
+  LinearIngester
 };
-//# sourceMappingURL=chunk-53URTRWH.js.map
+//# sourceMappingURL=chunk-FW435YKY.js.map