opencode-swarm 7.66.3 → 7.67.0

package/dist/cli/index.js

@@ -52,7 +52,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.66.3",
+    version: "7.67.0",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -17968,7 +17968,7 @@ function resolveExternalSkillsConfig(input) {
   };
   return merged;
 }
-var SEPARATORS, CANONICAL_ROLES_LONGEST_FIRST, CANONICAL_ROLES_SET, AgentOverrideConfigSchema, SwarmConfigSchema, HooksConfigSchema, ScoringWeightsSchema, DecisionDecaySchema, TokenRatiosSchema, ScoringConfigSchema, ContextBudgetConfigSchema, EvidenceConfigSchema, GateFeatureSchema, PlaceholderScanConfigSchema, QualityBudgetConfigSchema, GateConfigSchema, PipelineConfigSchema, PhaseCompleteConfigSchema, SummaryConfigSchema, ReviewPassesConfigSchema, AdversarialDetectionConfigSchema, AdversarialTestingConfigSchemaBase, AdversarialTestingConfigSchema, IntegrationAnalysisConfigSchema, DocsConfigSchema, DesignDocsConfigSchema, UIReviewConfigSchema, CompactionAdvisoryConfigSchema, LintConfigSchema, SecretscanConfigSchema, GuardrailsProfileSchema, DEFAULT_AGENT_PROFILES, DEFAULT_ARCHITECT_PROFILE, GuardrailsConfigSchema, WatchdogConfigSchema, SelfReviewConfigSchema, ToolFilterConfigSchema, PlanCursorConfigSchema, ContextMapConfigSchema, CheckpointConfigSchema, AutomationModeSchema, AutomationCapabilitiesSchema, AutomationConfigSchemaBase, AutomationConfigSchema, KnowledgeConfigSchema, MemoryConfigSchema, CuratorConfigSchema, ArchitecturalSupervisionConfigSchema, KnowledgeApplicationConfigSchema, SkillPropagationConfigSchema, SkillImproverConfigSchema, SpecWriterConfigSchema, SlopDetectorConfigSchema, IncrementalVerifyConfigSchema, CompactionConfigSchema, PrmConfigSchema, AgentAuthorityRuleSchema, AuthorityConfigSchema, GeneralCouncilMemberConfigSchema, GeneralCouncilConfigSchema, CouncilConfigSchema, ParallelizationConfigSchema, WorktreeIsolationConfigSchema, LeanTurboConfigSchema, StandardTurboConfigSchema, LeanTurboStrategyConfigSchema, TurboConfigSchema, ExternalSkillCandidateSourceTypeSchema, ExternalSkillCandidateEvaluationVerdictSchema, DiscoverySourceSchema, ExternalSkillCandidateSchema, ExternalSkillsConfigSchema, DEFAULT_EXTERNAL_SKILLS_CONFIG, PluginConfigSchema;
+var SEPARATORS, CANONICAL_ROLES_LONGEST_FIRST, CANONICAL_ROLES_SET, AgentOverrideConfigSchema, SwarmConfigSchema, HooksConfigSchema, ScoringWeightsSchema, DecisionDecaySchema, TokenRatiosSchema, ScoringConfigSchema, ContextBudgetConfigSchema, EvidenceConfigSchema, GateFeatureSchema, PlaceholderScanConfigSchema, QualityBudgetConfigSchema, GateConfigSchema, PipelineConfigSchema, PhaseCompleteConfigSchema, SummaryConfigSchema, ReviewPassesConfigSchema, AdversarialDetectionConfigSchema, AdversarialTestingConfigSchemaBase, AdversarialTestingConfigSchema, IntegrationAnalysisConfigSchema, DocsConfigSchema, DesignDocsConfigSchema, UIReviewConfigSchema, CompactionAdvisoryConfigSchema, LintConfigSchema, SecretscanConfigSchema, GuardrailsProfileSchema, DEFAULT_AGENT_PROFILES, DEFAULT_ARCHITECT_PROFILE, GuardrailsConfigSchema, WatchdogConfigSchema, SelfReviewConfigSchema, ToolFilterConfigSchema, PlanCursorConfigSchema, ContextMapConfigSchema, CheckpointConfigSchema, AutomationModeSchema, AutomationCapabilitiesSchema, AutomationConfigSchemaBase, AutomationConfigSchema, KnowledgeConfigSchema, MemoryConfigSchema, CuratorConfigSchema, ArchitecturalSupervisionConfigSchema, KnowledgeApplicationConfigSchema, SkillPropagationConfigSchema, SkillImproverConfigSchema, SpecWriterConfigSchema, SlopDetectorConfigSchema, IncrementalVerifyConfigSchema, CompactionConfigSchema, PrmConfigSchema, AgentAuthorityRuleSchema, AuthorityConfigSchema, GeneralCouncilMemberConfigSchema, GeneralCouncilConfigSchema, CouncilConfigSchema, PrMonitorConfigSchema, ParallelizationConfigSchema, WorktreeIsolationConfigSchema, LeanTurboConfigSchema, StandardTurboConfigSchema, LeanTurboStrategyConfigSchema, TurboConfigSchema, ExternalSkillCandidateSourceTypeSchema, ExternalSkillCandidateEvaluationVerdictSchema, DiscoverySourceSchema, ExternalSkillCandidateSchema, ExternalSkillsConfigSchema, DEFAULT_EXTERNAL_SKILLS_CONFIG, PluginConfigSchema;
 var init_schema = __esm(() => {
   init_zod();
   init_constants();
@@ -18647,6 +18647,24 @@ var init_schema = __esm(() => {
     phaseConcernsAllowComplete: exports_external.boolean().default(true).describe("When true, a phase-level council CONCERNS verdict with only MEDIUM/LOW findings does NOT block phase completion \u2014 the advisory notes are logged as warnings and the phase proceeds. When false, CONCERNS blocks like REJECT. Note: HIGH/CRITICAL findings from CONCERNS members are always promoted to requiredFixes and block at the tool level regardless of this setting. Default: true."),
     general: GeneralCouncilConfigSchema.optional()
   }).strict();
+  PrMonitorConfigSchema = exports_external.object({
+    enabled: exports_external.boolean().default(false),
+    poll_interval_seconds: exports_external.number().int().min(30).max(300).default(60),
+    max_subscriptions: exports_external.number().int().min(1).max(100).default(20),
+    max_prs_per_cycle: exports_external.number().int().min(1).max(20).default(5),
+    max_concurrent_pr_polls: exports_external.number().int().min(1).max(10).default(3),
+    poll_timeout_ms: exports_external.number().int().min(5000).max(120000).default(30000),
+    failure_threshold: exports_external.number().int().min(1).max(20).default(5),
+    cooldown_seconds: exports_external.number().int().min(5).max(600).default(30),
+    max_cooldown_seconds: exports_external.number().int().min(30).max(3600).default(300),
+    cleanup_ttl_days: exports_external.number().int().min(1).max(90).default(7),
+    auto_unsubscribe_on_merge: exports_external.boolean().default(true),
+    auto_unsubscribe_on_close: exports_external.boolean().default(true),
+    notify_ci_failure: exports_external.boolean().default(true),
+    notify_new_comments: exports_external.boolean().default(true),
+    notify_merge_conflict: exports_external.boolean().default(true),
+    auto_pr_feedback: exports_external.boolean().default(false)
+  }).strict();
   ParallelizationConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(false),
     maxConcurrentTasks: exports_external.number().int().min(1).max(64).default(1),
@@ -18991,6 +19009,7 @@ var init_schema = __esm(() => {
         every_minutes: 20
       }
     })),
+    pr_monitor: PrMonitorConfigSchema.optional(),
     external_skills: ExternalSkillsConfigSchema.optional()
   });
 });
@@ -53494,6 +53513,217 @@ var init_pr_feedback = __esm(() => {
   init_pr_ref();
 });
 
+// src/background/pr-subscriptions.ts
+import * as fs17 from "fs";
+import * as path43 from "path";
+function storePath(directory) {
+  return validateSwarmPath(directory, PR_SUBSCRIPTIONS_FILE);
+}
+function ensureSwarmDir2(directory) {
+  fs17.mkdirSync(path43.resolve(directory, ".swarm", "pr-monitor"), {
+    recursive: true
+  });
+}
+function buildCorrelationId(sessionID, repoFullName, prNumber) {
+  return `${sessionID}::${repoFullName}::${prNumber}`;
+}
+function readAllRecords(directory) {
+  let raw;
+  try {
+    raw = fs17.readFileSync(storePath(directory), "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return [];
+    log(`[pr-monitor] readAllRecords failed: ${err instanceof Error ? err.message : String(err)}`);
+    return [];
+  }
+  const folded = new Map;
+  for (const line of raw.split(`
+`)) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0)
+      continue;
+    let parsedJson;
+    try {
+      parsedJson = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const result = RecordSchema.safeParse(parsedJson);
+    if (!result.success)
+      continue;
+    folded.set(result.data.correlationId, result.data);
+  }
+  return [...folded.values()];
+}
+function appendRecord(directory, record3) {
+  const result = RecordSchema.safeParse(record3);
+  if (!result.success) {
+    throw new Error(`Invalid subscription record: ${result.error.message}`);
+  }
+  ensureSwarmDir2(directory);
+  fs17.appendFileSync(storePath(directory), `${JSON.stringify(record3)}
+`, "utf-8");
+}
+async function subscribe(directory, input) {
+  if (!directory || directory.trim() === "") {
+    throw new Error("directory is required");
+  }
+  if (!input.sessionID || input.sessionID.trim() === "") {
+    throw new Error("sessionID is required and must be non-empty");
+  }
+  if (!input.repoFullName || input.repoFullName.trim() === "") {
+    throw new Error("repoFullName is required and must be non-empty");
+  }
+  if (!input.prUrl || input.prUrl.trim() === "") {
+    throw new Error("prUrl is required and must be non-empty");
+  }
+  if (!input.prNumber || !Number.isInteger(input.prNumber) || input.prNumber <= 0) {
+    throw new Error("prNumber is required and must be a positive integer");
+  }
+  const correlationId = buildCorrelationId(input.sessionID, input.repoFullName, input.prNumber);
+  const now = Date.now();
+  return withEvidenceLock(directory, PR_SUBSCRIPTIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+    const existing = readAllRecords(directory);
+    const match = existing.find((r) => r.correlationId === correlationId && r.status === "active");
+    if (match) {
+      onSubscriptionCreated?.(directory, match);
+      return match;
+    }
+    if (input.maxSubscriptions !== undefined && input.maxSubscriptions > 0) {
+      const activeCount = existing.filter((r) => r.status === "active").length;
+      if (activeCount >= input.maxSubscriptions) {
+        throw new Error(`PR subscription limit reached: ${activeCount}/${input.maxSubscriptions}`);
+      }
+    }
+    const record3 = {
+      correlationId,
+      sessionID: input.sessionID,
+      prNumber: input.prNumber,
+      repoFullName: input.repoFullName,
+      prUrl: input.prUrl,
+      lastCheckedAt: now,
+      isWatching: true,
+      hasUnaddressedEvents: false,
+      status: "active",
+      createdAt: now,
+      updatedAt: now,
+      errorCount: 0
+    };
+    appendRecord(directory, record3);
+    onSubscriptionCreated?.(directory, record3);
+    return record3;
+  });
+}
+async function unsubscribe(directory, correlationId) {
+  if (!correlationId)
+    return null;
+  return withEvidenceLock(directory, PR_SUBSCRIPTIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+    const existing = readAllRecords(directory);
+    const match = existing.find((r) => r.correlationId === correlationId && r.status === "active");
+    if (!match)
+      return null;
+    const now = Date.now();
+    const removed = {
+      ...match,
+      status: "removed",
+      isWatching: false,
+      updatedAt: now
+    };
+    appendRecord(directory, removed);
+    return removed;
+  });
+}
+async function listActive(directory) {
+  return readAllRecords(directory).filter((r) => r.status === "active");
+}
+var PR_SUBSCRIPTIONS_FILE = "pr-monitor/subscriptions.jsonl", STORE_LOCK_AGENT = "pr-monitor", STORE_LOCK_TASK = "pr-subscriptions", onSubscriptionCreated = null, RecordSchema;
+var init_pr_subscriptions = __esm(() => {
+  init_zod();
+  init_lock();
+  init_utils2();
+  init_utils();
+  RecordSchema = exports_external.object({
+    correlationId: exports_external.string().min(1),
+    sessionID: exports_external.string().min(1),
+    prNumber: exports_external.number().int().positive(),
+    repoFullName: exports_external.string().regex(/^[^/]+\/[^/]+$/, "Must be owner/repo format"),
+    prUrl: exports_external.string().min(1).regex(/^https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/\d+$/, "Must be a valid GitHub PR URL"),
+    headRefOid: exports_external.string().optional(),
+    lastCheckedAt: exports_external.number(),
+    lastCommentId: exports_external.string().optional(),
+    lastCheckRunSet: exports_external.string().optional(),
+    mergeableState: exports_external.string().optional(),
+    isWatching: exports_external.boolean(),
+    hasUnaddressedEvents: exports_external.boolean(),
+    status: exports_external.enum(["active", "removed", "expired"]),
+    createdAt: exports_external.number(),
+    updatedAt: exports_external.number(),
+    errorCount: exports_external.number().int().min(0),
+    customPollIntervalSeconds: exports_external.number().int().positive().optional(),
+    customFailureThreshold: exports_external.number().int().min(0).optional(),
+    customCooldownSeconds: exports_external.number().int().min(0).optional()
+  }).strict();
+});
+
+// src/commands/pr-monitor-status.ts
+function formatRelativeTime(epochMs) {
+  const diffMs = Date.now() - epochMs;
+  if (diffMs < 0)
+    return "just now";
+  if (diffMs < 5000)
+    return "just now";
+  const diffSeconds = Math.floor(diffMs / 1000);
+  if (diffSeconds < 60)
+    return `${diffSeconds} seconds ago`;
+  const diffMinutes = Math.floor(diffSeconds / 60);
+  if (diffMinutes < 60)
+    return `${diffMinutes} minute${diffMinutes === 1 ? "" : "s"} ago`;
+  const diffHours = Math.floor(diffMinutes / 60);
+  if (diffHours < 24)
+    return `${diffHours} hour${diffHours === 1 ? "" : "s"} ago`;
+  const diffDays = Math.floor(diffHours / 24);
+  return `${diffDays} day${diffDays === 1 ? "" : "s"} ago`;
+}
+async function handlePrMonitorStatusCommand(directory, _args, sessionID) {
+  const allActive = await _internals26.listActive(directory);
+  const sessionSubs = allActive.filter((record3) => record3.sessionID === sessionID);
+  if (sessionSubs.length === 0) {
+    return "No active PR subscriptions for this session.";
+  }
+  const lines = [];
+  lines.push(`PR Monitor Status \u2014 Session: ${sessionID}`);
+  lines.push("");
+  const totalActive = allActive.length;
+  lines.push(`Active subscriptions (${sessionSubs.length}):`);
+  for (let i = 0;i < sessionSubs.length; i++) {
+    const sub = sessionSubs[i];
+    const index = i + 1;
+    lines.push(`  ${index}. ${sub.repoFullName}#${sub.prNumber}`);
+    lines.push(`     URL: ${sub.prUrl}`);
+    lines.push(`     Last checked: ${formatRelativeTime(sub.lastCheckedAt)}`);
+    lines.push(`     Watching: ${sub.isWatching ? "yes" : "no"}`);
+    lines.push(`     Errors: ${sub.errorCount}`);
+    if (i < sessionSubs.length - 1) {
+      lines.push("");
+    }
+  }
+  lines.push("");
+  if (totalActive !== sessionSubs.length) {
+    lines.push(`Total active across all sessions: ${totalActive}`);
+  }
+  return lines.join(`
+`);
+}
+var _internals26;
+var init_pr_monitor_status = __esm(() => {
+  init_pr_subscriptions();
+  _internals26 = {
+    formatRelativeTime,
+    listActive
+  };
+});
+
 // src/commands/pr-review.ts
 function parseArgs6(args) {
   const out = { council: false, rest: [] };
@@ -53553,6 +53783,172 @@ var init_pr_review = __esm(() => {
 `);
 });
 
+// src/commands/pr-subscribe.ts
+async function handlePrSubscribeCommand(directory, args, sessionID) {
+  const rest = args.filter((t) => t.trim().length > 0);
+  if (rest.length === 0) {
+    return [
+      "Usage: /swarm pr subscribe <pr-url|owner/repo#N|N>",
+      "",
+      "Subscribes the current session to receive advisory notifications",
+      "for the specified PR. Requires pr_monitor.enabled: true in config.",
+      "",
+      "  /swarm pr subscribe https://github.com/owner/repo/pull/42",
+      "  /swarm pr subscribe owner/repo#42",
+      "  /swarm pr subscribe 42"
+    ].join(`
+`);
+  }
+  const refToken = rest[0];
+  const prInfo = parsePrRef(refToken, directory);
+  if (!prInfo) {
+    if (looksLikePrRef(refToken)) {
+      return [
+        `Error: Could not resolve PR reference from "${refToken}".`,
+        "",
+        "That looked like a PR reference but could not be resolved.",
+        "Pass a full URL or `owner/repo#N`, or verify your git",
+        "`origin` remote points to a GitHub repository."
+      ].join(`
+`);
+    }
+    return [
+      `Error: "${refToken}" is not a valid PR reference.`,
+      "",
+      "Expected: full GitHub URL, owner/repo#N shorthand,",
+      "or a bare PR number (resolved against origin)."
+    ].join(`
+`);
+  }
+  const repoFullName = `${prInfo.owner}/${prInfo.repo}`;
+  const prUrl = `https://github.com/${prInfo.owner}/${prInfo.repo}/pull/${prInfo.number}`;
+  try {
+    const config3 = _internals27.loadPluginConfig(directory);
+    const prMonitorConfig = config3.pr_monitor;
+    if (!prMonitorConfig?.enabled) {
+      return [
+        "Error: PR Monitor is not enabled.",
+        "",
+        "Set `pr_monitor.enabled: true` in your opencode config to enable."
+      ].join(`
+`);
+    }
+    await _internals27.subscribe(directory, {
+      sessionID,
+      prNumber: prInfo.number,
+      repoFullName,
+      prUrl,
+      maxSubscriptions: prMonitorConfig?.max_subscriptions
+    });
+    return [
+      `Subscribed to ${prUrl}`,
+      `Session: ${sessionID}`,
+      `PR: ${repoFullName}#${prInfo.number}`,
+      "",
+      "The background PR monitor will now check this PR for",
+      "CI failures, new comments, review state changes, and",
+      "merge/close events. Notifications appear as session-scoped",
+      "advisories with dedup tokens."
+    ].join(`
+`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return [`Error: Failed to subscribe to ${prUrl}`, "", message].join(`
+`);
+  }
+}
+var _internals27;
+var init_pr_subscribe = __esm(() => {
+  init_pr_subscriptions();
+  init_loader();
+  init_pr_ref();
+  _internals27 = {
+    loadPluginConfig,
+    subscribe
+  };
+});
+
+// src/commands/pr-unsubscribe.ts
+async function handlePrUnsubscribeCommand(directory, args, sessionID) {
+  const rest = args.filter((t) => t.trim().length > 0);
+  if (rest.length === 0) {
+    return [
+      "Usage: /swarm pr unsubscribe <pr-url|owner/repo#N|N>",
+      "",
+      "Unsubscribes the current session from receiving advisory",
+      "notifications for the specified PR. Removes the active",
+      "subscription record.",
+      "",
+      "  /swarm pr unsubscribe https://github.com/owner/repo/pull/42",
+      "  /swarm pr unsubscribe owner/repo#42",
+      "  /swarm pr unsubscribe 42"
+    ].join(`
+`);
+  }
+  const refToken = rest[0];
+  const prInfo = _internals28.parsePrRef(refToken, directory);
+  if (!prInfo) {
+    if (_internals28.looksLikePrRef(refToken)) {
+      return [
+        `Error: Could not resolve PR reference from "${refToken}".`,
+        "",
+        "That looked like a PR reference but could not be resolved.",
+        "Pass a full URL or `owner/repo#N`, or verify your git",
+        "`origin` remote points to a GitHub repository."
+      ].join(`
+`);
+    }
+    return [
+      `Error: "${refToken}" is not a valid PR reference.`,
+      "",
+      "Expected: full GitHub URL, owner/repo#N shorthand,",
+      "or a bare PR number (resolved against origin)."
+    ].join(`
+`);
+  }
+  const repoFullName = `${prInfo.owner}/${prInfo.repo}`;
+  const prUrl = `https://github.com/${prInfo.owner}/${prInfo.repo}/pull/${prInfo.number}`;
+  try {
+    const correlationId = _internals28.buildCorrelationId(sessionID, repoFullName, prInfo.number);
+    const result = await _internals28.unsubscribe(directory, correlationId);
+    if (!result) {
+      return [
+        `Not subscribed to ${prUrl}`,
+        `Session: ${sessionID}`,
+        `PR: ${repoFullName}#${prInfo.number}`,
+        "",
+        "No active subscription found for this session and PR.",
+        "Use /swarm pr subscribe to start monitoring."
+      ].join(`
+`);
+    }
+    return [
+      `Unsubscribed from ${prUrl}`,
+      `Session: ${sessionID}`,
+      `PR: ${repoFullName}#${prInfo.number}`,
+      "",
+      "The background PR monitor will no longer check this PR for",
+      "the current session. Use /swarm pr subscribe to re-subscribe."
+    ].join(`
+`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return [`Error: Failed to unsubscribe from ${prUrl}`, "", message].join(`
+`);
+  }
+}
+var _internals28;
+var init_pr_unsubscribe = __esm(() => {
+  init_pr_subscriptions();
+  init_pr_ref();
+  _internals28 = {
+    unsubscribe,
+    buildCorrelationId,
+    parsePrRef,
+    looksLikePrRef
+  };
+});
+
 // src/utils/path-security.ts
 function containsPathTraversal(str) {
   if (/\.\.[/\\]/.test(str))
@@ -53585,8 +53981,8 @@ function containsControlChars(str) {
 var init_path_security = () => {};
 
 // src/tools/lint.ts
-import * as fs17 from "fs";
-import * as path43 from "path";
+import * as fs18 from "fs";
+import * as path44 from "path";
 function validateArgs(args) {
   if (typeof args !== "object" || args === null)
     return false;
@@ -53597,9 +53993,9 @@ function validateArgs(args) {
 }
 function getLinterCommand(linter, mode, projectDir) {
   const isWindows = process.platform === "win32";
-  const binDir = path43.join(projectDir, "node_modules", ".bin");
-  const biomeBin = isWindows ? path43.join(binDir, "biome.EXE") : path43.join(binDir, "biome");
-  const eslintBin = isWindows ? path43.join(binDir, "eslint.cmd") : path43.join(binDir, "eslint");
+  const binDir = path44.join(projectDir, "node_modules", ".bin");
+  const biomeBin = isWindows ? path44.join(binDir, "biome.EXE") : path44.join(binDir, "biome");
+  const eslintBin = isWindows ? path44.join(binDir, "eslint.cmd") : path44.join(binDir, "eslint");
   switch (linter) {
     case "biome":
       if (mode === "fix") {
@@ -53615,7 +54011,7 @@ function getLinterCommand(linter, mode, projectDir) {
 }
 function getAdditionalLinterCommand(linter, mode, cwd) {
   const gradlewName = process.platform === "win32" ? "gradlew.bat" : "gradlew";
-  const gradlew = fs17.existsSync(path43.join(cwd, gradlewName)) ? path43.join(cwd, gradlewName) : null;
+  const gradlew = fs18.existsSync(path44.join(cwd, gradlewName)) ? path44.join(cwd, gradlewName) : null;
   switch (linter) {
     case "ruff":
       return mode === "fix" ? ["ruff", "check", "--fix", "."] : ["ruff", "check", "."];
@@ -53649,12 +54045,12 @@ function getAdditionalLinterCommand(linter, mode, cwd) {
   }
 }
 function detectRuff(cwd) {
-  if (fs17.existsSync(path43.join(cwd, "ruff.toml")))
+  if (fs18.existsSync(path44.join(cwd, "ruff.toml")))
     return isCommandAvailable("ruff");
   try {
-    const pyproject = path43.join(cwd, "pyproject.toml");
-    if (fs17.existsSync(pyproject)) {
-      const content = fs17.readFileSync(pyproject, "utf-8");
+    const pyproject = path44.join(cwd, "pyproject.toml");
+    if (fs18.existsSync(pyproject)) {
+      const content = fs18.readFileSync(pyproject, "utf-8");
       if (content.includes("[tool.ruff]"))
         return isCommandAvailable("ruff");
     }
@@ -53662,21 +54058,21 @@ function detectRuff(cwd) {
   return false;
 }
 function detectClippy(cwd) {
-  return fs17.existsSync(path43.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
+  return fs18.existsSync(path44.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
 }
 function detectGolangciLint(cwd) {
-  return fs17.existsSync(path43.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
+  return fs18.existsSync(path44.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
 }
 function detectCheckstyle(cwd) {
-  const hasMaven = fs17.existsSync(path43.join(cwd, "pom.xml"));
-  const hasGradle = fs17.existsSync(path43.join(cwd, "build.gradle")) || fs17.existsSync(path43.join(cwd, "build.gradle.kts"));
-  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs17.existsSync(path43.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
+  const hasMaven = fs18.existsSync(path44.join(cwd, "pom.xml"));
+  const hasGradle = fs18.existsSync(path44.join(cwd, "build.gradle")) || fs18.existsSync(path44.join(cwd, "build.gradle.kts"));
+  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs18.existsSync(path44.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
   return (hasMaven || hasGradle) && hasBinary;
 }
 function detectKtlint(cwd) {
-  const hasKotlin = fs17.existsSync(path43.join(cwd, "build.gradle.kts")) || fs17.existsSync(path43.join(cwd, "build.gradle")) || (() => {
+  const hasKotlin = fs18.existsSync(path44.join(cwd, "build.gradle.kts")) || fs18.existsSync(path44.join(cwd, "build.gradle")) || (() => {
     try {
-      return fs17.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
+      return fs18.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
     } catch {
       return false;
     }
@@ -53685,7 +54081,7 @@ function detectKtlint(cwd) {
 }
 function detectDotnetFormat(cwd) {
   try {
-    const files = fs17.readdirSync(cwd);
+    const files = fs18.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"));
     return hasCsproj && isCommandAvailable("dotnet");
   } catch {
@@ -53693,14 +54089,14 @@ function detectDotnetFormat(cwd) {
   }
 }
 function detectCppcheck(cwd) {
-  if (fs17.existsSync(path43.join(cwd, "CMakeLists.txt"))) {
+  if (fs18.existsSync(path44.join(cwd, "CMakeLists.txt"))) {
     return isCommandAvailable("cppcheck");
   }
   try {
-    const dirsToCheck = [cwd, path43.join(cwd, "src")];
+    const dirsToCheck = [cwd, path44.join(cwd, "src")];
     const hasCpp = dirsToCheck.some((dir) => {
       try {
-        return fs17.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
+        return fs18.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
       } catch {
         return false;
       }
@@ -53711,13 +54107,13 @@ function detectCppcheck(cwd) {
   }
 }
 function detectSwiftlint(cwd) {
-  return fs17.existsSync(path43.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
+  return fs18.existsSync(path44.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
 }
 function detectDartAnalyze(cwd) {
-  return fs17.existsSync(path43.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs18.existsSync(path44.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRubocop(cwd) {
-  return (fs17.existsSync(path43.join(cwd, "Gemfile")) || fs17.existsSync(path43.join(cwd, "gems.rb")) || fs17.existsSync(path43.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
+  return (fs18.existsSync(path44.join(cwd, "Gemfile")) || fs18.existsSync(path44.join(cwd, "gems.rb")) || fs18.existsSync(path44.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
 }
 function detectAdditionalLinter(cwd) {
   if (detectRuff(cwd))
@@ -53745,10 +54141,10 @@ function detectAdditionalLinter(cwd) {
 function findBinInAncestors(startDir, binName) {
   let dir = startDir;
   while (true) {
-    const candidate = path43.join(dir, "node_modules", ".bin", binName);
-    if (fs17.existsSync(candidate))
+    const candidate = path44.join(dir, "node_modules", ".bin", binName);
+    if (fs18.existsSync(candidate))
       return candidate;
-    const parent = path43.dirname(dir);
+    const parent = path44.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -53757,11 +54153,11 @@ function findBinInAncestors(startDir, binName) {
 }
 function findBinInEnvPath(binName) {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path43.delimiter)) {
+  for (const dir of searchPath.split(path44.delimiter)) {
     if (!dir)
       continue;
-    const candidate = path43.join(dir, binName);
-    if (fs17.existsSync(candidate))
+    const candidate = path44.join(dir, binName);
+    if (fs18.existsSync(candidate))
       return candidate;
   }
   return null;
@@ -53769,17 +54165,17 @@ function findBinInEnvPath(binName) {
 async function detectAvailableLinter(directory) {
   if (!directory)
     return null;
-  if (!fs17.existsSync(directory))
+  if (!fs18.existsSync(directory))
     return null;
   const projectDir = directory;
   const isWindows = process.platform === "win32";
-  const biomeBin = isWindows ? path43.join(projectDir, "node_modules", ".bin", "biome.EXE") : path43.join(projectDir, "node_modules", ".bin", "biome");
-  const eslintBin = isWindows ? path43.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path43.join(projectDir, "node_modules", ".bin", "eslint");
+  const biomeBin = isWindows ? path44.join(projectDir, "node_modules", ".bin", "biome.EXE") : path44.join(projectDir, "node_modules", ".bin", "biome");
+  const eslintBin = isWindows ? path44.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path44.join(projectDir, "node_modules", ".bin", "eslint");
   const localResult = await _detectAvailableLinter(projectDir, biomeBin, eslintBin);
   if (localResult)
     return localResult;
-  const biomeAncestor = findBinInAncestors(path43.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
-  const eslintAncestor = findBinInAncestors(path43.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
+  const biomeAncestor = findBinInAncestors(path44.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
+  const eslintAncestor = findBinInAncestors(path44.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
   if (biomeAncestor || eslintAncestor) {
     return _detectAvailableLinter(projectDir, biomeAncestor ?? biomeBin, eslintAncestor ?? eslintBin);
   }
@@ -53798,11 +54194,11 @@ async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
       stderr: "pipe"
     });
     const biomeExit = biomeProc.exited;
-    const timeout = new Promise((resolve15) => setTimeout(() => resolve15("timeout"), DETECT_TIMEOUT));
+    const timeout = new Promise((resolve16) => setTimeout(() => resolve16("timeout"), DETECT_TIMEOUT));
     const result = await Promise.race([biomeExit, timeout]);
     if (result === "timeout") {
       biomeProc.kill();
-    } else if (biomeProc.exitCode === 0 && fs17.existsSync(biomeBin)) {
+    } else if (biomeProc.exitCode === 0 && fs18.existsSync(biomeBin)) {
       return "biome";
     }
   } catch {}
@@ -53812,11 +54208,11 @@ async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
       stderr: "pipe"
     });
     const eslintExit = eslintProc.exited;
-    const timeout = new Promise((resolve15) => setTimeout(() => resolve15("timeout"), DETECT_TIMEOUT));
+    const timeout = new Promise((resolve16) => setTimeout(() => resolve16("timeout"), DETECT_TIMEOUT));
     const result = await Promise.race([eslintExit, timeout]);
     if (result === "timeout") {
       eslintProc.kill();
-    } else if (eslintProc.exitCode === 0 && fs17.existsSync(eslintBin)) {
+    } else if (eslintProc.exitCode === 0 && fs18.existsSync(eslintBin)) {
       return "eslint";
     }
   } catch {}
@@ -53938,7 +54334,7 @@ async function runAdditionalLint(linter, mode, cwd) {
     };
   }
 }
-var MAX_OUTPUT_BYTES = 512000, MAX_COMMAND_LENGTH = 500, lint, _internals26;
+var MAX_OUTPUT_BYTES = 512000, MAX_COMMAND_LENGTH = 500, lint, _internals29;
 var init_lint = __esm(() => {
   init_zod();
   init_discovery();
@@ -53970,15 +54366,15 @@ var init_lint = __esm(() => {
       }
       const { mode } = args;
       const cwd = directory;
-      const linter = await _internals26.detectAvailableLinter(directory);
+      const linter = await _internals29.detectAvailableLinter(directory);
       if (linter) {
-        const result = await _internals26.runLint(linter, mode, directory);
+        const result = await _internals29.runLint(linter, mode, directory);
         return JSON.stringify(result, null, 2);
       }
-      const additionalLinter = _internals26.detectAdditionalLinter(cwd);
+      const additionalLinter = _internals29.detectAdditionalLinter(cwd);
       if (additionalLinter) {
         warn(`[lint] Using ${additionalLinter} linter for this project`);
-        const result = await _internals26.runAdditionalLint(additionalLinter, mode, cwd);
+        const result = await _internals29.runAdditionalLint(additionalLinter, mode, cwd);
         return JSON.stringify(result, null, 2);
       }
       const errorResult = {
@@ -53992,7 +54388,7 @@ For Rust: rustup component add clippy`
       return JSON.stringify(errorResult, null, 2);
     }
   });
-  _internals26 = {
+  _internals29 = {
     detectAvailableLinter,
     runLint,
     detectAdditionalLinter,
@@ -54001,8 +54397,8 @@ For Rust: rustup component add clippy`
 });
 
 // src/tools/secretscan.ts
-import * as fs18 from "fs";
-import * as path44 from "path";
+import * as fs19 from "fs";
+import * as path45 from "path";
 function calculateShannonEntropy(str) {
   if (str.length === 0)
     return 0;
@@ -54050,11 +54446,11 @@ function isGlobOrPathPattern(pattern) {
   return pattern.includes("/") || pattern.includes("\\") || /[*?[\]{}]/.test(pattern);
 }
 function loadSecretScanIgnore(scanDir) {
-  const ignorePath = path44.join(scanDir, ".secretscanignore");
+  const ignorePath = path45.join(scanDir, ".secretscanignore");
   try {
-    if (!fs18.existsSync(ignorePath))
+    if (!fs19.existsSync(ignorePath))
       return [];
-    const content = fs18.readFileSync(ignorePath, "utf8");
+    const content = fs19.readFileSync(ignorePath, "utf8");
     const patterns = [];
     for (const rawLine of content.split(/\r?\n/)) {
       const line = rawLine.trim();
@@ -54073,7 +54469,7 @@ function isExcluded(entry, relPath, exactNames, globPatterns) {
   if (exactNames.has(entry))
     return true;
   for (const pattern of globPatterns) {
-    if (path44.matchesGlob(relPath, pattern))
+    if (path45.matchesGlob(relPath, pattern))
       return true;
   }
   return false;
@@ -54094,7 +54490,7 @@ function validateDirectoryInput(dir) {
   return null;
 }
 function isBinaryFile(filePath, buffer) {
-  const ext = path44.extname(filePath).toLowerCase();
+  const ext = path45.extname(filePath).toLowerCase();
   if (DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
     return true;
   }
@@ -54172,7 +54568,7 @@ function createRedactedContext(line, findings) {
 function scanFileForSecrets(filePath) {
   const findings = [];
   try {
-    const lstat = fs18.lstatSync(filePath);
+    const lstat = fs19.lstatSync(filePath);
     if (lstat.isSymbolicLink()) {
       return findings;
     }
@@ -54181,14 +54577,14 @@ function scanFileForSecrets(filePath) {
     }
     let buffer;
     if (O_NOFOLLOW !== undefined) {
-      const fd = fs18.openSync(filePath, "r", O_NOFOLLOW);
+      const fd = fs19.openSync(filePath, "r", O_NOFOLLOW);
       try {
-        buffer = fs18.readFileSync(fd);
+        buffer = fs19.readFileSync(fd);
       } finally {
-        fs18.closeSync(fd);
+        fs19.closeSync(fd);
       }
     } else {
-      buffer = fs18.readFileSync(filePath);
+      buffer = fs19.readFileSync(filePath);
     }
     if (isBinaryFile(filePath, buffer)) {
       return findings;
@@ -54230,9 +54626,9 @@ function isSymlinkLoop(realPath, visited) {
   return false;
 }
 function isPathWithinScope(realPath, scanDir) {
-  const resolvedScanDir = path44.resolve(scanDir);
-  const resolvedRealPath = path44.resolve(realPath);
-  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path44.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
+  const resolvedScanDir = path45.resolve(scanDir);
+  const resolvedRealPath = path45.resolve(realPath);
+  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path45.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
 }
 function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, stats = {
   skippedDirs: 0,
@@ -54243,7 +54639,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
   const files = [];
   let entries;
   try {
-    entries = fs18.readdirSync(dir);
+    entries = fs19.readdirSync(dir);
   } catch {
     stats.fileErrors++;
     return files;
@@ -54258,15 +54654,15 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     return a.localeCompare(b);
   });
   for (const entry of entries) {
-    const fullPath = path44.join(dir, entry);
-    const relPath = path44.relative(scanDir, fullPath).replace(/\\/g, "/");
+    const fullPath = path45.join(dir, entry);
+    const relPath = path45.relative(scanDir, fullPath).replace(/\\/g, "/");
     if (isExcluded(entry, relPath, excludeExact, excludeGlobs)) {
       stats.skippedDirs++;
       continue;
     }
     let lstat;
     try {
-      lstat = fs18.lstatSync(fullPath);
+      lstat = fs19.lstatSync(fullPath);
     } catch {
       stats.fileErrors++;
       continue;
@@ -54278,7 +54674,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     if (lstat.isDirectory()) {
       let realPath;
       try {
-        realPath = fs18.realpathSync(fullPath);
+        realPath = fs19.realpathSync(fullPath);
       } catch {
         stats.fileErrors++;
         continue;
@@ -54294,7 +54690,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
       const subFiles = findScannableFiles(fullPath, excludeExact, excludeGlobs, scanDir, visited, stats);
       files.push(...subFiles);
     } else if (lstat.isFile()) {
-      const ext = path44.extname(fullPath).toLowerCase();
+      const ext = path45.extname(fullPath).toLowerCase();
       if (!DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
         files.push(fullPath);
       } else {
@@ -54306,7 +54702,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
 }
 async function runSecretscan(directory) {
   try {
-    const result = await _internals27.secretscan.execute({ directory }, {});
+    const result = await _internals30.secretscan.execute({ directory }, {});
     const jsonStr = typeof result === "string" ? result : result.output;
     return JSON.parse(jsonStr);
   } catch (e) {
@@ -54321,7 +54717,7 @@ async function runSecretscan(directory) {
     return errorResult;
   }
 }
-var MAX_FILE_PATH_LENGTH = 500, MAX_FILE_SIZE_BYTES, MAX_FILES_SCANNED = 1000, MAX_FINDINGS = 100, MAX_OUTPUT_BYTES2 = 512000, MAX_LINE_LENGTH = 1e4, MAX_CONTENT_BYTES, BINARY_SIGNATURES, BINARY_PREFIX_BYTES = 4, BINARY_NULL_CHECK_BYTES = 8192, BINARY_NULL_THRESHOLD = 0.1, DEFAULT_EXCLUDE_DIRS, DEFAULT_EXCLUDE_EXTENSIONS, SECRET_PATTERNS2, O_NOFOLLOW, secretscan, _internals27;
+var MAX_FILE_PATH_LENGTH = 500, MAX_FILE_SIZE_BYTES, MAX_FILES_SCANNED = 1000, MAX_FINDINGS = 100, MAX_OUTPUT_BYTES2 = 512000, MAX_LINE_LENGTH = 1e4, MAX_CONTENT_BYTES, BINARY_SIGNATURES, BINARY_PREFIX_BYTES = 4, BINARY_NULL_CHECK_BYTES = 8192, BINARY_NULL_THRESHOLD = 0.1, DEFAULT_EXCLUDE_DIRS, DEFAULT_EXCLUDE_EXTENSIONS, SECRET_PATTERNS2, O_NOFOLLOW, secretscan, _internals30;
 var init_secretscan = __esm(() => {
   init_zod();
   init_path_security();
@@ -54497,7 +54893,7 @@ var init_secretscan = __esm(() => {
       redactTemplate: () => "SK[REDACTED]"
     }
   ];
-  O_NOFOLLOW = process.platform !== "win32" ? fs18.constants.O_NOFOLLOW : undefined;
+  O_NOFOLLOW = process.platform !== "win32" ? fs19.constants.O_NOFOLLOW : undefined;
   secretscan = createSwarmTool({
     description: "Scan directory for potential secrets (API keys, tokens, passwords) using regex patterns and entropy heuristics. Returns metadata-only findings with redacted previews - NEVER returns raw secrets. Excludes common directories (node_modules, .git, dist, etc.) by default. Supports glob patterns (e.g. **/.svelte-kit/**, **/*.test.ts) and reads .secretscanignore at the scan root.",
     args: {
@@ -54554,15 +54950,15 @@ var init_secretscan = __esm(() => {
         }
       }
       try {
-        const _scanDirRaw = path44.resolve(directory);
+        const _scanDirRaw = path45.resolve(directory);
         const scanDir = (() => {
           try {
-            return fs18.realpathSync(_scanDirRaw);
+            return fs19.realpathSync(_scanDirRaw);
           } catch {
             return _scanDirRaw;
           }
         })();
-        if (!fs18.existsSync(scanDir)) {
+        if (!fs19.existsSync(scanDir)) {
           const errorResult = {
             error: "directory not found",
             scan_dir: directory,
@@ -54573,7 +54969,7 @@ var init_secretscan = __esm(() => {
           };
           return JSON.stringify(errorResult, null, 2);
         }
-        const dirStat = fs18.statSync(scanDir);
+        const dirStat = fs19.statSync(scanDir);
         if (!dirStat.isDirectory()) {
           const errorResult = {
             error: "target must be a directory, not a file",
@@ -54624,7 +55020,7 @@ var init_secretscan = __esm(() => {
             break;
           const fileFindings = scanFileForSecrets(filePath);
           try {
-            const stat5 = fs18.statSync(filePath);
+            const stat5 = fs19.statSync(filePath);
             if (stat5.size > MAX_FILE_SIZE_BYTES) {
               skippedFiles++;
               continue;
@@ -54693,19 +55089,19 @@ var init_secretscan = __esm(() => {
       }
     }
   });
-  _internals27 = {
+  _internals30 = {
     secretscan,
     runSecretscan
   };
 });
 
 // src/lang/default-backend.ts
-import * as fs19 from "fs";
-import * as path45 from "path";
+import * as fs20 from "fs";
+import * as path46 from "path";
 function detectFileExists(dir, pattern) {
   if (pattern.includes("*") || pattern.includes("?")) {
     try {
-      const files = fs19.readdirSync(dir);
+      const files = fs20.readdirSync(dir);
       const regex = new RegExp(`^${pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".")}$`);
       return files.some((f) => regex.test(f));
     } catch {
@@ -54713,7 +55109,7 @@ function detectFileExists(dir, pattern) {
     }
   }
   try {
-    fs19.accessSync(path45.join(dir, pattern));
+    fs20.accessSync(path46.join(dir, pattern));
     return true;
   } catch {
     return false;
@@ -54852,8 +55248,8 @@ function defaultBuildTestCommand(profile, framework, files, dir = ".", opts = {}
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs19.existsSync(path45.join(dir, "gradlew.bat"));
-      const hasGradlew = fs19.existsSync(path45.join(dir, "gradlew"));
+      const hasGradlewBat = fs20.existsSync(path46.join(dir, "gradlew.bat"));
+      const hasGradlew = fs20.existsSync(path46.join(dir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -54870,7 +55266,7 @@ function defaultBuildTestCommand(profile, framework, files, dir = ".", opts = {}
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs19.existsSync(path45.join(dir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs20.existsSync(path46.join(dir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -55159,23 +55555,23 @@ async function defaultSelectBuildCommand(profile, dir) {
   return null;
 }
 async function defaultTestFilesFor(profile, sourceFile, dir) {
-  const ext = path45.extname(sourceFile);
+  const ext = path46.extname(sourceFile);
   if (!profile.extensions.includes(ext))
     return [];
-  const base = path45.basename(sourceFile, ext);
-  const rel = path45.relative(dir, sourceFile);
-  const relDir = path45.dirname(rel);
+  const base = path46.basename(sourceFile, ext);
+  const rel = path46.relative(dir, sourceFile);
+  const relDir = path46.dirname(rel);
   const stripSrc = relDir.replace(/^src(\/|\\)/, "");
   const candidates = new Set;
   for (const tDir of ["tests", "test", "__tests__", "spec"]) {
     for (const suffix of ["", "_test", ".test", "_spec", ".spec"]) {
-      candidates.add(path45.join(dir, tDir, stripSrc, `${base}${suffix}${ext}`));
+      candidates.add(path46.join(dir, tDir, stripSrc, `${base}${suffix}${ext}`));
     }
   }
   const existing = [];
   for (const c of candidates) {
     try {
-      fs19.accessSync(c);
+      fs20.accessSync(c);
       existing.push(c);
     } catch {}
   }
@@ -55209,8 +55605,8 @@ var init_default_backend = __esm(() => {
 });
 
 // src/lang/backends/go.ts
-import * as fs20 from "fs";
-import * as path46 from "path";
+import * as fs21 from "fs";
+import * as path47 from "path";
 function extractImports(_sourceFile, source) {
   const out = new Set;
   IMPORT_REGEX_SINGLE.lastIndex = 0;
@@ -55236,7 +55632,7 @@ function extractImports(_sourceFile, source) {
 async function selectFramework(dir) {
   let content;
   try {
-    content = fs20.readFileSync(path46.join(dir, "go.mod"), "utf-8");
+    content = fs21.readFileSync(path47.join(dir, "go.mod"), "utf-8");
   } catch {
     return null;
   }
@@ -55257,16 +55653,16 @@ async function selectFramework(dir) {
 async function selectEntryPoints(dir) {
   const points = [];
   try {
-    fs20.accessSync(path46.join(dir, "main.go"));
+    fs21.accessSync(path47.join(dir, "main.go"));
     points.push("main.go");
   } catch {}
   try {
-    const cmdDir = path46.join(dir, "cmd");
-    const subdirs = fs20.readdirSync(cmdDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+    const cmdDir = path47.join(dir, "cmd");
+    const subdirs = fs21.readdirSync(cmdDir, { withFileTypes: true }).filter((d) => d.isDirectory());
     for (const sub of subdirs) {
-      const main = path46.join("cmd", sub.name, "main.go");
+      const main = path47.join("cmd", sub.name, "main.go");
       try {
-        fs20.accessSync(path46.join(dir, main));
+        fs21.accessSync(path47.join(dir, main));
         points.push(main);
       } catch {}
     }
@@ -55285,19 +55681,19 @@ function buildGoBackend() {
     selectEntryPoints
   };
 }
-var PROFILE_ID = "go", IMPORT_REGEX_SINGLE, IMPORT_REGEX_GROUP, IMPORT_REGEX_GROUP_LINE, _internals28;
+var PROFILE_ID = "go", IMPORT_REGEX_SINGLE, IMPORT_REGEX_GROUP, IMPORT_REGEX_GROUP_LINE, _internals31;
 var init_go = __esm(() => {
   init_default_backend();
   init_profiles();
   IMPORT_REGEX_SINGLE = /^\s*import\s+(?:[a-zA-Z_.][a-zA-Z0-9_]*\s+)?"([^"]+)"/gm;
   IMPORT_REGEX_GROUP = /^\s*import\s*\(([\s\S]*?)\)/gm;
   IMPORT_REGEX_GROUP_LINE = /(?:[a-zA-Z_.][a-zA-Z0-9_]*\s+)?"([^"]+)"/g;
-  _internals28 = { extractImports };
+  _internals31 = { extractImports };
 });
 
 // src/lang/backends/python.ts
-import * as fs21 from "fs";
-import * as path47 from "path";
+import * as fs22 from "fs";
+import * as path48 from "path";
 function parseImportTargets(rawTargets) {
   const cleaned = rawTargets.replace(/[()]/g, "").split(`
 `).map((line) => line.replace(/#.*$/, "").replace(/\\\s*$/, "")).join(" ");
@@ -55357,7 +55753,7 @@ async function selectFramework2(dir) {
   ];
   for (const candidate of ["pyproject.toml", "requirements.txt", "setup.py"]) {
     try {
-      const content = fs21.readFileSync(path47.join(dir, candidate), "utf-8");
+      const content = fs22.readFileSync(path48.join(dir, candidate), "utf-8");
       const lower = content.toLowerCase();
       for (const [pkg, name] of candidates) {
         if (lower.includes(pkg)) {
@@ -55371,7 +55767,7 @@ async function selectFramework2(dir) {
 async function selectEntryPoints2(dir) {
   const points = new Set;
   try {
-    const content = fs21.readFileSync(path47.join(dir, "pyproject.toml"), "utf-8");
+    const content = fs22.readFileSync(path48.join(dir, "pyproject.toml"), "utf-8");
     const scriptsBlock = content.match(/\[project\.scripts\][\s\S]*?(?=\n\[|$)/);
     if (scriptsBlock) {
       for (const line of scriptsBlock[0].split(`
@@ -55386,7 +55782,7 @@ async function selectEntryPoints2(dir) {
   } catch {}
   for (const name of ["manage.py", "main.py", "app.py", "__main__.py"]) {
     try {
-      fs21.accessSync(path47.join(dir, name));
+      fs22.accessSync(path48.join(dir, name));
       points.add(name);
     } catch {}
   }
@@ -55404,18 +55800,18 @@ function buildPythonBackend() {
     selectEntryPoints: selectEntryPoints2
   };
 }
-var PROFILE_ID2 = "python", IMPORT_REGEX_FROM_WITH_TARGETS, IMPORT_REGEX_IMPORT, _internals29;
+var PROFILE_ID2 = "python", IMPORT_REGEX_FROM_WITH_TARGETS, IMPORT_REGEX_IMPORT, _internals32;
 var init_python = __esm(() => {
   init_default_backend();
   init_profiles();
   IMPORT_REGEX_FROM_WITH_TARGETS = /^\s*from\s+(\.*[\w.]*)\s+import\s+(\([^)]*\)|[^\n#]+)/gm;
   IMPORT_REGEX_IMPORT = /^\s*import\s+([^\n#]+)/gm;
-  _internals29 = { extractImports: extractImports2 };
+  _internals32 = { extractImports: extractImports2 };
 });
 
 // src/test-impact/analyzer.ts
-import fs22 from "fs";
-import path48 from "path";
+import fs23 from "fs";
+import path49 from "path";
 function normalizePath(p) {
   return p.replace(/\\/g, "/");
 }
@@ -55435,7 +55831,7 @@ function sharedTrailingSegments(a, b) {
 function isCacheStale(impactMap, generatedAtMs) {
   for (const sourcePath of Object.keys(impactMap)) {
     try {
-      const stat5 = fs22.statSync(sourcePath);
+      const stat5 = fs23.statSync(sourcePath);
       if (stat5.mtimeMs > generatedAtMs) {
         return true;
       }
@@ -55449,15 +55845,15 @@ function resolveRelativeImport(fromDir, importPath) {
   if (!importPath.startsWith(".")) {
     return null;
   }
-  const resolved = path48.resolve(fromDir, importPath);
-  if (path48.extname(resolved)) {
-    if (fs22.existsSync(resolved) && fs22.statSync(resolved).isFile()) {
+  const resolved = path49.resolve(fromDir, importPath);
+  if (path49.extname(resolved)) {
+    if (fs23.existsSync(resolved) && fs23.statSync(resolved).isFile()) {
       return normalizePath(resolved);
     }
   } else {
     for (const ext of EXTENSIONS_TO_TRY) {
       const withExt = resolved + ext;
-      if (fs22.existsSync(withExt) && fs22.statSync(withExt).isFile()) {
+      if (fs23.existsSync(withExt) && fs23.statSync(withExt).isFile()) {
         return normalizePath(withExt);
       }
     }
@@ -55470,29 +55866,29 @@ function resolvePythonImport(fromDir, module) {
   const leadingDots = module.match(/^\.+/)?.[0].length ?? 0;
   let baseDir = fromDir;
   for (let i = 1;i < leadingDots; i++) {
-    baseDir = path48.dirname(baseDir);
+    baseDir = path49.dirname(baseDir);
   }
   const rest = module.slice(leadingDots);
   if (rest.length === 0) {
-    const initPath = path48.join(baseDir, "__init__.py");
-    if (fs22.existsSync(initPath) && fs22.statSync(initPath).isFile()) {
+    const initPath = path49.join(baseDir, "__init__.py");
+    if (fs23.existsSync(initPath) && fs23.statSync(initPath).isFile()) {
       return normalizePath(initPath);
     }
     return null;
   }
-  const subpath = rest.replace(/\./g, path48.sep);
+  const subpath = rest.replace(/\./g, path49.sep);
   const candidates = [
-    `${path48.join(baseDir, subpath)}.py`,
-    path48.join(baseDir, subpath, "__init__.py")
+    `${path49.join(baseDir, subpath)}.py`,
+    path49.join(baseDir, subpath, "__init__.py")
   ];
   for (const c of candidates) {
-    if (fs22.existsSync(c) && fs22.statSync(c).isFile())
+    if (fs23.existsSync(c) && fs23.statSync(c).isFile())
       return normalizePath(c);
   }
   return null;
 }
 function findGoModule(fromDir) {
-  const resolved = path48.resolve(fromDir);
+  const resolved = path49.resolve(fromDir);
   let cur = resolved;
   const walked = [];
   for (let i = 0;i < 16; i++) {
@@ -55504,8 +55900,8 @@ function findGoModule(fromDir) {
     }
     walked.push(cur);
     try {
-      const goMod = path48.join(cur, "go.mod");
-      const content = fs22.readFileSync(goMod, "utf-8");
+      const goMod = path49.join(cur, "go.mod");
+      const content = fs23.readFileSync(goMod, "utf-8");
       const moduleMatch = content.match(/^\s*module\s+"?([^"\s/]+(?:\/[^"\s]+)*)"?/m);
       if (moduleMatch) {
         const result = { moduleRoot: cur, modulePath: moduleMatch[1] };
@@ -55515,10 +55911,10 @@ function findGoModule(fromDir) {
       }
     } catch {}
     try {
-      fs22.accessSync(path48.join(cur, ".git"));
+      fs23.accessSync(path49.join(cur, ".git"));
       break;
     } catch {}
-    const parent = path48.dirname(cur);
+    const parent = path49.dirname(cur);
     if (parent === cur)
       break;
     cur = parent;
@@ -55530,20 +55926,20 @@ function findGoModule(fromDir) {
 function resolveGoImport(fromDir, importPath) {
   let dir = null;
   if (importPath.startsWith(".")) {
-    dir = path48.resolve(fromDir, importPath);
+    dir = path49.resolve(fromDir, importPath);
   } else {
     const mod = findGoModule(fromDir);
     if (mod && (importPath === mod.modulePath || importPath.startsWith(`${mod.modulePath}/`))) {
       const subpath = importPath.slice(mod.modulePath.length);
-      dir = path48.join(mod.moduleRoot, subpath);
+      dir = path49.join(mod.moduleRoot, subpath);
     }
   }
   if (dir === null)
     return [];
-  if (!fs22.existsSync(dir) || !fs22.statSync(dir).isDirectory())
+  if (!fs23.existsSync(dir) || !fs23.statSync(dir).isDirectory())
     return [];
   try {
-    return fs22.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath(path48.join(dir, f)));
+    return fs23.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath(path49.join(dir, f)));
   } catch {
     return [];
   }
@@ -55563,13 +55959,13 @@ function findTestFilesSync(cwd) {
   function walk(dir, visitedInodes) {
     let entries;
     try {
-      entries = fs22.readdirSync(dir, { withFileTypes: true });
+      entries = fs23.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     let dirInode;
     try {
-      dirInode = fs22.statSync(dir).ino;
+      dirInode = fs23.statSync(dir).ino;
     } catch {
       return;
     }
@@ -55582,15 +55978,15 @@ function findTestFilesSync(cwd) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (!skipDirs.has(entry.name)) {
-          walk(path48.join(dir, entry.name), visitedInodes);
+          walk(path49.join(dir, entry.name), visitedInodes);
         }
       } else if (entry.isFile()) {
         const name = entry.name;
         const isTsTest = /\.(test|spec)\.(ts|tsx|js|jsx)$/.test(name) || dir.includes("__tests__") && /\.(ts|tsx|js|jsx)$/.test(name);
-        const isPyTest = /^test_.+\.py$/.test(name) || /.+_test\.py$/.test(name) || dir.includes(`${path48.sep}tests${path48.sep}`) && name.endsWith(".py");
+        const isPyTest = /^test_.+\.py$/.test(name) || /.+_test\.py$/.test(name) || dir.includes(`${path49.sep}tests${path49.sep}`) && name.endsWith(".py");
         const isGoTest = /.+_test\.go$/.test(name);
         if (isTsTest || isPyTest || isGoTest) {
-          testFiles.push(normalizePath(path48.join(dir, entry.name)));
+          testFiles.push(normalizePath(path49.join(dir, entry.name)));
         }
       }
     }
@@ -55615,8 +56011,8 @@ function extractImports3(content) {
   ];
 }
 function addImpactEdgesForTestFile(testFile, content, impactMap) {
-  const ext = path48.extname(testFile).toLowerCase();
-  const testDir = path48.dirname(testFile);
+  const ext = path49.extname(testFile).toLowerCase();
+  const testDir = path49.dirname(testFile);
   function addEdge(source) {
     if (!impactMap[source])
       impactMap[source] = [];
@@ -55634,7 +56030,7 @@ function addImpactEdgesForTestFile(testFile, content, impactMap) {
     return;
   }
   if (PYTHON_EXTENSIONS.has(ext)) {
-    const modules = _internals29.extractImports(testFile, content);
+    const modules = _internals32.extractImports(testFile, content);
     for (const mod of modules) {
       const resolved = resolvePythonImport(testDir, mod);
       if (resolved !== null)
@@ -55643,7 +56039,7 @@ function addImpactEdgesForTestFile(testFile, content, impactMap) {
     return;
   }
   if (GO_EXTENSIONS.has(ext)) {
-    const imports = _internals28.extractImports(testFile, content);
+    const imports = _internals31.extractImports(testFile, content);
     for (const importPath of imports) {
       const sourceFiles = resolveGoImport(testDir, importPath);
       for (const source of sourceFiles)
@@ -55658,7 +56054,7 @@ async function buildImpactMapInternal(cwd) {
   for (const testFile of testFiles) {
     let content;
     try {
-      content = fs22.readFileSync(testFile, "utf-8");
+      content = fs23.readFileSync(testFile, "utf-8");
     } catch {
       continue;
     }
@@ -55670,22 +56066,22 @@ async function buildImpactMapInternal(cwd) {
   return impactMap;
 }
 async function buildImpactMap(cwd) {
-  const impactMap = await _internals30.buildImpactMapInternal(cwd);
-  await _internals30.saveImpactMap(cwd, impactMap);
+  const impactMap = await _internals33.buildImpactMapInternal(cwd);
+  await _internals33.saveImpactMap(cwd, impactMap);
   return impactMap;
 }
 async function loadImpactMap(cwd, options) {
-  const cachePath = path48.join(cwd, ".swarm", "cache", "impact-map.json");
-  if (fs22.existsSync(cachePath)) {
+  const cachePath = path49.join(cwd, ".swarm", "cache", "impact-map.json");
+  if (fs23.existsSync(cachePath)) {
     try {
-      const content = fs22.readFileSync(cachePath, "utf-8");
+      const content = fs23.readFileSync(cachePath, "utf-8");
       const data = JSON.parse(content);
       if (data.map !== null && typeof data.map === "object" && !Array.isArray(data.map)) {
         const map3 = data.map;
         const hasValidValues = Object.values(map3).every((v) => Array.isArray(v) && v.every((item) => typeof item === "string"));
         if (hasValidValues) {
           const generatedAt = new Date(data.generatedAt).getTime();
-          if (!_internals30.isCacheStale(map3, generatedAt)) {
+          if (!_internals33.isCacheStale(map3, generatedAt)) {
             return map3;
           }
           if (options?.skipRebuild) {
@@ -55705,24 +56101,24 @@ async function loadImpactMap(cwd, options) {
   if (options?.skipRebuild) {
     return {};
   }
-  return _internals30.buildImpactMap(cwd);
+  return _internals33.buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
-  if (!path48.isAbsolute(cwd)) {
+  if (!path49.isAbsolute(cwd)) {
     throw new Error(`saveImpactMap requires an absolute project root path, got: "${cwd}"`);
   }
-  _internals30.validateProjectRoot(cwd);
-  const cacheDir2 = path48.join(cwd, ".swarm", "cache");
-  const cachePath = path48.join(cacheDir2, "impact-map.json");
-  if (!fs22.existsSync(cacheDir2)) {
-    fs22.mkdirSync(cacheDir2, { recursive: true });
+  _internals33.validateProjectRoot(cwd);
+  const cacheDir2 = path49.join(cwd, ".swarm", "cache");
+  const cachePath = path49.join(cacheDir2, "impact-map.json");
+  if (!fs23.existsSync(cacheDir2)) {
+    fs23.mkdirSync(cacheDir2, { recursive: true });
   }
   const data = {
     generatedAt: new Date().toISOString(),
     fileCount: Object.keys(impactMap).length,
     map: impactMap
   };
-  fs22.writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
+  fs23.writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
 }
 async function analyzeImpact(changedFiles, cwd, budget) {
   if (!Array.isArray(changedFiles)) {
@@ -55735,7 +56131,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
     };
   }
   const validFiles = changedFiles.filter((f) => typeof f === "string" && f.length > 0 && !f.includes("\x00"));
-  const impactMap = await _internals30.loadImpactMap(cwd);
+  const impactMap = await _internals33.loadImpactMap(cwd);
   const impactedTestsSet = new Set;
   const untestedFiles = [];
   let visitedCount = 0;
@@ -55745,7 +56141,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
       budgetExceeded = true;
       break;
     }
-    const normalizedChanged = normalizePath(path48.resolve(changedFile));
+    const normalizedChanged = normalizePath(path49.resolve(changedFile));
     const tests = impactMap[normalizedChanged];
     if (tests && tests.length > 0) {
       for (const test of tests) {
@@ -55759,13 +56155,13 @@ async function analyzeImpact(changedFiles, cwd, budget) {
       if (budgetExceeded)
         break;
     } else {
-      const changedDir = normalizePath(path48.dirname(normalizedChanged));
-      const changedInputDir = normalizePath(path48.dirname(changedFile));
+      const changedDir = normalizePath(path49.dirname(normalizedChanged));
+      const changedInputDir = normalizePath(path49.dirname(changedFile));
       const suffixMatches = Object.entries(impactMap).filter(([sourcePath]) => {
         return sourcePath.endsWith(changedFile) || changedFile.endsWith(sourcePath) || sourcePath.endsWith(normalizedChanged) || normalizedChanged.endsWith(sourcePath);
       }).sort(([sourceA], [sourceB]) => {
-        const sourceDirA = normalizePath(path48.dirname(sourceA));
-        const sourceDirB = normalizePath(path48.dirname(sourceB));
+        const sourceDirA = normalizePath(path49.dirname(sourceA));
+        const sourceDirB = normalizePath(path49.dirname(sourceB));
         const exactA = sourceDirA === changedDir || changedInputDir !== "." && (sourceDirA === changedInputDir || sourceDirA.endsWith(`/${changedInputDir}`));
         const exactB = sourceDirB === changedDir || changedInputDir !== "." && (sourceDirB === changedInputDir || sourceDirB.endsWith(`/${changedInputDir}`));
         if (exactA !== exactB)
@@ -55820,7 +56216,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
     budgetExceeded
   };
 }
-var IMPORT_REGEX_ES, IMPORT_REGEX_REQUIRE, IMPORT_REGEX_REEXPORT, TS_EXTENSIONS, PYTHON_EXTENSIONS, GO_EXTENSIONS, EXTENSIONS_TO_TRY, goModuleCache, _internals30;
+var IMPORT_REGEX_ES, IMPORT_REGEX_REQUIRE, IMPORT_REGEX_REEXPORT, TS_EXTENSIONS, PYTHON_EXTENSIONS, GO_EXTENSIONS, EXTENSIONS_TO_TRY, goModuleCache, _internals33;
 var init_analyzer = __esm(() => {
   init_manager2();
   init_go();
@@ -55833,7 +56229,7 @@ var init_analyzer = __esm(() => {
   GO_EXTENSIONS = new Set([".go"]);
   EXTENSIONS_TO_TRY = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
   goModuleCache = new Map;
-  _internals30 = {
+  _internals33 = {
     validateProjectRoot,
     normalizePath,
     isCacheStale,
@@ -56072,16 +56468,16 @@ function detectFlakyTests(allHistory) {
 var FLAKY_THRESHOLD = 0.3, MIN_RUNS_FOR_QUARANTINE = 5, MAX_HISTORY_RUNS = 20;
 
 // src/test-impact/history-store.ts
-import fs23 from "fs";
-import path49 from "path";
+import fs24 from "fs";
+import path50 from "path";
 function getHistoryPath(workingDir) {
   if (!workingDir) {
     throw new Error("getHistoryPath requires a working directory \u2014 project root must be provided by the caller");
   }
-  if (!path49.isAbsolute(workingDir)) {
+  if (!path50.isAbsolute(workingDir)) {
     throw new Error(`getHistoryPath requires an absolute project root path, got: "${workingDir}"`);
   }
-  return path49.join(workingDir, ".swarm", "cache", "test-history.jsonl");
+  return path50.join(workingDir, ".swarm", "cache", "test-history.jsonl");
 }
 function sanitizeErrorMessage(errorMessage) {
   if (errorMessage === undefined) {
@@ -56168,13 +56564,13 @@ function batchAppendTestRuns(records, workingDir) {
     }
   }
   const historyPath = getHistoryPath(workingDir);
-  const historyDir = path49.dirname(historyPath);
-  _internals31.validateProjectRoot(workingDir);
-  if (!fs23.existsSync(historyDir)) {
-    fs23.mkdirSync(historyDir, { recursive: true });
+  const historyDir = path50.dirname(historyPath);
+  _internals34.validateProjectRoot(workingDir);
+  if (!fs24.existsSync(historyDir)) {
+    fs24.mkdirSync(historyDir, { recursive: true });
   }
   withHistoryWriteLock(historyPath, () => {
-    const existingRecords = readAllRecords(historyPath);
+    const existingRecords = readAllRecords2(historyPath);
     const sanitizedRecords = records.map((record3) => ({
       ...record3,
       timestamp: record3.timestamp || new Date().toISOString(),
@@ -56205,13 +56601,13 @@ function batchAppendTestRuns(records, workingDir) {
 `)}
 `;
       const tempPath = `${historyPath}.tmp`;
-      fs23.writeFileSync(tempPath, content, "utf-8");
-      fs23.renameSync(tempPath, historyPath);
+      fs24.writeFileSync(tempPath, content, "utf-8");
+      fs24.renameSync(tempPath, historyPath);
     } catch (err) {
       try {
         const tempPath = `${historyPath}.tmp`;
-        if (fs23.existsSync(tempPath)) {
-          fs23.unlinkSync(tempPath);
+        if (fs24.existsSync(tempPath)) {
+          fs24.unlinkSync(tempPath);
         }
       } catch {}
       throw new Error(`Failed to write test history: ${err instanceof Error ? err.message : String(err)}`);
@@ -56223,7 +56619,7 @@ function withHistoryWriteLock(historyPath, fn) {
   const deadline = Date.now() + HISTORY_WRITE_LOCK_TIMEOUT_MS;
   while (true) {
     try {
-      fs23.mkdirSync(lockPath);
+      fs24.mkdirSync(lockPath);
       break;
     } catch (error93) {
       const code = error93 instanceof Error && "code" in error93 ? error93.code : undefined;
@@ -56234,9 +56630,9 @@ function withHistoryWriteLock(historyPath, fn) {
         throw new Error(`Timed out waiting for test history lock: ${historyPath}`);
       }
       try {
-        const lockStat = fs23.statSync(lockPath);
+        const lockStat = fs24.statSync(lockPath);
         if (Date.now() - lockStat.mtimeMs >= HISTORY_WRITE_LOCK_STALE_MS) {
-          fs23.rmSync(lockPath, { recursive: true, force: true });
+          fs24.rmSync(lockPath, { recursive: true, force: true });
           continue;
         }
       } catch {}
@@ -56251,7 +56647,7 @@ function withHistoryWriteLock(historyPath, fn) {
     return fn();
   } finally {
     try {
-      fs23.rmSync(lockPath, { recursive: true, force: true });
+      fs24.rmSync(lockPath, { recursive: true, force: true });
     } catch {}
   }
   function sleepSync(ms) {
@@ -56259,12 +56655,12 @@ function withHistoryWriteLock(historyPath, fn) {
     while (Date.now() < until) {}
   }
 }
-function readAllRecords(historyPath) {
-  if (!fs23.existsSync(historyPath)) {
+function readAllRecords2(historyPath) {
+  if (!fs24.existsSync(historyPath)) {
     return [];
   }
   try {
-    const content = fs23.readFileSync(historyPath, "utf-8");
+    const content = fs24.readFileSync(historyPath, "utf-8");
     const lines = content.split(`
 `);
     const records = [];
@@ -56288,11 +56684,11 @@ function readAllRecords(historyPath) {
 }
 function getAllHistory(workingDir) {
   const historyPath = getHistoryPath(workingDir);
-  const records = readAllRecords(historyPath);
+  const records = readAllRecords2(historyPath);
   records.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
   return records;
 }
-var MAX_HISTORY_PER_TEST = 20, MAX_ERROR_LENGTH = 500, MAX_STACK_LENGTH = 200, MAX_CHANGED_FILES = 50, HISTORY_WRITE_LOCK_TIMEOUT_MS = 5000, HISTORY_WRITE_LOCK_STALE_MS = 60000, HISTORY_WRITE_LOCK_BACKOFF_MS = 10, DANGEROUS_PROPERTY_NAMES, _internals31;
+var MAX_HISTORY_PER_TEST = 20, MAX_ERROR_LENGTH = 500, MAX_STACK_LENGTH = 200, MAX_CHANGED_FILES = 50, HISTORY_WRITE_LOCK_TIMEOUT_MS = 5000, HISTORY_WRITE_LOCK_STALE_MS = 60000, HISTORY_WRITE_LOCK_BACKOFF_MS = 10, DANGEROUS_PROPERTY_NAMES, _internals34;
 var init_history_store = __esm(() => {
   init_manager2();
   DANGEROUS_PROPERTY_NAMES = new Set([
@@ -56300,14 +56696,14 @@ var init_history_store = __esm(() => {
     "constructor",
     "prototype"
   ]);
-  _internals31 = {
+  _internals34 = {
     validateProjectRoot
   };
 });
 
 // src/tools/resolve-working-directory.ts
-import * as fs24 from "fs";
-import * as path50 from "path";
+import * as fs25 from "fs";
+import * as path51 from "path";
 function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (workingDirectory == null || workingDirectory === "") {
     if (typeof fallbackDirectory !== "string" || fallbackDirectory === "") {
@@ -56339,18 +56735,18 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       };
     }
   }
-  const rawPathParts = workingDirectory.split(path50.sep);
+  const rawPathParts = workingDirectory.split(path51.sep);
   if (rawPathParts.includes("..")) {
     return {
       success: false,
       message: "Invalid working_directory: path traversal sequences (..) are not allowed"
     };
   }
-  const normalizedDir = path50.normalize(workingDirectory);
-  const resolvedDir = path50.resolve(normalizedDir);
+  const normalizedDir = path51.normalize(workingDirectory);
+  const resolvedDir = path51.resolve(normalizedDir);
   let statResult;
   try {
-    statResult = fs24.statSync(resolvedDir);
+    statResult = fs25.statSync(resolvedDir);
   } catch {
     return {
       success: false,
@@ -56366,16 +56762,16 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (typeof fallbackDirectory !== "string" || fallbackDirectory === "") {
     return { success: true, directory: resolvedDir };
   }
-  const resolvedFallback = path50.resolve(fallbackDirectory);
+  const resolvedFallback = path51.resolve(fallbackDirectory);
   let fallbackExists = false;
   try {
-    fs24.statSync(resolvedFallback);
+    fs25.statSync(resolvedFallback);
     fallbackExists = true;
   } catch {
     fallbackExists = false;
   }
   if (fallbackExists) {
-    const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path50.sep);
+    const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path51.sep);
     if (isSubdirectory) {
       return {
         success: false,
@@ -56421,8 +56817,8 @@ var init_registry_backend = __esm(() => {
 });
 
 // src/lang/framework-detector.ts
-import * as fs25 from "fs";
-import * as path51 from "path";
+import * as fs26 from "fs";
+import * as path52 from "path";
 function detectLaravelProject(directory) {
   const signals = getLaravelSignals(directory);
   const signalCount = [
@@ -56439,21 +56835,21 @@ function getLaravelSignals(directory) {
   return { hasArtisanFile, hasLaravelFrameworkDep, hasConfigApp };
 }
 function checkArtisanFile(directory) {
-  const artisanPath = path51.join(directory, "artisan");
-  if (!fs25.existsSync(artisanPath))
+  const artisanPath = path52.join(directory, "artisan");
+  if (!fs26.existsSync(artisanPath))
     return false;
   try {
-    return fs25.statSync(artisanPath).isFile();
+    return fs26.statSync(artisanPath).isFile();
   } catch {
     return false;
   }
 }
 function checkLaravelFrameworkDep(directory) {
-  const composerPath = path51.join(directory, "composer.json");
-  if (!fs25.existsSync(composerPath))
+  const composerPath = path52.join(directory, "composer.json");
+  if (!fs26.existsSync(composerPath))
     return false;
   try {
-    const content = fs25.readFileSync(composerPath, "utf-8");
+    const content = fs26.readFileSync(composerPath, "utf-8");
     const parsed = JSON.parse(content);
     const require2 = parsed?.require ?? {};
     return typeof require2["laravel/framework"] === "string";
@@ -56462,7 +56858,7 @@ function checkLaravelFrameworkDep(directory) {
   }
 }
 function checkConfigApp(directory) {
-  return fs25.existsSync(path51.join(directory, "config", "app.php"));
+  return fs26.existsSync(path52.join(directory, "config", "app.php"));
 }
 var init_framework_detector = () => {};
 
@@ -56494,18 +56890,18 @@ var init_php = __esm(() => {
 });
 
 // src/lang/backends/typescript.ts
-import * as fs26 from "fs";
-import * as path52 from "path";
+import * as fs27 from "fs";
+import * as path53 from "path";
 function readPackageJsonRaw(dir) {
   try {
-    const content = fs26.readFileSync(path52.join(dir, "package.json"), "utf-8");
+    const content = fs27.readFileSync(path53.join(dir, "package.json"), "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 function readPackageJson(dir) {
-  return _internals32.readPackageJsonRaw(dir);
+  return _internals35.readPackageJsonRaw(dir);
 }
 function readPackageJsonTestScript(dir) {
   return readPackageJson(dir)?.scripts?.test ?? null;
@@ -56675,7 +57071,7 @@ function buildTypescriptBackend() {
     selectEntryPoints: selectEntryPoints3
   };
 }
-var PROFILE_ID4 = "typescript", IMPORT_REGEX_ES2, IMPORT_REGEX_BARE, IMPORT_REGEX_REQUIRE2, IMPORT_REGEX_DYNAMIC, IMPORT_REGEX_REEXPORT2, _internals32;
+var PROFILE_ID4 = "typescript", IMPORT_REGEX_ES2, IMPORT_REGEX_BARE, IMPORT_REGEX_REQUIRE2, IMPORT_REGEX_DYNAMIC, IMPORT_REGEX_REEXPORT2, _internals35;
 var init_typescript = __esm(() => {
   init_default_backend();
   init_profiles();
@@ -56684,7 +57080,7 @@ var init_typescript = __esm(() => {
   IMPORT_REGEX_REQUIRE2 = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
   IMPORT_REGEX_DYNAMIC = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
   IMPORT_REGEX_REEXPORT2 = /export\s+(?:\{[^}]*\}|\*)\s+from\s+['"]([^'"]+)['"]/g;
-  _internals32 = {
+  _internals35 = {
     readPackageJsonRaw,
     readPackageJsonTestScript,
     frameworkFromScriptsTest
@@ -56717,13 +57113,13 @@ __export(exports_dispatch, {
   pickedProfiles: () => pickedProfiles,
   pickBackend: () => pickBackend,
   clearDispatchCache: () => clearDispatchCache,
-  _internals: () => _internals33
+  _internals: () => _internals36
 });
-import * as fs27 from "fs";
-import * as path53 from "path";
+import * as fs28 from "fs";
+import * as path54 from "path";
 function safeReaddirSet(dir) {
   try {
-    return new Set(fs27.readdirSync(dir));
+    return new Set(fs28.readdirSync(dir));
   } catch {
     return new Set;
   }
@@ -56737,14 +57133,14 @@ function manifestHash(dir) {
     if (!entries.has(name))
       continue;
     try {
-      const stat5 = fs27.statSync(path53.join(dir, name));
+      const stat5 = fs28.statSync(path54.join(dir, name));
       parts.push(`${name}:${stat5.size}:${stat5.mtimeMs}:${stat5.ino}`);
     } catch {}
   }
   return parts.join("|");
 }
 function findManifestRoot(start) {
-  const resolved = path53.resolve(start);
+  const resolved = path54.resolve(start);
   const cached3 = manifestRootCache.get(resolved);
   if (cached3 !== undefined)
     return cached3;
@@ -56763,7 +57159,7 @@ function findManifestRoot(start) {
         return cur;
       }
     }
-    const parent = path53.dirname(cur);
+    const parent = path54.dirname(cur);
     if (parent === cur)
       break;
     cur = parent;
@@ -56772,7 +57168,7 @@ function findManifestRoot(start) {
   return start;
 }
 function evictIfNeeded() {
-  if (cache.size <= _internals33.cacheCapacity)
+  if (cache.size <= _internals36.cacheCapacity)
     return;
   let oldestKey;
   let oldestOrder = Infinity;
@@ -56803,7 +57199,7 @@ async function pickBackend(dir) {
     evictIfNeeded();
     return null;
   }
-  const profiles = await _internals33.detectProjectLanguages(root);
+  const profiles = await _internals36.detectProjectLanguages(root);
   if (profiles.length === 0) {
     cache.set(cacheKey, {
       hash: hash4,
@@ -56835,12 +57231,12 @@ function clearDispatchCache() {
   manifestRootCache.clear();
   insertCounter = 0;
 }
-var _internals33, cache, insertCounter = 0, MANIFEST_FILES, _MANIFEST_SET, manifestRootCache;
+var _internals36, cache, insertCounter = 0, MANIFEST_FILES, _MANIFEST_SET, manifestRootCache;
 var init_dispatch = __esm(() => {
   init_backends();
   init_detector();
   init_registry_backend();
-  _internals33 = {
+  _internals36 = {
     detectProjectLanguages,
     cacheCapacity: 64
   };
@@ -56872,14 +57268,14 @@ var init_dispatch = __esm(() => {
 });
 
 // src/tools/test-runner.ts
-import * as fs28 from "fs";
-import * as path54 from "path";
+import * as fs29 from "fs";
+import * as path55 from "path";
 async function estimateFanOut(sourceFiles, cwd) {
   try {
     const impactMap = await loadImpactMap(cwd, { skipRebuild: true });
     const uniqueTestFiles = new Set;
     for (const sourceFile of sourceFiles) {
-      const resolvedPath = path54.resolve(cwd, sourceFile);
+      const resolvedPath = path55.resolve(cwd, sourceFile);
       const normalizedPath = resolvedPath.replace(/\\/g, "/");
       const testFiles = impactMap[normalizedPath];
       if (testFiles) {
@@ -56961,19 +57357,19 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return fs28.existsSync(path54.join(cwd, "go.mod")) && isCommandAvailable("go");
+  return fs29.existsSync(path55.join(cwd, "go.mod")) && isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return fs28.existsSync(path54.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
+  return fs29.existsSync(path55.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  const hasBuildFile = fs28.existsSync(path54.join(cwd, "build.gradle")) || fs28.existsSync(path54.join(cwd, "build.gradle.kts"));
-  const hasGradlew = fs28.existsSync(path54.join(cwd, "gradlew")) || fs28.existsSync(path54.join(cwd, "gradlew.bat"));
+  const hasBuildFile = fs29.existsSync(path55.join(cwd, "build.gradle")) || fs29.existsSync(path55.join(cwd, "build.gradle.kts"));
+  const hasGradlew = fs29.existsSync(path55.join(cwd, "gradlew")) || fs29.existsSync(path55.join(cwd, "gradlew.bat"));
   return hasBuildFile && (hasGradlew || isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
   try {
-    const files = fs28.readdirSync(cwd);
+    const files = fs29.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj"));
     return hasCsproj && isCommandAvailable("dotnet");
   } catch {
@@ -56981,25 +57377,25 @@ function detectDotnetTest(cwd) {
   }
 }
 function detectCTest(cwd) {
-  const hasSource = fs28.existsSync(path54.join(cwd, "CMakeLists.txt"));
-  const hasBuildCache = fs28.existsSync(path54.join(cwd, "CMakeCache.txt")) || fs28.existsSync(path54.join(cwd, "build", "CMakeCache.txt"));
+  const hasSource = fs29.existsSync(path55.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = fs29.existsSync(path55.join(cwd, "CMakeCache.txt")) || fs29.existsSync(path55.join(cwd, "build", "CMakeCache.txt"));
   return (hasSource || hasBuildCache) && isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return fs28.existsSync(path54.join(cwd, "Package.swift")) && isCommandAvailable("swift");
+  return fs29.existsSync(path55.join(cwd, "Package.swift")) && isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return fs28.existsSync(path54.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs29.existsSync(path55.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  const hasRSpecFile = fs28.existsSync(path54.join(cwd, ".rspec"));
-  const hasGemfile = fs28.existsSync(path54.join(cwd, "Gemfile"));
-  const hasSpecDir = fs28.existsSync(path54.join(cwd, "spec"));
+  const hasRSpecFile = fs29.existsSync(path55.join(cwd, ".rspec"));
+  const hasGemfile = fs29.existsSync(path55.join(cwd, "Gemfile"));
+  const hasSpecDir = fs29.existsSync(path55.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
   return hasRSpec && (isCommandAvailable("bundle") || isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return fs28.existsSync(path54.join(cwd, "test")) && (fs28.existsSync(path54.join(cwd, "Gemfile")) || fs28.existsSync(path54.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
+  return fs29.existsSync(path55.join(cwd, "test")) && (fs29.existsSync(path55.join(cwd, "Gemfile")) || fs29.existsSync(path55.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
 }
 async function detectTestFrameworkViaDispatch(cwd) {
   try {
@@ -57062,9 +57458,9 @@ async function parseTestOutputViaDispatch(framework, output, baseDir) {
 async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
-    const packageJsonPath = path54.join(baseDir, "package.json");
-    if (fs28.existsSync(packageJsonPath)) {
-      const content = fs28.readFileSync(packageJsonPath, "utf-8");
+    const packageJsonPath = path55.join(baseDir, "package.json");
+    if (fs29.existsSync(packageJsonPath)) {
+      const content = fs29.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       const _deps = pkg.dependencies || {};
       const devDeps = pkg.devDependencies || {};
@@ -57083,38 +57479,38 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (fs28.existsSync(path54.join(baseDir, "bun.lockb")) || fs28.existsSync(path54.join(baseDir, "bun.lock"))) {
+      if (fs29.existsSync(path55.join(baseDir, "bun.lockb")) || fs29.existsSync(path55.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
     }
   } catch {}
   try {
-    const pyprojectTomlPath = path54.join(baseDir, "pyproject.toml");
-    const setupCfgPath = path54.join(baseDir, "setup.cfg");
-    const requirementsTxtPath = path54.join(baseDir, "requirements.txt");
-    if (fs28.existsSync(pyprojectTomlPath)) {
-      const content = fs28.readFileSync(pyprojectTomlPath, "utf-8");
+    const pyprojectTomlPath = path55.join(baseDir, "pyproject.toml");
+    const setupCfgPath = path55.join(baseDir, "setup.cfg");
+    const requirementsTxtPath = path55.join(baseDir, "requirements.txt");
+    if (fs29.existsSync(pyprojectTomlPath)) {
+      const content = fs29.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
         return "pytest";
       if (content.includes("pytest"))
         return "pytest";
     }
-    if (fs28.existsSync(setupCfgPath)) {
-      const content = fs28.readFileSync(setupCfgPath, "utf-8");
+    if (fs29.existsSync(setupCfgPath)) {
+      const content = fs29.readFileSync(setupCfgPath, "utf-8");
       if (content.includes("[pytest]"))
         return "pytest";
     }
-    if (fs28.existsSync(requirementsTxtPath)) {
-      const content = fs28.readFileSync(requirementsTxtPath, "utf-8");
+    if (fs29.existsSync(requirementsTxtPath)) {
+      const content = fs29.readFileSync(requirementsTxtPath, "utf-8");
       if (content.includes("pytest"))
         return "pytest";
     }
   } catch {}
   try {
-    const cargoTomlPath = path54.join(baseDir, "Cargo.toml");
-    if (fs28.existsSync(cargoTomlPath)) {
-      const content = fs28.readFileSync(cargoTomlPath, "utf-8");
+    const cargoTomlPath = path55.join(baseDir, "Cargo.toml");
+    if (fs29.existsSync(cargoTomlPath)) {
+      const content = fs29.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
         if (content.includes("tokio") || content.includes("mockall") || content.includes("pretty_assertions")) {
           return "cargo";
@@ -57123,10 +57519,10 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const pesterConfigPath = path54.join(baseDir, "pester.config.ps1");
-    const pesterConfigJsonPath = path54.join(baseDir, "pester.config.ps1.json");
-    const pesterPs1Path = path54.join(baseDir, "tests.ps1");
-    if (fs28.existsSync(pesterConfigPath) || fs28.existsSync(pesterConfigJsonPath) || fs28.existsSync(pesterPs1Path)) {
+    const pesterConfigPath = path55.join(baseDir, "pester.config.ps1");
+    const pesterConfigJsonPath = path55.join(baseDir, "pester.config.ps1.json");
+    const pesterPs1Path = path55.join(baseDir, "tests.ps1");
+    if (fs29.existsSync(pesterConfigPath) || fs29.existsSync(pesterConfigJsonPath) || fs29.existsSync(pesterPs1Path)) {
       return "pester";
     }
   } catch {}
@@ -57154,12 +57550,12 @@ function isTestDirectoryPath(normalizedPath) {
   return normalizedPath.split("/").some((segment) => TEST_DIRECTORY_NAMES.includes(segment));
 }
 function resolveWorkspacePath(file3, workingDir) {
-  return path54.isAbsolute(file3) ? path54.resolve(file3) : path54.resolve(workingDir, file3);
+  return path55.isAbsolute(file3) ? path55.resolve(file3) : path55.resolve(workingDir, file3);
 }
 function toWorkspaceOutputPath(absolutePath, workingDir, preferRelative) {
   if (!preferRelative)
     return absolutePath;
-  return path54.relative(workingDir, absolutePath);
+  return path55.relative(workingDir, absolutePath);
 }
 function dedupePush(target, value) {
   if (!target.includes(value)) {
@@ -57196,18 +57592,18 @@ function buildLanguageSpecificTestNames(nameWithoutExt, ext) {
   }
 }
 function getRepoLevelCandidateDirectories(workingDir, relativePath, ext) {
-  const relativeDir = path54.dirname(relativePath);
+  const relativeDir = path55.dirname(relativePath);
   const nestedRelativeDir = relativeDir === "." ? "" : relativeDir;
   const directories = TEST_DIRECTORY_NAMES.flatMap((dirName) => {
-    const rootDir = path54.join(workingDir, dirName);
-    return nestedRelativeDir ? [rootDir, path54.join(rootDir, nestedRelativeDir)] : [rootDir];
+    const rootDir = path55.join(workingDir, dirName);
+    return nestedRelativeDir ? [rootDir, path55.join(rootDir, nestedRelativeDir)] : [rootDir];
   });
   const normalizedRelativePath = relativePath.replace(/\\/g, "/");
   if (ext === ".java" && normalizedRelativePath.startsWith("src/main/java/")) {
-    directories.push(path54.join(workingDir, "src/test/java", path54.dirname(normalizedRelativePath.slice("src/main/java/".length))));
+    directories.push(path55.join(workingDir, "src/test/java", path55.dirname(normalizedRelativePath.slice("src/main/java/".length))));
   }
   if ((ext === ".kt" || ext === ".java") && normalizedRelativePath.startsWith("src/main/kotlin/")) {
-    directories.push(path54.join(workingDir, "src/test/kotlin", path54.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
+    directories.push(path55.join(workingDir, "src/test/kotlin", path55.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
   }
   return [...new Set(directories)];
 }
@@ -57235,23 +57631,23 @@ function isLanguageSpecificTestFile(basename9) {
 }
 function isConventionTestFilePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
-  const basename9 = path54.basename(filePath);
+  const basename9 = path55.basename(filePath);
   return hasCompoundTestExtension(basename9) || basename9.includes(".spec.") || basename9.includes(".test.") || isLanguageSpecificTestFile(basename9) || isTestDirectoryPath(normalizedPath);
 }
 function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
   const testFiles = [];
   for (const file3 of sourceFiles) {
     const absoluteFile = resolveWorkspacePath(file3, workingDir);
-    const relativeFile = path54.relative(workingDir, absoluteFile);
-    const basename9 = path54.basename(absoluteFile);
-    const dirname31 = path54.dirname(absoluteFile);
-    const preferRelativeOutput = !path54.isAbsolute(file3);
+    const relativeFile = path55.relative(workingDir, absoluteFile);
+    const basename9 = path55.basename(absoluteFile);
+    const dirname31 = path55.dirname(absoluteFile);
+    const preferRelativeOutput = !path55.isAbsolute(file3);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file3)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
       continue;
     }
     const nameWithoutExt = basename9.replace(/\.[^.]+$/, "");
-    const ext = path54.extname(basename9);
+    const ext = path55.extname(basename9);
     const genericTestNames = [
       `${nameWithoutExt}.spec${ext}`,
       `${nameWithoutExt}.test${ext}`
@@ -57260,7 +57656,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const colocatedCandidates = [
       ...genericTestNames,
       ...languageSpecificTestNames
-    ].map((candidateName) => path54.join(dirname31, candidateName));
+    ].map((candidateName) => path55.join(dirname31, candidateName));
     const testDirectoryNames = [
       basename9,
       ...genericTestNames,
@@ -57269,11 +57665,11 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const repoLevelDirectories = getRepoLevelCandidateDirectories(workingDir, relativeFile, ext);
     const possibleTestFiles = [
       ...colocatedCandidates,
-      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path54.join(dirname31, dirName, candidateName))),
-      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path54.join(candidateDir, candidateName)))
+      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path55.join(dirname31, dirName, candidateName))),
+      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path55.join(candidateDir, candidateName)))
     ];
     for (const testFile of possibleTestFiles) {
-      if (fs28.existsSync(testFile)) {
+      if (fs29.existsSync(testFile)) {
         dedupePush(testFiles, toWorkspaceOutputPath(testFile, workingDir, preferRelativeOutput));
       }
     }
@@ -57290,8 +57686,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
   for (const testFile of candidateTestFiles) {
     try {
       const absoluteTestFile = resolveWorkspacePath(testFile, workingDir);
-      const content = fs28.readFileSync(absoluteTestFile, "utf-8");
-      const testDir = path54.dirname(absoluteTestFile);
+      const content = fs29.readFileSync(absoluteTestFile, "utf-8");
+      const testDir = path55.dirname(absoluteTestFile);
       const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
       let match;
       match = importRegex.exec(content);
@@ -57299,8 +57695,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         const importPath = match[1];
         let resolvedImport;
         if (importPath.startsWith(".")) {
-          resolvedImport = path54.resolve(testDir, importPath);
-          const existingExt = path54.extname(resolvedImport);
+          resolvedImport = path55.resolve(testDir, importPath);
+          const existingExt = path55.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -57311,7 +57707,7 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               ".cjs"
             ]) {
               const withExt = resolvedImport + extToTry;
-              if (absoluteSourceFiles.includes(withExt) || fs28.existsSync(withExt)) {
+              if (absoluteSourceFiles.includes(withExt) || fs29.existsSync(withExt)) {
                 resolvedImport = withExt;
                 break;
               }
@@ -57320,12 +57716,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         } else {
           continue;
         }
-        const importBasename = path54.basename(resolvedImport, path54.extname(resolvedImport));
-        const importDir = path54.dirname(resolvedImport);
+        const importBasename = path55.basename(resolvedImport, path55.extname(resolvedImport));
+        const importDir = path55.dirname(resolvedImport);
         for (const sourceFile of absoluteSourceFiles) {
-          const sourceDir = path54.dirname(sourceFile);
-          const sourceBasename = path54.basename(sourceFile, path54.extname(sourceFile));
-          const isRelatedDir = importDir === sourceDir || importDir === path54.join(sourceDir, "__tests__") || importDir === path54.join(sourceDir, "tests") || importDir === path54.join(sourceDir, "test") || importDir === path54.join(sourceDir, "spec");
+          const sourceDir = path55.dirname(sourceFile);
+          const sourceBasename = path55.basename(sourceFile, path55.extname(sourceFile));
+          const isRelatedDir = importDir === sourceDir || importDir === path55.join(sourceDir, "__tests__") || importDir === path55.join(sourceDir, "tests") || importDir === path55.join(sourceDir, "test") || importDir === path55.join(sourceDir, "spec");
           if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
             dedupePush(testFiles, testFile);
             break;
@@ -57338,8 +57734,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
       while (match !== null) {
         const importPath = match[1];
         if (importPath.startsWith(".")) {
-          let resolvedImport = path54.resolve(testDir, importPath);
-          const existingExt = path54.extname(resolvedImport);
+          let resolvedImport = path55.resolve(testDir, importPath);
+          const existingExt = path55.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -57350,18 +57746,18 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               ".cjs"
             ]) {
               const withExt = resolvedImport + extToTry;
-              if (absoluteSourceFiles.includes(withExt) || fs28.existsSync(withExt)) {
+              if (absoluteSourceFiles.includes(withExt) || fs29.existsSync(withExt)) {
                 resolvedImport = withExt;
                 break;
               }
             }
           }
-          const importDir = path54.dirname(resolvedImport);
-          const importBasename = path54.basename(resolvedImport, path54.extname(resolvedImport));
+          const importDir = path55.dirname(resolvedImport);
+          const importBasename = path55.basename(resolvedImport, path55.extname(resolvedImport));
           for (const sourceFile of absoluteSourceFiles) {
-            const sourceDir = path54.dirname(sourceFile);
-            const sourceBasename = path54.basename(sourceFile, path54.extname(sourceFile));
-            const isRelatedDir = importDir === sourceDir || importDir === path54.join(sourceDir, "__tests__") || importDir === path54.join(sourceDir, "tests") || importDir === path54.join(sourceDir, "test") || importDir === path54.join(sourceDir, "spec");
+            const sourceDir = path55.dirname(sourceFile);
+            const sourceBasename = path55.basename(sourceFile, path55.extname(sourceFile));
+            const isRelatedDir = importDir === sourceDir || importDir === path55.join(sourceDir, "__tests__") || importDir === path55.join(sourceDir, "tests") || importDir === path55.join(sourceDir, "test") || importDir === path55.join(sourceDir, "spec");
             if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
               dedupePush(testFiles, testFile);
               break;
@@ -57481,8 +57877,8 @@ function buildTestCommand2(framework, scope, files, coverage, baseDir, bail) {
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs28.existsSync(path54.join(baseDir, "gradlew.bat"));
-      const hasGradlew = fs28.existsSync(path54.join(baseDir, "gradlew"));
+      const hasGradlewBat = fs29.existsSync(path55.join(baseDir, "gradlew.bat"));
+      const hasGradlew = fs29.existsSync(path55.join(baseDir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -57499,7 +57895,7 @@ function buildTestCommand2(framework, scope, files, coverage, baseDir, bail) {
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs28.existsSync(path54.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs29.existsSync(path55.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -57933,13 +58329,13 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
     };
   }
   const startTime = Date.now();
-  const vitestJsonOutputPath = framework === "vitest" ? path54.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
+  const vitestJsonOutputPath = framework === "vitest" ? path55.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
   try {
     if (vitestJsonOutputPath) {
       try {
-        fs28.mkdirSync(path54.dirname(vitestJsonOutputPath), { recursive: true });
-        if (fs28.existsSync(vitestJsonOutputPath)) {
-          fs28.unlinkSync(vitestJsonOutputPath);
+        fs29.mkdirSync(path55.dirname(vitestJsonOutputPath), { recursive: true });
+        if (fs29.existsSync(vitestJsonOutputPath)) {
+          fs29.unlinkSync(vitestJsonOutputPath);
         }
       } catch {}
     }
@@ -57948,9 +58344,9 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
       stderr: "pipe",
       cwd
     });
-    const timeoutPromise = new Promise((resolve19) => setTimeout(() => {
+    const timeoutPromise = new Promise((resolve20) => setTimeout(() => {
       proc.kill();
-      resolve19(-1);
+      resolve20(-1);
     }, timeout_ms));
     const [exitCode, stdoutResult, stderrResult] = await Promise.all([
       Promise.race([proc.exited, timeoutPromise]),
@@ -57965,8 +58361,8 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
     }
     if (vitestJsonOutputPath) {
       try {
-        if (fs28.existsSync(vitestJsonOutputPath)) {
-          const vitestJsonOutput = fs28.readFileSync(vitestJsonOutputPath, "utf-8");
+        if (fs29.existsSync(vitestJsonOutputPath)) {
+          const vitestJsonOutput = fs29.readFileSync(vitestJsonOutputPath, "utf-8");
           if (vitestJsonOutput.trim().length > 0) {
             output += (output ? `
 ` : "") + vitestJsonOutput;
@@ -58053,10 +58449,10 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
 }
 function normalizeHistoryTestFile(testFile, workingDir) {
   const normalized = testFile.replace(/\\/g, "/");
-  if (!path54.isAbsolute(testFile))
+  if (!path55.isAbsolute(testFile))
     return normalized;
-  const relative11 = path54.relative(workingDir, testFile);
-  if (relative11.startsWith("..") || path54.isAbsolute(relative11)) {
+  const relative11 = path55.relative(workingDir, testFile);
+  if (relative11.startsWith("..") || path55.isAbsolute(relative11)) {
     return normalized;
   }
   return relative11.replace(/\\/g, "/");
@@ -58394,7 +58790,7 @@ var init_test_runner = __esm(() => {
         const sourceFiles = args.files.filter((file3) => {
           if (directTestFiles.includes(file3))
             return false;
-          const ext = path54.extname(file3).toLowerCase();
+          const ext = path55.extname(file3).toLowerCase();
           return SOURCE_EXTENSIONS.has(ext);
         });
         const invalidFiles = args.files.filter((file3) => !directTestFiles.includes(file3) && !sourceFiles.includes(file3));
@@ -58440,7 +58836,7 @@ var init_test_runner = __esm(() => {
           if (isConventionTestFilePath(f)) {
             return false;
           }
-          const ext = path54.extname(f).toLowerCase();
+          const ext = path55.extname(f).toLowerCase();
           return SOURCE_EXTENSIONS.has(ext);
         });
         if (sourceFiles.length === 0) {
@@ -58490,7 +58886,7 @@ var init_test_runner = __esm(() => {
           if (isConventionTestFilePath(f)) {
             return false;
           }
-          const ext = path54.extname(f).toLowerCase();
+          const ext = path55.extname(f).toLowerCase();
           return SOURCE_EXTENSIONS.has(ext);
         });
         if (sourceFiles.length === 0) {
@@ -58542,8 +58938,8 @@ var init_test_runner = __esm(() => {
           }
           if (impactResult.impactedTests.length > 0) {
             testFiles = impactResult.impactedTests.map((absPath) => {
-              const relativePath = path54.relative(workingDir, absPath);
-              return path54.isAbsolute(relativePath) ? absPath : relativePath;
+              const relativePath = path55.relative(workingDir, absPath);
+              return path55.isAbsolute(relativePath) ? absPath : relativePath;
             });
           } else {
             graphFallbackReason = "no impacted tests found via impact analysis, falling back to graph";
@@ -58621,8 +59017,8 @@ var init_test_runner = __esm(() => {
 });
 
 // src/services/preflight-service.ts
-import * as fs29 from "fs";
-import * as path55 from "path";
+import * as fs30 from "fs";
+import * as path56 from "path";
 function validateDirectoryPath(dir) {
   if (!dir || typeof dir !== "string") {
     throw new Error("Directory path is required");
@@ -58630,8 +59026,8 @@ function validateDirectoryPath(dir) {
   if (dir.includes("..")) {
     throw new Error("Directory path must not contain path traversal sequences");
   }
-  const normalized = path55.normalize(dir);
-  const absolutePath = path55.isAbsolute(normalized) ? normalized : path55.resolve(normalized);
+  const normalized = path56.normalize(dir);
+  const absolutePath = path56.isAbsolute(normalized) ? normalized : path56.resolve(normalized);
   return absolutePath;
 }
 function validateTimeout(timeoutMs, defaultValue) {
@@ -58654,9 +59050,9 @@ function validateTimeout(timeoutMs, defaultValue) {
 }
 function getPackageVersion(dir) {
   try {
-    const packagePath = path55.join(dir, "package.json");
-    if (fs29.existsSync(packagePath)) {
-      const content = fs29.readFileSync(packagePath, "utf-8");
+    const packagePath = path56.join(dir, "package.json");
+    if (fs30.existsSync(packagePath)) {
+      const content = fs30.readFileSync(packagePath, "utf-8");
       const pkg = JSON.parse(content);
       return pkg.version ?? null;
     }
@@ -58665,9 +59061,9 @@ function getPackageVersion(dir) {
 }
 function getChangelogVersion(dir) {
   try {
-    const changelogPath = path55.join(dir, "CHANGELOG.md");
-    if (fs29.existsSync(changelogPath)) {
-      const content = fs29.readFileSync(changelogPath, "utf-8");
+    const changelogPath = path56.join(dir, "CHANGELOG.md");
+    if (fs30.existsSync(changelogPath)) {
+      const content = fs30.readFileSync(changelogPath, "utf-8");
       const match = content.match(/^##\s*\[?(\d+\.\d+\.\d+)\]?/m);
       if (match) {
         return match[1];
@@ -58679,10 +59075,10 @@ function getChangelogVersion(dir) {
 function getVersionFileVersion(dir) {
   const possibleFiles = ["VERSION.txt", "version.txt", "VERSION", "version"];
   for (const file3 of possibleFiles) {
-    const filePath = path55.join(dir, file3);
-    if (fs29.existsSync(filePath)) {
+    const filePath = path56.join(dir, file3);
+    if (fs30.existsSync(filePath)) {
       try {
-        const content = fs29.readFileSync(filePath, "utf-8").trim();
+        const content = fs30.readFileSync(filePath, "utf-8").trim();
         const match = content.match(/(\d+\.\d+\.\d+)/);
         if (match) {
           return match[1];
@@ -58695,9 +59091,9 @@ function getVersionFileVersion(dir) {
 async function runVersionCheck(dir, _timeoutMs) {
   const startTime = Date.now();
   try {
-    const packageVersion = _internals34.getPackageVersion(dir);
-    const changelogVersion = _internals34.getChangelogVersion(dir);
-    const versionFileVersion = _internals34.getVersionFileVersion(dir);
+    const packageVersion = _internals37.getPackageVersion(dir);
+    const changelogVersion = _internals37.getChangelogVersion(dir);
+    const versionFileVersion = _internals37.getVersionFileVersion(dir);
     const versions3 = [];
     if (packageVersion)
       versions3.push(`package.json: ${packageVersion}`);
@@ -59061,7 +59457,7 @@ async function runPreflight(dir, phase, config3) {
   const reportId = `preflight-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   let validatedDir;
   try {
-    validatedDir = _internals34.validateDirectoryPath(dir);
+    validatedDir = _internals37.validateDirectoryPath(dir);
   } catch (error93) {
     return {
       id: reportId,
@@ -59081,7 +59477,7 @@ async function runPreflight(dir, phase, config3) {
   }
   let validatedTimeout;
   try {
-    validatedTimeout = _internals34.validateTimeout(config3?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
+    validatedTimeout = _internals37.validateTimeout(config3?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
   } catch (error93) {
     return {
       id: reportId,
@@ -59122,12 +59518,12 @@ async function runPreflight(dir, phase, config3) {
   });
   const checks5 = [];
   log("[Preflight] Running lint check...");
-  const lintResult = await _internals34.runLintCheck(validatedDir, cfg.linter, cfg.checkTimeoutMs);
+  const lintResult = await _internals37.runLintCheck(validatedDir, cfg.linter, cfg.checkTimeoutMs);
   checks5.push(lintResult);
   log(`[Preflight] Lint check: ${lintResult.status} ${lintResult.message}`);
   if (!cfg.skipTests) {
     log("[Preflight] Running tests check...");
-    const testsResult = await _internals34.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
+    const testsResult = await _internals37.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
     checks5.push(testsResult);
     log(`[Preflight] Tests check: ${testsResult.status} ${testsResult.message}`);
   } else {
@@ -59139,7 +59535,7 @@ async function runPreflight(dir, phase, config3) {
   }
   if (!cfg.skipSecrets) {
     log("[Preflight] Running secrets check...");
-    const secretsResult = await _internals34.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
+    const secretsResult = await _internals37.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
     checks5.push(secretsResult);
     log(`[Preflight] Secrets check: ${secretsResult.status} ${secretsResult.message}`);
   } else {
@@ -59151,7 +59547,7 @@ async function runPreflight(dir, phase, config3) {
   }
   if (!cfg.skipEvidence) {
     log("[Preflight] Running evidence check...");
-    const evidenceResult = await _internals34.runEvidenceCheck(validatedDir);
+    const evidenceResult = await _internals37.runEvidenceCheck(validatedDir);
     checks5.push(evidenceResult);
     log(`[Preflight] Evidence check: ${evidenceResult.status} ${evidenceResult.message}`);
   } else {
@@ -59162,12 +59558,12 @@ async function runPreflight(dir, phase, config3) {
     });
   }
   log("[Preflight] Running requirement coverage check...");
-  const reqCoverageResult = await _internals34.runRequirementCoverageCheck(validatedDir, phase);
+  const reqCoverageResult = await _internals37.runRequirementCoverageCheck(validatedDir, phase);
   checks5.push(reqCoverageResult);
   log(`[Preflight] Requirement coverage check: ${reqCoverageResult.status} ${reqCoverageResult.message}`);
   if (!cfg.skipVersion) {
     log("[Preflight] Running version check...");
-    const versionResult = await _internals34.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
+    const versionResult = await _internals37.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
     checks5.push(versionResult);
     log(`[Preflight] Version check: ${versionResult.status} ${versionResult.message}`);
   } else {
@@ -59230,10 +59626,10 @@ function formatPreflightMarkdown(report) {
 async function handlePreflightCommand(directory, _args) {
   const plan = await loadPlan(directory);
   const phase = plan?.current_phase ?? 1;
-  const report = await _internals34.runPreflight(directory, phase);
-  return _internals34.formatPreflightMarkdown(report);
+  const report = await _internals37.runPreflight(directory, phase);
+  return _internals37.formatPreflightMarkdown(report);
 }
-var MIN_CHECK_TIMEOUT_MS = 5000, MAX_CHECK_TIMEOUT_MS = 300000, DEFAULT_CONFIG, _internals34;
+var MIN_CHECK_TIMEOUT_MS = 5000, MAX_CHECK_TIMEOUT_MS = 300000, DEFAULT_CONFIG, _internals37;
 var init_preflight_service = __esm(() => {
   init_gate_bridge();
   init_manager2();
@@ -59252,7 +59648,7 @@ var init_preflight_service = __esm(() => {
     testScope: "convention",
     linter: "biome"
   };
-  _internals34 = {
+  _internals37 = {
     runPreflight,
     formatPreflightMarkdown,
     handlePreflightCommand,
@@ -59500,13 +59896,13 @@ class CircuitBreaker {
     if (this.config.callTimeoutMs <= 0) {
       return fn();
     }
-    return new Promise((resolve20, reject) => {
+    return new Promise((resolve21, reject) => {
       const timeout = setTimeout(() => {
         reject(new Error(`Call timeout after ${this.config.callTimeoutMs}ms`));
       }, this.config.callTimeoutMs);
       fn().then((result) => {
         clearTimeout(timeout);
-        resolve20(result);
+        resolve21(result);
       }).catch((error93) => {
         clearTimeout(timeout);
         reject(error93);
@@ -59793,7 +60189,7 @@ var init_queue = __esm(() => {
 
 // src/background/worker.ts
 function sleep(ms) {
-  return new Promise((resolve20) => setTimeout(resolve20, ms));
+  return new Promise((resolve21) => setTimeout(resolve21, ms));
 }
 
 class WorkerManager {
@@ -60138,8 +60534,8 @@ var init_manager3 = __esm(() => {
 });
 
 // src/commands/reset.ts
-import * as fs30 from "fs";
-import * as path56 from "path";
+import * as fs31 from "fs";
+import * as path57 from "path";
 async function handleResetCommand(directory, args) {
   const hasConfirm = args.includes("--confirm");
   if (!hasConfirm) {
@@ -60167,8 +60563,8 @@ async function handleResetCommand(directory, args) {
   for (const filename of filesToReset) {
     try {
       const resolvedPath = validateSwarmPath(directory, filename);
-      if (fs30.existsSync(resolvedPath)) {
-        fs30.unlinkSync(resolvedPath);
+      if (fs31.existsSync(resolvedPath)) {
+        fs31.unlinkSync(resolvedPath);
         results.push(`- \u2705 Deleted ${filename}`);
       } else {
         results.push(`- \u23ED\uFE0F ${filename} not found (skipped)`);
@@ -60179,9 +60575,9 @@ async function handleResetCommand(directory, args) {
   }
   for (const filename of ["SWARM_PLAN.md", "SWARM_PLAN.json"]) {
     try {
-      const rootPath = path56.join(directory, filename);
-      if (fs30.existsSync(rootPath)) {
-        fs30.unlinkSync(rootPath);
+      const rootPath = path57.join(directory, filename);
+      if (fs31.existsSync(rootPath)) {
+        fs31.unlinkSync(rootPath);
         results.push(`- \u2705 Deleted ${filename} (root)`);
       }
     } catch {}
@@ -60194,8 +60590,8 @@ async function handleResetCommand(directory, args) {
   }
   try {
     const summariesPath = validateSwarmPath(directory, "summaries");
-    if (fs30.existsSync(summariesPath)) {
-      fs30.rmSync(summariesPath, { recursive: true, force: true });
+    if (fs31.existsSync(summariesPath)) {
+      fs31.rmSync(summariesPath, { recursive: true, force: true });
       results.push("- \u2705 Deleted summaries/ directory");
     } else {
       results.push("- \u23ED\uFE0F summaries/ not found (skipped)");
@@ -60218,14 +60614,14 @@ var init_reset = __esm(() => {
 });
 
 // src/commands/reset-session.ts
-import * as fs31 from "fs";
-import * as path57 from "path";
+import * as fs32 from "fs";
+import * as path58 from "path";
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
     const statePath = validateSwarmPath(directory, "session/state.json");
-    if (fs31.existsSync(statePath)) {
-      fs31.unlinkSync(statePath);
+    if (fs32.existsSync(statePath)) {
+      fs32.unlinkSync(statePath);
       results.push("\u2705 Deleted .swarm/session/state.json");
     } else {
       results.push("\u23ED\uFE0F state.json not found (already clean)");
@@ -60234,15 +60630,15 @@ async function handleResetSessionCommand(directory, _args) {
     results.push("\u274C Failed to delete state.json");
   }
   try {
-    const sessionDir = path57.dirname(validateSwarmPath(directory, "session/state.json"));
-    if (fs31.existsSync(sessionDir)) {
-      const files = fs31.readdirSync(sessionDir);
+    const sessionDir = path58.dirname(validateSwarmPath(directory, "session/state.json"));
+    if (fs32.existsSync(sessionDir)) {
+      const files = fs32.readdirSync(sessionDir);
       const otherFiles = files.filter((f) => f !== "state.json");
       let deletedCount = 0;
       for (const file3 of otherFiles) {
-        const filePath = path57.join(sessionDir, file3);
-        if (fs31.lstatSync(filePath).isFile()) {
-          fs31.unlinkSync(filePath);
+        const filePath = path58.join(sessionDir, file3);
+        if (fs32.lstatSync(filePath).isFile()) {
+          fs32.unlinkSync(filePath);
           deletedCount++;
         }
       }
@@ -60272,7 +60668,7 @@ var init_reset_session = __esm(() => {
 });
 
 // src/summaries/manager.ts
-import * as path58 from "path";
+import * as path59 from "path";
 function sanitizeSummaryId(id) {
   if (!id || id.length === 0) {
     throw new Error("Invalid summary ID: empty string");
@@ -60295,7 +60691,7 @@ function sanitizeSummaryId(id) {
 }
 async function loadFullOutput(directory, id) {
   const sanitizedId = sanitizeSummaryId(id);
-  const relativePath = path58.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path59.join("summaries", `${sanitizedId}.json`);
   validateSwarmPath(directory, relativePath);
   const content = await readSwarmFileAsync(directory, relativePath);
   if (content === null) {
@@ -60357,18 +60753,18 @@ var init_retrieve = __esm(() => {
 });
 
 // src/commands/rollback.ts
-import * as fs32 from "fs";
-import * as path59 from "path";
+import * as fs33 from "fs";
+import * as path60 from "path";
 async function handleRollbackCommand(directory, args) {
   const phaseArg = args[0];
   if (!phaseArg) {
     const manifestPath2 = validateSwarmPath(directory, "checkpoints/manifest.json");
-    if (!fs32.existsSync(manifestPath2)) {
+    if (!fs33.existsSync(manifestPath2)) {
       return "No checkpoints found. Use `/swarm checkpoint` to create checkpoints.";
     }
     let manifest2;
     try {
-      manifest2 = JSON.parse(fs32.readFileSync(manifestPath2, "utf-8"));
+      manifest2 = JSON.parse(fs33.readFileSync(manifestPath2, "utf-8"));
     } catch {
       return "Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.";
     }
@@ -60390,12 +60786,12 @@ async function handleRollbackCommand(directory, args) {
     return "Error: Phase number must be a positive integer.";
   }
   const manifestPath = validateSwarmPath(directory, "checkpoints/manifest.json");
-  if (!fs32.existsSync(manifestPath)) {
+  if (!fs33.existsSync(manifestPath)) {
     return `Error: No checkpoints found. Cannot rollback to phase ${targetPhase}.`;
   }
   let manifest;
   try {
-    manifest = JSON.parse(fs32.readFileSync(manifestPath, "utf-8"));
+    manifest = JSON.parse(fs33.readFileSync(manifestPath, "utf-8"));
   } catch {
     return `Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.`;
   }
@@ -60405,10 +60801,10 @@ async function handleRollbackCommand(directory, args) {
     return `Error: Checkpoint for phase ${targetPhase} not found. Available phases: ${available}`;
   }
   const checkpointDir = validateSwarmPath(directory, `checkpoints/phase-${targetPhase}`);
-  if (!fs32.existsSync(checkpointDir)) {
+  if (!fs33.existsSync(checkpointDir)) {
     return `Error: Checkpoint directory for phase ${targetPhase} does not exist.`;
   }
-  const checkpointFiles = fs32.readdirSync(checkpointDir);
+  const checkpointFiles = fs33.readdirSync(checkpointDir);
   if (checkpointFiles.length === 0) {
     return `Error: Checkpoint for phase ${targetPhase} is empty. Cannot rollback.`;
   }
@@ -60423,10 +60819,10 @@ async function handleRollbackCommand(directory, args) {
     if (EXCLUDE_FILES.has(file3) || file3.startsWith("plan-ledger.archived-")) {
       continue;
     }
-    const src = path59.join(checkpointDir, file3);
-    const dest = path59.join(swarmDir, file3);
+    const src = path60.join(checkpointDir, file3);
+    const dest = path60.join(swarmDir, file3);
     try {
-      fs32.cpSync(src, dest, { recursive: true, force: true });
+      fs33.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file3);
     } catch (error93) {
       failures.push({ file: file3, error: error93.message });
@@ -60443,14 +60839,14 @@ async function handleRollbackCommand(directory, args) {
     ].join(`
 `);
   }
-  const existingLedgerPath = path59.join(swarmDir, "plan-ledger.jsonl");
-  if (fs32.existsSync(existingLedgerPath)) {
-    fs32.unlinkSync(existingLedgerPath);
+  const existingLedgerPath = path60.join(swarmDir, "plan-ledger.jsonl");
+  if (fs33.existsSync(existingLedgerPath)) {
+    fs33.unlinkSync(existingLedgerPath);
   }
   try {
-    const planJsonPath = path59.join(swarmDir, "plan.json");
-    if (fs32.existsSync(planJsonPath)) {
-      const planRaw = fs32.readFileSync(planJsonPath, "utf-8");
+    const planJsonPath = path60.join(swarmDir, "plan.json");
+    if (fs33.existsSync(planJsonPath)) {
+      const planRaw = fs33.readFileSync(planJsonPath, "utf-8");
       const plan = PlanSchema.parse(JSON.parse(planRaw));
       const planId = derivePlanId(plan);
       const planHash = computePlanHash(plan);
@@ -60477,7 +60873,7 @@ async function handleRollbackCommand(directory, args) {
     timestamp: new Date().toISOString()
   };
   try {
-    fs32.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
+    fs33.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
 `);
   } catch (error93) {
     console.error("Failed to write rollback event:", error93 instanceof Error ? error93.message : String(error93));
@@ -60706,11 +61102,11 @@ Ensure this is a git repository with commit history.`;
   const report = reportLines.filter(Boolean).join(`
 `);
   try {
-    const fs33 = await import("fs/promises");
-    const path60 = await import("path");
-    const reportPath = path60.join(directory, ".swarm", "simulate-report.md");
-    await fs33.mkdir(path60.dirname(reportPath), { recursive: true });
-    await fs33.writeFile(reportPath, report, "utf-8");
+    const fs34 = await import("fs/promises");
+    const path61 = await import("path");
+    const reportPath = path61.join(directory, ".swarm", "simulate-report.md");
+    await fs34.mkdir(path61.dirname(reportPath), { recursive: true });
+    await fs34.writeFile(reportPath, report, "utf-8");
   } catch (err) {
     const writeErr = err instanceof Error ? err.message : String(err);
     warn(`simulate: failed to write report to ${directory}/.swarm/simulate-report.md`, writeErr);
@@ -60764,15 +61160,15 @@ var init_knowledge_escalator = __esm(() => {
 });
 
 // src/turbo/lean/state.ts
-import * as fs33 from "fs";
-import * as path60 from "path";
+import * as fs34 from "fs";
+import * as path61 from "path";
 function nowISO2() {
   return new Date().toISOString();
 }
-function ensureSwarmDir2(directory) {
-  const swarmDir = path60.resolve(directory, ".swarm");
-  if (!fs33.existsSync(swarmDir)) {
-    fs33.mkdirSync(swarmDir, { recursive: true });
+function ensureSwarmDir3(directory) {
+  const swarmDir = path61.resolve(directory, ".swarm");
+  if (!fs34.existsSync(swarmDir)) {
+    fs34.mkdirSync(swarmDir, { recursive: true });
   }
   return swarmDir;
 }
@@ -60814,17 +61210,17 @@ function markStateUnreadable2(directory, reason) {
 }
 function readPersisted2(directory) {
   try {
-    const filePath = path60.join(directory, ".swarm", STATE_FILE2);
-    if (!fs33.existsSync(filePath)) {
+    const filePath = path61.join(directory, ".swarm", STATE_FILE2);
+    if (!fs34.existsSync(filePath)) {
       const seed = emptyPersisted2();
       try {
-        ensureSwarmDir2(directory);
-        fs33.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
+        ensureSwarmDir3(directory);
+        fs34.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
 `, "utf-8");
       } catch {}
       return seed;
     }
-    const raw = fs33.readFileSync(filePath, "utf-8");
+    const raw = fs34.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || parsed.version !== 1 || !parsed.sessions || typeof parsed.sessions !== "object" || Array.isArray(parsed.sessions)) {
       markStateUnreadable2(directory, `malformed shape (version=${parsed?.version}, sessions type=${Array.isArray(parsed?.sessions) ? "array" : typeof parsed?.sessions})`);
@@ -60849,8 +61245,8 @@ function writePersisted2(directory, persisted) {
   let tmpPath;
   let payload;
   try {
-    ensureSwarmDir2(directory);
-    filePath = path60.join(directory, ".swarm", STATE_FILE2);
+    ensureSwarmDir3(directory);
+    filePath = path61.join(directory, ".swarm", STATE_FILE2);
     tmpPath = `${filePath}.tmp.${Date.now()}`;
     persisted.updatedAt = nowISO2();
     payload = `${JSON.stringify(persisted, null, 2)}
@@ -60861,14 +61257,14 @@ function writePersisted2(directory, persisted) {
     throw new Error(`Lean Turbo state persistence prepare failed: ${msg}`);
   }
   try {
-    fs33.writeFileSync(tmpPath, payload, "utf-8");
-    fs33.renameSync(tmpPath, filePath);
+    fs34.writeFileSync(tmpPath, payload, "utf-8");
+    fs34.renameSync(tmpPath, filePath);
   } catch (error93) {
     const msg = error93 instanceof Error ? error93.message : String(error93);
     error(`[turbo/lean/state] Failed to persist ${STATE_FILE2} atomically: ${msg}`);
     try {
-      if (fs33.existsSync(tmpPath)) {
-        fs33.unlinkSync(tmpPath);
+      if (fs34.existsSync(tmpPath)) {
+        fs34.unlinkSync(tmpPath);
       }
     } catch {}
     throw new Error(`Lean Turbo state persistence failed: ${msg}`);
@@ -60977,10 +61373,10 @@ var init_context_budget_service = __esm(() => {
 
 // src/services/status-service.ts
 import * as fsSync3 from "fs";
-import * as path61 from "path";
+import * as path62 from "path";
 function readSpecStalenessSnapshot(directory) {
   try {
-    const p = path61.join(directory, ".swarm", "spec-staleness.json");
+    const p = path62.join(directory, ".swarm", "spec-staleness.json");
     if (!fsSync3.existsSync(p))
       return { stale: false };
     const raw = fsSync3.readFileSync(p, "utf-8");
@@ -61075,7 +61471,7 @@ async function getStatusData(directory, agents) {
 }
 function enrichWithLeanTurbo(status, directory) {
   const turboMode = hasActiveTurboMode();
-  const leanActive = _internals35.hasActiveLeanTurbo();
+  const leanActive = _internals38.hasActiveLeanTurbo();
   let turboStrategy = "off";
   if (leanActive) {
     turboStrategy = "lean";
@@ -61094,7 +61490,7 @@ function enrichWithLeanTurbo(status, directory) {
     }
   }
   if (leanSessionID) {
-    const runState = _internals35.loadLeanTurboRunState(directory, leanSessionID);
+    const runState = _internals38.loadLeanTurboRunState(directory, leanSessionID);
     if (runState) {
       status.leanTurboPhase = runState.phase;
       status.leanMaxParallelCoders = runState.maxParallelCoders;
@@ -61126,7 +61522,7 @@ function enrichWithLeanTurbo(status, directory) {
       }
     }
   }
-  status.fullAutoActive = _internals35.hasActiveFullAuto();
+  status.fullAutoActive = _internals38.hasActiveFullAuto();
   return status;
 }
 function formatStatusMarkdown(status) {
@@ -61214,7 +61610,7 @@ async function handleStatusCommand(directory, agents) {
   }
   return formatStatusMarkdown(statusData);
 }
-var _internals35;
+var _internals38;
 var init_status_service = __esm(() => {
   init_extractors();
   init_knowledge_escalator();
@@ -61224,7 +61620,7 @@ var init_status_service = __esm(() => {
   init_state3();
   init_compaction_service();
   init_context_budget_service();
-  _internals35 = {
+  _internals38 = {
     loadLeanTurboRunState,
     hasActiveLeanTurbo,
     hasActiveFullAuto
@@ -61315,7 +61711,7 @@ async function handleTurboCommand(directory, args, sessionID) {
   if (arg0 === "on") {
     let strategy = "standard";
     try {
-      const { config: config3 } = _internals36.loadPluginConfigWithMeta(directory);
+      const { config: config3 } = _internals39.loadPluginConfigWithMeta(directory);
       if (config3.turbo?.strategy === "lean") {
         strategy = "lean";
       }
@@ -61370,7 +61766,7 @@ function enableLeanTurbo(session, directory, sessionID) {
   let maxParallelCoders = 4;
   let conflictPolicy = "serialize";
   try {
-    const { config: config3 } = _internals36.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals39.loadPluginConfigWithMeta(directory);
     const leanConfig = config3.turbo?.lean;
     if (leanConfig) {
       maxParallelCoders = leanConfig.max_parallel_coders ?? 4;
@@ -61440,13 +61836,13 @@ function buildStatusMessage2(session, directory, sessionID) {
   ].join(`
 `);
 }
-var _internals36;
+var _internals39;
 var init_turbo = __esm(() => {
   init_config();
   init_state();
   init_state3();
   init_logger();
-  _internals36 = {
+  _internals39 = {
     loadPluginConfigWithMeta
   };
 });
@@ -61513,8 +61909,8 @@ var init_write_retro2 = __esm(() => {
 });
 
 // src/commands/command-dispatch.ts
-import fs34 from "fs";
-import path62 from "path";
+import fs35 from "fs";
+import path63 from "path";
 function normalizeSwarmCommandInput(command, argumentText) {
   if (command !== "swarm" && !command.startsWith("swarm-")) {
     return { isSwarmCommand: false, tokens: [] };
@@ -61539,7 +61935,7 @@ function formatCommandNotFound(tokens) {
   const attemptedCommand = tokens[0] || "";
   const MAX_DISPLAY = 100;
   const displayCommand = attemptedCommand.length > MAX_DISPLAY ? `${attemptedCommand.slice(0, MAX_DISPLAY)}...` : attemptedCommand;
-  const similar = _internals37.findSimilarCommands(attemptedCommand);
+  const similar = _internals40.findSimilarCommands(attemptedCommand);
   const header = `Command \`/swarm ${displayCommand}\` not found.`;
   const suggestions = similar.length > 0 ? `Did you mean:
 ${similar.map((cmd) => `  - /swarm ${cmd}`).join(`
@@ -61550,11 +61946,11 @@ ${similar.map((cmd) => `  - /swarm ${cmd}`).join(`
 `);
 }
 function maybeMarkFirstRun(directory) {
-  const sentinelPath = path62.join(directory, ".swarm", ".first-run-complete");
+  const sentinelPath = path63.join(directory, ".swarm", ".first-run-complete");
   try {
-    const swarmDir = path62.join(directory, ".swarm");
-    fs34.mkdirSync(swarmDir, { recursive: true });
-    fs34.writeFileSync(sentinelPath, `first-run-complete: ${new Date().toISOString()}
+    const swarmDir = path63.join(directory, ".swarm");
+    fs35.mkdirSync(swarmDir, { recursive: true });
+    fs35.writeFileSync(sentinelPath, `first-run-complete: ${new Date().toISOString()}
 `, { flag: "wx" });
     return true;
   } catch {
@@ -62084,7 +62480,7 @@ async function buildSwarmCommandPrompt(args) {
     packageRoot,
     registeredAgents
   } = args;
-  const resolved = _internals37.resolveCommand(tokens);
+  const resolved = _internals40.resolveCommand(tokens);
   if (!resolved) {
     if (tokens.length === 0) {
       return buildHelpText();
@@ -62254,7 +62650,7 @@ function findSimilarCommands(query) {
   }
   const scored = VALID_COMMANDS.map((cmd) => {
     const cmdLower = cmd.toLowerCase();
-    const fullScore = _internals37.levenshteinDistance(q, cmdLower);
+    const fullScore = _internals40.levenshteinDistance(q, cmdLower);
     let tokenScore = Infinity;
     if (cmd.includes(" ") || cmd.includes("-")) {
       const qTokens = q.split(/[\s-]+/);
@@ -62267,7 +62663,7 @@ function findSimilarCommands(query) {
         for (const ct of cmdTokens) {
           if (ct.length === 0)
             continue;
-          const dist = _internals37.levenshteinDistance(qt, ct);
+          const dist = _internals40.levenshteinDistance(qt, ct);
           if (dist < minDist)
             minDist = dist;
         }
@@ -62277,7 +62673,7 @@ function findSimilarCommands(query) {
     }
     const dashStrippedQ = q.replace(/-/g, "");
     const dashStrippedCmd = cmdLower.replace(/-/g, "");
-    const dashScore = _internals37.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
+    const dashScore = _internals40.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
     const score = Math.min(fullScore, tokenScore, dashScore);
     return { cmd, score };
   });
@@ -62309,11 +62705,11 @@ async function handleHelpCommand(ctx) {
     return buildHelpText2();
   }
   const tokens = targetCommand.split(/\s+/);
-  const resolved = _internals37.resolveCommand(tokens);
+  const resolved = _internals40.resolveCommand(tokens);
   if (resolved) {
-    return _internals37.buildDetailedHelp(resolved.key, resolved.entry);
+    return _internals40.buildDetailedHelp(resolved.key, resolved.entry);
   }
-  const similar = _internals37.findSimilarCommands(targetCommand);
+  const similar = _internals40.findSimilarCommands(targetCommand);
   const { buildHelpText: fullHelp } = await Promise.resolve().then(() => (init_commands(), exports_commands));
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
@@ -62355,24 +62751,24 @@ function validateAliases() {
       }
       aliasTargets.get(target).push(name);
       const visited = new Set;
-      const path63 = [];
+      const path64 = [];
       let current = target;
       while (current) {
         const currentEntry = COMMAND_REGISTRY[current];
         if (!currentEntry)
           break;
         if (visited.has(current)) {
-          const cycleStart = path63.indexOf(current);
+          const cycleStart = path64.indexOf(current);
           const fullChain = [
             name,
-            ...path63.slice(0, cycleStart > 0 ? cycleStart : path63.length),
+            ...path64.slice(0, cycleStart > 0 ? cycleStart : path64.length),
             current
           ].join(" \u2192 ");
           errors5.push(`Circular alias detected: ${fullChain}`);
           break;
         }
         visited.add(current);
-        path63.push(current);
+        path64.push(current);
         current = currentEntry.aliasOf || "";
       }
     }
@@ -62413,7 +62809,7 @@ function resolveCommand(tokens) {
   }
   return null;
 }
-var COMMAND_REGISTRY, VALID_COMMANDS, _internals37, validation;
+var COMMAND_REGISTRY, VALID_COMMANDS, _internals40, validation;
 var init_registry = __esm(() => {
   init_bundled_skills();
   init_acknowledge_spec_drift();
@@ -62443,7 +62839,10 @@ var init_registry = __esm(() => {
   init_memory2();
   init_plan();
   init_pr_feedback();
+  init_pr_monitor_status();
   init_pr_review();
+  init_pr_subscribe();
+  init_pr_unsubscribe();
   init_preflight();
   init_promote();
   init_qa_gates();
@@ -62491,7 +62890,7 @@ var init_registry = __esm(() => {
       clashesWithNativeCcCommand: "/agents"
     },
     help: {
-      handler: (ctx) => _internals37.handleHelpCommand(ctx),
+      handler: (ctx) => _internals40.handleHelpCommand(ctx),
       description: "Show help for swarm commands",
       category: "core",
       args: "[command]",
@@ -62769,6 +63168,27 @@ Subcommands:
       details: "Triggers MODE: PR_FEEDBACK \u2014 ingests existing pull-request feedback (review threads, requested changes, CI/check failures, merge conflicts, stale branch state, pasted notes), verifies every claim against source, clusters related problems, fixes confirmed items, validates the branch, and reports closure status for every ledger item. Distinct from /swarm pr-review, which discovers new findings. The PR reference is optional: with none, the architect builds the ledger from the current PR/branch; text after the reference is forwarded as extra instructions. Supports full GitHub URL, owner/repo#N shorthand, or bare PR number (resolved against origin).",
       category: "agent"
     },
+    "pr subscribe": {
+      handler: (ctx) => handlePrSubscribeCommand(ctx.directory, ctx.args, ctx.sessionID),
+      description: "Subscribe the current session to PR state-change notifications",
+      args: "<pr-url|owner/repo#N|N>",
+      details: "Subscribes the current session to receive advisory notifications for the specified PR. When pr_monitor.enabled is true, the background polling worker will detect CI failures, new comments, merge conflicts, review state changes, and merge/close events. Notifications are delivered as session-scoped advisories with dedup tokens. Supports full GitHub URL, owner/repo#N shorthand, or bare PR number (resolved against origin). Requires pr_monitor.enabled: true in config.",
+      category: "agent"
+    },
+    "pr unsubscribe": {
+      handler: (ctx) => handlePrUnsubscribeCommand(ctx.directory, ctx.args, ctx.sessionID),
+      description: "Unsubscribe the current session from PR state-change notifications",
+      args: "<pr-url|owner/repo#N|N>",
+      details: "Unsubscribes the current session from receiving advisory notifications for the specified PR. Removes the active subscription record. Supports full GitHub URL, owner/repo#N shorthand, or bare PR number (resolved against origin).",
+      category: "agent"
+    },
+    "pr status": {
+      handler: (ctx) => handlePrMonitorStatusCommand(ctx.directory, ctx.args, ctx.sessionID),
+      description: "Show PR monitor subscription status for the current session",
+      args: "",
+      details: "Displays all active PR subscriptions for the current session. Shows PR URL, last checked time, watching status, and error count per subscription. Also shows total active subscriptions across all sessions.",
+      category: "agent"
+    },
     "deep-dive": {
       handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handleDeepDiveCommand),
       description: "Launch deep codebase audit with parallel explorer waves, dual reviewers, and critic challenge [scope]",
@@ -63018,7 +63438,7 @@ Subcommands:
     }
   };
   VALID_COMMANDS = Object.keys(COMMAND_REGISTRY);
-  _internals37 = {
+  _internals40 = {
     handleHelpCommand,
     validateAliases,
     resolveCommand,
@@ -63026,7 +63446,7 @@ Subcommands:
     findSimilarCommands,
     buildDetailedHelp
   };
-  validation = _internals37.validateAliases();
+  validation = _internals40.validateAliases();
   if (!validation.valid) {
     throw new Error(`COMMAND_REGISTRY alias validation failed:
 ${validation.errors.join(`
@@ -63044,72 +63464,72 @@ init_package();
 init_registry();
 init_cache_paths();
 init_constants();
-import * as fs35 from "fs";
+import * as fs36 from "fs";
 import * as os9 from "os";
-import * as path63 from "path";
+import * as path64 from "path";
 var { version: version5 } = package_default;
 var CONFIG_DIR = getPluginConfigDir();
-var OPENCODE_CONFIG_PATH = path63.join(CONFIG_DIR, "opencode.json");
-var PLUGIN_CONFIG_PATH = path63.join(CONFIG_DIR, "opencode-swarm.json");
-var PROMPTS_DIR = path63.join(CONFIG_DIR, "opencode-swarm");
+var OPENCODE_CONFIG_PATH = path64.join(CONFIG_DIR, "opencode.json");
+var PLUGIN_CONFIG_PATH = path64.join(CONFIG_DIR, "opencode-swarm.json");
+var PROMPTS_DIR = path64.join(CONFIG_DIR, "opencode-swarm");
 var OPENCODE_PLUGIN_CACHE_PATHS = getPluginCachePaths();
 var OPENCODE_PLUGIN_LOCK_FILE_PATHS = getPluginLockFilePaths();
 function isSafeCachePath(p) {
-  const resolved = path63.resolve(p);
-  const home = path63.resolve(os9.homedir());
+  const resolved = path64.resolve(p);
+  const home = path64.resolve(os9.homedir());
   if (resolved === "/" || resolved === home || resolved.length <= home.length) {
     return false;
   }
-  const segments = resolved.split(path63.sep).filter((s) => s.length > 0);
+  const segments = resolved.split(path64.sep).filter((s) => s.length > 0);
   if (segments.length < 4) {
     return false;
   }
-  const leaf = path63.basename(resolved);
+  const leaf = path64.basename(resolved);
   if (leaf !== "opencode-swarm@latest" && leaf !== "opencode-swarm") {
     return false;
   }
-  const parent = path63.basename(path63.dirname(resolved));
+  const parent = path64.basename(path64.dirname(resolved));
   if (parent !== "packages" && parent !== "node_modules") {
     return false;
   }
-  const grandparent = path63.basename(path63.dirname(path63.dirname(resolved)));
+  const grandparent = path64.basename(path64.dirname(path64.dirname(resolved)));
   if (grandparent !== "opencode") {
     return false;
   }
   return true;
 }
 function isSafeLockFilePath(p) {
-  const resolved = path63.resolve(p);
-  const home = path63.resolve(os9.homedir());
+  const resolved = path64.resolve(p);
+  const home = path64.resolve(os9.homedir());
   if (resolved === "/" || resolved === home || resolved.length <= home.length) {
     return false;
   }
-  const segments = resolved.split(path63.sep).filter((s) => s.length > 0);
+  const segments = resolved.split(path64.sep).filter((s) => s.length > 0);
   if (segments.length < 4) {
     return false;
   }
-  const leaf = path63.basename(resolved);
+  const leaf = path64.basename(resolved);
   if (leaf !== "bun.lock" && leaf !== "bun.lockb" && leaf !== "package-lock.json") {
     return false;
   }
-  const parent = path63.basename(path63.dirname(resolved));
+  const parent = path64.basename(path64.dirname(resolved));
   if (parent !== "opencode") {
     return false;
   }
-  const grandparent = path63.basename(path63.dirname(path63.dirname(resolved)));
+  const grandparent = path64.basename(path64.dirname(path64.dirname(resolved)));
   if (grandparent === "opencode") {
     return false;
   }
   return true;
 }
 function ensureDir(dir) {
-  if (!fs35.existsSync(dir)) {
-    fs35.mkdirSync(dir, { recursive: true });
+  if (!fs36.existsSync(dir)) {
+    fs36.mkdirSync(dir, { recursive: true });
   }
 }
 function loadJson(filepath) {
   try {
-    const content = fs35.readFileSync(filepath, "utf-8");
+    const content = fs36.readFileSync(filepath, "utf-8");
     const stripped = content.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (match, comment) => comment ? "" : match).replace(/,(\s*[}\]])/g, "$1");
     return JSON.parse(stripped);
   } catch {
@@ -63117,14 +63537,14 @@ function loadJson(filepath) {
   }
 }
 function saveJson(filepath, data) {
-  fs35.writeFileSync(filepath, `${JSON.stringify(data, null, 2)}
+  fs36.writeFileSync(filepath, `${JSON.stringify(data, null, 2)}
 `, "utf-8");
 }
 function writeProjectConfigIfMissing(cwd) {
   try {
-    const opencodeDir = path63.join(cwd, ".opencode");
-    const projectConfigPath = path63.join(opencodeDir, "opencode-swarm.json");
-    if (fs35.existsSync(projectConfigPath)) {
+    const opencodeDir = path64.join(cwd, ".opencode");
+    const projectConfigPath = path64.join(opencodeDir, "opencode-swarm.json");
+    if (fs36.existsSync(projectConfigPath)) {
       return;
     }
     ensureDir(opencodeDir);
@@ -63140,7 +63560,7 @@ async function install() {
 `);
   ensureDir(CONFIG_DIR);
   ensureDir(PROMPTS_DIR);
-  const LEGACY_CONFIG_PATH = path63.join(CONFIG_DIR, "config.json");
+  const LEGACY_CONFIG_PATH = path64.join(CONFIG_DIR, "config.json");
   let opencodeConfig = loadJson(OPENCODE_CONFIG_PATH);
   if (!opencodeConfig) {
     const legacyConfig = loadJson(LEGACY_CONFIG_PATH);
@@ -63187,7 +63607,7 @@ async function install() {
     console.warn(`\u26A0 Could not clear opencode lock file \u2014 you may need to delete it manually:
   ${failed}`);
   }
-  if (!fs35.existsSync(PLUGIN_CONFIG_PATH)) {
+  if (!fs36.existsSync(PLUGIN_CONFIG_PATH)) {
     const defaultConfig = {
       agents: { ...DEFAULT_AGENT_CONFIGS },
       max_iterations: 5
@@ -63266,14 +63686,14 @@ function evictPluginCaches() {
   const cleared = [];
   const failed = [];
   for (const cachePath of OPENCODE_PLUGIN_CACHE_PATHS) {
-    if (!fs35.existsSync(cachePath))
+    if (!fs36.existsSync(cachePath))
       continue;
     if (!isSafeCachePath(cachePath)) {
       failed.push(`${cachePath} (refused: failed safety check)`);
       continue;
     }
     try {
-      fs35.rmSync(cachePath, { recursive: true, force: true });
+      fs36.rmSync(cachePath, { recursive: true, force: true });
       cleared.push(cachePath);
     } catch (err) {
       failed.push(`${cachePath} (${err instanceof Error ? err.message : String(err)})`);
@@ -63285,14 +63705,14 @@ function evictLockFiles() {
   const cleared = [];
   const failed = [];
   for (const lockPath of OPENCODE_PLUGIN_LOCK_FILE_PATHS) {
-    if (!fs35.existsSync(lockPath))
+    if (!fs36.existsSync(lockPath))
       continue;
     if (!isSafeLockFilePath(lockPath)) {
       failed.push(`${lockPath} (refused: failed safety check)`);
       continue;
     }
     try {
-      fs35.unlinkSync(lockPath);
+      fs36.unlinkSync(lockPath);
       cleared.push(lockPath);
     } catch (err) {
       const code = err?.code;
@@ -63311,7 +63731,7 @@ async function uninstall() {
 `);
     const opencodeConfig = loadJson(OPENCODE_CONFIG_PATH);
     if (!opencodeConfig) {
-      if (fs35.existsSync(OPENCODE_CONFIG_PATH)) {
+      if (fs36.existsSync(OPENCODE_CONFIG_PATH)) {
         console.log(`\u2717 Could not parse opencode config at: ${OPENCODE_CONFIG_PATH}`);
         return 1;
       } else {
@@ -63343,13 +63763,13 @@ async function uninstall() {
     console.log("\u2713 Re-enabled default OpenCode agents (explore, general)");
     if (process.argv.includes("--clean")) {
       let cleaned = false;
-      if (fs35.existsSync(PLUGIN_CONFIG_PATH)) {
-        fs35.unlinkSync(PLUGIN_CONFIG_PATH);
+      if (fs36.existsSync(PLUGIN_CONFIG_PATH)) {
+        fs36.unlinkSync(PLUGIN_CONFIG_PATH);
         console.log(`\u2713 Removed plugin config: ${PLUGIN_CONFIG_PATH}`);
         cleaned = true;
       }
-      if (fs35.existsSync(PROMPTS_DIR)) {
-        fs35.rmSync(PROMPTS_DIR, { recursive: true });
+      if (fs36.existsSync(PROMPTS_DIR)) {
+        fs36.rmSync(PROMPTS_DIR, { recursive: true });
         console.log(`\u2713 Removed custom prompts: ${PROMPTS_DIR}`);
         cleaned = true;
       }