@triedotdev/mcp 1.0.142 → 1.0.143

package/dist/index.js

@@ -32,8 +32,10 @@ import {
   InteractiveDashboard,
   StreamingManager,
   TrieCheckTool,
+  TrieCloudFixTool,
   TrieExplainTool,
   TrieFeedbackTool,
+  TrieFixTool,
   TrieGetBlockersTool,
   TrieGetDecisionsTool,
   TrieGetGovernanceTool,
@@ -46,7 +48,7 @@ import {
   getPrompt,
   getSystemPrompt,
   handleCheckpointTool
-} from "./chunk-Y2LYDCJD.js";
+} from "./chunk-AIJF67CF.js";
 import "./chunk-23RJT5WT.js";
 import "./chunk-N2EDZTKG.js";
 import {
@@ -91,9 +93,7 @@ import {
   getSkillRegistry
 } from "./chunk-G76DYVGX.js";
 import {
-  getAutonomyConfig,
-  loadAutonomyConfig,
-  saveAutonomyConfig
+  getAutonomyConfig
 } from "./chunk-5KJ4UJOY.js";
 import {
   findSimilarIssues,
@@ -195,1151 +195,10 @@ function detectAITool() {
   };
 }
 
-// src/tools/fix.ts
+// src/tools/test.ts
 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, 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 = isAbsolute(file) ? file : resolve(workDir, file);
-    if (!existsSync(filePath)) {
-      return {
-        content: [{
-          type: "text",
-          text: `\u274C File not found: ${filePath}`
-        }]
-      };
-    }
-    const content = await readFile(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: relative(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:** \`${relative(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 = isAbsolute(file) ? file : resolve(workDir, file);
-    if (!existsSync(filePath)) {
-      return {
-        content: [{
-          type: "text",
-          text: `\u274C File not found: ${filePath}`
-        }]
-      };
-    }
-    const content = await readFile(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:** \`${relative(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 = extname(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: getRecentIssues2 } = await import("./issue-store-LZWZIGM7.js");
-    pendingFixes.clear();
-    const recentIssues = await getRecentIssues2({ 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
-import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-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) {
-    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);
-    console.log("About to resolve issues...");
-    const allIssues = await this.resolveIssues(args?.issueIds);
-    console.log(`Resolved ${allIssues.length} issues`);
-    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.");
-    }
-    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-..."'
-    );
-  }
-  async resolveIssues(issueIds) {
-    let pending = getPendingFixes();
-    if (pending.length === 0) {
-      try {
-        console.log("Loading issues from memory...");
-        const { getRecentIssues: getRecentIssues2 } = await import("./issue-store-LZWZIGM7.js");
-        const recentIssues = await getRecentIssues2({ 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 = 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";
+import { extname, relative, resolve, isAbsolute, dirname, basename, join } from "path";
 var TrieTestTool = class {
   async execute(args) {
     const { action, files, framework, style = "unit" } = args || {};
@@ -1392,15 +251,15 @@ ${"\u2501".repeat(60)}
     const workDir = getWorkingDirectory(void 0, true);
     const allUnits = [];
     for (const file of files) {
-      const resolvedPath = isAbsolute2(file) ? file : resolve2(workDir, file);
-      if (!existsSync3(resolvedPath)) {
+      const resolvedPath = isAbsolute(file) ? file : resolve(workDir, file);
+      if (!existsSync(resolvedPath)) {
         output += `[!] File not found: ${file}
 `;
         continue;
       }
-      const code = await readFile3(resolvedPath, "utf-8");
+      const code = await readFile(resolvedPath, "utf-8");
       const language = this.detectLanguage(resolvedPath);
-      const relativePath = relative2(workDir, resolvedPath);
+      const relativePath = relative(workDir, resolvedPath);
       const units = this.extractTestableUnits(code, language);
       allUnits.push({ file: relativePath, units });
       output += `### \u{1F4C4} ${relativePath}
@@ -1431,7 +290,7 @@ ${"\u2501".repeat(60)}
 `;
     for (const { file, units } of allUnits) {
       if (units.length === 0) continue;
-      const code = await readFile3(resolve2(workDir, file), "utf-8");
+      const code = await readFile(resolve(workDir, file), "utf-8");
       const language = this.detectLanguage(file);
       const prompt = getPrompt("test", "generate", {
         code,
@@ -1476,21 +335,21 @@ ${"\u2501".repeat(60)}
 `;
     const workDir = getWorkingDirectory(void 0, true);
     for (const file of files) {
-      const resolvedPath = isAbsolute2(file) ? file : resolve2(workDir, file);
-      if (!existsSync3(resolvedPath)) {
+      const resolvedPath = isAbsolute(file) ? file : resolve(workDir, file);
+      if (!existsSync(resolvedPath)) {
         output += `[!] File not found: ${file}
 `;
         continue;
       }
-      const code = await readFile3(resolvedPath, "utf-8");
+      const code = await readFile(resolvedPath, "utf-8");
       const language = this.detectLanguage(resolvedPath);
-      const relativePath = relative2(workDir, resolvedPath);
+      const relativePath = relative(workDir, resolvedPath);
       const units = this.extractTestableUnits(code, language);
       const testFile = await this.findTestFile(resolvedPath);
       let testCode = "";
       let testedUnits = [];
       if (testFile) {
-        testCode = await readFile3(testFile, "utf-8");
+        testCode = await readFile(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;
@@ -1501,7 +360,7 @@ ${"\u2501".repeat(60)}
       output += `**Coverage:** ${coverageIcon} ${coverage}% (${testedUnits.length}/${units.length} units)
 `;
       if (testFile) {
-        output += `**Test file:** \`${relative2(workDir, testFile)}\`
+        output += `**Test file:** \`${relative(workDir, testFile)}\`
 `;
       } else {
         output += `**Test file:** \u274C Not found
@@ -1558,14 +417,14 @@ ${"\u2501".repeat(60)}
 `;
     const workDir = getWorkingDirectory(void 0, true);
     for (const file of files) {
-      const resolvedPath = isAbsolute2(file) ? file : resolve2(workDir, file);
-      if (!existsSync3(resolvedPath)) {
+      const resolvedPath = isAbsolute(file) ? file : resolve(workDir, file);
+      if (!existsSync(resolvedPath)) {
         output += `[!] File not found: ${file}
 `;
         continue;
       }
-      const code = await readFile3(resolvedPath, "utf-8");
-      const relativePath = relative2(workDir, resolvedPath);
+      const code = await readFile(resolvedPath, "utf-8");
+      const relativePath = relative(workDir, resolvedPath);
       const patterns = this.detectTestablePatterns(code);
       output += `### \u{1F4C4} ${relativePath}
 
@@ -1801,8 +660,8 @@ ${"\u2501".repeat(60)}
   }
   async findTestFile(sourcePath) {
     const dir = dirname(sourcePath);
-    const base = basename(sourcePath, extname2(sourcePath));
-    const ext = extname2(sourcePath);
+    const base = basename(sourcePath, extname(sourcePath));
+    const ext = extname(sourcePath);
     const patterns = [
       `${base}.test${ext}`,
       `${base}.spec${ext}`,
@@ -1810,16 +669,16 @@ ${"\u2501".repeat(60)}
       `test_${base}${ext}`
     ];
     for (const pattern of patterns) {
-      const testPath = join2(dir, pattern);
-      if (existsSync3(testPath)) {
+      const testPath = join(dir, pattern);
+      if (existsSync(testPath)) {
         return testPath;
       }
     }
-    const testsDir = join2(dir, "__tests__");
-    if (existsSync3(testsDir)) {
+    const testsDir = join(dir, "__tests__");
+    if (existsSync(testsDir)) {
       for (const pattern of patterns) {
-        const testPath = join2(testsDir, pattern);
-        if (existsSync3(testPath)) {
+        const testPath = join(testsDir, pattern);
+        if (existsSync(testPath)) {
           return testPath;
         }
       }
@@ -1866,10 +725,10 @@ ${"\u2501".repeat(60)}
   }
   async detectTestFramework() {
     const workDir = getWorkingDirectory(void 0, true);
-    const packagePath = resolve2(workDir, "package.json");
-    if (existsSync3(packagePath)) {
+    const packagePath = resolve(workDir, "package.json");
+    if (existsSync(packagePath)) {
       try {
-        const pkg = JSON.parse(await readFile3(packagePath, "utf-8"));
+        const pkg = JSON.parse(await readFile(packagePath, "utf-8"));
         const deps = { ...pkg.dependencies, ...pkg.devDependencies };
         if (deps.vitest) return "vitest";
         if (deps.jest) return "jest";
@@ -1877,13 +736,13 @@ ${"\u2501".repeat(60)}
       } catch {
       }
     }
-    if (existsSync3(resolve2(workDir, "pytest.ini")) || existsSync3(resolve2(workDir, "pyproject.toml"))) {
+    if (existsSync(resolve(workDir, "pytest.ini")) || existsSync(resolve(workDir, "pyproject.toml"))) {
       return "pytest";
     }
     return "jest";
   }
   detectLanguage(filePath) {
-    const ext = extname2(filePath).toLowerCase();
+    const ext = extname(filePath).toLowerCase();
     const langMap = {
       ".ts": "typescript",
       ".tsx": "tsx",
@@ -1936,9 +795,9 @@ trie_test action:"run" files:["src/utils.test.ts"]
 };
 
 // src/tools/watch.ts
-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 { watch, existsSync as existsSync2, readFileSync } from "fs";
+import { stat, readFile as readFile2 } from "fs/promises";
+import { join as join2, extname as extname2, basename as basename2 } from "path";
 import { createHash } from "crypto";
 var WATCH_EXTENSIONS = /* @__PURE__ */ new Set([
   ".ts",
@@ -2156,17 +1015,17 @@ 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 (!existsSync4(dir)) return;
+    if (!existsSync2(dir)) return;
     try {
       const dirStat = await stat(dir);
       if (!dirStat.isDirectory()) return;
       const watcher = watch(dir, { persistent: true, recursive: true }, (_eventType, filename) => {
         if (!filename) return;
         if (this.shouldSkipPath(filename)) return;
-        const ext = extname3(filename).toLowerCase();
+        const ext = extname2(filename).toLowerCase();
         if (!WATCH_EXTENSIONS.has(ext)) return;
-        const fullPath = join3(dir, filename);
-        if (!existsSync4(fullPath)) return;
+        const fullPath = join2(dir, filename);
+        if (!existsSync2(fullPath)) return;
         this.state.pendingFiles.add(fullPath);
         if (this.state.scanDebounceTimer) {
           clearTimeout(this.state.scanDebounceTimer);
@@ -2212,7 +1071,7 @@ Detected changes in ${files.length} file(s):`);
           const fileContents = await Promise.all(
             files.map(async (file) => {
               try {
-                const content = await readFile4(file, "utf-8");
+                const content = await readFile2(file, "utf-8");
                 return { file, content };
               } catch {
                 return null;
@@ -2290,7 +1149,7 @@ ${f.content.slice(0, 1e3)}`
   }
   isQuiet() {
     const projectPath = this.watchedDirectory || getWorkingDirectory(void 0, true);
-    const quietPath = join3(getTrieDirectory(projectPath), "quiet.json");
+    const quietPath = join2(getTrieDirectory(projectPath), "quiet.json");
     try {
       const raw = readFileSync(quietPath, "utf-8");
       const data = JSON.parse(raw);
@@ -2458,7 +1317,7 @@ ${f.content.slice(0, 1e3)}`
     if (lastClean && Date.now() - lastClean < this.cleanFileCooldownMs) {
       return 0;
     }
-    const fileNode = await graph.getNode("file", join3(projectPath, file));
+    const fileNode = await graph.getNode("file", join2(projectPath, file));
     if (!fileNode) return score;
     const data = fileNode.data;
     const riskScores = { critical: 10, high: 6, medium: 2, low: 1 };
@@ -2546,7 +1405,7 @@ ${f.content.slice(0, 1e3)}`
         const fileContents = await Promise.all(
           filesToScan.map(async ({ file, relativePath }) => {
             try {
-              const content = await readFile4(file, "utf-8");
+              const content = await readFile2(file, "utf-8");
               return { path: relativePath, content: content.slice(0, charLimit) };
             } catch {
               return null;
@@ -2711,7 +1570,7 @@ ${filesBlock}`,
             fixChangeId: null,
             reportedVia: "detected"
           });
-          const filePath = join3(projectPath, issue.file);
+          const filePath = join2(projectPath, issue.file);
           const fileNode = await graph.getNode("file", filePath);
           if (fileNode) {
             await graph.addEdge(fileNode.id, incident.id, "affects");
@@ -2843,7 +1702,7 @@ ${filesBlock}`,
       const recentFiles = /* @__PURE__ */ new Set();
       const uncommittedFiles = await getGitChangedFiles(projectPath);
       if (uncommittedFiles) {
-        uncommittedFiles.forEach((f) => recentFiles.add(join3(projectPath, f)));
+        uncommittedFiles.forEach((f) => recentFiles.add(join2(projectPath, f)));
       }
       const oneDayAgo = Date.now() - 24 * 60 * 60 * 1e3;
       const recentChanges = await getChangedFilesSinceTimestamp(projectPath, oneDayAgo);
@@ -2851,8 +1710,8 @@ ${filesBlock}`,
         recentChanges.forEach((f) => recentFiles.add(f));
       }
       const filesToCheck = Array.from(recentFiles).filter((file) => {
-        const ext = extname3(file).toLowerCase();
-        return WATCH_EXTENSIONS.has(ext) && existsSync4(file);
+        const ext = extname2(file).toLowerCase();
+        return WATCH_EXTENSIONS.has(ext) && existsSync2(file);
       });
       console.debug("[Initial Scan] Files discovered for initial scan:", {
         totalRecentFiles: recentFiles.size,
@@ -2874,7 +1733,7 @@ ${filesBlock}`,
       const fileContents = await Promise.all(
         filesToScan.map(async (file) => {
           try {
-            const content = await readFile4(file, "utf-8");
+            const content = await readFile2(file, "utf-8");
             const relativePath = file.replace(projectPath + "/", "");
             return { path: relativePath, content: content.slice(0, maxCharsPerFile) };
           } catch {
@@ -3220,9 +2079,9 @@ To get a full report, run \`trie_scan\` on your codebase.`
 };
 
 // src/tools/pr-review.ts
-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";
+import { readFile as readFile3 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3, basename as basename3, resolve as resolve2, isAbsolute as isAbsolute2 } from "path";
 
 // src/skills/built-in/super-reviewer.ts
 var CRITICAL_REVIEW_CHECKLIST = {
@@ -3335,8 +2194,8 @@ Usage:
    */
   async getPRInfo(pr, worktree) {
     if (worktree) {
-      const worktreePath = isAbsolute3(worktree) ? worktree : resolve3(getWorkingDirectory(void 0, true), worktree);
-      if (!existsSync5(worktreePath)) {
+      const worktreePath = isAbsolute2(worktree) ? worktree : resolve2(getWorkingDirectory(void 0, true), worktree);
+      if (!existsSync3(worktreePath)) {
         return { success: false, error: `Worktree not found: ${worktreePath}` };
       }
       return {
@@ -3469,8 +2328,8 @@ Usage:
       "rfcs"
     ];
     for (const docPath of designDocPaths) {
-      const fullPath = join4(cwd, docPath);
-      if (existsSync5(fullPath)) {
+      const fullPath = join3(cwd, docPath);
+      if (existsSync3(fullPath)) {
       }
     }
     return designDocs;
@@ -3483,9 +2342,9 @@ Usage:
     const cwd = getWorkingDirectory(void 0, true);
     await Promise.all(filePaths.map(async (filePath) => {
       try {
-        const fullPath = isAbsolute3(filePath) ? filePath : join4(cwd, filePath);
-        if (existsSync5(fullPath)) {
-          const content = await readFile5(fullPath, "utf-8");
+        const fullPath = isAbsolute2(filePath) ? filePath : join3(cwd, filePath);
+        if (existsSync3(fullPath)) {
+          const content = await readFile3(fullPath, "utf-8");
           contents.set(filePath, content);
         }
       } catch {
@@ -5246,9 +4105,9 @@ var ToolRegistry = class {
 };
 
 // src/server/resource-manager.ts
-import { readdir, readFile as readFile6 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-import { join as join5, dirname as dirname2 } from "path";
+import { readdir, readFile as readFile4 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 
 // src/skills/installer.ts
@@ -5373,7 +4232,7 @@ var ResourceManager = class {
   }
   async getScanReportResources() {
     try {
-      const reportsDir = join5(getWorkingDirectory(void 0, true), "trie-reports");
+      const reportsDir = join4(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) => ({
@@ -5473,10 +4332,10 @@ var ResourceManager = class {
   async getUIAppResource(uri, appId) {
     const currentFile = fileURLToPath(import.meta.url);
     const distDir = dirname2(dirname2(currentFile));
-    const uiDir = join5(distDir, "ui");
-    const htmlPath = join5(uiDir, `${appId}.html`);
+    const uiDir = join4(distDir, "ui");
+    const htmlPath = join4(uiDir, `${appId}.html`);
     try {
-      if (!existsSync6(htmlPath)) {
+      if (!existsSync4(htmlPath)) {
         return {
           contents: [{
             uri,
@@ -5485,7 +4344,7 @@ var ResourceManager = class {
           }]
         };
       }
-      const content = await readFile6(htmlPath, "utf-8");
+      const content = await readFile4(htmlPath, "utf-8");
       return {
         contents: [{
           uri,
@@ -5665,10 +4524,10 @@ var ResourceManager = class {
     } catch {
     }
     summary.push("---", "", "# Detailed Context", "");
-    const agentsMdPath = join5(getTrieDirectory(workDir), "AGENTS.md");
+    const agentsMdPath = join4(getTrieDirectory(workDir), "AGENTS.md");
     try {
-      if (existsSync6(agentsMdPath)) {
-        const agentsContent = await readFile6(agentsMdPath, "utf-8");
+      if (existsSync4(agentsMdPath)) {
+        const agentsContent = await readFile4(agentsMdPath, "utf-8");
         summary.push(agentsContent);
       } else {
         const contextSummary = await getContextForAI();
@@ -5793,8 +4652,8 @@ This information is automatically available to Claude Code, Cursor, and other AI
   }
   async getCacheStatsResource(uri) {
     try {
-      const cachePath = join5(getTrieDirectory(getWorkingDirectory(void 0, true)), ".trie-cache.json");
-      const cacheContent = await readFile6(cachePath, "utf-8");
+      const cachePath = join4(getTrieDirectory(getWorkingDirectory(void 0, true)), ".trie-cache.json");
+      const cacheContent = await readFile4(cachePath, "utf-8");
       const cache = JSON.parse(cacheContent);
       const fileCount = Object.keys(cache.files || {}).length;
       const totalVulns = Object.values(cache.files || {}).reduce((acc, file) => {
@@ -5873,9 +4732,9 @@ This information is automatically available to Claude Code, Cursor, and other AI
   }
   async getScanReportResource(uri, parsedUri) {
     const fileName = parsedUri.replace("reports/", "");
-    const reportPath = join5(getWorkingDirectory(void 0, true), "trie-reports", fileName);
+    const reportPath = join4(getWorkingDirectory(void 0, true), "trie-reports", fileName);
     try {
-      const content = await readFile6(reportPath, "utf-8");
+      const content = await readFile4(reportPath, "utf-8");
       return {
         contents: [{
           uri,
@@ -6022,32 +4881,32 @@ async function findOpenPort() {
   return portChecks.find((port) => port !== null) || null;
 }
 async function checkPort(port) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve3) => {
     const testServer = createServer();
     let portInUse = false;
     testServer.once("error", (err) => {
       if (err.code === "EADDRINUSE") {
         portInUse = true;
-        testHttpPort(port).then(resolve4).catch(() => resolve4(false));
+        testHttpPort(port).then(resolve3).catch(() => resolve3(false));
       } else {
-        resolve4(false);
+        resolve3(false);
       }
     });
     testServer.once("listening", () => {
       testServer.close();
-      resolve4(false);
+      resolve3(false);
     });
     setTimeout(() => {
       if (!portInUse) {
         testServer.close();
-        resolve4(false);
+        resolve3(false);
       }
     }, 1e3);
     testServer.listen(port, "127.0.0.1");
   });
 }
 async function testHttpPort(port) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve3) => {
     const req = request({
       hostname: "localhost",
       port,
@@ -6055,18 +4914,18 @@ async function testHttpPort(port) {
       method: "GET",
       timeout: 2e3
     }, (res) => {
-      resolve4(res.statusCode !== void 0);
+      resolve3(res.statusCode !== void 0);
       res.on("data", () => {
       });
       res.on("end", () => {
       });
     });
     req.on("error", () => {
-      resolve4(false);
+      resolve3(false);
     });
     req.on("timeout", () => {
       req.destroy();
-      resolve4(false);
+      resolve3(false);
     });
     req.end();
   });