@triedotdev/mcp 1.0.138 → 1.0.140

package/dist/index.js

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
+import {
+  GitHubIngester
+} from "./chunk-YOJGSRZK.js";
 import {
   CodebaseIndex
-} from "./chunk-3RRXWX3V.js";
+} from "./chunk-AF2APASP.js";
 import {
-  LinearIngester,
   appendToSection,
   completeBootstrap,
   getContextForAI,
@@ -13,7 +15,6 @@ import {
   initProjectInfo,
   initializeBootstrapFiles,
   loadBootstrapContext,
-  loadConfig,
   loadContextState,
   loadProjectInfo,
   loadRules,
@@ -21,12 +22,13 @@ import {
   needsBootstrap,
   projectInfoExists,
   updateProjectSection
-} from "./chunk-D3AS5LY7.js";
+} from "./chunk-7OJ6JIPL.js";
 import {
-  getAutonomyConfig
-} from "./chunk-J5EMP4XW.js";
+  LinearIngester
+} from "./chunk-LD7ZEFNY.js";
 import {
   ExtractionPipeline,
+  GitHubBranchesTool,
   InteractiveDashboard,
   StreamingManager,
   TrieCheckTool,
@@ -37,27 +39,28 @@ import {
   TrieGetGovernanceTool,
   TrieGetRelatedDecisionsTool,
   TrieGetRelatedGovernanceTool,
+  TriePipelineTool,
   TrieQueryContextTool,
   TrieScanTool,
   TrieTellTool,
   getPrompt,
   getSystemPrompt,
   handleCheckpointTool
-} from "./chunk-X3F5QDER.js";
-import "./chunk-YOKQ25IW.js";
+} from "./chunk-4O2KRHK4.js";
 import "./chunk-23RJT5WT.js";
-import "./chunk-FOCXXIXY.js";
-import "./chunk-67GSG2ST.js";
+import "./chunk-OQ4A3RDY.js";
+import "./chunk-YEIJW6X6.js";
+import "./chunk-XTTZAQWJ.js";
 import "./chunk-3MUCUZ46.js";
 import {
   exportToJson,
   formatFriendlyError,
-  getChangedFilesSinceTimestamp,
-  getGitChangedFiles,
   importFromJson,
-  isTrieInitialized,
-  runShellCommandSync
-} from "./chunk-EDDT4ZIH.js";
+  isTrieInitialized
+} from "./chunk-GXF6JOCN.js";
+import {
+  loadConfig
+} from "./chunk-NKHO34UZ.js";
 import "./chunk-4C67GV3O.js";
 import "./chunk-ZV2K6M7T.js";
 import {
@@ -65,43 +68,51 @@ import {
   getGlobalMemoryStats,
   listTrackedProjects,
   searchGlobalPatterns
-} from "./chunk-6LLH3TBZ.js";
-import "./chunk-GFFUDJMK.js";
+} from "./chunk-UOSTOLU7.js";
+import {
+  ContextGraph
+} from "./chunk-FH335WL5.js";
+import "./chunk-75ADWWUF.js";
 import {
   isAIAvailable,
   runAIAnalysis
-} from "./chunk-Y32FM3MR.js";
+} from "./chunk-FPEMP54L.js";
 import "./chunk-LT6VUZG2.js";
-import "./chunk-F4NJ4CBP.js";
-import "./chunk-IXO4G4D3.js";
-import "./chunk-6NLHFIYA.js";
-import {
-  getStorage
-} from "./chunk-FG467PDD.js";
-import {
-  ContextGraph
-} from "./chunk-QSWUPSLK.js";
-import {
-  getSkillRegistry
-} from "./chunk-G76DYVGX.js";
-import {
-  getOutputManager
-} from "./chunk-TIMIKBY2.js";
 import {
   findSimilarIssues,
+  getChangedFilesSinceTimestamp,
+  getGitChangedFiles,
   getMemoryStats,
   getRecentIssues,
   markIssueResolved,
   purgeIssues,
+  runShellCommandSync,
   searchIssues,
   storeIssues
-} from "./chunk-Z2P4WST6.js";
+} from "./chunk-62POBLFC.js";
 import "./chunk-4MJ52WBH.js";
 import "./chunk-43X6JBEM.js";
+import "./chunk-F4NJ4CBP.js";
+import "./chunk-IXO4G4D3.js";
+import "./chunk-6NLHFIYA.js";
+import {
+  getStorage
+} from "./chunk-FG467PDD.js";
+import {
+  getSkillRegistry
+} from "./chunk-G76DYVGX.js";
+import {
+  getAutonomyConfig,
+  loadAutonomyConfig,
+  saveAutonomyConfig
+} from "./chunk-5KJ4UJOY.js";
 import {
   getTrieDirectory,
   getWorkingDirectory
 } from "./chunk-SH7H3WRU.js";
+import {
+  getOutputManager
+} from "./chunk-TIMIKBY2.js";
 import {
   isInteractiveMode
 } from "./chunk-APMV77PU.js";
@@ -188,10 +199,248 @@ function detectAITool() {
 import { readFile } from "fs/promises";
 import { existsSync } from "fs";
 import { extname, relative, resolve, isAbsolute } from "path";
+
+// src/tools/fix-triage.ts
+var EFFORT_SCORES = {
+  trivial: -6,
+  easy: -3,
+  medium: 0,
+  hard: 4
+};
+var SEVERITY_SCORES = {
+  critical: 4,
+  serious: 2,
+  moderate: -1,
+  low: -3
+};
+function triageIssue(issue, context, occurrence, config, pipeline) {
+  const reasons = [];
+  if (config?.level === "passive") {
+    return {
+      strategy: "local-ai",
+      score: 0,
+      confidence: 1,
+      reasons: ["Autonomy level is passive \u2014 cloud dispatch disabled"],
+      fallback: "local-ai"
+    };
+  }
+  if (config?.cloudAgentEnabled === false) {
+    return {
+      strategy: "local-ai",
+      score: 0,
+      confidence: 1,
+      reasons: ["Cloud agent not enabled (run trie_cloud_fix action:configure)"],
+      fallback: "local-ai"
+    };
+  }
+  let score = 0;
+  const effort = issue.effort ?? "medium";
+  const effortScore = EFFORT_SCORES[effort] ?? 0;
+  if (effortScore !== 0) {
+    score += effortScore;
+    reasons.push(`effort:${effort}`);
+  }
+  const severityScore = SEVERITY_SCORES[issue.severity] ?? 0;
+  if (severityScore !== 0) {
+    score += severityScore;
+    reasons.push(`severity:${issue.severity}`);
+  }
+  if (issue.autoFixable) {
+    score -= 2;
+    reasons.push("autoFixable");
+  }
+  if (issue.confidence < 0.7) {
+    score -= 2;
+    reasons.push(`low confidence (${(issue.confidence * 100).toFixed(0)}%)`);
+  }
+  if (issue.cwe) {
+    score += 3;
+    reasons.push(`cwe:${issue.cwe}`);
+  }
+  if (issue.owasp) {
+    score += 2;
+    reasons.push(`owasp:${issue.owasp}`);
+  }
+  if (issue.category === "security") {
+    score += 2;
+    reasons.push("category:security");
+  }
+  if (context) {
+    if (context.hasTests) {
+      score += 1;
+      reasons.push("has tests");
+    } else {
+      score -= 2;
+      reasons.push("no tests");
+    }
+    if (context.complexity === "high") {
+      score += 1;
+      reasons.push("high complexity");
+    }
+    if (context.touchesAuth || context.touchesCrypto || context.touchesPayments) {
+      score += 2;
+      reasons.push("touches auth/crypto/payments");
+    }
+    if (context.touchesDatabase) {
+      score += 1;
+      reasons.push("touches database");
+    }
+  }
+  if (occurrence) {
+    if (occurrence.count >= 5) {
+      score += 3;
+      reasons.push(`${occurrence.count}\xD7 seen`);
+    } else if (occurrence.count >= 3) {
+      score += 1;
+      reasons.push(`${occurrence.count}\xD7 seen`);
+    }
+    if (occurrence.escalationLevel === "block") {
+      score += 4;
+      reasons.push("escalation:block");
+    } else if (occurrence.escalationLevel === "escalate") {
+      score += 2;
+      reasons.push("escalation:escalate");
+    }
+  }
+  if (config?.level === "aggressive") {
+    score -= 1;
+    reasons.push("aggressive mode (\u22121 threshold)");
+  }
+  if (pipeline) {
+    if (pipeline.hasLinkedPR && pipeline.prState === "open") {
+      score -= 2;
+      reasons.push("has open PR");
+    }
+    if (pipeline.hasLinkedTicket && pipeline.ticketStatus?.toLowerCase().includes("started")) {
+      score -= 1;
+      reasons.push("ticket in active sprint");
+    }
+    if (pipeline.hasLinkedTicket && pipeline.ticketPriority === "urgent") {
+      score += 1;
+      reasons.push("ticket:urgent");
+    }
+    if (!pipeline.hasLinkedTicket && !pipeline.hasLinkedPR && issue.severity === "critical") {
+      score += 2;
+      reasons.push("critical, no ticket/PR (falling through cracks)");
+    }
+  }
+  let strategy;
+  if (score < 0 && issue.autoFixable) {
+    strategy = "inline-auto";
+  } else if (score < 4) {
+    strategy = "local-ai";
+  } else {
+    strategy = "cloud-agent";
+  }
+  const confidence = Math.min(1, Math.abs(score) / 8);
+  return { strategy, score, confidence, reasons, fallback: "local-ai" };
+}
+function triageIssues(issues, context, occurrences, config, pipelineContexts) {
+  const results = /* @__PURE__ */ new Map();
+  const summary = {
+    inlineAuto: [],
+    localAi: [],
+    cloudAgent: [],
+    cloudAgentScore: 0
+  };
+  for (const issue of issues) {
+    const occurrence = occurrences?.get(issue.id);
+    const pipeline = pipelineContexts?.get(issue.id);
+    const result = triageIssue(issue, context, occurrence, config, pipeline);
+    results.set(issue.id, result);
+    switch (result.strategy) {
+      case "inline-auto":
+        summary.inlineAuto.push(issue);
+        break;
+      case "local-ai":
+        summary.localAi.push(issue);
+        break;
+      case "cloud-agent":
+        summary.cloudAgent.push(issue);
+        summary.cloudAgentScore += result.score;
+        break;
+    }
+  }
+  return { results, summary };
+}
+function formatTriageTable(results, issues) {
+  const LINE = "\u2500".repeat(68);
+  const lines = [];
+  lines.push("FIX ROUTING PLAN");
+  lines.push(LINE);
+  lines.push(
+    padEnd("Issue", 32) + padEnd("Strategy", 14) + padEnd("Score", 7) + "Reason"
+  );
+  for (const issue of issues) {
+    const r = results.get(issue.id);
+    if (!r) continue;
+    const loc = `${shortPath(issue.file)}:${issue.line ?? "?"}`;
+    const scoreStr = r.score >= 0 ? `+${r.score}` : String(r.score);
+    lines.push(
+      padEnd(loc, 32) + padEnd(r.strategy, 14) + padEnd(scoreStr, 7) + r.reasons.join(", ")
+    );
+  }
+  lines.push(LINE);
+  const counts = [];
+  const cloud = issues.filter((i) => results.get(i.id)?.strategy === "cloud-agent");
+  const local = issues.filter((i) => results.get(i.id)?.strategy === "local-ai");
+  const auto = issues.filter((i) => results.get(i.id)?.strategy === "inline-auto");
+  if (cloud.length) counts.push(`${cloud.length} for cloud agent`);
+  if (local.length) counts.push(`${local.length} for local AI`);
+  if (auto.length) counts.push(`${auto.length} auto-fixable`);
+  lines.push(counts.join(", "));
+  if (cloud.length > 0) {
+    const ids = cloud.map((i) => `"${i.id}"`).join(",");
+    lines.push("");
+    lines.push(`To dispatch cloud issues:  trie_cloud_fix action:dispatch issueIds:[${ids}]`);
+  }
+  if (local.length > 0) {
+    const ids = local.map((i) => `"${i.id}"`).join(",");
+    lines.push(`To fix local issues:       trie_fix issueIds:[${ids}]`);
+  }
+  return lines.join("\n");
+}
+function formatCloudRecommendation(results, issues) {
+  const cloud = issues.filter((i) => {
+    const r = results.get(i.id);
+    return r && r.score >= 4;
+  });
+  if (cloud.length === 0) return null;
+  const LINE = "\u2500".repeat(65);
+  const lines = [];
+  lines.push(LINE);
+  lines.push(
+    `${cloud.length} issue${cloud.length > 1 ? "s" : ""} qualify for cloud agent verification (test-verified fix + PR):`
+  );
+  for (const issue of cloud) {
+    const r = results.get(issue.id);
+    const loc = `${shortPath(issue.file)}:${issue.line ?? "?"}`;
+    const scoreStr = r.score >= 0 ? `+${r.score}` : String(r.score);
+    lines.push(`  \u2022 ${padEnd(loc, 30)} \u2014 score ${scoreStr} (${r.reasons.join(", ")})`);
+  }
+  const ids = cloud.map((i) => `"${i.id}"`).join(",");
+  lines.push("");
+  lines.push(`Run: trie_cloud_fix action:dispatch issueIds:[${ids}]`);
+  lines.push(LINE);
+  return lines.join("\n");
+}
+function shortPath(file) {
+  const parts = file.split("/");
+  return parts.length > 2 ? parts.slice(-2).join("/") : file;
+}
+function padEnd(str, len) {
+  if (str.length >= len) return str.slice(0, len);
+  return str + " ".repeat(len - str.length);
+}
+
+// src/tools/fix.ts
 var pendingFixes = /* @__PURE__ */ new Map();
 var TrieFixTool = class {
   async execute(args) {
-    const { issueIds, file, line, issue, fix, autoApprove = false, dryRun = false } = args || {};
+    const { issueIds, file, line, issue, fix, autoApprove = false, dryRun = false, action } = args || {};
+    if (action === "route") {
+      return this.routeIssues(issueIds);
+    }
     if (issueIds && issueIds.length > 0) {
       return this.fixByIds(issueIds, autoApprove, dryRun);
     }
@@ -211,6 +460,37 @@ var TrieFixTool = class {
       }]
     };
   }
+  async routeIssues(issueIds) {
+    const pending = getPendingFixes();
+    if (pending.length === 0) {
+      return {
+        content: [{ type: "text", text: "No pending issues. Run `trie_scan` first to detect issues." }]
+      };
+    }
+    const issues = pending.map((p) => ({
+      id: p.id,
+      severity: p.severity ?? "moderate",
+      effort: p.effort,
+      issue: p.issue,
+      fix: p.suggestedFix,
+      file: p.file,
+      line: p.line,
+      confidence: p.confidence,
+      autoFixable: p.autoFixable ?? false,
+      agent: "trie_scan",
+      cwe: p.cwe,
+      owasp: p.owasp,
+      category: p.category
+    }));
+    const filtered = issueIds && issueIds.length > 0 ? issues.filter((i) => issueIds.includes(i.id)) : issues;
+    const workDir = getWorkingDirectory(void 0, true);
+    const config = await loadAutonomyConfig(workDir);
+    const { results } = triageIssues(filtered, void 0, void 0, config);
+    const table = formatTriageTable(results, filtered);
+    return { content: [{ type: "text", text: `
+${table}
+` }] };
+  }
   async fixByIds(issueIds, autoApprove, dryRun) {
     const results = [];
     let fixed = 0;
@@ -254,6 +534,7 @@ ${"\u2501".repeat(60)}
 
 **Summary:** ${fixed} fixed, ${failed} failed, ${issueIds.length - fixed - failed} skipped
 `;
+    output += await this.appendCloudRecommendation(issueIds);
     return { content: [{ type: "text", text: output }] };
   }
   async applyFix(file, line, issue, fix, dryRun) {
@@ -505,6 +786,33 @@ trie_fix
 The AI will analyze each issue, generate the fix, and you can review before applying.
 `;
   }
+  async appendCloudRecommendation(handledIds) {
+    try {
+      const pending = getPendingFixes();
+      const remaining = pending.filter((p) => !handledIds.includes(p.id) || pendingFixes.get(p.id)?.status === "pending");
+      if (remaining.length === 0) return "";
+      const issues = remaining.map((p) => ({
+        id: p.id,
+        severity: "moderate",
+        issue: p.issue,
+        fix: p.suggestedFix,
+        file: p.file,
+        line: p.line,
+        confidence: p.confidence,
+        autoFixable: false,
+        agent: "trie_scan"
+      }));
+      const workDir = getWorkingDirectory(void 0, true);
+      const config = await loadAutonomyConfig(workDir);
+      const { results } = triageIssues(issues, void 0, void 0, config);
+      const footer = formatCloudRecommendation(results, issues);
+      return footer ? `
+${footer}
+` : "";
+    } catch {
+      return "";
+    }
+  }
   detectLanguage(filePath) {
     const ext = extname(filePath).toLowerCase();
     const langMap = {
@@ -519,11 +827,459 @@ The AI will analyze each issue, generate the fix, and you can review before appl
     return langMap[ext] || "plaintext";
   }
 };
+function getPendingFixes() {
+  return Array.from(pendingFixes.values());
+}
 
-// src/tools/test.ts
-import { readFile as readFile2 } from "fs/promises";
+// src/tools/cloud-fix.ts
+import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
-import { extname as extname2, relative as relative2, resolve as resolve2, isAbsolute as isAbsolute2, dirname, basename, join } from "path";
+import { join } from "path";
+import { execSync } from "child_process";
+
+// src/integrations/cursor-cloud-agent.ts
+var BASE_URL = "https://api.cursor.com/v1";
+var CursorCloudAgentClient = class {
+  apiKey;
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  /**
+   * Dispatch an issue to a cloud agent for fixing.
+   */
+  async dispatch(issue, triageResult, repoUrl, branch) {
+    const prompt = this.buildPrompt(issue, triageResult);
+    const body = {
+      prompt,
+      repo: repoUrl,
+      branch,
+      metadata: {
+        issueId: issue.id,
+        file: issue.file,
+        line: issue.line,
+        severity: issue.severity,
+        agent: issue.agent
+      }
+    };
+    const res = await this.request("POST", "/agents/tasks", body);
+    return {
+      jobId: res.id ?? res.taskId ?? res.jobId,
+      status: "dispatched",
+      artifactUrls: [],
+      dispatchedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Poll job status.
+   */
+  async poll(jobId) {
+    const res = await this.request("GET", `/agents/tasks/${jobId}`);
+    const status = mapStatus(res.status);
+    const prUrl = extractPrUrl(res);
+    const artifactUrls = this.extractArtifacts(res);
+    return { status, prUrl, artifactUrls };
+  }
+  /**
+   * Get artifact URLs for a completed job.
+   */
+  async getArtifacts(jobId) {
+    const res = await this.request("GET", `/agents/tasks/${jobId}`);
+    return this.extractArtifacts(res);
+  }
+  /**
+   * Cancel a running job.
+   */
+  async cancelJob(jobId) {
+    await this.request("DELETE", `/agents/tasks/${jobId}`);
+  }
+  // --------------------------------------------------------------------------
+  // Internal
+  // --------------------------------------------------------------------------
+  buildPrompt(issue, triageResult) {
+    const parts = [
+      "You are fixing a verified issue in the codebase.",
+      "",
+      `Issue: ${issue.issue}`,
+      `File: ${issue.file}${issue.line ? `:${issue.line}` : ""}`,
+      `Severity: ${issue.severity} | Effort: ${issue.effort ?? "medium"}`,
+      `Agent that found it: ${issue.agent}`,
+      `Suggested fix: ${issue.fix}`
+    ];
+    if (issue.cwe) parts.push(`CWE: ${issue.cwe}`);
+    if (issue.owasp) parts.push(`OWASP: ${issue.owasp}`);
+    parts.push(`Triage confidence: ${triageResult.confidence.toFixed(2)}`);
+    parts.push(`Why cloud agent: ${triageResult.reasons.join(", ")}`);
+    parts.push("");
+    parts.push("Steps:");
+    parts.push(`1. Apply the minimal fix described above to ${issue.file}`);
+    parts.push("2. Run the existing test suite (detect test runner from package.json scripts)");
+    parts.push("3. Screenshot the passing test output \u2014 this is the verification artifact");
+    parts.push("4. If tests fail, iterate on the fix until they pass (max 3 attempts)");
+    parts.push("5. Open a PR with only this single change \u2014 do not bundle other fixes");
+    parts.push("6. Include the screenshot in the PR description as evidence");
+    return parts.join("\n");
+  }
+  async request(method, path2, body) {
+    const url = `${BASE_URL}${path2}`;
+    const headers = {
+      "Authorization": `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json"
+    };
+    const init = { method, headers };
+    if (body) init.body = JSON.stringify(body);
+    const res = await fetch(url, init);
+    if (res.status === 401) {
+      throw new Error(
+        'Cursor API key is invalid or expired.\nUpdate it: trie_cloud_fix action:configure apiKey:"key-..."'
+      );
+    }
+    if (res.status === 404) {
+      throw new Error(`Job not found: ${path2}`);
+    }
+    if (res.status >= 500) {
+      throw new Error(
+        `Cursor API returned ${res.status}. The service may be temporarily unavailable \u2014 retry in a few minutes.`
+      );
+    }
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`Cursor API error ${res.status}: ${text}`);
+    }
+    return res.json();
+  }
+  extractArtifacts(res) {
+    const urls = [];
+    if (Array.isArray(res.messages)) {
+      for (const msg of res.messages) {
+        if (typeof msg.content === "string") {
+          const matches = msg.content.match(/https:\/\/[^\s)]+\.(png|jpg|mp4|webm)/g);
+          if (matches) urls.push(...matches);
+        }
+      }
+    }
+    if (Array.isArray(res.artifacts)) {
+      for (const a of res.artifacts) {
+        if (a.url) urls.push(a.url);
+      }
+    }
+    return [...new Set(urls)];
+  }
+};
+function mapStatus(raw) {
+  switch (raw) {
+    case "pending":
+    case "queued":
+      return "pending";
+    case "running":
+    case "in_progress":
+      return "running";
+    case "completed":
+    case "succeeded":
+    case "verified":
+      return "completed";
+    default:
+      return "failed";
+  }
+}
+function extractPrUrl(res) {
+  if (typeof res.prUrl === "string") return res.prUrl;
+  if (typeof res.pr_url === "string") return res.pr_url;
+  if (typeof res.pullRequestUrl === "string") return res.pullRequestUrl;
+  if (Array.isArray(res.messages)) {
+    for (const msg of res.messages) {
+      if (typeof msg.content === "string") {
+        const match = msg.content.match(/https:\/\/github\.com\/[^\s)]+\/pull\/\d+/);
+        if (match) return match[0];
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/tools/cloud-fix.ts
+var TrieCloudFixTool = class {
+  async execute(args) {
+    const { action = "status" } = args || {};
+    switch (action) {
+      case "configure":
+        return this.configure(args);
+      case "dispatch":
+        return this.dispatch(args);
+      case "status":
+        return this.status();
+      case "artifacts":
+        return this.artifacts(args);
+      case "cancel":
+        return this.cancel(args);
+      default:
+        return this.text(`Unknown action "${action}". Use: configure | dispatch | status | artifacts | cancel`);
+    }
+  }
+  // --------------------------------------------------------------------------
+  // configure
+  // --------------------------------------------------------------------------
+  async configure(args) {
+    const apiKey = args?.apiKey || process.env.CURSOR_API_KEY;
+    if (!apiKey) {
+      return this.text(
+        'Missing API key.\n\nUsage:  trie_cloud_fix action:configure apiKey:"key-..."\nOr set: export CURSOR_API_KEY="key-..."'
+      );
+    }
+    const workDir = getWorkingDirectory(void 0, true);
+    await saveAutonomyConfig(workDir, { cloudAgentEnabled: true, cursorApiKey: apiKey });
+    return this.text("Cursor API key saved. Cloud agent dispatch enabled.");
+  }
+  // --------------------------------------------------------------------------
+  // dispatch
+  // --------------------------------------------------------------------------
+  async dispatch(args) {
+    const workDir = getWorkingDirectory(void 0, true);
+    const apiKey = await this.resolveApiKey(workDir);
+    if (!apiKey) return this.setupGuard();
+    const config = await loadAutonomyConfig(workDir);
+    const allIssues = this.resolveIssues(args?.issueIds);
+    if (allIssues.length === 0) {
+      return this.text("No issues to dispatch. Run trie_scan first, then trie_fix action:route.");
+    }
+    const { results, summary } = triageIssues(allIssues, void 0, void 0, config);
+    const lines = [];
+    lines.push(formatTriageTable(results, allIssues));
+    lines.push("");
+    for (const issue of allIssues) {
+      const r = results.get(issue.id);
+      if (r && r.strategy !== "cloud-agent") {
+        lines.push(`Skipped ${issue.id}: routed to ${r.strategy} (score ${r.score >= 0 ? "+" : ""}${r.score} \u2014 ${r.reasons.join(", ")})`);
+      }
+    }
+    if (summary.cloudAgent.length === 0) {
+      lines.push("\nNo issues qualify for cloud dispatch. Use trie_fix for local fixes.");
+      return this.text(lines.join("\n"));
+    }
+    const client = new CursorCloudAgentClient(apiKey);
+    const repoUrl = this.getRepoUrl(workDir);
+    const branch = this.getBranch(workDir);
+    const store = await this.loadJobs(workDir);
+    lines.push("\nDISPATCHED");
+    for (const issue of summary.cloudAgent) {
+      const triageResult = results.get(issue.id);
+      try {
+        const job = await client.dispatch(issue, triageResult, repoUrl, branch);
+        store.jobs[issue.id] = {
+          issueId: issue.id,
+          jobId: job.jobId,
+          status: "dispatched",
+          score: triageResult.score,
+          strategy: "cloud-agent",
+          dispatchedAt: job.dispatchedAt,
+          artifactUrls: [],
+          prUrl: null
+        };
+        lines.push(`  ${issue.id}  ${shortPath2(issue.file)}:${issue.line ?? "?"}  job:${job.jobId}  (score +${triageResult.score})`);
+      } catch (err) {
+        lines.push(`  ${issue.id}  FAILED: ${err.message}`);
+      }
+    }
+    await this.saveJobs(workDir, store);
+    lines.push("");
+    lines.push("Cloud agents are running in isolated VMs. Check back with:");
+    lines.push("trie_cloud_fix action:status");
+    return this.text(lines.join("\n"));
+  }
+  // --------------------------------------------------------------------------
+  // status
+  // --------------------------------------------------------------------------
+  async status() {
+    const workDir = getWorkingDirectory(void 0, true);
+    const apiKey = await this.resolveApiKey(workDir);
+    if (!apiKey) return this.setupGuard();
+    const store = await this.loadJobs(workDir);
+    const entries = Object.values(store.jobs);
+    if (entries.length === 0) {
+      return this.text("No cloud jobs. Dispatch with: trie_cloud_fix action:dispatch");
+    }
+    const client = new CursorCloudAgentClient(apiKey);
+    const LINE = "\u2500".repeat(68);
+    const lines = ["JOB STATUS", LINE];
+    lines.push(padEnd2("Issue", 32) + padEnd2("Status", 12) + padEnd2("PR", 28) + "Age");
+    for (const job of entries) {
+      if (job.status === "dispatched" || job.status === "running") {
+        try {
+          const poll = await client.poll(job.jobId);
+          if (poll.status === "completed" && poll.prUrl) {
+            job.status = "verified";
+            job.prUrl = poll.prUrl;
+          } else if (poll.status === "running") {
+            job.status = "running";
+          } else if (poll.status === "failed") {
+            job.status = "failed";
+          }
+          if (poll.artifactUrls.length) {
+            job.artifactUrls = poll.artifactUrls;
+          }
+        } catch {
+        }
+      }
+      const age = formatAge(job.dispatchedAt);
+      const pr = job.prUrl ?? "\u2014";
+      lines.push(padEnd2(job.issueId, 32) + padEnd2(job.status, 12) + padEnd2(pr, 28) + age);
+    }
+    lines.push(LINE);
+    await this.saveJobs(workDir, store);
+    return this.text(lines.join("\n"));
+  }
+  // --------------------------------------------------------------------------
+  // artifacts
+  // --------------------------------------------------------------------------
+  async artifacts(args) {
+    const workDir = getWorkingDirectory(void 0, true);
+    const apiKey = await this.resolveApiKey(workDir);
+    if (!apiKey) return this.setupGuard();
+    const store = await this.loadJobs(workDir);
+    const jobId = args?.jobId;
+    const targets = jobId ? Object.values(store.jobs).filter((j) => j.jobId === jobId) : Object.values(store.jobs).filter((j) => j.status === "verified");
+    if (targets.length === 0) {
+      return this.text(jobId ? `No job found with id ${jobId}` : "No completed jobs with artifacts.");
+    }
+    const client = new CursorCloudAgentClient(apiKey);
+    const lines = [];
+    for (const job of targets) {
+      try {
+        const artifacts = await client.getArtifacts(job.jobId);
+        job.artifactUrls = artifacts;
+      } catch {
+      }
+      lines.push(`Issue: ${job.issueId}`);
+      lines.push(`PR:         ${job.prUrl ?? "N/A"}`);
+      for (const url of job.artifactUrls) {
+        const ext = url.split(".").pop();
+        const label = ext === "mp4" || ext === "webm" ? "Video" : "Screenshot";
+        lines.push(`${label}:    ${url}`);
+      }
+      if (job.status === "verified") {
+        lines.push("Agent verified: all tests pass with this fix applied.");
+      }
+      lines.push("");
+    }
+    await this.saveJobs(workDir, store);
+    return this.text(lines.join("\n"));
+  }
+  // --------------------------------------------------------------------------
+  // cancel
+  // --------------------------------------------------------------------------
+  async cancel(args) {
+    const workDir = getWorkingDirectory(void 0, true);
+    const apiKey = await this.resolveApiKey(workDir);
+    if (!apiKey) return this.setupGuard();
+    const jobId = args?.jobId;
+    if (!jobId) {
+      return this.text('Provide jobId to cancel. Example: trie_cloud_fix action:cancel jobId:"cursor-task-xyz"');
+    }
+    const store = await this.loadJobs(workDir);
+    const entry = Object.values(store.jobs).find((j) => j.jobId === jobId);
+    if (!entry) {
+      return this.text(`Job ${jobId} not found in cloud-jobs.json.`);
+    }
+    const client = new CursorCloudAgentClient(apiKey);
+    try {
+      await client.cancelJob(jobId);
+    } catch (err) {
+      return this.text(`Cancel failed: ${err.message}`);
+    }
+    delete store.jobs[entry.issueId];
+    await this.saveJobs(workDir, store);
+    return this.text(`Job ${jobId} cancelled and removed.`);
+  }
+  // --------------------------------------------------------------------------
+  // Helpers
+  // --------------------------------------------------------------------------
+  async resolveApiKey(workDir) {
+    if (process.env.CURSOR_API_KEY) return process.env.CURSOR_API_KEY;
+    const config = await loadAutonomyConfig(workDir);
+    return config.cursorApiKey ?? null;
+  }
+  setupGuard() {
+    return this.text(
+      'Cloud Agent dispatch requires a Cursor API key.\n\nGet your key at: cursor.com/settings \u2192 API Keys\nThen run: trie_cloud_fix action:configure apiKey:"key-..."\n\nOr set the environment variable: export CURSOR_API_KEY="key-..."'
+    );
+  }
+  resolveIssues(issueIds) {
+    const pending = getPendingFixes();
+    const issues = pending.map((p) => ({
+      id: p.id,
+      severity: p.severity ?? "moderate",
+      effort: p.effort,
+      issue: p.issue,
+      fix: p.suggestedFix,
+      file: p.file,
+      line: p.line,
+      confidence: p.confidence,
+      autoFixable: p.autoFixable ?? false,
+      agent: "trie_scan",
+      cwe: p.cwe,
+      owasp: p.owasp,
+      category: p.category
+    }));
+    if (issueIds && issueIds.length > 0) {
+      return issues.filter((i) => issueIds.includes(i.id));
+    }
+    return issues;
+  }
+  getRepoUrl(workDir) {
+    try {
+      return execSync("git remote get-url origin", { cwd: workDir, encoding: "utf-8" }).trim();
+    } catch {
+      return "unknown";
+    }
+  }
+  getBranch(workDir) {
+    try {
+      return execSync("git rev-parse --abbrev-ref HEAD", { cwd: workDir, encoding: "utf-8" }).trim();
+    } catch {
+      return "main";
+    }
+  }
+  async loadJobs(workDir) {
+    const path2 = join(getTrieDirectory(workDir), "cloud-jobs.json");
+    try {
+      if (existsSync2(path2)) {
+        const raw = await readFile2(path2, "utf-8");
+        return JSON.parse(raw);
+      }
+    } catch {
+    }
+    return { jobs: {} };
+  }
+  async saveJobs(workDir, store) {
+    const trieDir = getTrieDirectory(workDir);
+    if (!existsSync2(trieDir)) await mkdir(trieDir, { recursive: true });
+    const path2 = join(trieDir, "cloud-jobs.json");
+    await writeFile(path2, JSON.stringify(store, null, 2));
+  }
+  text(msg) {
+    return { content: [{ type: "text", text: msg }] };
+  }
+};
+function formatAge(isoDate) {
+  const ms = Date.now() - new Date(isoDate).getTime();
+  const mins = Math.floor(ms / 6e4);
+  if (mins < 60) return `${mins}m`;
+  const hrs = Math.floor(mins / 60);
+  if (hrs < 24) return `${hrs}h ${mins % 60}m`;
+  return `${Math.floor(hrs / 24)}d`;
+}
+function shortPath2(file) {
+  const parts = file.split("/");
+  return parts.length > 2 ? parts.slice(-2).join("/") : file;
+}
+function padEnd2(str, len) {
+  if (str.length >= len) return str.slice(0, len);
+  return str + " ".repeat(len - str.length);
+}
+
+// src/tools/test.ts
+import { readFile as readFile3 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { extname as extname2, relative as relative2, resolve as resolve2, isAbsolute as isAbsolute2, dirname, basename, join as join2 } from "path";
 var TrieTestTool = class {
   async execute(args) {
     const { action, files, framework, style = "unit" } = args || {};
@@ -577,12 +1333,12 @@ ${"\u2501".repeat(60)}
     const allUnits = [];
     for (const file of files) {
       const resolvedPath = isAbsolute2(file) ? file : resolve2(workDir, file);
-      if (!existsSync2(resolvedPath)) {
+      if (!existsSync3(resolvedPath)) {
         output += `[!] File not found: ${file}
 `;
         continue;
       }
-      const code = await readFile2(resolvedPath, "utf-8");
+      const code = await readFile3(resolvedPath, "utf-8");
       const language = this.detectLanguage(resolvedPath);
       const relativePath = relative2(workDir, resolvedPath);
       const units = this.extractTestableUnits(code, language);
@@ -615,7 +1371,7 @@ ${"\u2501".repeat(60)}
 `;
     for (const { file, units } of allUnits) {
       if (units.length === 0) continue;
-      const code = await readFile2(resolve2(workDir, file), "utf-8");
+      const code = await readFile3(resolve2(workDir, file), "utf-8");
       const language = this.detectLanguage(file);
       const prompt = getPrompt("test", "generate", {
         code,
@@ -661,12 +1417,12 @@ ${"\u2501".repeat(60)}
     const workDir = getWorkingDirectory(void 0, true);
     for (const file of files) {
       const resolvedPath = isAbsolute2(file) ? file : resolve2(workDir, file);
-      if (!existsSync2(resolvedPath)) {
+      if (!existsSync3(resolvedPath)) {
         output += `[!] File not found: ${file}
 `;
         continue;
       }
-      const code = await readFile2(resolvedPath, "utf-8");
+      const code = await readFile3(resolvedPath, "utf-8");
       const language = this.detectLanguage(resolvedPath);
       const relativePath = relative2(workDir, resolvedPath);
       const units = this.extractTestableUnits(code, language);
@@ -674,7 +1430,7 @@ ${"\u2501".repeat(60)}
       let testCode = "";
       let testedUnits = [];
       if (testFile) {
-        testCode = await readFile2(testFile, "utf-8");
+        testCode = await readFile3(testFile, "utf-8");
         testedUnits = this.findTestedUnits(testCode, units.map((u) => u.name));
       }
       const coverage = units.length > 0 ? Math.round(testedUnits.length / units.length * 100) : 0;
@@ -743,12 +1499,12 @@ ${"\u2501".repeat(60)}
     const workDir = getWorkingDirectory(void 0, true);
     for (const file of files) {
       const resolvedPath = isAbsolute2(file) ? file : resolve2(workDir, file);
-      if (!existsSync2(resolvedPath)) {
+      if (!existsSync3(resolvedPath)) {
         output += `[!] File not found: ${file}
 `;
         continue;
       }
-      const code = await readFile2(resolvedPath, "utf-8");
+      const code = await readFile3(resolvedPath, "utf-8");
       const relativePath = relative2(workDir, resolvedPath);
       const patterns = this.detectTestablePatterns(code);
       output += `### \u{1F4C4} ${relativePath}
@@ -994,16 +1750,16 @@ ${"\u2501".repeat(60)}
       `test_${base}${ext}`
     ];
     for (const pattern of patterns) {
-      const testPath = join(dir, pattern);
-      if (existsSync2(testPath)) {
+      const testPath = join2(dir, pattern);
+      if (existsSync3(testPath)) {
         return testPath;
       }
     }
-    const testsDir = join(dir, "__tests__");
-    if (existsSync2(testsDir)) {
+    const testsDir = join2(dir, "__tests__");
+    if (existsSync3(testsDir)) {
       for (const pattern of patterns) {
-        const testPath = join(testsDir, pattern);
-        if (existsSync2(testPath)) {
+        const testPath = join2(testsDir, pattern);
+        if (existsSync3(testPath)) {
           return testPath;
         }
       }
@@ -1051,9 +1807,9 @@ ${"\u2501".repeat(60)}
   async detectTestFramework() {
     const workDir = getWorkingDirectory(void 0, true);
     const packagePath = resolve2(workDir, "package.json");
-    if (existsSync2(packagePath)) {
+    if (existsSync3(packagePath)) {
       try {
-        const pkg = JSON.parse(await readFile2(packagePath, "utf-8"));
+        const pkg = JSON.parse(await readFile3(packagePath, "utf-8"));
         const deps = { ...pkg.dependencies, ...pkg.devDependencies };
         if (deps.vitest) return "vitest";
         if (deps.jest) return "jest";
@@ -1061,7 +1817,7 @@ ${"\u2501".repeat(60)}
       } catch {
       }
     }
-    if (existsSync2(resolve2(workDir, "pytest.ini")) || existsSync2(resolve2(workDir, "pyproject.toml"))) {
+    if (existsSync3(resolve2(workDir, "pytest.ini")) || existsSync3(resolve2(workDir, "pyproject.toml"))) {
       return "pytest";
     }
     return "jest";
@@ -1120,9 +1876,9 @@ trie_test action:"run" files:["src/utils.test.ts"]
 };
 
 // src/tools/watch.ts
-import { watch, existsSync as existsSync3, readFileSync } from "fs";
-import { stat, readFile as readFile3 } from "fs/promises";
-import { join as join2, extname as extname3, basename as basename2 } from "path";
+import { watch, existsSync as existsSync4, readFileSync } from "fs";
+import { stat, readFile as readFile4 } from "fs/promises";
+import { join as join3, extname as extname3, basename as basename2 } from "path";
 import { createHash } from "crypto";
 var WATCH_EXTENSIONS = /* @__PURE__ */ new Set([
   ".ts",
@@ -1176,8 +1932,11 @@ var TrieWatchTool = class _TrieWatchTool {
   streamingManager = void 0;
   dashboard = void 0;
   lastHypothesisCheck = 0;
+  pipelineSyncTimer = null;
   static HYPOTHESIS_CHECK_INTERVAL_MS = 3e5;
   // Check every 5 minutes
+  static PIPELINE_SYNC_INTERVAL_MS = 30 * 60 * 1e3;
+  // 30 minutes
   async execute(args) {
     const { action, directory, debounceMs = 1e3 } = args;
     switch (action) {
@@ -1237,16 +1996,27 @@ var TrieWatchTool = class _TrieWatchTool {
       const storage = getStorage(directory);
       await storage.initialize();
       const unresolvedNudges = await storage.queryNudges({ resolved: false });
+      console.debug(`[Watch] Found ${unresolvedNudges.length} unresolved nudges in storage`);
       for (const nudge of unresolvedNudges) {
+        let mappedSeverity = "high";
+        if (nudge.severity === "critical") {
+          mappedSeverity = "critical";
+        } else if (nudge.severity === "high") {
+          mappedSeverity = "high";
+        }
         this.state.nudges.push({
-          file: nudge.file ? basename2(nudge.file) : "unknown",
+          file: nudge.file || "unknown",
+          // Keep full path, don't use basename
           message: nudge.message,
-          severity: nudge.severity === "critical" ? "critical" : "high",
+          severity: mappedSeverity,
           timestamp: new Date(nudge.timestamp).toLocaleTimeString("en-US", { hour12: false })
         });
+        console.debug(`[Watch] Loaded nudge: ${nudge.message.slice(0, 60)}... (${nudge.severity} -> ${mappedSeverity})`);
       }
       if (unresolvedNudges.length > 0) {
-        console.debug(`[Watch] Loaded ${unresolvedNudges.length} unresolved nudges from storage`);
+        console.log(`[Watch] \u2713 Loaded ${unresolvedNudges.length} unresolved nudges from storage`);
+      } else {
+        console.debug(`[Watch] No unresolved nudges found in storage`);
       }
     } catch (error) {
       console.error("[Watch] Failed to load nudges from storage:", error);
@@ -1284,7 +2054,11 @@ var TrieWatchTool = class _TrieWatchTool {
     setTimeout(() => {
       void this.initialGoalComplianceScan();
       void this.initialHypothesisGeneration();
+      void this.syncPipelineIntegrations();
     }, 1e3);
+    this.pipelineSyncTimer = setInterval(() => {
+      void this.syncPipelineIntegrations();
+    }, _TrieWatchTool.PIPELINE_SYNC_INTERVAL_MS);
     const indexStatus = this.codebaseIndex?.isEmpty() ? "BUILDING (one-time, speeds up goal checks)" : "READY";
     return {
       content: [{
@@ -1322,7 +2096,7 @@ Your Trie agent is now autonomously watching and learning from your codebase.
     return parts.some((p) => SKIP_DIRS.has(p) || p.startsWith(".") && p !== ".");
   }
   async watchDirectory(dir, debounceMs) {
-    if (!existsSync3(dir)) return;
+    if (!existsSync4(dir)) return;
     try {
       const dirStat = await stat(dir);
       if (!dirStat.isDirectory()) return;
@@ -1331,8 +2105,8 @@ Your Trie agent is now autonomously watching and learning from your codebase.
         if (this.shouldSkipPath(filename)) return;
         const ext = extname3(filename).toLowerCase();
         if (!WATCH_EXTENSIONS.has(ext)) return;
-        const fullPath = join2(dir, filename);
-        if (!existsSync3(fullPath)) return;
+        const fullPath = join3(dir, filename);
+        if (!existsSync4(fullPath)) return;
         this.state.pendingFiles.add(fullPath);
         if (this.state.scanDebounceTimer) {
           clearTimeout(this.state.scanDebounceTimer);
@@ -1378,7 +2152,7 @@ Detected changes in ${files.length} file(s):`);
           const fileContents = await Promise.all(
             files.map(async (file) => {
               try {
-                const content = await readFile3(file, "utf-8");
+                const content = await readFile4(file, "utf-8");
                 return { file, content };
               } catch {
                 return null;
@@ -1456,7 +2230,7 @@ ${f.content.slice(0, 1e3)}`
   }
   isQuiet() {
     const projectPath = this.watchedDirectory || getWorkingDirectory(void 0, true);
-    const quietPath = join2(getTrieDirectory(projectPath), "quiet.json");
+    const quietPath = join3(getTrieDirectory(projectPath), "quiet.json");
     try {
       const raw = readFileSync(quietPath, "utf-8");
       const data = JSON.parse(raw);
@@ -1473,7 +2247,7 @@ ${f.content.slice(0, 1e3)}`
   async checkAndGenerateHypotheses(projectPath) {
     if (!isAIAvailable()) return;
     try {
-      const { getHypothesisEngine } = await import("./hypothesis-K3KQJOXJ.js");
+      const { getHypothesisEngine } = await import("./hypothesis-JCUMZKTG.js");
       const { getOutputManager: getOutputManager2 } = await import("./output-manager-DZO5LGSG.js");
       const hypothesisEngine = getHypothesisEngine(projectPath);
       const recentIssues = Array.from(this.state.issueCache.values()).flat();
@@ -1540,7 +2314,7 @@ ${f.content.slice(0, 1e3)}`
     const totalIssues = Array.from(this.state.issueCache.values()).flat().length;
     if (totalIssues < 5) return;
     try {
-      const { ContextGraph: ContextGraph2 } = await import("./graph-X2FMRQLG.js");
+      const { ContextGraph: ContextGraph2 } = await import("./graph-J4OGTYCO.js");
       const { IncidentIndex } = await import("./incident-index-BWW2UEY7.js");
       const { TriePatternDiscovery } = await import("./pattern-discovery-F7LU5K6E.js");
       const graph = new ContextGraph2(projectPath);
@@ -1624,7 +2398,7 @@ ${f.content.slice(0, 1e3)}`
     if (lastClean && Date.now() - lastClean < this.cleanFileCooldownMs) {
       return 0;
     }
-    const fileNode = await graph.getNode("file", join2(projectPath, file));
+    const fileNode = await graph.getNode("file", join3(projectPath, file));
     if (!fileNode) return score;
     const data = fileNode.data;
     const riskScores = { critical: 10, high: 6, medium: 2, low: 1 };
@@ -1683,7 +2457,7 @@ ${f.content.slice(0, 1e3)}`
       if (remaining < 500) return;
       try {
         const graph = new ContextGraph(projectPath);
-        const { getActiveGoals, recordGoalViolationCaught } = await import("./goal-validator-GISXYANK.js");
+        const { getActiveGoals, recordGoalViolationCaught } = await import("./goal-validator-HNXXUCPW.js");
         console.debug("[AI Watcher] Loading active goals...");
         const activeGoals = await getActiveGoals(projectPath);
         const hasGoals = activeGoals.length > 0;
@@ -1712,7 +2486,7 @@ ${f.content.slice(0, 1e3)}`
         const fileContents = await Promise.all(
           filesToScan.map(async ({ file, relativePath }) => {
             try {
-              const content = await readFile3(file, "utf-8");
+              const content = await readFile4(file, "utf-8");
               return { path: relativePath, content: content.slice(0, charLimit) };
             } catch {
               return null;
@@ -1877,7 +2651,7 @@ ${filesBlock}`,
             fixChangeId: null,
             reportedVia: "detected"
           });
-          const filePath = join2(projectPath, issue.file);
+          const filePath = join3(projectPath, issue.file);
           const fileNode = await graph.getNode("file", filePath);
           if (fileNode) {
             await graph.addEdge(fileNode.id, incident.id, "affects");
@@ -1935,7 +2709,7 @@ ${filesBlock}`,
     const projectPath = this.watchedDirectory || getWorkingDirectory(void 0, true);
     console.debug("[Initial Hypothesis] Starting initial hypothesis generation", { projectPath });
     try {
-      const { getHypothesisEngine } = await import("./hypothesis-K3KQJOXJ.js");
+      const { getHypothesisEngine } = await import("./hypothesis-JCUMZKTG.js");
       const hypothesisEngine = getHypothesisEngine(projectPath);
       console.debug("[Initial Hypothesis] Running AI-powered hypothesis generation...");
       const generated = await hypothesisEngine.generateHypothesesWithAI({
@@ -1993,7 +2767,7 @@ ${filesBlock}`,
     const projectPath = this.watchedDirectory || getWorkingDirectory(void 0, true);
     console.debug("[Initial Scan] Starting initial goal compliance scan", { projectPath });
     try {
-      const { getActiveGoals, recordGoalViolationCaught } = await import("./goal-validator-GISXYANK.js");
+      const { getActiveGoals, recordGoalViolationCaught } = await import("./goal-validator-HNXXUCPW.js");
       const activeGoals = await getActiveGoals(projectPath);
       console.debug("[Initial Scan] Loaded goals for initial scan:", {
         goalCount: activeGoals.length,
@@ -2009,7 +2783,7 @@ ${filesBlock}`,
       const recentFiles = /* @__PURE__ */ new Set();
       const uncommittedFiles = await getGitChangedFiles(projectPath);
       if (uncommittedFiles) {
-        uncommittedFiles.forEach((f) => recentFiles.add(join2(projectPath, f)));
+        uncommittedFiles.forEach((f) => recentFiles.add(join3(projectPath, f)));
       }
       const oneDayAgo = Date.now() - 24 * 60 * 60 * 1e3;
       const recentChanges = await getChangedFilesSinceTimestamp(projectPath, oneDayAgo);
@@ -2018,7 +2792,7 @@ ${filesBlock}`,
       }
       const filesToCheck = Array.from(recentFiles).filter((file) => {
         const ext = extname3(file).toLowerCase();
-        return WATCH_EXTENSIONS.has(ext) && existsSync3(file);
+        return WATCH_EXTENSIONS.has(ext) && existsSync4(file);
       });
       console.debug("[Initial Scan] Files discovered for initial scan:", {
         totalRecentFiles: recentFiles.size,
@@ -2040,7 +2814,7 @@ ${filesBlock}`,
       const fileContents = await Promise.all(
         filesToScan.map(async (file) => {
           try {
-            const content = await readFile3(file, "utf-8");
+            const content = await readFile4(file, "utf-8");
             const relativePath = file.replace(projectPath + "/", "");
             return { path: relativePath, content: content.slice(0, maxCharsPerFile) };
           } catch {
@@ -2146,6 +2920,50 @@ ${filesBlock}`,
       }
     }
   }
+  async syncPipelineIntegrations() {
+    const projectPath = this.watchedDirectory || getWorkingDirectory(void 0, true);
+    try {
+      const config = await loadConfig();
+      const hasLinear = !!(config.apiKeys?.linear ?? process.env.LINEAR_API_KEY);
+      const hasGithub = !!(config.apiKeys?.github ?? process.env.GITHUB_TOKEN);
+      if (!hasLinear && !hasGithub) return;
+      const graph = new ContextGraph(projectPath);
+      if (hasLinear) {
+        try {
+          const { LinearIngester: LinearIngester2 } = await import("./linear-ingester-JRDQAIAA.js");
+          const ingester = new LinearIngester2(projectPath, graph);
+          await ingester.syncTickets();
+          if (!isInteractiveMode()) {
+            console.error("[Pipeline] Linear tickets synced");
+          }
+        } catch (error) {
+          if (!isInteractiveMode()) {
+            console.error(`[Pipeline] Linear sync failed: ${error}`);
+          }
+        }
+      }
+      if (hasGithub) {
+        try {
+          const { GitHubIngester: GitHubIngester2 } = await import("./github-ingester-J2ZFYXVE.js");
+          const ingester = new GitHubIngester2(graph);
+          const token = await ingester.getApiToken();
+          const repoInfo = ingester.getRepoInfo(projectPath);
+          if (repoInfo) {
+            await ingester.syncPullRequests(repoInfo.owner, repoInfo.name, token);
+            await ingester.syncIssues(repoInfo.owner, repoInfo.name, token);
+            if (!isInteractiveMode()) {
+              console.error("[Pipeline] GitHub PRs/issues synced");
+            }
+          }
+        } catch (error) {
+          if (!isInteractiveMode()) {
+            console.error(`[Pipeline] GitHub sync failed: ${error}`);
+          }
+        }
+      }
+    } catch {
+    }
+  }
   async stopWatching() {
     if (!this.state.isRunning) {
       return {
@@ -2163,6 +2981,10 @@ ${filesBlock}`,
       this.extractionPipeline.close();
       this.extractionPipeline = null;
     }
+    if (this.pipelineSyncTimer) {
+      clearInterval(this.pipelineSyncTimer);
+      this.pipelineSyncTimer = null;
+    }
     if (this.codebaseIndex) {
       await this.codebaseIndex.save();
       this.codebaseIndex = null;
@@ -2222,7 +3044,7 @@ Use \`trie_watch start\` to begin autonomous scanning.`
     ).join("\n");
     let agencyStatus = "";
     try {
-      const { getTrieAgent } = await import("./trie-agent-XMSGMD7E.js");
+      const { getTrieAgent } = await import("./trie-agent-M6PHM6UD.js");
       const trieAgent = getTrieAgent(this.watchedDirectory || getWorkingDirectory(void 0, true));
       await trieAgent.initialize();
       const status = await trieAgent.getAgencyStatus();
@@ -2290,7 +3112,8 @@ ${recentNudges || "(none)"}
       ...params.suggestedAction && { suggestedAction: params.suggestedAction }
     };
     this.state.nudges.push({
-      file: params.file ? basename2(params.file) : "unknown",
+      file: params.file || "unknown",
+      // Keep full path for consistency with loaded nudges
       message: params.message,
       severity: params.severity === "warning" || params.severity === "info" ? "high" : params.severity,
       timestamp: (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false })
@@ -2298,6 +3121,7 @@ ${recentNudges || "(none)"}
     try {
       const storage = getStorage(this.watchedDirectory);
       await storage.storeNudge(nudge);
+      console.debug(`[Watch] \u2713 Persisted nudge to storage: ${nudge.message.slice(0, 60)}...`);
     } catch (error) {
       console.error("[Watch] Failed to persist nudge to storage:", error);
     }
@@ -2336,9 +3160,9 @@ To get a full report, run \`trie_scan\` on your codebase.`
 };
 
 // src/tools/pr-review.ts
-import { readFile as readFile4 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import { join as join3, basename as basename3, resolve as resolve3, isAbsolute as isAbsolute3 } from "path";
+import { readFile as readFile5 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { join as join4, basename as basename3, resolve as resolve3, isAbsolute as isAbsolute3 } from "path";
 
 // src/skills/built-in/super-reviewer.ts
 var CRITICAL_REVIEW_CHECKLIST = {
@@ -2452,7 +3276,7 @@ Usage:
   async getPRInfo(pr, worktree) {
     if (worktree) {
       const worktreePath = isAbsolute3(worktree) ? worktree : resolve3(getWorkingDirectory(void 0, true), worktree);
-      if (!existsSync4(worktreePath)) {
+      if (!existsSync5(worktreePath)) {
         return { success: false, error: `Worktree not found: ${worktreePath}` };
       }
       return {
@@ -2585,8 +3409,8 @@ Usage:
       "rfcs"
     ];
     for (const docPath of designDocPaths) {
-      const fullPath = join3(cwd, docPath);
-      if (existsSync4(fullPath)) {
+      const fullPath = join4(cwd, docPath);
+      if (existsSync5(fullPath)) {
       }
     }
     return designDocs;
@@ -2599,9 +3423,9 @@ Usage:
     const cwd = getWorkingDirectory(void 0, true);
     await Promise.all(filePaths.map(async (filePath) => {
       try {
-        const fullPath = isAbsolute3(filePath) ? filePath : join3(cwd, filePath);
-        if (existsSync4(fullPath)) {
-          const content = await readFile4(fullPath, "utf-8");
+        const fullPath = isAbsolute3(filePath) ? filePath : join4(cwd, filePath);
+        if (existsSync5(fullPath)) {
+          const content = await readFile5(fullPath, "utf-8");
           contents.set(filePath, content);
         }
       } catch {
@@ -3465,6 +4289,65 @@ var LinearSyncTool = class {
   }
 };
 
+// src/tools/github-sync.ts
+var GitHubSyncTool = class {
+  async execute(input) {
+    try {
+      const workDir = input.directory || getWorkingDirectory(void 0, true);
+      const graph = new ContextGraph(workDir);
+      const ingester = new GitHubIngester(graph);
+      const token = await ingester.getApiToken();
+      if (!token) {
+        return {
+          isError: true,
+          content: [{
+            type: "text",
+            text: 'GitHub token not configured.\n\nSet one of:\n  \u2022 Environment variable: GITHUB_TOKEN=ghp_...\n  \u2022 Config dialog (C key) \u2192 API Keys \u2192 GitHub\n  \u2022 .trie/config.json: { "apiKeys": { "github": "ghp_..." } }\n\nToken needs `repo` scope for private repos, `public_repo` for public.'
+          }]
+        };
+      }
+      const repoInfo = ingester.getRepoInfo(workDir);
+      if (!repoInfo) {
+        return {
+          isError: true,
+          content: [{
+            type: "text",
+            text: "Could not detect GitHub repository.\n\nMake sure this directory is a git repo with a GitHub remote:\n  git remote get-url origin"
+          }]
+        };
+      }
+      const prResult = await ingester.syncPullRequests(repoInfo.owner, repoInfo.name, token);
+      const issueResult = await ingester.syncIssues(repoInfo.owner, repoInfo.name, token);
+      const LINE = "\u2500".repeat(45);
+      const lines = [
+        "GITHUB SYNC",
+        LINE,
+        `Repo:  ${repoInfo.owner}/${repoInfo.name}`,
+        `Pulled ${prResult.prs} open PR${prResult.prs !== 1 ? "s" : ""}, ${issueResult.issues} open issue${issueResult.issues !== 1 ? "s" : ""}`,
+        `Linked ${prResult.linkedTickets} PR${prResult.linkedTickets !== 1 ? "s" : ""} to Linear tickets`,
+        `Linked ${prResult.linkedFiles} PR${prResult.linkedFiles !== 1 ? "s" : ""} to changed files in context graph`,
+        LINE,
+        "Next sync: trie_github_sync",
+        "Or use trie_pipeline for consolidated view."
+      ];
+      return {
+        content: [{
+          type: "text",
+          text: lines.join("\n")
+        }]
+      };
+    } catch (error) {
+      return {
+        isError: true,
+        content: [{
+          type: "text",
+          text: `GitHub sync failed: ${error.message}`
+        }]
+      };
+    }
+  }
+};
+
 // src/tools/index-codebase.ts
 import { glob } from "glob";
 var INDEXABLE_EXTENSIONS = [
@@ -3617,6 +4500,7 @@ var ToolRegistry = class {
   initializeTools() {
     this.tools.set("scan", new TrieScanTool());
     this.tools.set("fix", new TrieFixTool());
+    this.tools.set("cloud_fix", new TrieCloudFixTool());
     this.tools.set("explain", new TrieExplainTool());
     this.tools.set("test", new TrieTestTool());
     this.tools.set("watch", new TrieWatchTool());
@@ -3633,6 +4517,9 @@ var ToolRegistry = class {
     this.tools.set("ok", new TrieFeedbackTool());
     this.tools.set("bad", new TrieFeedbackTool());
     this.tools.set("linear_sync", new LinearSyncTool());
+    this.tools.set("github_sync", new GitHubSyncTool());
+    this.tools.set("github_branches", new GitHubBranchesTool());
+    this.tools.set("pipeline", new TriePipelineTool());
     this.tools.set("index", new TrieIndexTool());
     this.tools.set("get_governance", new TrieGetGovernanceTool());
     this.tools.set("get_decisions", new TrieGetDecisionsTool());
@@ -3757,10 +4644,15 @@ var ToolRegistry = class {
       },
       {
         name: "trie_fix",
-        description: "Apply high-confidence fixes to code. Alias: fix",
+        description: "Apply high-confidence fixes to code. Use action:route to see triage plan first. Alias: fix",
         inputSchema: {
           type: "object",
           properties: {
+            action: {
+              type: "string",
+              enum: ["route"],
+              description: "route: show fix routing plan without applying fixes"
+            },
             issueIds: {
               type: "array",
               items: { type: "string" },
@@ -3773,6 +4665,34 @@ var ToolRegistry = class {
           }
         }
       },
+      {
+        name: "trie_cloud_fix",
+        description: "Dispatch issues to Cursor cloud agents for verified, test-passing fixes. The cloud agent runs in an isolated VM, applies the fix, runs tests, screenshots the result, and opens a PR. Use trie_fix action:route first to see which issues qualify.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: ["configure", "dispatch", "status", "artifacts", "cancel"],
+              description: "configure: save API key | dispatch: send to cloud | status: poll jobs | artifacts: get screenshots + PR links | cancel: abort a job"
+            },
+            issueIds: {
+              type: "array",
+              items: { type: "string" },
+              description: "Issue IDs to dispatch (from trie_scan). If omitted, dispatches all cloud-eligible pending issues."
+            },
+            apiKey: {
+              type: "string",
+              description: "Cursor API key (configure action only)"
+            },
+            jobId: {
+              type: "string",
+              description: "Job ID for cancel or artifacts actions"
+            }
+          },
+          required: ["action"]
+        }
+      },
       {
         name: "trie_explain",
         description: "Explain code, issues, or changes in plain language. Alias: explain",
@@ -4118,6 +5038,51 @@ var ToolRegistry = class {
           }
         }
       },
+      {
+        name: "trie_github_sync",
+        description: "Sync open PRs and issues from GitHub into the Trie context graph. Links PRs to files they touch and to Linear tickets mentioned in PR descriptions. Run once to initialize, or periodically to stay current.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            directory: { type: "string", description: "Project directory (defaults to current workspace)" }
+          }
+        }
+      },
+      {
+        name: "trie_github_branches",
+        description: "Fetch GitHub branches with latest commit info. Use when the user asks which branch has the latest updates, what branches exist, or when branches were last updated. Requires GitHub API key.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            directory: { type: "string", description: "Project directory (defaults to current workspace)" },
+            limit: { type: "number", description: "Max branches to return (default 15, max 30)" }
+          }
+        }
+      },
+      {
+        name: "trie_pipeline",
+        description: "Get consolidated pipeline status: open PRs, active Linear tickets, open GitHub issues, and Trie scan issues not yet in any ticket or PR (coverage gaps). Use to understand where work stands and what is falling through the cracks.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: ["status", "coverage", "create_tickets"],
+              description: "status: full pipeline view | coverage: only show Trie issues with no ticket/PR | create_tickets: open Linear tickets for uncovered issues"
+            },
+            focus: {
+              type: "string",
+              description: "Optional file path or Linear ticket ID to narrow the view"
+            },
+            issueIds: {
+              type: "array",
+              items: { type: "string" },
+              description: "Issue IDs to create tickets for (create_tickets action only)"
+            },
+            directory: { type: "string", description: "Project directory" }
+          }
+        }
+      },
       {
         name: "trie_get_governance",
         description: "Query governance records (architectural decisions, standards, team agreements) from governance ledger with targeted retrieval. Prevents context pollution by returning only relevant records.",
@@ -4221,9 +5186,9 @@ var ToolRegistry = class {
 };
 
 // src/server/resource-manager.ts
-import { readdir, readFile as readFile5 } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
-import { join as join4, dirname as dirname2 } from "path";
+import { readdir, readFile as readFile6 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { join as join5, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 
 // src/skills/installer.ts
@@ -4348,7 +5313,7 @@ var ResourceManager = class {
   }
   async getScanReportResources() {
     try {
-      const reportsDir = join4(getWorkingDirectory(void 0, true), "trie-reports");
+      const reportsDir = join5(getWorkingDirectory(void 0, true), "trie-reports");
       const files = await readdir(reportsDir);
       const reportFiles = files.filter((f) => f.endsWith(".txt") || f.endsWith(".json"));
       return reportFiles.slice(0, 10).map((file) => ({
@@ -4448,10 +5413,10 @@ var ResourceManager = class {
   async getUIAppResource(uri, appId) {
     const currentFile = fileURLToPath(import.meta.url);
     const distDir = dirname2(dirname2(currentFile));
-    const uiDir = join4(distDir, "ui");
-    const htmlPath = join4(uiDir, `${appId}.html`);
+    const uiDir = join5(distDir, "ui");
+    const htmlPath = join5(uiDir, `${appId}.html`);
     try {
-      if (!existsSync5(htmlPath)) {
+      if (!existsSync6(htmlPath)) {
         return {
           contents: [{
             uri,
@@ -4460,7 +5425,7 @@ var ResourceManager = class {
           }]
         };
       }
-      const content = await readFile5(htmlPath, "utf-8");
+      const content = await readFile6(htmlPath, "utf-8");
       return {
         contents: [{
           uri,
@@ -4640,10 +5605,10 @@ var ResourceManager = class {
     } catch {
     }
     summary.push("---", "", "# Detailed Context", "");
-    const agentsMdPath = join4(getTrieDirectory(workDir), "AGENTS.md");
+    const agentsMdPath = join5(getTrieDirectory(workDir), "AGENTS.md");
     try {
-      if (existsSync5(agentsMdPath)) {
-        const agentsContent = await readFile5(agentsMdPath, "utf-8");
+      if (existsSync6(agentsMdPath)) {
+        const agentsContent = await readFile6(agentsMdPath, "utf-8");
         summary.push(agentsContent);
       } else {
         const contextSummary = await getContextForAI();
@@ -4768,8 +5733,8 @@ This information is automatically available to Claude Code, Cursor, and other AI
   }
   async getCacheStatsResource(uri) {
     try {
-      const cachePath = join4(getTrieDirectory(getWorkingDirectory(void 0, true)), ".trie-cache.json");
-      const cacheContent = await readFile5(cachePath, "utf-8");
+      const cachePath = join5(getTrieDirectory(getWorkingDirectory(void 0, true)), ".trie-cache.json");
+      const cacheContent = await readFile6(cachePath, "utf-8");
       const cache = JSON.parse(cacheContent);
       const fileCount = Object.keys(cache.files || {}).length;
       const totalVulns = Object.values(cache.files || {}).reduce((acc, file) => {
@@ -4848,9 +5813,9 @@ This information is automatically available to Claude Code, Cursor, and other AI
   }
   async getScanReportResource(uri, parsedUri) {
     const fileName = parsedUri.replace("reports/", "");
-    const reportPath = join4(getWorkingDirectory(void 0, true), "trie-reports", fileName);
+    const reportPath = join5(getWorkingDirectory(void 0, true), "trie-reports", fileName);
     try {
-      const content = await readFile5(reportPath, "utf-8");
+      const content = await readFile6(reportPath, "utf-8");
       return {
         contents: [{
           uri,
@@ -5450,8 +6415,25 @@ npx playwright install chromium
         case "cp":
         case "save":
           return await this.toolRegistry.getTool("checkpoint").execute(args);
-        default:
+        case "cloud_fix":
+          return await this.toolRegistry.getTool("cloud_fix").execute(args);
+        case "linear_sync":
+          return await this.toolRegistry.getTool("linear_sync").execute(args);
+        case "github_sync":
+          return await this.toolRegistry.getTool("github_sync").execute(args);
+        case "github_branches":
+          return await this.toolRegistry.getTool("github_branches").execute(args);
+        case "pipeline":
+          return await this.toolRegistry.getTool("pipeline").execute(args);
+        case "index":
+          return await this.toolRegistry.getTool("index").execute(args);
+        default: {
+          const tool = this.toolRegistry.getTool(normalizedName);
+          if (tool) {
+            return await tool.execute(args);
+          }
           throw new Error(`Unknown tool: ${name}`);
+        }
       }
     } catch (error) {
       return {
@@ -5477,12 +6459,12 @@ npx playwright install chromium
   }
   normalizeName(name) {
     const stripNamespace = (n) => {
-      const trimmed = n.trim();
+      const trimmed = n.trim().replace(/\s*\([^)]*\)\s*$/, "").trim();
       const withoutSlash = trimmed.startsWith("/") ? trimmed.slice(1) : trimmed;
       const parts = withoutSlash.split(":");
-      const base = parts[0] || withoutSlash;
+      const base = (parts[0] || withoutSlash).trim();
       const slashParts = base.split("/");
-      return slashParts[slashParts.length - 1] || base;
+      return (slashParts[slashParts.length - 1] || base).trim();
     };
     const rawName = stripNamespace(name);
     return rawName.startsWith("trie_") ? rawName.slice("trie_".length) : rawName;