@triedotdev/mcp 1.0.142 → 1.0.144

package/dist/{chunk-Y2LYDCJD.js → chunk-5FQTNPBP.js}

@@ -977,9 +977,9 @@ function useDashboard() {
 }
 
 // src/cli/dashboard/App.tsx
-import { existsSync as existsSync3 } from "fs";
-import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
-import { join as join2 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { readFile as readFile4, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { join as join3 } from "path";
 
 // src/cli/dashboard/components/Header.tsx
 import { Box, Text, useStdout } from "ink";
@@ -1739,7 +1739,7 @@ function truncate(str, max) {
 }
 function OverviewView() {
   const { state, dispatch } = useDashboard();
-  const { progress, signalExtraction, watch, issues, activityLog, activityPage, pendingFixes, selectedFixIndex } = state;
+  const { progress, signalExtraction, watch, issues, activityLog, activityPage, pendingFixes: pendingFixes2, selectedFixIndex } = state;
   const { totalIssues } = progress;
   const { stdout } = useStdout4();
   const cols = stdout?.columns || 80;
@@ -1748,7 +1748,7 @@ function OverviewView() {
   const endTime = state.scanComplete && state.scanEndTime ? state.scanEndTime : Date.now();
   const elapsed = ((endTime - state.scanStartTime) / 1e3).toFixed(1);
   const criticalIssues = issues.filter((i) => i.severity === "critical").slice(0, 3);
-  const activeFixes = pendingFixes.filter((f) => f.status === "pending" || f.status === "applying");
+  const activeFixes = pendingFixes2.filter((f) => f.status === "pending" || f.status === "applying");
   const activityRows = activeFixes.length > 0 ? 5 : 8;
   const startIdx = activityPage * activityRows;
   const pageActivities = activityLog.slice(startIdx, startIdx + activityRows);
@@ -5513,6 +5513,1191 @@ trie_explain type:"risk" target:"Adding Stripe integration for payments"
   }
 };
 
+// src/tools/cloud-fix.ts
+import { readFile as readFile3, writeFile, mkdir } from "fs/promises";
+import { existsSync as existsSync4, readFileSync } from "fs";
+import { join as join2 } 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/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
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { extname as extname2, relative as relative2, resolve as resolve2, isAbsolute as isAbsolute2 } from "path";
+var pendingFixes = /* @__PURE__ */ new Map();
+var TrieFixTool = class {
+  async execute(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);
+    }
+    if (file && fix) {
+      return this.applyFix(file, line || 1, issue || "User-specified fix", fix, dryRun);
+    }
+    if (pendingFixes.size > 0) {
+      return this.showPendingFixes();
+    }
+    if (file && issue) {
+      return this.generateFixPrompt(file, line || 1, issue);
+    }
+    return {
+      content: [{
+        type: "text",
+        text: this.getHelpText()
+      }]
+    };
+  }
+  async routeIssues(issueIds) {
+    await loadPendingFixesFromMemory();
+    const pending = getPendingFixes();
+    if (pending.length === 0) {
+      return {
+        content: [{ type: "text", text: "No pending issues. Run trie_scan to detect new issues, or check memory with trie_memory action:recent." }]
+      };
+    }
+    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;
+    let failed = 0;
+    for (const id of issueIds) {
+      const pendingFix = pendingFixes.get(id);
+      if (!pendingFix) {
+        results.push(`\u274C Issue ${id}: Not found in pending fixes`);
+        failed++;
+        continue;
+      }
+      if (pendingFix.confidence < 0.8 && !autoApprove) {
+        results.push(`[!] Issue ${id}: Confidence too low (${(pendingFix.confidence * 100).toFixed(0)}%) - use autoApprove:true to override`);
+        continue;
+      }
+      if (dryRun) {
+        results.push(`\u{1F50D} Issue ${id}: Would fix "${pendingFix.issue}" in ${pendingFix.file}:${pendingFix.line}`);
+        continue;
+      }
+      try {
+        results.push(`\u2705 Issue ${id}: Fix prepared for ${pendingFix.file}:${pendingFix.line}`);
+        results.push(`   Issue: ${pendingFix.issue}`);
+        results.push(`   Fix: ${pendingFix.suggestedFix}`);
+        pendingFix.status = "applied";
+        fixed++;
+      } catch (error) {
+        results.push(`\u274C Issue ${id}: Failed to apply - ${error}`);
+        failed++;
+      }
+    }
+    let output = `
+${"\u2501".repeat(60)}
+`;
+    output += `\u{1F527} FIX RESULTS
+`;
+    output += `${"\u2501".repeat(60)}
+
+`;
+    output += results.join("\n");
+    output += `
+
+**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) {
+    const workDir = getWorkingDirectory(void 0, true);
+    const filePath = isAbsolute2(file) ? file : resolve2(workDir, file);
+    if (!existsSync3(filePath)) {
+      return {
+        content: [{
+          type: "text",
+          text: `\u274C File not found: ${filePath}`
+        }]
+      };
+    }
+    const content = await readFile2(filePath, "utf-8");
+    const lines = content.split("\n");
+    const language = this.detectLanguage(filePath);
+    const contextStart = Math.max(0, line - 10);
+    const contextEnd = Math.min(lines.length, line + 10);
+    const contextLines = lines.slice(contextStart, contextEnd);
+    const prompt = getPrompt("fix", "apply", {
+      issue,
+      fix,
+      language,
+      code: contextLines.join("\n"),
+      filePath: relative2(workDir, filePath),
+      line: String(line)
+    });
+    const systemPrompt = getSystemPrompt("fix");
+    let output = `
+${"\u2501".repeat(60)}
+`;
+    output += `\u{1F527} FIX APPLICATION REQUEST
+`;
+    output += `${"\u2501".repeat(60)}
+
+`;
+    output += `## \u{1F4CD} Target
+
+`;
+    output += `- **File:** \`${relative2(workDir, filePath)}\`
+`;
+    output += `- **Line:** ${line}
+`;
+    output += `- **Issue:** ${issue}
+`;
+    output += `- **Requested Fix:** ${fix}
+
+`;
+    output += `## \u{1F4C4} Current Code Context
+
+`;
+    output += `\`\`\`${language}
+`;
+    for (let i = 0; i < contextLines.length; i++) {
+      const lineNum = contextStart + i + 1;
+      const marker = lineNum === line ? "\u2192 " : "  ";
+      output += `${marker}${lineNum.toString().padStart(4)} | ${contextLines[i]}
+`;
+    }
+    output += `\`\`\`
+
+`;
+    if (dryRun) {
+      output += `## \u{1F50D} Dry Run Mode
+
+`;
+      output += `No changes will be made. Review the fix below:
+
+`;
+    }
+    output += `${"\u2500".repeat(60)}
+`;
+    output += `## \u{1F9E0} Fix Request for AI
+
+`;
+    output += `**Role:** ${systemPrompt.split("\n")[0]}
+
+`;
+    output += prompt;
+    output += `
+${"\u2500".repeat(60)}
+`;
+    output += `
+### After generating the fix, apply it with:
+
+`;
+    output += `\`\`\`
+`;
+    output += `Use the edit_file tool to apply the generated code changes
+`;
+    output += `\`\`\`
+`;
+    return { content: [{ type: "text", text: output }] };
+  }
+  async generateFixPrompt(file, line, issue) {
+    const workDir = getWorkingDirectory(void 0, true);
+    const filePath = isAbsolute2(file) ? file : resolve2(workDir, file);
+    if (!existsSync3(filePath)) {
+      return {
+        content: [{
+          type: "text",
+          text: `\u274C File not found: ${filePath}`
+        }]
+      };
+    }
+    const content = await readFile2(filePath, "utf-8");
+    const lines = content.split("\n");
+    const language = this.detectLanguage(filePath);
+    const contextStart = Math.max(0, line - 20);
+    const contextEnd = Math.min(lines.length, line + 20);
+    const contextLines = lines.slice(contextStart, contextEnd);
+    let output = `
+${"\u2501".repeat(60)}
+`;
+    output += `\u{1F527} FIX GENERATION REQUEST
+`;
+    output += `${"\u2501".repeat(60)}
+
+`;
+    output += `## \u{1F4CD} Issue Details
+
+`;
+    output += `- **File:** \`${relative2(workDir, filePath)}\`
+`;
+    output += `- **Line:** ${line}
+`;
+    output += `- **Issue:** ${issue}
+
+`;
+    output += `## \u{1F4C4} Code Context
+
+`;
+    output += `\`\`\`${language}
+`;
+    for (let i = 0; i < contextLines.length; i++) {
+      const lineNum = contextStart + i + 1;
+      const marker = lineNum === line ? "\u2192 " : "  ";
+      output += `${marker}${lineNum.toString().padStart(4)} | ${contextLines[i]}
+`;
+    }
+    output += `\`\`\`
+
+`;
+    output += `## \u{1F9E0} Analysis Request
+
+`;
+    output += `Please analyze this issue and provide:
+
+`;
+    output += `1. **Root cause** - Why does this issue occur?
+`;
+    output += `2. **Impact** - What could go wrong if unfixed?
+`;
+    output += `3. **Fix** - The exact code change needed
+`;
+    output += `4. **Verification** - How to test the fix works
+
+`;
+    output += `After analysis, you can apply the fix using the edit_file tool.
+`;
+    return { content: [{ type: "text", text: output }] };
+  }
+  showPendingFixes() {
+    let output = `
+${"\u2501".repeat(60)}
+`;
+    output += `\u{1F527} PENDING FIXES
+`;
+    output += `${"\u2501".repeat(60)}
+
+`;
+    if (pendingFixes.size === 0) {
+      output += `No pending fixes. Run \`trie_scan\` first to detect issues.
+`;
+      return { content: [{ type: "text", text: output }] };
+    }
+    const fixes = Array.from(pendingFixes.values());
+    const byStatus = {
+      pending: fixes.filter((f) => f.status === "pending"),
+      applied: fixes.filter((f) => f.status === "applied"),
+      rejected: fixes.filter((f) => f.status === "rejected")
+    };
+    if (byStatus.pending.length > 0) {
+      output += `## \u23F3 Pending (${byStatus.pending.length})
+
+`;
+      output += `| ID | File | Line | Issue | Confidence |
+`;
+      output += `|----|------|------|-------|------------|
+`;
+      for (const fix of byStatus.pending) {
+        const conf = `${(fix.confidence * 100).toFixed(0)}%`;
+        const shortFile = fix.file.split("/").slice(-2).join("/");
+        output += `| ${fix.id} | ${shortFile} | ${fix.line} | ${fix.issue.slice(0, 40)}... | ${conf} |
+`;
+      }
+      output += "\n";
+    }
+    output += `### Commands
+
+`;
+    output += `- Fix all high-confidence: \`trie_fix autoApprove:true\`
+`;
+    output += `- Fix specific: \`trie_fix issueIds:["id1", "id2"]\`
+`;
+    output += `- Preview: \`trie_fix dryRun:true\`
+`;
+    return { content: [{ type: "text", text: output }] };
+  }
+  getHelpText() {
+    return `
+${"\u2501".repeat(60)}
+\u{1F527} TRIE FIX - AI-POWERED CODE FIXING
+${"\u2501".repeat(60)}
+
+## Usage
+
+### Fix issues from a scan:
+\`\`\`
+trie_fix issueIds:["issue-1", "issue-2"]
+\`\`\`
+
+### Auto-fix all high-confidence issues:
+\`\`\`
+trie_fix autoApprove:true
+\`\`\`
+
+### Fix specific file and line:
+\`\`\`
+trie_fix file:"src/app.ts" line:42 issue:"SQL injection" fix:"Use parameterized query"
+\`\`\`
+
+### Preview fixes without applying:
+\`\`\`
+trie_fix dryRun:true
+\`\`\`
+
+### View pending fixes:
+\`\`\`
+trie_fix
+\`\`\`
+
+## Workflow
+
+1. Run \`trie_scan\` to detect issues
+2. Review the issues found
+3. Run \`trie_fix\` to apply fixes
+
+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 = extname2(filePath).toLowerCase();
+    const langMap = {
+      ".ts": "typescript",
+      ".tsx": "tsx",
+      ".js": "javascript",
+      ".jsx": "jsx",
+      ".py": "python",
+      ".go": "go",
+      ".rs": "rust"
+    };
+    return langMap[ext] || "plaintext";
+  }
+};
+function getPendingFixes() {
+  return Array.from(pendingFixes.values());
+}
+async function loadPendingFixesFromMemory() {
+  try {
+    const { getRecentIssues } = await import("./issue-store-LZWZIGM7.js");
+    pendingFixes.clear();
+    const recentIssues = await getRecentIssues({ limit: 50, includeResolved: false });
+    for (const storedIssue of recentIssues) {
+      const fix = {
+        id: storedIssue.id,
+        file: storedIssue.file,
+        line: storedIssue.line || 0,
+        issue: storedIssue.issue,
+        suggestedFix: storedIssue.fix,
+        confidence: 0.8,
+        // Default confidence for memory issues
+        status: "pending",
+        severity: storedIssue.severity,
+        autoFixable: true,
+        // Memory issues are generally auto-fixable
+        category: storedIssue.category
+      };
+      pendingFixes.set(fix.id, fix);
+    }
+  } catch (error) {
+    console.warn("Failed to load pending fixes from memory:", error);
+  }
+}
+
+// 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) {
+    console.log("Cloud dispatch starting...");
+    const workDir = getWorkingDirectory(void 0, true);
+    const apiKey = await this.resolveApiKey(workDir);
+    if (!apiKey) return this.setupGuard();
+    const config = await loadAutonomyConfig(workDir);
+    const forceCloud = args?.forceCloud === true;
+    console.log("About to resolve issues...");
+    let allIssues = await this.resolveIssues(args?.issueIds);
+    if (allIssues.length === 0 && args?.file && args?.issue && args?.fix) {
+      const adHocId = `ad-hoc-${Date.now()}`;
+      allIssues = [{
+        id: adHocId,
+        severity: args.severity ?? "critical",
+        effort: args.effort ?? "hard",
+        issue: args.issue,
+        fix: args.fix,
+        file: args.file,
+        line: args.line ?? 1,
+        confidence: 0.9,
+        autoFixable: false,
+        agent: "user",
+        category: args.category
+      }];
+      console.log(`Created ad-hoc issue ${adHocId} for cloud dispatch`);
+    }
+    if (allIssues.length === 0) {
+      return this.text("No issues to dispatch. Run trie_scan to detect new issues, or check memory with trie_memory action:recent. For ad-hoc fixes, pass file, issue, and fix.");
+    }
+    const { results, summary } = triageIssues(allIssues, void 0, void 0, config);
+    const lines = [];
+    const toDispatch = forceCloud ? allIssues : summary.cloudAgent;
+    if (forceCloud) {
+      lines.push("FIX ROUTING PLAN (forceCloud: bypassing triage)");
+      lines.push("\u2500".repeat(68));
+      for (const issue of allIssues) {
+        lines.push(`  ${shortPath2(issue.file)}:${issue.line ?? "?"}  \u2192 cloud-agent (user requested)`);
+      }
+      lines.push("");
+    } else {
+      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.");
+        lines.push("To force cloud dispatch: trie_cloud_fix action:dispatch forceCloud:true");
+        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 toDispatch) {
+      const triageResult = forceCloud ? { strategy: "cloud-agent", score: 6, confidence: 1, reasons: ["forceCloud: user requested cloud dispatch"], fallback: "local-ai" } : 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 fromEnv = this.loadCursorKeyFromEnv(workDir);
+    if (fromEnv) return fromEnv;
+    const config = await loadAutonomyConfig(workDir);
+    return config.cursorApiKey ?? null;
+  }
+  loadCursorKeyFromEnv(workDir) {
+    for (const envFile of [".env", ".env.local", ".env.production"]) {
+      const envPath = join2(workDir, envFile);
+      if (!existsSync4(envPath)) continue;
+      try {
+        const content = readFileSync(envPath, "utf-8");
+        const match = content.match(/^\s*CURSOR_API_KEY\s*=\s*(.+)$/m);
+        if (match?.[1]) {
+          const key = match[1].trim().replace(/^["']|["']$/g, "");
+          if (key.length > 10) return key;
+        }
+      } catch {
+      }
+    }
+    return null;
+  }
+  setupGuard() {
+    return this.text(
+      'Cloud Agent dispatch requires a Cursor API key.\n\nGet your key at: cursor.com/settings \u2192 API Keys\n\nThen either:\n  \u2022 trie_cloud_fix action:configure apiKey:"key-..."\n  \u2022 Or add to Config \u2192 API Keys \u2192 Cursor (press s in watch mode)\n  \u2022 Or set: export CURSOR_API_KEY="key-..."\n  \u2022 Or add CURSOR_API_KEY=... to your .env file'
+    );
+  }
+  async resolveIssues(issueIds) {
+    let pending = getPendingFixes();
+    if (pending.length === 0) {
+      try {
+        console.log("Loading issues from memory...");
+        const { getRecentIssues } = await import("./issue-store-LZWZIGM7.js");
+        const recentIssues = await getRecentIssues({ limit: 50, includeResolved: false });
+        console.log(`Found ${recentIssues.length} recent issues in memory`);
+        const memoryIssues = recentIssues.map((storedIssue) => ({
+          id: storedIssue.id,
+          severity: storedIssue.severity || "moderate",
+          issue: storedIssue.issue,
+          fix: storedIssue.fix,
+          file: storedIssue.file,
+          line: storedIssue.line,
+          confidence: 0.8,
+          // Default confidence for memory issues
+          autoFixable: true,
+          // Memory issues are generally auto-fixable
+          agent: storedIssue.agent,
+          category: storedIssue.category
+        }));
+        console.log(`Converted ${memoryIssues.length} memory issues for cloud dispatch`);
+        if (issueIds && issueIds.length > 0) {
+          return memoryIssues.filter((i) => issueIds.includes(i.id));
+        }
+        return memoryIssues;
+      } catch (error) {
+        console.warn("Failed to load issues from memory:", error);
+        console.warn("Error details:", error);
+      }
+    }
+    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 = join2(getTrieDirectory(workDir), "cloud-jobs.json");
+    try {
+      if (existsSync4(path2)) {
+        const raw = await readFile3(path2, "utf-8");
+        return JSON.parse(raw);
+      }
+    } catch {
+    }
+    return { jobs: {} };
+  }
+  async saveJobs(workDir, store) {
+    const trieDir = getTrieDirectory(workDir);
+    if (!existsSync4(trieDir)) await mkdir(trieDir, { recursive: true });
+    const path2 = join2(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/query-tools.ts
 var TrieGetGovernanceTool = class {
   async execute(input) {
@@ -5946,7 +7131,7 @@ var TriePipelineTool = class {
         );
         const prInfo = linkedPR ? `PR #${linkedPR.data.prNumber} (CI: ${linkedPR.data.ciStatus})` : "No PR yet";
         lines.push(
-          `  ${padEnd(t.data.ticketId, 10)}${padEnd(truncate2(t.data.title, 35), 37)}${padEnd(t.data.priority, 9)}${prInfo}`
+          `  ${padEnd3(t.data.ticketId, 10)}${padEnd3(truncate2(t.data.title, 35), 37)}${padEnd3(t.data.priority, 9)}${prInfo}`
         );
       }
       lines.push("");
@@ -5963,7 +7148,7 @@ var TriePipelineTool = class {
         const stateTag = pr.data.isDraft ? "draft" : pr.data.state;
         const ticketRef = pr.data.linkedTicketIds.length > 0 ? ` (${pr.data.linkedTicketIds.join(", ")})` : "";
         lines.push(
-          `  #${padEnd(String(pr.data.prNumber), 5)}${padEnd(truncate2(pr.data.title, 30) + ticketRef, 42)}${padEnd(stateTag, 10)}CI: ${padEnd(pr.data.ciStatus, 10)}Review: ${pr.data.reviewStatus}`
+          `  #${padEnd3(String(pr.data.prNumber), 5)}${padEnd3(truncate2(pr.data.title, 30) + ticketRef, 42)}${padEnd3(stateTag, 10)}CI: ${padEnd3(pr.data.ciStatus, 10)}Review: ${pr.data.reviewStatus}`
         );
       }
       lines.push("");
@@ -5977,7 +7162,7 @@ var TriePipelineTool = class {
         const labels = issue.data.labels.length > 0 ? `[${issue.data.labels.join(", ")}]` : "";
         const linked = issue.data.linkedTicketIds.length > 0 ? `linked: ${issue.data.linkedTicketIds.join(", ")}` : "no ticket";
         lines.push(
-          `  #${padEnd(String(issue.data.issueNumber), 5)}${padEnd(truncate2(issue.data.title, 35), 37)}${padEnd(labels, 18)}${linked}`
+          `  #${padEnd3(String(issue.data.issueNumber), 5)}${padEnd3(truncate2(issue.data.title, 35), 37)}${padEnd3(labels, 18)}${linked}`
         );
       }
       if (ghIssues.length > 10) {
@@ -5990,8 +7175,8 @@ var TriePipelineTool = class {
     if (uncoveredIssues.length > 0) {
       lines.push(`COVERAGE GAPS (${uncoveredIssues.length} Trie issue${uncoveredIssues.length !== 1 ? "s" : ""} with no ticket or PR)`);
       for (const issue of uncoveredIssues.slice(0, 10)) {
-        const loc = `${shortPath(issue.data.file)}:${issue.data.line ?? "?"}`;
-        lines.push(`  ${padEnd(loc, 32)}${padEnd(issue.data.severity, 10)}${truncate2(issue.data.issueText, 40)}`);
+        const loc = `${shortPath3(issue.data.file)}:${issue.data.line ?? "?"}`;
+        lines.push(`  ${padEnd3(loc, 32)}${padEnd3(issue.data.severity, 10)}${truncate2(issue.data.issueText, 40)}`);
       }
       if (uncoveredIssues.length > 10) {
         lines.push(`  ... and ${uncoveredIssues.length - 10} more`);
@@ -6117,8 +7302,8 @@ var TriePipelineTool = class {
         if (group.items.length === 0) continue;
         lines.push(`${group.label} (${group.items.length}):`);
         for (const issue of group.items.slice(0, 10)) {
-          const loc = `${shortPath(issue.data.file)}:${issue.data.line ?? "?"}`;
-          lines.push(`  ${padEnd(loc, 32)}${truncate2(issue.data.issueText, 45)}`);
+          const loc = `${shortPath3(issue.data.file)}:${issue.data.line ?? "?"}`;
+          lines.push(`  ${padEnd3(loc, 32)}${truncate2(issue.data.issueText, 45)}`);
         }
         if (group.items.length > 10) {
           lines.push(`  ... and ${group.items.length - 10} more`);
@@ -6291,11 +7476,11 @@ var TriePipelineTool = class {
     return parts.join("\n");
   }
 };
-function shortPath(file) {
+function shortPath3(file) {
   const parts = file.split("/");
   return parts.length > 2 ? parts.slice(-2).join("/") : file;
 }
-function padEnd(str, len) {
+function padEnd3(str, len) {
   if (str.length >= len) return str.slice(0, len);
   return str + " ".repeat(len - str.length);
 }
@@ -6305,7 +7490,7 @@ function truncate2(str, maxLen) {
 }
 
 // src/tools/github-branches.ts
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 var GitHubBranchesTool = class {
   async execute(input) {
     const workDir = input.directory || getWorkingDirectory(void 0, true);
@@ -6375,7 +7560,7 @@ Check token validity and repo access. Token needs \`repo\` or \`public_repo\` sc
   }
   getRepoInfo(projectPath) {
     try {
-      const url = execSync("git remote get-url origin", {
+      const url = execSync2("git remote get-url origin", {
         cwd: projectPath,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -6719,6 +7904,44 @@ var CHAT_TOOLS = [
       },
       required: ["hypothesisId"]
     }
+  },
+  {
+    name: "trie_cloud_fix",
+    description: 'Dispatch to Cursor Cloud agents. Default: triage routes issues. When user explicitly says they want cloud (e.g. "fix with cloud agent") \u2014 pass forceCloud:true to honor their choice, do not reject. For ad-hoc (no scan issues): pass file, issue, fix from prior trie_propose_fix. Actions: configure, dispatch, status, artifacts, cancel.',
+    input_schema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["configure", "dispatch", "status", "artifacts", "cancel"],
+          description: "Action: configure (save apiKey), dispatch (send issues), status (check jobs), artifacts (get results), cancel (abort job)"
+        },
+        apiKey: {
+          type: "string",
+          description: "Cursor API key (only for action:configure). Get at cursor.com/settings \u2192 API Keys."
+        },
+        issueIds: {
+          type: "array",
+          items: { type: "string" },
+          description: "Issue IDs to dispatch (for action:dispatch). Omit to dispatch all cloud-eligible issues."
+        },
+        forceCloud: {
+          type: "boolean",
+          description: "When true, bypass triage and dispatch ALL issues to cloud. Use when user explicitly requests cloud fix."
+        },
+        file: {
+          type: "string",
+          description: "For ad-hoc dispatch: file path (use with issue and fix when no scan issues)"
+        },
+        issue: { type: "string", description: "For ad-hoc dispatch: issue description" },
+        fix: { type: "string", description: "For ad-hoc dispatch: suggested fix" },
+        line: { type: "number", description: "For ad-hoc dispatch: line number" },
+        jobId: {
+          type: "string",
+          description: "Job ID for action:artifacts or action:cancel"
+        }
+      }
+    }
   }
 ];
 async function executeTool(name, input, onProgress) {
@@ -7076,6 +8299,24 @@ ${truncated}`;
           return `Scan failed: ${error.message}`;
         }
       }
+      case "trie_cloud_fix": {
+        const cloudFixTool = new TrieCloudFixTool();
+        const cloudFixArgs = {
+          action: input.action || "status"
+        };
+        if (input.apiKey) cloudFixArgs.apiKey = String(input.apiKey);
+        if (Array.isArray(input.issueIds)) cloudFixArgs.issueIds = input.issueIds;
+        if (input.jobId) cloudFixArgs.jobId = String(input.jobId);
+        if (input.forceCloud === true) cloudFixArgs.forceCloud = true;
+        if (input.file) cloudFixArgs.file = String(input.file);
+        if (input.issue) cloudFixArgs.issue = String(input.issue);
+        if (input.fix) cloudFixArgs.fix = String(input.fix);
+        if (typeof input.line === "number") cloudFixArgs.line = input.line;
+        if (input.severity) cloudFixArgs.severity = String(input.severity);
+        if (input.effort) cloudFixArgs.effort = String(input.effort);
+        const result = await cloudFixTool.execute(cloudFixArgs);
+        return textFromResult(result);
+      }
       case "trie_test_hypothesis": {
         const hypothesisId = String(input.hypothesisId || "").trim();
         if (!hypothesisId) {
@@ -7257,10 +8498,17 @@ async function buildContext(workDir, dashboardState) {
   return parts.length > 0 ? parts.join("\n\n") : "No context data available yet.";
 }
 function chatHistoryToMessages(history) {
-  return history.map((m) => ({
-    role: m.role,
-    content: m.content
-  }));
+  return history.map((m) => {
+    let content = m.content;
+    const fixes = m.pendingFixes ?? (m.pendingFix ? [m.pendingFix] : []);
+    if (fixes.length > 0) {
+      const fixCtx = fixes.map((f) => `file: ${f.file}, goal: ${f.goal}, violation: ${f.violation}${f.suggestedFix ? `, suggestedFix: ${f.suggestedFix}` : ""}`).join("; ");
+      content = content ? `${content}
+
+[Proposed fix context: ${fixCtx}]` : `[Proposed fix context: ${fixCtx}]`;
+    }
+    return { role: m.role, content };
+  });
 }
 var SYSTEM_PROMPT = `You are Trie, a code assistant embedded in a terminal TUI.
 
@@ -7313,12 +8561,21 @@ var SYSTEM_PROMPT = `You are Trie, a code assistant embedded in a terminal TUI.
 5. AFTER the tool call completes, the system will ask for user confirmation - do NOT add your own confirmation message
 6. When the user says "yes", "yes to all", or "no", the system handles spawning Claude Code automatically
 
+**When user asks to dispatch or fix with Cursor Cloud agent:**
+- Default: Call trie_cloud_fix action:dispatch \u2014 triage runs and routes issues as usual.
+- If user EXPLICITLY says they want cloud (e.g. "fix it with cloud agent", "I want cloud", "use cursor cloud"): add forceCloud:true so triage does not override their choice. Do NOT suggest local fix instead \u2014 honor their request.
+- If there are no scan issues but the conversation has a recent trie_propose_fix: use ad-hoc dispatch with file, issue, fix from that context.
+- If the tool returns "Cloud Agent dispatch requires a Cursor API key", tell the user to configure it.
+- For status: trie_cloud_fix action:status
+
 Examples:
 - User: "do we have emojis?" \u2192 Check nudges first. If none or unclear: Call trie_scan_for_goal_violations to scan the codebase.
 - User: "run a full scan for emojis" \u2192 Call trie_scan_for_goal_violations directly.
 - User: "fix the emoji violations" \u2192 Find ALL emoji violations in nudges, call trie_propose_fixes_batch ONCE with all fixes, then STOP
 - User responds "yes to all" after proposal \u2192 Just say "Spawning Claude Code to fix all files..." The system handles it.
 - User: "search for TODO comments" \u2192 If there's a goal about TODOs, use trie_scan_for_goal_violations. Otherwise explain no such goal exists.
+- User: "fix it with cloud agent" (explicit) \u2192 Call trie_cloud_fix action:dispatch forceCloud:true \u2014 honor their choice, don't suggest local.
+- User: "dispatch to cloud" (generic) \u2192 Call trie_cloud_fix action:dispatch \u2014 triage as usual.
 
 Answer concisely. Reference specific files, decisions, and patterns when relevant.`;
 function ChatView() {
@@ -7502,14 +8759,14 @@ ${contextBlock}`;
           content: result.content
         };
         const pendingFixRegex = /\[PENDING_FIX:(.+?)\]/g;
-        const pendingFixes = [];
+        const pendingFixes2 = [];
         let match;
         while ((match = pendingFixRegex.exec(result.content)) !== null) {
           try {
             const jsonStr = match[1];
             if (jsonStr) {
               const fixData = JSON.parse(jsonStr);
-              pendingFixes.push(fixData);
+              pendingFixes2.push(fixData);
             }
           } catch {
           }
@@ -7523,8 +8780,8 @@ ${contextBlock}`;
                 const jsonStr = toolMatch[1];
                 if (jsonStr) {
                   const fixData = JSON.parse(jsonStr);
-                  if (!pendingFixes.some((f) => f.file === fixData.file)) {
-                    pendingFixes.push(fixData);
+                  if (!pendingFixes2.some((f) => f.file === fixData.file)) {
+                    pendingFixes2.push(fixData);
                   }
                 }
               } catch {
@@ -7532,13 +8789,13 @@ ${contextBlock}`;
             }
           }
         }
-        if (pendingFixes.length > 0) {
+        if (pendingFixes2.length > 0) {
           action.content = result.content.replace(/\[PENDING_FIX:.+?\]/g, "").trim();
-          const firstFix = pendingFixes[0];
-          if (pendingFixes.length === 1 && firstFix) {
+          const firstFix = pendingFixes2[0];
+          if (pendingFixes2.length === 1 && firstFix) {
             action.pendingFix = firstFix;
           } else {
-            action.pendingFixes = pendingFixes;
+            action.pendingFixes = pendingFixes2;
           }
         }
         if (result.toolCalls && result.toolCalls.length > 0) {
@@ -7986,8 +9243,8 @@ async function applyGoalFix(fix, dispatch) {
       return;
     }
     const projectPath = getWorkingDirectory(void 0, true);
-    const fullPath = join2(projectPath, fix.file);
-    const content = await readFile2(fullPath, "utf-8");
+    const fullPath = join3(projectPath, fix.file);
+    const content = await readFile4(fullPath, "utf-8");
     const result = await runAIAnalysis({
       systemPrompt: `You are a precise code fixer. The user has a quality goal: "${fix.goalDescription}".
 A violation was detected: "${fix.description}"
@@ -8013,7 +9270,7 @@ ${content}
     if (fixedContent.startsWith("```")) {
       fixedContent = fixedContent.replace(/^```\w*\n?/, "").replace(/\n?```$/, "");
     }
-    await writeFile(fullPath, fixedContent, "utf-8");
+    await writeFile2(fullPath, fixedContent, "utf-8");
     const { recordGoalViolationFixed, getActiveGoals } = await import("./goal-validator-DA3JQ6JN.js");
     const goals = await getActiveGoals(projectPath);
     const matchedGoal = goals.find((g) => g.description === fix.goalDescription);
@@ -8037,11 +9294,11 @@ function DashboardApp({ onReady }) {
   dispatchRef.current = dispatch;
   const stateRef = useRef4(state);
   stateRef.current = state;
-  const configPath = join2(getTrieDirectory(getWorkingDirectory(void 0, true)), "agent.json");
+  const configPath = join3(getTrieDirectory(getWorkingDirectory(void 0, true)), "agent.json");
   const loadConfig2 = useCallback7(async () => {
-    if (!existsSync3(configPath)) return;
+    if (!existsSync5(configPath)) return;
     try {
-      const raw = await readFile2(configPath, "utf-8");
+      const raw = await readFile4(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       dispatchRef.current({ type: "SET_AGENT_CONFIG", config: parsed });
     } catch {
@@ -8050,8 +9307,8 @@ function DashboardApp({ onReady }) {
   const persistConfig = useCallback7(async () => {
     try {
       const workDir = getWorkingDirectory(void 0, true);
-      await mkdir(getTrieDirectory(workDir), { recursive: true });
-      await writeFile(configPath, JSON.stringify(stateRef.current.agentConfig, null, 2), "utf-8");
+      await mkdir2(getTrieDirectory(workDir), { recursive: true });
+      await writeFile2(configPath, JSON.stringify(stateRef.current.agentConfig, null, 2), "utf-8");
       const { saveAutonomyConfig: saveAutonomyConfig2, loadAutonomyConfig: loadAutonomyConfig2 } = await import("./autonomy-config-ZCOSTMPD.js");
       const autonomy = await loadAutonomyConfig2(workDir);
       autonomy.aiWatcher = stateRef.current.agentConfig.aiWatcher;
@@ -8382,6 +9639,8 @@ export {
   TrieScanTool,
   getPrompt,
   getSystemPrompt,
+  TrieFixTool,
+  TrieCloudFixTool,
   TrieExplainTool,
   StreamingManager,
   ExtractionPipeline,
@@ -8399,4 +9658,4 @@ export {
   GitHubBranchesTool,
   InteractiveDashboard
 };
-//# sourceMappingURL=chunk-Y2LYDCJD.js.map
+//# sourceMappingURL=chunk-5FQTNPBP.js.map