opencode-swarm 7.68.0 → 7.68.2

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.68.0",
+    version: "7.68.2",
     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",
@@ -73712,7 +73712,7 @@ var init_history = __esm(() => {
   init_history_service();
 });
 
-// src/commands/issue.ts
+// src/commands/pr-ref.ts
 import { execSync as execSync2 } from "node:child_process";
 function sanitizeUrl(raw) {
   let urlStr = raw.trim();
@@ -73731,6 +73731,22 @@ function sanitizeUrl(raw) {
   }
   return urlStr.trim();
 }
+function sanitizeInstructions(raw) {
+  const collapsed = raw.replace(/\s+/g, " ").trim();
+  const stripped = collapsed.replace(/\[\s*MODE\s*:[^\]]*\]/gi, "");
+  const normalized = stripped.replace(/\s+/g, " ").trim();
+  if (normalized.length <= MAX_INSTRUCTIONS_LEN)
+    return normalized;
+  return `${normalized.slice(0, MAX_INSTRUCTIONS_LEN)}…`;
+}
+function hasNonAsciiHostname(hostname5) {
+  for (const ch of hostname5) {
+    const cp = ch.codePointAt(0);
+    if (cp !== undefined && cp > 127)
+      return true;
+  }
+  return false;
+}
 function isPrivateHost(url3) {
   const host = url3.hostname.toLowerCase();
   if (host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "0.0.0.0") {
@@ -73763,13 +73779,182 @@ function validateAndSanitizeUrl(rawUrl) {
   if (!sanitized.startsWith("https://")) {
     return { error: "URL must use HTTPS scheme" };
   }
+  try {
+    const url3 = new URL(sanitized);
+    if (hasNonAsciiHostname(url3.hostname)) {
+      return { error: "Non-ASCII hostnames are not allowed" };
+    }
+    if (isPrivateHost(url3)) {
+      return { error: "Private or localhost URLs are not allowed" };
+    }
+    const githubPrPattern = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/([0-9]+)\/?$/;
+    if (!githubPrPattern.test(sanitized)) {
+      return {
+        error: "URL must be a GitHub pull request URL (https://github.com/owner/repo/pull/N)"
+      };
+    }
+    return { sanitized };
+  } catch {
+    return { error: "Invalid URL format" };
+  }
+}
+function parsePrRef(input, cwd) {
+  const urlMatch = input.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)\/?$/i);
+  if (urlMatch) {
+    return {
+      owner: urlMatch[1],
+      repo: urlMatch[2],
+      number: parseInt(urlMatch[3], 10)
+    };
+  }
+  const shorthandMatch = input.match(/^([^/]+)\/([^#]+)#(\d+)$/);
+  if (shorthandMatch) {
+    return {
+      owner: shorthandMatch[1],
+      repo: shorthandMatch[2],
+      number: parseInt(shorthandMatch[3], 10)
+    };
+  }
+  const bareMatch = input.match(/^(\d+)$/);
+  if (bareMatch) {
+    const prNumber = parseInt(bareMatch[1], 10);
+    const remoteUrl = detectGitRemote(cwd);
+    if (!remoteUrl) {
+      return null;
+    }
+    const parsed = parseGitRemoteUrl(remoteUrl);
+    if (!parsed) {
+      return null;
+    }
+    return {
+      owner: parsed.owner,
+      repo: parsed.repo,
+      number: prNumber
+    };
+  }
+  return null;
+}
+function detectGitRemote(cwd) {
+  try {
+    const remoteUrl = _internals35.execSync("git remote get-url origin", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5000,
+      ...cwd ? { cwd } : {}
+    }).trim();
+    return remoteUrl || null;
+  } catch {
+    return null;
+  }
+}
+function parseGitRemoteUrl(remoteUrl) {
+  const httpsMatch = remoteUrl.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/i);
+  if (httpsMatch) {
+    return {
+      owner: httpsMatch[1],
+      repo: httpsMatch[2].replace(/\.git$/, "")
+    };
+  }
+  const sshMatch = remoteUrl.match(/^git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/i);
+  if (sshMatch) {
+    return {
+      owner: sshMatch[1],
+      repo: sshMatch[2].replace(/\.git$/, "")
+    };
+  }
+  const pathMatch = remoteUrl.match(/\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/);
+  if (pathMatch) {
+    return {
+      owner: pathMatch[1],
+      repo: pathMatch[2].replace(/\.git$/, "")
+    };
+  }
+  return null;
+}
+function looksLikePrRef(token) {
+  return /^https?:\/\//i.test(token) || /^[^/]+\/[^#]+#\d+$/.test(token) || /^\d+$/.test(token);
+}
+function resolvePrCommandInput(rest, cwd) {
+  if (rest.length === 0) {
+    return null;
+  }
+  const refToken = rest[0];
+  const instructions = sanitizeInstructions(rest.slice(1).join(" "));
+  const isFullUrl = /^https?:\/\//i.test(refToken);
+  const prInfo = parsePrRef(isFullUrl ? sanitizeUrl(refToken) : refToken, cwd);
+  if (!prInfo) {
+    return { error: `Could not parse PR reference from "${refToken}"` };
+  }
+  const prUrl = `https://github.com/${prInfo.owner}/${prInfo.repo}/pull/${prInfo.number}`;
+  const result = validateAndSanitizeUrl(prUrl);
+  if ("error" in result) {
+    return { error: result.error };
+  }
+  return { prUrl: result.sanitized, instructions };
+}
+var _internals35, MAX_URL_LEN = 2048, MAX_INSTRUCTIONS_LEN = 1000;
+var init_pr_ref = __esm(() => {
+  _internals35 = { execSync: execSync2 };
+});
+
+// src/commands/issue.ts
+import { execSync as execSync3 } from "node:child_process";
+function sanitizeUrl2(raw) {
+  let urlStr = raw.trim();
+  urlStr = urlStr.replace(/\[\s*MODE\s*:[^\]]*\]/gi, "");
+  const fragmentIdx = urlStr.indexOf("#");
+  if (fragmentIdx !== -1) {
+    urlStr = urlStr.slice(0, fragmentIdx);
+  }
+  const queryIdx = urlStr.indexOf("?");
+  if (queryIdx !== -1) {
+    urlStr = urlStr.slice(0, queryIdx);
+  }
+  urlStr = urlStr.replace(/^[A-Za-z][A-Za-z0-9+.-]*:\/\/[^@/]+@/, "https://");
+  if (urlStr.length > MAX_URL_LEN2) {
+    urlStr = urlStr.slice(0, MAX_URL_LEN2);
+  }
+  return urlStr.trim();
+}
+function isPrivateHost2(url3) {
+  const host = url3.hostname.toLowerCase();
+  if (host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "0.0.0.0") {
+    return true;
+  }
+  if (host.startsWith("localhost") || host === "localhost.com") {
+    return true;
+  }
+  const ipv4Private = /^10\./;
+  const ipv4172 = /^172\.(1[6-9]|2\d|3[0-1])\./;
+  const ipv4192 = /^192\.168\./;
+  const ipv6Private = /^fe80:/i;
+  const ipv6Unique = /^f[cd][0-9a-f]{2}:/i;
+  if (ipv4Private.test(host) || ipv4172.test(host) || ipv4192.test(host) || ipv6Private.test(host) || ipv6Unique.test(host)) {
+    return true;
+  }
+  if (host.startsWith("::ffff:")) {
+    const inner = host.slice(7);
+    if (ipv4Private.test(inner) || ipv4172.test(inner) || ipv4192.test(inner)) {
+      return true;
+    }
+  }
+  return false;
+}
+function validateAndSanitizeUrl2(rawUrl) {
+  const sanitized = sanitizeUrl2(rawUrl);
+  if (!sanitized) {
+    return { error: "Empty URL" };
+  }
+  if (!sanitized.startsWith("https://")) {
+    return { error: "URL must use HTTPS scheme" };
+  }
   try {
     const url3 = new URL(sanitized);
     const hostname5 = url3.hostname;
     if (/[\u0080-\u{10FFFF}]/u.test(hostname5)) {
       return { error: "Non-ASCII hostnames are not allowed" };
     }
-    if (isPrivateHost(url3)) {
+    if (isPrivateHost2(url3)) {
       return { error: "Private or localhost URLs are not allowed" };
     }
     const githubIssuePattern = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/issues\/([0-9]+)\/?$/;
@@ -73828,7 +74013,7 @@ function parseIssueRef(input) {
   const bareMatch = input.match(/^(\d+)$/);
   if (bareMatch) {
     const issueNumber = parseInt(bareMatch[1], 10);
-    const remoteUrl = detectGitRemote();
+    const remoteUrl = detectGitRemote2();
     if (!remoteUrl) {
       return null;
     }
@@ -73844,9 +74029,9 @@ function parseIssueRef(input) {
   }
   return null;
 }
-function detectGitRemote() {
+function detectGitRemote2() {
   try {
-    const remoteUrl = execSync2("git remote get-url origin", {
+    const remoteUrl = execSync3("git remote get-url origin", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5000
@@ -73856,23 +74041,6 @@ function detectGitRemote() {
     return null;
   }
 }
-function parseGitRemoteUrl(remoteUrl) {
-  const httpsMatch = remoteUrl.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/i);
-  if (httpsMatch) {
-    return {
-      owner: httpsMatch[1],
-      repo: httpsMatch[2].replace(/\.git$/, "")
-    };
-  }
-  const sshMatch = remoteUrl.match(/^git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/i);
-  if (sshMatch) {
-    return {
-      owner: sshMatch[1],
-      repo: sshMatch[2].replace(/\.git$/, "")
-    };
-  }
-  return null;
-}
 function handleIssueCommand(_directory, args2) {
   const parsed = parseArgs5(args2);
   const rawInput = parsed.rest.join(" ").trim();
@@ -73880,14 +74048,14 @@ function handleIssueCommand(_directory, args2) {
     return USAGE5;
   }
   const isFullUrl = /^https?:\/\//i.test(rawInput);
-  const issueInfo = parseIssueRef(isFullUrl ? sanitizeUrl(rawInput) : rawInput);
+  const issueInfo = parseIssueRef(isFullUrl ? sanitizeUrl2(rawInput) : rawInput);
   if (!issueInfo) {
     return `Error: Could not parse issue reference from "${rawInput}"
 
 ${USAGE5}`;
   }
   const issueUrl = `https://github.com/${issueInfo.owner}/${issueInfo.repo}/issues/${issueInfo.number}`;
-  const result = validateAndSanitizeUrl(issueUrl);
+  const result = validateAndSanitizeUrl2(issueUrl);
   if ("error" in result) {
     return `Error: ${result.error}
 
@@ -73903,8 +74071,9 @@ ${USAGE5}`;
   const flagsStr = flags2.length > 0 ? ` ${flags2.join(" ")}` : "";
   return `[MODE: ISSUE_INGEST issue="${result.sanitized}"${flagsStr}]`;
 }
-var MAX_URL_LEN = 2048, USAGE5;
+var MAX_URL_LEN2 = 2048, USAGE5;
 var init_issue = __esm(() => {
+  init_pr_ref();
   USAGE5 = [
     "Usage: /swarm issue <url|owner/repo#N|N> [--plan] [--trace] [--no-repro]",
     "",
@@ -73929,6 +74098,7 @@ var KNOWLEDGE_SCHEMA_VERSION = 2;
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { existsSync as existsSync32, readFileSync as readFileSync17 } from "node:fs";
 import { mkdir as mkdir14, readFile as readFile16, writeFile as writeFile12 } from "node:fs/promises";
+import * as os13 from "node:os";
 import * as path53 from "node:path";
 async function migrateKnowledgeToExternal(_directory, _config) {
   return {
@@ -73971,9 +74141,9 @@ async function migrateContextToKnowledge(directory, config3) {
       skippedReason: "empty-context"
     };
   }
-  const rawEntries = _internals35.parseContextMd(contextContent);
+  const rawEntries = _internals36.parseContextMd(contextContent);
   if (rawEntries.length === 0) {
-    await _internals35.writeSentinel(sentinelPath, 0, 0);
+    await _internals36.writeSentinel(sentinelPath, 0, 0);
     return {
       migrated: true,
       entriesMigrated: 0,
@@ -73984,10 +74154,10 @@ async function migrateContextToKnowledge(directory, config3) {
   const existing = await readKnowledge(knowledgePath);
   let migrated = 0;
   let dropped = 0;
-  const projectName = _internals35.inferProjectName(directory);
+  const projectName = _internals36.inferProjectName(directory);
   for (const raw of rawEntries) {
     if (config3.validation_enabled !== false) {
-      const category = raw.categoryHint ?? _internals35.inferCategoryFromText(raw.text);
+      const category = raw.categoryHint ?? _internals36.inferCategoryFromText(raw.text);
       const result = validateLesson(raw.text, existing.map((e) => e.lesson), {
         category,
         scope: "global",
@@ -74007,8 +74177,8 @@ async function migrateContextToKnowledge(directory, config3) {
     const entry = {
       id: randomUUID6(),
       tier: "swarm",
-      lesson: _internals35.truncateLesson(raw.text),
-      category: raw.categoryHint ?? _internals35.inferCategoryFromText(raw.text),
+      lesson: _internals36.truncateLesson(raw.text),
+      category: raw.categoryHint ?? _internals36.inferCategoryFromText(raw.text),
       tags: [...inferredTags, `migration:${raw.sourceSection}`],
       scope: "global",
       confidence: 0.3,
@@ -74031,7 +74201,7 @@ async function migrateContextToKnowledge(directory, config3) {
   if (migrated > 0) {
     await rewriteKnowledge(knowledgePath, existing);
   }
-  await _internals35.writeSentinel(sentinelPath, migrated, dropped);
+  await _internals36.writeSentinel(sentinelPath, migrated, dropped);
   log(`[knowledge-migrator] Migrated ${migrated} entries, dropped ${dropped}`);
   return {
     migrated: true,
@@ -74040,8 +74210,125 @@ async function migrateContextToKnowledge(directory, config3) {
     entriesTotal: rawEntries.length
   };
 }
+async function migrateHiveKnowledgeLegacy(config3) {
+  const legacyHivePath = _internals36.resolveLegacyHiveKnowledgePath();
+  const canonicalHivePath = resolveHiveKnowledgePath();
+  const sentinelPath = path53.join(path53.dirname(canonicalHivePath), ".hive-knowledge-migrated");
+  if (existsSync32(sentinelPath)) {
+    return {
+      migrated: false,
+      entriesMigrated: 0,
+      entriesDropped: 0,
+      entriesTotal: 0,
+      skippedReason: "sentinel-exists"
+    };
+  }
+  if (!existsSync32(legacyHivePath)) {
+    return {
+      migrated: false,
+      entriesMigrated: 0,
+      entriesDropped: 0,
+      entriesTotal: 0,
+      skippedReason: "no-context-file"
+    };
+  }
+  const legacyEntries = await readKnowledge(legacyHivePath);
+  if (legacyEntries.length === 0) {
+    await _internals36.writeSentinel(sentinelPath, 0, 0);
+    return {
+      migrated: true,
+      entriesMigrated: 0,
+      entriesDropped: 0,
+      entriesTotal: 0
+    };
+  }
+  const existingHiveEntries = await readKnowledge(canonicalHivePath);
+  let migrated = 0;
+  let dropped = 0;
+  const entryErrors = [];
+  for (const legacyEntry of legacyEntries) {
+    try {
+      const lesson = legacyEntry.lesson;
+      if (!lesson || typeof lesson !== "string" || lesson.length < 15) {
+        dropped++;
+        continue;
+      }
+      const dup = findNearDuplicate(lesson, existingHiveEntries, config3.dedup_threshold ?? 0.6);
+      if (dup) {
+        dropped++;
+        continue;
+      }
+      const category = legacyEntry.category || "process";
+      const validationResult = validateLesson(lesson, existingHiveEntries.map((e) => e.lesson), {
+        category,
+        scope: "global",
+        confidence: 0.3
+      });
+      if (!validationResult.valid) {
+        const errorMsg = `Validation failed for legacy entry: ${validationResult.reason}`;
+        entryErrors.push(errorMsg);
+        warn(`[knowledge-migrator] ${errorMsg}`);
+        dropped++;
+        continue;
+      }
+      const confidence = legacyEntry.confidence ?? 0.8;
+      const scopeTag = legacyEntry.scope_tag || "global";
+      const legacyId = legacyEntry.id;
+      const existingIds = new Set(existingHiveEntries.map((e) => e.id));
+      const resolvedId = legacyId && existingIds.has(legacyId) ? randomUUID6() : legacyId || randomUUID6();
+      if (legacyId && existingIds.has(legacyId)) {
+        warn(`[knowledge-migrator] Legacy entry ID collision for "${legacyId}", generating new UUID`);
+      }
+      const newHiveEntry = {
+        id: resolvedId,
+        tier: "hive",
+        lesson: _internals36.truncateLesson(lesson),
+        category,
+        tags: ["migration:legacy-hive"],
+        scope: scopeTag,
+        confidence: Math.min(Math.max(confidence, 0), 1),
+        status: "established",
+        confirmed_by: [],
+        retrieval_outcomes: {
+          applied_count: 0,
+          succeeded_after_count: 0,
+          failed_after_count: 0
+        },
+        schema_version: KNOWLEDGE_SCHEMA_VERSION,
+        created_at: legacyEntry.created_at || new Date().toISOString(),
+        updated_at: legacyEntry.updated_at || new Date().toISOString(),
+        source_project: "legacy-promotion",
+        encounter_score: 1
+      };
+      try {
+        await _internals36.appendKnowledge(canonicalHivePath, newHiveEntry);
+        existingHiveEntries.push(newHiveEntry);
+        migrated++;
+      } catch (appendError) {
+        const errorMsg = `Failed to append entry: ${appendError instanceof Error ? appendError.message : String(appendError)}`;
+        entryErrors.push(errorMsg);
+        warn(`[knowledge-migrator] ${errorMsg}`);
+        dropped++;
+      }
+    } catch (entryError) {
+      const errorMsg = `Unexpected error processing legacy entry: ${entryError instanceof Error ? entryError.message : String(entryError)}`;
+      entryErrors.push(errorMsg);
+      warn(`[knowledge-migrator] ${errorMsg}`);
+      dropped++;
+    }
+  }
+  await _internals36.writeSentinel(sentinelPath, migrated, dropped);
+  log(`[knowledge-migrator] Migrated ${migrated} legacy hive entries, dropped ${dropped}`);
+  return {
+    migrated: true,
+    entriesMigrated: migrated,
+    entriesDropped: dropped,
+    entriesTotal: legacyEntries.length,
+    ...entryErrors.length > 0 && { entryErrors }
+  };
+}
 function parseContextMd(content) {
-  const sections = _internals35.splitIntoSections(content);
+  const sections = _internals36.splitIntoSections(content);
   const entries = [];
   const seen = new Set;
   const sectionPatterns = [
@@ -74057,7 +74344,7 @@ function parseContextMd(content) {
     const match = sectionPatterns.find((sp) => sp.pattern.test(section.heading));
     if (!match)
       continue;
-    const bullets = _internals35.extractBullets(section.body);
+    const bullets = _internals36.extractBullets(section.body);
     for (const bullet of bullets) {
       if (bullet.length < 15)
         continue;
@@ -74066,9 +74353,9 @@ function parseContextMd(content) {
         continue;
       seen.add(normalized);
       entries.push({
-        text: _internals35.truncateLesson(bullet),
+        text: _internals36.truncateLesson(bullet),
         sourceSection: match.sourceSection,
-        categoryHint: _internals35.inferCategoryFromText(bullet)
+        categoryHint: _internals36.inferCategoryFromText(bullet)
       });
     }
   }
@@ -74161,21 +74448,37 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
   await mkdir14(path53.dirname(sentinelPath), { recursive: true });
   await writeFile12(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
-var _internals35;
+function resolveLegacyHiveKnowledgePath() {
+  const platform = process.platform;
+  const home = process.env.HOME || os13.homedir();
+  let dataDir;
+  if (platform === "win32") {
+    dataDir = path53.join(process.env.LOCALAPPDATA || path53.join(home, "AppData", "Local"), "opencode-swarm", "Data");
+  } else if (platform === "darwin") {
+    dataDir = path53.join(home, "Library", "Application Support", "opencode-swarm");
+  } else {
+    dataDir = path53.join(process.env.XDG_DATA_HOME || path53.join(home, ".local", "share"), "opencode-swarm");
+  }
+  return path53.join(dataDir, "hive-knowledge.jsonl");
+}
+var _internals36;
 var init_knowledge_migrator = __esm(() => {
   init_logger();
   init_knowledge_store();
   init_knowledge_validator();
-  _internals35 = {
+  _internals36 = {
+    appendKnowledge,
     migrateContextToKnowledge,
     migrateKnowledgeToExternal,
+    migrateHiveKnowledgeLegacy,
     parseContextMd,
     splitIntoSections,
     extractBullets,
     inferCategoryFromText,
     truncateLesson: truncateLesson2,
     inferProjectName,
-    writeSentinel
+    writeSentinel,
+    resolveLegacyHiveKnowledgePath
   };
 });
 
@@ -74247,24 +74550,43 @@ async function handleKnowledgeRestoreCommand(directory, args2) {
 }
 async function handleKnowledgeMigrateCommand(directory, args2) {
   const targetDir = args2[0] || directory;
+  const config3 = KnowledgeConfigSchema.parse({});
   try {
-    const result = await migrateContextToKnowledge(targetDir, KnowledgeConfigSchema.parse({}));
-    if (result.skippedReason) {
-      switch (result.skippedReason) {
+    const contextResult = await migrateContextToKnowledge(targetDir, config3);
+    const hiveResult = await migrateHiveKnowledgeLegacy(config3);
+    const messages = [];
+    if (contextResult.skippedReason) {
+      switch (contextResult.skippedReason) {
         case "sentinel-exists":
-          return "⏭ Migration already completed for this project. Delete .swarm/.knowledge-migrated to re-run.";
+          messages.push("⏭ Context migration already completed. Delete .swarm/.knowledge-migrated to re-run.");
+          break;
         case "no-context-file":
-          return "ℹ️ No .swarm/context.md found — nothing to migrate.";
+          messages.push("ℹ️ No .swarm/context.md found — nothing to migrate.");
+          break;
         case "empty-context":
-          return "ℹ️ .swarm/context.md is empty — nothing to migrate.";
-        default:
-          return "⚠️ Migration skipped for an unknown reason.";
+          messages.push("ℹ️ .swarm/context.md is empty — nothing to migrate.");
+          break;
       }
+    } else {
+      messages.push(`✅ Context migration: ${contextResult.entriesMigrated} entries added, ${contextResult.entriesDropped} dropped`);
     }
-    return `✅ Migration complete: ${result.entriesMigrated} entries added, ${result.entriesDropped} dropped (validation/dedup), ${result.entriesTotal} total processed.`;
+    if (hiveResult.skippedReason) {
+      switch (hiveResult.skippedReason) {
+        case "sentinel-exists":
+          messages.push("⏭ Hive legacy migration already completed. Delete the sentinel in the hive data dir to re-run.");
+          break;
+        case "no-context-file":
+          messages.push("ℹ️ No legacy hive-knowledge.jsonl found — nothing to migrate.");
+          break;
+      }
+    } else if (hiveResult.migrated) {
+      messages.push(`✅ Hive legacy migration: ${hiveResult.entriesMigrated} entries added, ${hiveResult.entriesDropped} dropped`);
+    }
+    return messages.join(`
+`);
   } catch (error93) {
-    console.warn("[knowledge-command] migrateContextToKnowledge error:", error93 instanceof Error ? error93.message : String(error93));
-    return "❌ Migration failed. Check .swarm/context.md is readable.";
+    console.warn("[knowledge-command] migration error:", error93 instanceof Error ? error93.message : String(error93));
+    return "❌ Migration failed. Check that knowledge source files are readable.";
   }
 }
 async function handleKnowledgeListCommand(directory, _args) {
@@ -77324,7 +77646,7 @@ var init_gateway = __esm(() => {
 
 // src/memory/evaluation.ts
 import * as fs27 from "node:fs/promises";
-import * as os13 from "node:os";
+import * as os14 from "node:os";
 import * as path58 from "node:path";
 async function evaluateMemoryRecallFixtures(options) {
   const fixtureDirectory = path58.resolve(options.fixtureDirectory);
@@ -77336,7 +77658,7 @@ async function evaluateMemoryRecallFixtures(options) {
   for (const fixture of fixtures) {
     const materialized = materializeFixture(fixture);
     for (const providerName of providers) {
-      const tempRoot = await fs27.realpath(await fs27.mkdtemp(path58.join(os13.tmpdir(), "swarm-memory-eval-")));
+      const tempRoot = await fs27.realpath(await fs27.mkdtemp(path58.join(os14.tmpdir(), "swarm-memory-eval-")));
       const provider = createEvaluationProvider(providerName, tempRoot);
       try {
         await provider.initialize?.();
@@ -78652,9 +78974,9 @@ var init_memory2 = __esm(() => {
 
 // src/services/plan-service.ts
 async function getPlanData(directory, phaseArg) {
-  const plan = await _internals36.loadPlanJsonOnly(directory);
+  const plan = await _internals37.loadPlanJsonOnly(directory);
   if (plan) {
-    const fullMarkdown = _internals36.derivePlanMarkdown(plan);
+    const fullMarkdown = _internals37.derivePlanMarkdown(plan);
     if (phaseArg === undefined || phaseArg === null || phaseArg === "") {
       return {
         hasPlan: true,
@@ -78697,7 +79019,7 @@ async function getPlanData(directory, phaseArg) {
       isLegacy: false
     };
   }
-  const planContent = await _internals36.readSwarmFileAsync(directory, "plan.md");
+  const planContent = await _internals37.readSwarmFileAsync(directory, "plan.md");
   if (!planContent) {
     return {
       hasPlan: false,
@@ -78793,11 +79115,11 @@ async function handlePlanCommand(directory, args2) {
   const planData = await getPlanData(directory, phaseArg);
   return formatPlanMarkdown(planData);
 }
-var _internals36;
+var _internals37;
 var init_plan_service = __esm(() => {
   init_utils2();
   init_manager();
-  _internals36 = {
+  _internals37 = {
     loadPlanJsonOnly,
     derivePlanMarkdown,
     readSwarmFileAsync
@@ -78809,191 +79131,6 @@ var init_plan = __esm(() => {
   init_plan_service();
 });
 
-// src/commands/pr-ref.ts
-import { execSync as execSync3 } from "node:child_process";
-function sanitizeUrl2(raw) {
-  let urlStr = raw.trim();
-  urlStr = urlStr.replace(/\[\s*MODE\s*:[^\]]*\]/gi, "");
-  const fragmentIdx = urlStr.indexOf("#");
-  if (fragmentIdx !== -1) {
-    urlStr = urlStr.slice(0, fragmentIdx);
-  }
-  const queryIdx = urlStr.indexOf("?");
-  if (queryIdx !== -1) {
-    urlStr = urlStr.slice(0, queryIdx);
-  }
-  urlStr = urlStr.replace(/^[A-Za-z][A-Za-z0-9+.-]*:\/\/[^@/]+@/, "https://");
-  if (urlStr.length > MAX_URL_LEN2) {
-    urlStr = urlStr.slice(0, MAX_URL_LEN2);
-  }
-  return urlStr.trim();
-}
-function sanitizeInstructions(raw) {
-  const collapsed = raw.replace(/\s+/g, " ").trim();
-  const stripped = collapsed.replace(/\[\s*MODE\s*:[^\]]*\]/gi, "");
-  const normalized = stripped.replace(/\s+/g, " ").trim();
-  if (normalized.length <= MAX_INSTRUCTIONS_LEN)
-    return normalized;
-  return `${normalized.slice(0, MAX_INSTRUCTIONS_LEN)}…`;
-}
-function hasNonAsciiHostname(hostname5) {
-  for (const ch of hostname5) {
-    const cp = ch.codePointAt(0);
-    if (cp !== undefined && cp > 127)
-      return true;
-  }
-  return false;
-}
-function isPrivateHost2(url3) {
-  const host = url3.hostname.toLowerCase();
-  if (host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "0.0.0.0") {
-    return true;
-  }
-  if (host.startsWith("localhost") || host === "localhost.com") {
-    return true;
-  }
-  const ipv4Private = /^10\./;
-  const ipv4172 = /^172\.(1[6-9]|2\d|3[0-1])\./;
-  const ipv4192 = /^192\.168\./;
-  const ipv6Private = /^fe80:/i;
-  const ipv6Unique = /^f[cd][0-9a-f]{2}:/i;
-  if (ipv4Private.test(host) || ipv4172.test(host) || ipv4192.test(host) || ipv6Private.test(host) || ipv6Unique.test(host)) {
-    return true;
-  }
-  if (host.startsWith("::ffff:")) {
-    const inner = host.slice(7);
-    if (ipv4Private.test(inner) || ipv4172.test(inner) || ipv4192.test(inner)) {
-      return true;
-    }
-  }
-  return false;
-}
-function validateAndSanitizeUrl2(rawUrl) {
-  const sanitized = sanitizeUrl2(rawUrl);
-  if (!sanitized) {
-    return { error: "Empty URL" };
-  }
-  if (!sanitized.startsWith("https://")) {
-    return { error: "URL must use HTTPS scheme" };
-  }
-  try {
-    const url3 = new URL(sanitized);
-    if (hasNonAsciiHostname(url3.hostname)) {
-      return { error: "Non-ASCII hostnames are not allowed" };
-    }
-    if (isPrivateHost2(url3)) {
-      return { error: "Private or localhost URLs are not allowed" };
-    }
-    const githubPrPattern = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/([0-9]+)\/?$/;
-    if (!githubPrPattern.test(sanitized)) {
-      return {
-        error: "URL must be a GitHub pull request URL (https://github.com/owner/repo/pull/N)"
-      };
-    }
-    return { sanitized };
-  } catch {
-    return { error: "Invalid URL format" };
-  }
-}
-function parsePrRef(input, cwd) {
-  const urlMatch = input.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)\/?$/i);
-  if (urlMatch) {
-    return {
-      owner: urlMatch[1],
-      repo: urlMatch[2],
-      number: parseInt(urlMatch[3], 10)
-    };
-  }
-  const shorthandMatch = input.match(/^([^/]+)\/([^#]+)#(\d+)$/);
-  if (shorthandMatch) {
-    return {
-      owner: shorthandMatch[1],
-      repo: shorthandMatch[2],
-      number: parseInt(shorthandMatch[3], 10)
-    };
-  }
-  const bareMatch = input.match(/^(\d+)$/);
-  if (bareMatch) {
-    const prNumber = parseInt(bareMatch[1], 10);
-    const remoteUrl = detectGitRemote2(cwd);
-    if (!remoteUrl) {
-      return null;
-    }
-    const parsed = parseGitRemoteUrl2(remoteUrl);
-    if (!parsed) {
-      return null;
-    }
-    return {
-      owner: parsed.owner,
-      repo: parsed.repo,
-      number: prNumber
-    };
-  }
-  return null;
-}
-function detectGitRemote2(cwd) {
-  try {
-    const remoteUrl = _internals37.execSync("git remote get-url origin", {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 5000,
-      ...cwd ? { cwd } : {}
-    }).trim();
-    return remoteUrl || null;
-  } catch {
-    return null;
-  }
-}
-function parseGitRemoteUrl2(remoteUrl) {
-  const httpsMatch = remoteUrl.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/i);
-  if (httpsMatch) {
-    return {
-      owner: httpsMatch[1],
-      repo: httpsMatch[2].replace(/\.git$/, "")
-    };
-  }
-  const sshMatch = remoteUrl.match(/^git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/i);
-  if (sshMatch) {
-    return {
-      owner: sshMatch[1],
-      repo: sshMatch[2].replace(/\.git$/, "")
-    };
-  }
-  const pathMatch = remoteUrl.match(/\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/);
-  if (pathMatch) {
-    return {
-      owner: pathMatch[1],
-      repo: pathMatch[2].replace(/\.git$/, "")
-    };
-  }
-  return null;
-}
-function looksLikePrRef(token) {
-  return /^https?:\/\//i.test(token) || /^[^/]+\/[^#]+#\d+$/.test(token) || /^\d+$/.test(token);
-}
-function resolvePrCommandInput(rest, cwd) {
-  if (rest.length === 0) {
-    return null;
-  }
-  const refToken = rest[0];
-  const instructions = sanitizeInstructions(rest.slice(1).join(" "));
-  const isFullUrl = /^https?:\/\//i.test(refToken);
-  const prInfo = parsePrRef(isFullUrl ? sanitizeUrl2(refToken) : refToken, cwd);
-  if (!prInfo) {
-    return { error: `Could not parse PR reference from "${refToken}"` };
-  }
-  const prUrl = `https://github.com/${prInfo.owner}/${prInfo.repo}/pull/${prInfo.number}`;
-  const result = validateAndSanitizeUrl2(prUrl);
-  if ("error" in result) {
-    return { error: result.error };
-  }
-  return { prUrl: result.sanitized, instructions };
-}
-var _internals37, MAX_URL_LEN2 = 2048, MAX_INSTRUCTIONS_LEN = 1000;
-var init_pr_ref = __esm(() => {
-  _internals37 = { execSync: execSync3 };
-});
-
 // src/commands/pr-feedback.ts
 function handlePrFeedbackCommand(directory, args2) {
   const rest = args2.filter((t) => t.trim().length > 0);
@@ -104023,7 +104160,7 @@ init_path_security();
 import * as fsSync5 from "node:fs";
 import { existsSync as existsSync61, realpathSync as realpathSync13 } from "node:fs";
 import * as fsPromises5 from "node:fs/promises";
-import * as os14 from "node:os";
+import * as os15 from "node:os";
 import * as path101 from "node:path";
 
 // src/tools/symbols.ts
@@ -104777,8 +104914,8 @@ function isRefusedWorkspaceRoot(target) {
       refused.add(path101.resolve(p));
     }
   };
-  add2(os14.homedir());
-  add2(os14.tmpdir());
+  add2(os15.homedir());
+  add2(os15.tmpdir());
   add2("/");
   add2("/Users");
   add2("/home");