opencode-swarm 7.88.3 → 7.89.0

package/dist/cli/{index-g6f4tt38.js → index-9w07ye9b.js}

@@ -20,7 +20,7 @@ import {
   validateActionability,
   validateActionableFields,
   validateLesson
-} from "./index-32axfg6h.js";
+} from "./index-1ccnwh54.js";
 import {
   appendKnowledge,
   appendRejectedLesson,
@@ -31,23 +31,30 @@ import {
   enforceKnowledgeCap,
   findNearDuplicate,
   inferTags,
+  isLinked,
   normalize,
   readKnowledge,
+  readLinkPointer,
   readRejectedLessons,
   readRetractionRecords,
+  removeLinkPointer,
   resolveHiveKnowledgePath,
   resolveHiveRejectedPath,
+  resolveKnowledgeStoreDir,
+  resolveLinkDir,
   resolveSwarmKnowledgePath,
   rewriteKnowledge,
+  sanitizeLinkId,
   transactFile,
-  transactKnowledge
-} from "./index-e8pk68cc.js";
+  transactKnowledge,
+  writeLinkPointer
+} from "./index-axwxkbdd.js";
 import {
   detectStraySwarmDirs,
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-819xp49y.js";
+} from "./index-bywt2171.js";
 import {
   AGENT_TOOL_MAP,
   ALL_SUBAGENT_NAMES,
@@ -60,7 +67,7 @@ import {
   TOOL_NAME_SET,
   resolveExternalSkillsConfig,
   stripKnownSwarmPrefix
-} from "./index-0asbrmdx.js";
+} from "./index-123s7kjc.js";
 import {
   MAX_TRANSIENT_RETRIES,
   PlanSchema,
@@ -899,7 +906,7 @@ var init_executor = __esm(() => {
 // package.json
 var package_default = {
   name: "opencode-swarm",
-  version: "7.88.3",
+  version: "7.89.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",
@@ -4074,6 +4081,64 @@ function readEarliestSessionStart(directory) {
   }
 }
 
+// src/session/worktree-link-suggestion.ts
+import { execFile } from "child_process";
+var GIT_TIMEOUT_MS = 1500;
+var MAX_SUGGESTED_SESSIONS = 500;
+var _suggestedSessions = new Set;
+function markSuggested(sessionId) {
+  if (_suggestedSessions.has(sessionId)) {
+    return;
+  }
+  if (_suggestedSessions.size >= MAX_SUGGESTED_SESSIONS) {
+    const oldest = _suggestedSessions.values().next().value;
+    if (oldest !== undefined) {
+      _suggestedSessions.delete(oldest);
+    }
+  }
+  _suggestedSessions.add(sessionId);
+}
+function countWorktrees(directory) {
+  return new Promise((resolve4) => {
+    try {
+      const child = execFile("git", ["-C", directory, "worktree", "list", "--porcelain"], { timeout: GIT_TIMEOUT_MS, windowsHide: true, encoding: "utf-8" }, (err, stdout) => {
+        if (err || typeof stdout !== "string") {
+          resolve4(0);
+          return;
+        }
+        let count = 0;
+        for (const line of stdout.split(`
+`)) {
+          if (line.startsWith("worktree "))
+            count++;
+        }
+        resolve4(count);
+      });
+      try {
+        child.stdin?.end();
+      } catch {}
+      child.on("error", () => resolve4(0));
+    } catch {
+      resolve4(0);
+    }
+  });
+}
+async function maybeSuggestWorktreeLink(directory, sessionId) {
+  try {
+    if (!directory || !sessionId)
+      return;
+    if (_suggestedSessions.has(sessionId))
+      return;
+    markSuggested(sessionId);
+    if (isLinked(directory))
+      return;
+    const worktrees = await countWorktrees(directory);
+    if (worktrees > 1) {
+      console.warn(`[opencode-swarm] Detected ${worktrees} git worktrees of this repo. ` + "Run `/swarm link` in each to share swarm knowledge across them " + "(or `/swarm link <name>` to share with similar projects).");
+    }
+  } catch {}
+}
+
 // src/state/agent-run-context.ts
 class AgentRunContext {
   runId;
@@ -4119,6 +4184,7 @@ var swarmState = {
   curatorInitAgentNames: [],
   curatorPhaseAgentNames: [],
   curatorPostmortemAgentNames: [],
+  curatorConsolidationAgentNames: [],
   skillImproverAgentNames: [],
   specWriterAgentNames: [],
   currentCriticalShownIds: new Map,
@@ -4145,6 +4211,7 @@ function resetSwarmState() {
   swarmState.curatorInitAgentNames = [];
   swarmState.curatorPhaseAgentNames = [];
   swarmState.curatorPostmortemAgentNames = [];
+  swarmState.curatorConsolidationAgentNames = [];
   swarmState.skillImproverAgentNames = [];
   swarmState.specWriterAgentNames = [];
   swarmState.currentCriticalShownIds.clear();
@@ -4163,6 +4230,7 @@ function resetSwarmStatePreservingSingletons() {
   const preservedCuratorInitAgentNames = swarmState.curatorInitAgentNames;
   const preservedCuratorPhaseAgentNames = swarmState.curatorPhaseAgentNames;
   const preservedCuratorPostmortemAgentNames = swarmState.curatorPostmortemAgentNames;
+  const preservedCuratorConsolidationAgentNames = swarmState.curatorConsolidationAgentNames;
   const preservedSkillImproverAgentNames = swarmState.skillImproverAgentNames;
   const preservedSpecWriterAgentNames = swarmState.specWriterAgentNames;
   const preservedGeneratedAgentNames = swarmState.generatedAgentNames;
@@ -4172,6 +4240,7 @@ function resetSwarmStatePreservingSingletons() {
   swarmState.curatorInitAgentNames = preservedCuratorInitAgentNames;
   swarmState.curatorPhaseAgentNames = preservedCuratorPhaseAgentNames;
   swarmState.curatorPostmortemAgentNames = preservedCuratorPostmortemAgentNames;
+  swarmState.curatorConsolidationAgentNames = preservedCuratorConsolidationAgentNames;
   swarmState.skillImproverAgentNames = preservedSkillImproverAgentNames;
   swarmState.specWriterAgentNames = preservedSpecWriterAgentNames;
   swarmState.generatedAgentNames = preservedGeneratedAgentNames;
@@ -4251,6 +4320,9 @@ function startAgentSession(sessionId, agentName, staleDurationMs = 7200000, dire
     try {
       recordSessionStart(directory, now);
     } catch {}
+    queueMicrotask(() => {
+      maybeSuggestWorktreeLink(directory, sessionId);
+    });
   }
   telemetry.sessionStarted(sessionId, agentName);
   swarmState.activeAgent.set(sessionId, agentName);
@@ -5235,7 +5307,7 @@ function createSwarmTool(opts) {
 // src/tools/checkpoint.ts
 var CHECKPOINT_LOG_PATH = ".swarm/checkpoints.json";
 var MAX_LABEL_LENGTH = 100;
-var GIT_TIMEOUT_MS = 30000;
+var GIT_TIMEOUT_MS2 = 30000;
 var GIT_MAX_BUFFER_BYTES = 5 * 1024 * 1024;
 var SHELL_METACHARACTERS = /[;|&$`(){}<>!'"]/;
 var SAFE_LABEL_PATTERN = /^[a-zA-Z0-9_ -]+$/;
@@ -5315,7 +5387,7 @@ function gitExec(args, cwd) {
     const result = child_process.spawnSync("git", args, {
       cwd,
       encoding: "utf-8",
-      timeout: GIT_TIMEOUT_MS,
+      timeout: GIT_TIMEOUT_MS2,
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true,
       maxBuffer: GIT_MAX_BUFFER_BYTES
@@ -5720,13 +5792,15 @@ function resolveCuratorAgentName(mode, sessionId) {
   const suffixMap = {
     init: "curator_init",
     phase: "curator_phase",
-    postmortem: "curator_postmortem"
+    postmortem: "curator_postmortem",
+    consolidation: "curator_consolidation"
   };
   const suffix = suffixMap[mode];
   const registeredNamesMap = {
     init: swarmState.curatorInitAgentNames,
     phase: swarmState.curatorPhaseAgentNames,
-    postmortem: swarmState.curatorPostmortemAgentNames
+    postmortem: swarmState.curatorPostmortemAgentNames,
+    consolidation: swarmState.curatorConsolidationAgentNames
   };
   const registeredNames = registeredNamesMap[mode];
   if (registeredNames.length === 1)
@@ -6171,7 +6245,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings.push(`Pending proposals capped at ${MAX_PROPOSALS} (had ${proposals.length}); older entries truncated.`);
       proposals = proposals.slice(0, MAX_PROPOSALS);
     }
-    const unactionablePath = path13.join(directory, ".swarm", "knowledge-unactionable.jsonl");
+    const unactionablePath = path13.join(resolveKnowledgeStoreDir(directory), "knowledge-unactionable.jsonl");
     let unactionable = readJsonlFile(unactionablePath, MAX_UNACTIONABLE);
     if (unactionable.length > MAX_UNACTIONABLE) {
       warnings.push(`Unactionable entries capped at ${MAX_UNACTIONABLE} (had ${unactionable.length}); older entries truncated.`);
@@ -6190,7 +6264,7 @@ async function runCuratorPostMortem(directory, options = {}) {
     let reportContent;
     if (options.llmDelegate) {
       try {
-        const { CURATOR_POSTMORTEM_PROMPT: CURATOR_POSTMORTEM_PROMPT2 } = await import("./explorer-gz70sm9b.js");
+        const { CURATOR_POSTMORTEM_PROMPT: CURATOR_POSTMORTEM_PROMPT2 } = await import("./explorer-h2fnj343.js");
         const userInput = assembleLLMInput(effectivePlanId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports);
         const ac = new AbortController;
         const timer = setTimeout(() => ac.abort(), 300000);
@@ -11282,6 +11356,10 @@ var ACTIVE_STATE_TO_CLEAN = [
   "swarm.db-shm",
   "swarm.db-wal"
 ];
+var KNOWLEDGE_FAMILY_ARTIFACTS = new Set([
+  "knowledge.jsonl",
+  "knowledge-rejected.jsonl"
+]);
 var ACTIVE_STATE_DIRS_TO_CLEAN = [
   "evidence",
   "session",
@@ -11539,7 +11617,7 @@ async function runFinalizeStage(ctx) {
     }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-vb6jkxgg.js");
+    const { CuratorConfigSchema: CCS } = await import("./schema-t9th7frq.js");
     const { config: pmLoadedConfig } = _internals20.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
@@ -11641,10 +11719,17 @@ async function runArchiveStage(ctx) {
   try {
     await fs11.mkdir(ctx.archiveDir, { recursive: true });
     const WAL_SIDECAR_FILES = new Set(["swarm.db-shm", "swarm.db-wal"]);
+    const linkedKnowledgeShared = isLinked(ctx.directory);
+    if (linkedKnowledgeShared) {
+      ctx.warnings.push("Worktree is linked: shared knowledge (knowledge.jsonl, knowledge-rejected.jsonl) lives in the link store and is not archived or cleaned by /swarm close. Manage it via the link.");
+    }
     for (const artifact of ARCHIVE_ARTIFACTS) {
       if (WAL_SIDECAR_FILES.has(artifact)) {
         continue;
       }
+      if (linkedKnowledgeShared && KNOWLEDGE_FAMILY_ARTIFACTS.has(artifact)) {
+        continue;
+      }
       const srcPath = path24.join(ctx.swarmDir, artifact);
       const destPath = path24.join(ctx.archiveDir, artifact);
       if (artifact === "swarm.db") {
@@ -11734,8 +11819,19 @@ async function runArchiveEvidenceRetention(ctx) {
 async function runCleanStage(ctx) {
   let configBackupsRemoved = 0;
   const cleanedFiles = [];
+  const linkedKnowledgeShared = isLinked(ctx.directory);
+  if (linkedKnowledgeShared) {
+    for (const artifact of KNOWLEDGE_FAMILY_ARTIFACTS) {
+      if (ctx.archivedActiveStateFiles.has(artifact)) {
+        ctx.warnings.push(`[link-guard] Shared knowledge artifact "${artifact}" appears in ` + "the archive set while this worktree is linked \u2014 archive stage " + "should have skipped it. Artifact will NOT be deleted.");
+      }
+    }
+  }
   if (ctx.archivedActiveStateFiles.size > 0) {
     for (const artifact of ACTIVE_STATE_TO_CLEAN) {
+      if (linkedKnowledgeShared && KNOWLEDGE_FAMILY_ARTIFACTS.has(artifact)) {
+        continue;
+      }
       if (!ctx.archivedActiveStateFiles.has(artifact)) {
         const reason = ctx.archiveFailureReasons?.get(artifact);
         ctx.warnings.push(reason ? `Preserved ${artifact} because it was not successfully archived: ${reason}.` : `Preserved ${artifact} because it was not successfully archived.`);
@@ -15220,7 +15316,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-jzbgpbdh.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-g04wdz19.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true);
     output = formatDoctorMarkdown(fixResult.result);
   } else {
@@ -17969,7 +18065,7 @@ async function handleKnowledgeRestoreCommand(directory, args) {
     return "Invalid entry ID. IDs must be 1-64 characters: letters, digits, hyphens, underscores only.";
   }
   try {
-    const quarantinePath = join30(directory, ".swarm", "knowledge-quarantined.jsonl");
+    const quarantinePath = join30(resolveKnowledgeStoreDir(directory), "knowledge-quarantined.jsonl");
     const entries = await readKnowledge(quarantinePath);
     const resolved = resolveEntryByPrefix(entries, inputId);
     if ("error" in resolved) {
@@ -18219,6 +18315,163 @@ var _internals31 = {
   computeLearningMetrics
 };
 
+// src/commands/link.ts
+import { existsSync as existsSync23 } from "fs";
+import * as path39 from "path";
+
+// src/knowledge/identity.ts
+import * as child_process5 from "child_process";
+import { createHash as createHash4 } from "crypto";
+import * as path38 from "path";
+function deriveProjectHash(directory) {
+  const absolutePath = path38.resolve(directory);
+  let hashInput;
+  try {
+    const remoteUrl = child_process5.execSync("git remote get-url origin", {
+      cwd: directory,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"],
+      timeout: 1500
+    }).trim();
+    hashInput = remoteUrl.length > 0 ? remoteUrl : absolutePath;
+  } catch {
+    hashInput = absolutePath;
+  }
+  const hash = createHash4("sha256").update(hashInput).digest("hex");
+  return hash.slice(0, 12);
+}
+
+// src/commands/link.ts
+var DEDUP_THRESHOLD = 0.6;
+async function mergeLocalKnowledgeIntoLink(localSwarmDir, linkDir) {
+  const localPath = path39.join(localSwarmDir, "knowledge.jsonl");
+  const sharedPath = path39.join(linkDir, "knowledge.jsonl");
+  if (!existsSync23(localPath))
+    return { merged: 0, skipped: 0 };
+  let merged = 0;
+  let skipped = 0;
+  const { readFileSync: readFileSync15 } = await import("fs");
+  let changed = false;
+  await transactKnowledge(sharedPath, (sharedEntries) => {
+    const localEntries = [];
+    try {
+      const content = readFileSync15(localPath, "utf-8");
+      for (const line of content.split(`
+`)) {
+        if (line.trim()) {
+          try {
+            localEntries.push(JSON.parse(line));
+          } catch {}
+        }
+      }
+    } catch {
+      return null;
+    }
+    if (localEntries.length === 0)
+      return null;
+    const result = [...sharedEntries];
+    const seenIds = new Set(result.map((e) => e.id));
+    changed = false;
+    for (const entry of localEntries) {
+      if (seenIds.has(entry.id)) {
+        skipped++;
+        continue;
+      }
+      if (findNearDuplicate(entry.lesson, result, DEDUP_THRESHOLD)) {
+        skipped++;
+        continue;
+      }
+      result.push(entry);
+      seenIds.add(entry.id);
+      merged++;
+      changed = true;
+    }
+    return changed ? result : null;
+  });
+  return { merged, skipped };
+}
+function formatStatus(directory) {
+  const pointer = readLinkPointer(directory);
+  if (!pointer) {
+    return [
+      "\u2139\uFE0F This worktree is NOT linked. Its swarm knowledge is local to `.swarm/`.",
+      "Run `/swarm link` to share knowledge across worktrees of this repo,",
+      "or `/swarm link <name>` to share with deliberately similar projects."
+    ].join(`
+`);
+  }
+  const linkDir = resolveLinkDir(pointer.linkId);
+  const lines = [
+    "\uD83D\uDD17 Linked \u2014 swarm knowledge is shared.",
+    `  link id:   ${pointer.linkId}`
+  ];
+  if (pointer.name)
+    lines.push(`  name:      ${pointer.name}`);
+  lines.push(`  shared at: ${linkDir}`);
+  lines.push(`  since:     ${pointer.createdAt}`);
+  lines.push("Run `/swarm unlink` to stop sharing (keeps a local copy).");
+  return lines.join(`
+`);
+}
+async function handleLinkCommand(directory, args) {
+  const first = args[0];
+  if (first === "status") {
+    return formatStatus(directory);
+  }
+  const nameArg = args.find((a) => !a.startsWith("--"));
+  let linkId;
+  let displayName;
+  if (nameArg) {
+    const sanitized = sanitizeLinkId(nameArg);
+    if (!sanitized) {
+      return `\u274C Invalid link name "${nameArg}". Use letters, digits, '.', '-', or '_'.`;
+    }
+    linkId = sanitized;
+    displayName = nameArg;
+  } else {
+    try {
+      linkId = deriveProjectHash(directory);
+    } catch (error2) {
+      return `\u274C Failed to derive project hash: ${error2 instanceof Error ? error2.message : String(error2)}`;
+    }
+  }
+  const existing = readLinkPointer(directory);
+  if (existing && existing.linkId === linkId) {
+    return `\u2139\uFE0F Already linked to "${linkId}".
+${formatStatus(directory)}`;
+  }
+  const linkDir = resolveLinkDir(linkId);
+  let merge;
+  try {
+    merge = await mergeLocalKnowledgeIntoLink(path39.join(directory, ".swarm"), linkDir);
+  } catch (error2) {
+    return `\u274C Failed to merge local knowledge into the link store: ${error2 instanceof Error ? error2.message : String(error2)}`;
+  }
+  const pointer = {
+    version: 1,
+    linkId,
+    name: displayName,
+    createdAt: new Date().toISOString(),
+    source: "manual"
+  };
+  try {
+    await writeLinkPointer(directory, pointer);
+  } catch (error2) {
+    return `\u274C Failed to write link pointer: ${error2 instanceof Error ? error2.message : String(error2)}`;
+  }
+  const relinkNote = existing ? `
+(Re-linked from previous link "${existing.linkId}".)` : "";
+  const historyNote = merge.merged > 0 ? `
+  note: merged lessons keep their text; their outcome-history counters re-accrue in the shared store.` : "";
+  return [
+    `\uD83D\uDD17 Linked this worktree to shared knowledge store "${linkId}".`,
+    `  merged ${merge.merged} local lesson(s) into the shared store` + (merge.skipped > 0 ? ` (${merge.skipped} already present)` : "") + ".",
+    `  shared at: ${linkDir}`,
+    "All swarms linked to this id now read and write the same knowledge." + relinkNote + historyNote
+  ].join(`
+`);
+}
+
 // src/commands/loop.ts
 var MAX_OBJECTIVE_LEN = 2000;
 var DEPTHS2 = new Set(["standard", "exhaustive"]);
@@ -18334,11 +18587,42 @@ ${USAGE7}`;
 }
 
 // src/commands/memory.ts
-import { existsSync as existsSync25 } from "fs";
-import * as path43 from "path";
+import { existsSync as existsSync26 } from "fs";
+import * as path46 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/memory/config.ts
+var DEFAULT_DECAY_HALF_LIFE_DAYS = {
+  scratch: 7,
+  todo: 30,
+  code_pattern: 90,
+  test_pattern: 90,
+  failure_pattern: 90,
+  api_finding: 180,
+  evidence: 180,
+  architecture_decision: 0,
+  repo_convention: 0,
+  project_fact: 0,
+  security_note: 0,
+  user_preference: 0
+};
+var DEFAULT_IMPORTANCE_CONFIG = {
+  wRecency: 0.2,
+  wFrequency: 0.2,
+  wFreshness: 0.15,
+  wConfidence: 0.25,
+  lambda: 0.05,
+  mu: 0.01,
+  n: 50,
+  threshold: 0.2
+};
+var DEFAULT_CONSOLIDATION_CONFIG = {
+  enabled: false,
+  maxClustersPerPass: 10,
+  jaccardThreshold: 0.3,
+  autoApplyMinConfidence: 0.6,
+  decayHalfLifeDays: { ...DEFAULT_DECAY_HALF_LIFE_DAYS }
+};
 var DEFAULT_MEMORY_CONFIG = {
   enabled: false,
   provider: "sqlite",
@@ -18368,7 +18652,12 @@ var DEFAULT_MEMORY_CONFIG = {
   maintenance: {
     lowUtilityMaxConfidence: 0.45,
     lowUtilityMinAgeDays: 30,
-    autoCompactEveryNRecalls: 50
+    autoCompactEveryNRecalls: 50,
+    importance: { ...DEFAULT_IMPORTANCE_CONFIG }
+  },
+  consolidation: {
+    ...DEFAULT_CONSOLIDATION_CONFIG,
+    decayHalfLifeDays: { ...DEFAULT_DECAY_HALF_LIFE_DAYS }
   },
   hardDelete: false
 };
@@ -18413,7 +18702,19 @@ function resolveMemoryConfig(input) {
     },
     maintenance: {
       ...DEFAULT_MEMORY_CONFIG.maintenance,
-      ...input?.maintenance ?? {}
+      ...input?.maintenance ?? {},
+      importance: {
+        ...DEFAULT_MEMORY_CONFIG.maintenance.importance,
+        ...input?.maintenance?.importance ?? {}
+      }
+    },
+    consolidation: {
+      ...DEFAULT_MEMORY_CONFIG.consolidation,
+      ...input?.consolidation ?? {},
+      decayHalfLifeDays: {
+        ...DEFAULT_MEMORY_CONFIG.consolidation.decayHalfLifeDays,
+        ...input?.consolidation?.decayHalfLifeDays ?? {}
+      }
     }
   };
 }
@@ -18429,11 +18730,11 @@ class MemoryValidationError extends Error {
 // src/memory/evaluation.ts
 import * as fs17 from "fs/promises";
 import * as os9 from "os";
-import * as path42 from "path";
+import * as path44 from "path";
 
 // src/memory/local-jsonl-provider.ts
 import { randomUUID as randomUUID5 } from "crypto";
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync24 } from "fs";
 import {
   appendFile as appendFile3,
   mkdir as mkdir10,
@@ -18441,10 +18742,10 @@ import {
   rename as rename5,
   writeFile as writeFile10
 } from "fs/promises";
-import * as path38 from "path";
+import * as path40 from "path";
 
 // src/memory/schema.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 
 // src/memory/redaction.ts
 var SECRET_PATTERNS = [
@@ -18501,6 +18802,9 @@ function containsSecret(text) {
   return findSecrets(text).length > 0;
 }
 
+// src/memory/sentinel.ts
+var MEMORY_RECALL_SENTINEL = "## Retrieved Swarm Memory";
+
 // src/memory/schema.ts
 var MemoryScopeTypeSchema = exports_external.enum([
   "global_user",
@@ -18684,7 +18988,7 @@ function stableScopeKey(scope) {
 }
 function computeMemoryContentHash(recordLike) {
   const normalized = normalizeMemoryText(recordLike.text).toLowerCase();
-  return createHash4("sha256").update(`${stableScopeKey(recordLike.scope)}
+  return createHash5("sha256").update(`${stableScopeKey(recordLike.scope)}
 ${recordLike.kind}
 ${normalized}`).digest("hex");
 }
@@ -18702,6 +19006,9 @@ function hasEvidenceSource(record) {
 }
 function validateMemoryRecordRules(record, options) {
   const parsed = MemoryRecordSchema.parse(record);
+  if (parsed.text.includes(MEMORY_RECALL_SENTINEL)) {
+    throw new MemoryValidationError("memory text cannot contain the recall sentinel header");
+  }
   const expectedHash = computeMemoryContentHash(parsed);
   const expectedId = createMemoryId(parsed);
   if (parsed.contentHash !== expectedHash) {
@@ -18813,165 +19120,6 @@ function normalizeTags(tags) {
   return Array.from(new Set(tags.map((tag) => tag.toLowerCase().replace(/[^\w-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "")).filter(Boolean))).slice(0, 32);
 }
 
-// src/memory/maintenance.ts
-var DEFAULT_LOW_UTILITY_MAX_CONFIDENCE = 0.45;
-var DEFAULT_LOW_UTILITY_MIN_AGE_DAYS = 30;
-async function buildMemoryMaintenanceReport(provider, options = {}) {
-  const now = options.now ?? new Date;
-  const limit = Math.max(1, Math.trunc(options.limit ?? 20));
-  const memories = await provider.list({
-    includeExpired: true,
-    includeInactive: true
-  });
-  const proposals = await loadMaintenanceProposals(provider, limit);
-  const recallUsage = provider.listRecallUsage ? await provider.listRecallUsage() : [];
-  const usageByMemory = summarizeRecallByMemory(recallUsage);
-  const usageByRole = summarizeRecallByRole(recallUsage);
-  const activeMemories = memories.filter((memory) => isActiveMemory(memory, now));
-  const deletedMemories = memories.filter((memory) => memory.metadata.deleted === true);
-  const expiredScratchMemories = memories.filter((memory) => memory.kind === "scratch" && isExpired(memory, now));
-  const supersededMemories = memories.filter((memory) => Boolean(memory.supersededBy));
-  const lowUtilityMemories = activeMemories.filter((memory) => isLowUtility(memory, usageByMemory, now, {
-    maxConfidence: options.lowUtilityMaxConfidence ?? DEFAULT_LOW_UTILITY_MAX_CONFIDENCE,
-    minAgeDays: options.lowUtilityMinAgeDays ?? DEFAULT_LOW_UTILITY_MIN_AGE_DAYS
-  })).sort(memorySort);
-  const neverRecalledMemories = activeMemories.filter((memory) => !usageByMemory.has(memory.id)).sort(memorySort);
-  const rejectedProposalReasons = proposals.filter((proposal) => proposal.status === "rejected").sort(proposalSort);
-  const pendingProposals = proposals.filter((proposal) => proposal.status === "pending").sort(proposalSort);
-  return {
-    generatedAt: now.toISOString(),
-    totalMemories: memories.length,
-    activeMemories: activeMemories.length,
-    deletedMemories: deletedMemories.slice(0, limit),
-    expiredScratchMemories: expiredScratchMemories.slice(0, limit),
-    supersededMemories: supersededMemories.slice(0, limit),
-    supersededChains: buildSupersededChains(memories).slice(0, limit),
-    lowUtilityMemories: lowUtilityMemories.slice(0, limit),
-    neverRecalledMemories: neverRecalledMemories.slice(0, limit),
-    mostRecalledMemories: Array.from(usageByMemory.values()).sort((a, b) => b.count - a.count || b.lastRecalledAt.localeCompare(a.lastRecalledAt) || a.memoryId.localeCompare(b.memoryId)).slice(0, limit),
-    recallByAgentRole: Array.from(usageByRole.values()).sort((a, b) => b.count - a.count || a.agentRole.localeCompare(b.agentRole)).slice(0, limit),
-    rejectedProposalReasons: rejectedProposalReasons.slice(0, limit),
-    pendingProposals: pendingProposals.slice(0, limit),
-    recallEventCount: recallUsage.length
-  };
-}
-function shouldCompactMemory(memory, now = new Date) {
-  if (memory.metadata.deleted === true)
-    return "deleted";
-  if (memory.supersededBy)
-    return "superseded";
-  if (memory.kind === "scratch" && isExpired(memory, now)) {
-    return "expired_scratch";
-  }
-  return null;
-}
-function isActiveMemory(memory, now) {
-  return memory.metadata.deleted !== true && !memory.supersededBy && !isExpired(memory, now);
-}
-function isLowUtility(memory, usageByMemory, now, options) {
-  if (usageByMemory.has(memory.id))
-    return false;
-  const updated = Date.parse(memory.updatedAt);
-  const ageDays = Number.isFinite(updated) ? (now.getTime() - updated) / (24 * 60 * 60 * 1000) : 0;
-  return memory.confidence <= options.maxConfidence || ageDays >= options.minAgeDays;
-}
-function summarizeRecallByMemory(usageEvents) {
-  const byMemory = new Map;
-  for (const event of usageEvents) {
-    event.memoryIds.forEach((memoryId, index) => {
-      const role = event.agentRole ?? "unknown";
-      const existing = byMemory.get(memoryId) ?? {
-        memoryId,
-        count: 0,
-        lastRecalledAt: event.timestamp,
-        agentRoles: {},
-        averageScore: 0,
-        scoreTotal: 0,
-        scoreCount: 0
-      };
-      existing.count++;
-      existing.lastRecalledAt = event.timestamp > existing.lastRecalledAt ? event.timestamp : existing.lastRecalledAt;
-      existing.agentRoles[role] = (existing.agentRoles[role] ?? 0) + 1;
-      const score = event.scores[index];
-      if (typeof score === "number" && Number.isFinite(score)) {
-        existing.scoreTotal += score;
-        existing.scoreCount++;
-        existing.averageScore = existing.scoreTotal / existing.scoreCount;
-      }
-      byMemory.set(memoryId, existing);
-    });
-  }
-  return new Map(Array.from(byMemory, ([memoryId, value]) => [
-    memoryId,
-    {
-      memoryId,
-      count: value.count,
-      lastRecalledAt: value.lastRecalledAt,
-      agentRoles: value.agentRoles,
-      averageScore: value.averageScore
-    }
-  ]));
-}
-async function loadMaintenanceProposals(provider, limit) {
-  if (!provider.listProposals)
-    return [];
-  const [pending, rejected, recent] = await Promise.all([
-    provider.listProposals({ status: "pending", limit }),
-    provider.listProposals({ status: "rejected", limit }),
-    provider.listProposals({ limit: Math.max(limit * 4, 100) })
-  ]);
-  const byId = new Map;
-  for (const proposal of [...pending, ...rejected, ...recent]) {
-    byId.set(proposal.id, proposal);
-  }
-  return Array.from(byId.values());
-}
-function summarizeRecallByRole(usageEvents) {
-  const byRole = new Map;
-  for (const event of usageEvents) {
-    const role = event.agentRole ?? "unknown";
-    const existing = byRole.get(role) ?? {
-      agentRole: role,
-      count: 0,
-      memoryIds: {}
-    };
-    existing.count++;
-    for (const memoryId of event.memoryIds) {
-      existing.memoryIds[memoryId] = (existing.memoryIds[memoryId] ?? 0) + 1;
-    }
-    byRole.set(role, existing);
-  }
-  return byRole;
-}
-function buildSupersededChains(memories) {
-  const byId = new Map(memories.map((memory) => [memory.id, memory]));
-  const supersededIds = new Set(memories.filter((memory) => memory.supersededBy).map((memory) => memory.id));
-  const roots = memories.filter((memory) => memory.supersededBy && !(memory.supersedes ?? []).some((id) => supersededIds.has(id)));
-  return roots.map((root) => {
-    const chain = [root.id];
-    const seen = new Set(chain);
-    let cursor = root;
-    while (cursor?.supersededBy && !seen.has(cursor.supersededBy)) {
-      chain.push(cursor.supersededBy);
-      seen.add(cursor.supersededBy);
-      cursor = byId.get(cursor.supersededBy);
-    }
-    return {
-      rootId: root.id,
-      chain,
-      reason: typeof root.metadata.supersedeReason === "string" ? root.metadata.supersedeReason : undefined
-    };
-  });
-}
-function memorySort(a, b) {
-  return b.updatedAt.localeCompare(a.updatedAt) || a.id.localeCompare(b.id);
-}
-function proposalSort(a, b) {
-  const aTime = a.reviewedAt ?? a.createdAt;
-  const bTime = b.reviewedAt ?? b.createdAt;
-  return bTime.localeCompare(aTime) || a.id.localeCompare(b.id);
-}
-
 // src/memory/role-profiles.ts
 var MEMORY_RECALL_PROFILES = {
   architect: {
@@ -19079,6 +19227,14 @@ var SCORING_WEIGHTS = {
 function tokenize(text) {
   return new Set(text.toLowerCase().replace(/[^\w\s-]/g, " ").split(/\s+/).map((token) => token.trim()).filter(Boolean));
 }
+function importanceScore(input, weights) {
+  const recency = input.daysSinceLastRecall === null ? 0 : Math.exp(-weights.lambda * Math.max(0, input.daysSinceLastRecall));
+  const denom = Math.log1p(Math.max(1, weights.n));
+  const frequency = denom === 0 ? 0 : Math.log1p(Math.max(0, input.retrievalCount)) / denom;
+  const freshness = Math.exp(-weights.mu * Math.max(0, input.daysSinceCreated));
+  const confidence = Math.min(1, Math.max(0, input.confidence));
+  return weights.wRecency * recency + weights.wFrequency * frequency + weights.wFreshness * freshness + weights.wConfidence * confidence;
+}
 function normalizeKindText(kind) {
   return kind.replace(/_/g, " ");
 }
@@ -19258,6 +19414,180 @@ function unionTokens(...sets) {
   return union;
 }
 
+// src/memory/maintenance.ts
+var DEFAULT_IMPORTANCE_WEIGHTS = {
+  wRecency: 0.2,
+  wFrequency: 0.2,
+  wFreshness: 0.15,
+  wConfidence: 0.25,
+  lambda: 0.05,
+  mu: 0.01,
+  n: 50
+};
+var DEFAULT_IMPORTANCE_THRESHOLD = 0.2;
+var MS_PER_DAY2 = 24 * 60 * 60 * 1000;
+async function buildMemoryMaintenanceReport(provider, options = {}) {
+  const now = options.now ?? new Date;
+  const limit = Math.max(1, Math.trunc(options.limit ?? 20));
+  const memories = await provider.list({
+    includeExpired: true,
+    includeInactive: true
+  });
+  const proposals = await loadMaintenanceProposals(provider, limit);
+  const recallUsage = provider.listRecallUsage ? await provider.listRecallUsage() : [];
+  const usageByMemory = summarizeRecallByMemory(recallUsage);
+  const usageByRole = summarizeRecallByRole(recallUsage);
+  const activeMemories = memories.filter((memory) => isActiveMemory(memory, now));
+  const deletedMemories = memories.filter((memory) => memory.metadata.deleted === true);
+  const expiredScratchMemories = memories.filter((memory) => memory.kind === "scratch" && isExpired(memory, now));
+  const supersededMemories = memories.filter((memory) => Boolean(memory.supersededBy));
+  const lowUtilityMemories = activeMemories.filter((memory) => isLowUtility(memory, usageByMemory, now, {
+    weights: options.importanceWeights ?? DEFAULT_IMPORTANCE_WEIGHTS,
+    threshold: options.importanceThreshold ?? DEFAULT_IMPORTANCE_THRESHOLD
+  })).sort(memorySort);
+  const neverRecalledMemories = activeMemories.filter((memory) => !usageByMemory.has(memory.id)).sort(memorySort);
+  const rejectedProposalReasons = proposals.filter((proposal) => proposal.status === "rejected").sort(proposalSort);
+  const pendingProposals = proposals.filter((proposal) => proposal.status === "pending").sort(proposalSort);
+  return {
+    generatedAt: now.toISOString(),
+    totalMemories: memories.length,
+    activeMemories: activeMemories.length,
+    deletedMemories: deletedMemories.slice(0, limit),
+    expiredScratchMemories: expiredScratchMemories.slice(0, limit),
+    supersededMemories: supersededMemories.slice(0, limit),
+    supersededChains: buildSupersededChains(memories).slice(0, limit),
+    lowUtilityMemories: lowUtilityMemories.slice(0, limit),
+    neverRecalledMemories: neverRecalledMemories.slice(0, limit),
+    mostRecalledMemories: Array.from(usageByMemory.values()).sort((a, b) => b.count - a.count || b.lastRecalledAt.localeCompare(a.lastRecalledAt) || a.memoryId.localeCompare(b.memoryId)).slice(0, limit),
+    recallByAgentRole: Array.from(usageByRole.values()).sort((a, b) => b.count - a.count || a.agentRole.localeCompare(b.agentRole)).slice(0, limit),
+    rejectedProposalReasons: rejectedProposalReasons.slice(0, limit),
+    pendingProposals: pendingProposals.slice(0, limit),
+    recallEventCount: recallUsage.length
+  };
+}
+function shouldCompactMemory(memory, now = new Date) {
+  if (memory.metadata.deleted === true)
+    return "deleted";
+  if (memory.supersededBy)
+    return "superseded";
+  if (memory.kind === "scratch" && isExpired(memory, now)) {
+    return "expired_scratch";
+  }
+  return null;
+}
+function isActiveMemory(memory, now) {
+  return memory.metadata.deleted !== true && !memory.supersededBy && !isExpired(memory, now);
+}
+function isLowUtility(memory, usageByMemory, now, options) {
+  if (usageByMemory.has(memory.id))
+    return false;
+  const created = Date.parse(memory.createdAt);
+  const daysSinceCreated = Number.isFinite(created) ? Math.max(0, (now.getTime() - created) / MS_PER_DAY2) : 0;
+  const importance = importanceScore({
+    confidence: memory.confidence,
+    retrievalCount: 0,
+    daysSinceLastRecall: null,
+    daysSinceCreated
+  }, options.weights);
+  return importance < options.threshold;
+}
+function summarizeRecallByMemory(usageEvents) {
+  const byMemory = new Map;
+  for (const event of usageEvents) {
+    event.memoryIds.forEach((memoryId, index) => {
+      const role = event.agentRole ?? "unknown";
+      const existing = byMemory.get(memoryId) ?? {
+        memoryId,
+        count: 0,
+        lastRecalledAt: event.timestamp,
+        agentRoles: {},
+        averageScore: 0,
+        scoreTotal: 0,
+        scoreCount: 0
+      };
+      existing.count++;
+      existing.lastRecalledAt = event.timestamp > existing.lastRecalledAt ? event.timestamp : existing.lastRecalledAt;
+      existing.agentRoles[role] = (existing.agentRoles[role] ?? 0) + 1;
+      const score = event.scores[index];
+      if (typeof score === "number" && Number.isFinite(score)) {
+        existing.scoreTotal += score;
+        existing.scoreCount++;
+        existing.averageScore = existing.scoreTotal / existing.scoreCount;
+      }
+      byMemory.set(memoryId, existing);
+    });
+  }
+  return new Map(Array.from(byMemory, ([memoryId, value]) => [
+    memoryId,
+    {
+      memoryId,
+      count: value.count,
+      lastRecalledAt: value.lastRecalledAt,
+      agentRoles: value.agentRoles,
+      averageScore: value.averageScore
+    }
+  ]));
+}
+async function loadMaintenanceProposals(provider, limit) {
+  if (!provider.listProposals)
+    return [];
+  const [pending, rejected, recent] = await Promise.all([
+    provider.listProposals({ status: "pending", limit }),
+    provider.listProposals({ status: "rejected", limit }),
+    provider.listProposals({ limit: Math.max(limit * 4, 100) })
+  ]);
+  const byId = new Map;
+  for (const proposal of [...pending, ...rejected, ...recent]) {
+    byId.set(proposal.id, proposal);
+  }
+  return Array.from(byId.values());
+}
+function summarizeRecallByRole(usageEvents) {
+  const byRole = new Map;
+  for (const event of usageEvents) {
+    const role = event.agentRole ?? "unknown";
+    const existing = byRole.get(role) ?? {
+      agentRole: role,
+      count: 0,
+      memoryIds: {}
+    };
+    existing.count++;
+    for (const memoryId of event.memoryIds) {
+      existing.memoryIds[memoryId] = (existing.memoryIds[memoryId] ?? 0) + 1;
+    }
+    byRole.set(role, existing);
+  }
+  return byRole;
+}
+function buildSupersededChains(memories) {
+  const byId = new Map(memories.map((memory) => [memory.id, memory]));
+  const supersededIds = new Set(memories.filter((memory) => memory.supersededBy).map((memory) => memory.id));
+  const roots = memories.filter((memory) => memory.supersededBy && !(memory.supersedes ?? []).some((id) => supersededIds.has(id)));
+  return roots.map((root) => {
+    const chain = [root.id];
+    const seen = new Set(chain);
+    let cursor = root;
+    while (cursor?.supersededBy && !seen.has(cursor.supersededBy)) {
+      chain.push(cursor.supersededBy);
+      seen.add(cursor.supersededBy);
+      cursor = byId.get(cursor.supersededBy);
+    }
+    return {
+      rootId: root.id,
+      chain,
+      reason: typeof root.metadata.supersedeReason === "string" ? root.metadata.supersedeReason : undefined
+    };
+  });
+}
+function memorySort(a, b) {
+  return b.updatedAt.localeCompare(a.updatedAt) || a.id.localeCompare(b.id);
+}
+function proposalSort(a, b) {
+  const aTime = a.reviewedAt ?? a.createdAt;
+  const bTime = b.reviewedAt ?? b.createdAt;
+  return bTime.localeCompare(aTime) || a.id.localeCompare(b.id);
+}
+
 // src/memory/local-jsonl-provider.ts
 class LocalJsonlMemoryProvider {
   name = "local-jsonl";
@@ -19273,7 +19603,7 @@ class LocalJsonlMemoryProvider {
   pathFor(file) {
     const storageDir = this.config.storageDir.replace(/^\.swarm[/\\]?/, "");
     const filename = file === "memories" ? "memories.jsonl" : file === "proposals" ? "proposals.jsonl" : "audit.jsonl";
-    return validateSwarmPath(this.rootDirectory, path38.join(storageDir, filename));
+    return validateSwarmPath(this.rootDirectory, path40.join(storageDir, filename));
   }
   async initialize() {
     if (this.initialized)
@@ -19600,7 +19930,7 @@ function validateLoadedProposals(values, config) {
   return { records, invalidCount };
 }
 async function readJsonl(filePath) {
-  if (!existsSync23(filePath))
+  if (!existsSync24(filePath))
     return [];
   const content = await readFile12(filePath, "utf-8");
   const records = [];
@@ -19656,12 +19986,12 @@ function parseRecallUsageEvent(event) {
   }
 }
 async function appendJsonl(filePath, value) {
-  await mkdir10(path38.dirname(filePath), { recursive: true });
+  await mkdir10(path40.dirname(filePath), { recursive: true });
   await appendFile3(filePath, `${JSON.stringify(value)}
 `, "utf-8");
 }
 async function writeJsonlAtomic(filePath, values) {
-  await mkdir10(path38.dirname(filePath), { recursive: true });
+  await mkdir10(path40.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp.${randomUUID5()}`;
   const content = values.map((value) => JSON.stringify(value)).join(`
 `) + (values.length > 0 ? `
@@ -19672,18 +20002,18 @@ async function writeJsonlAtomic(filePath, values) {
 
 // src/memory/provider-pool.ts
 import { realpathSync as realpathSync2 } from "fs";
-import * as path41 from "path";
+import * as path43 from "path";
 
 // src/memory/sqlite-provider.ts
 import { randomUUID as randomUUID6 } from "crypto";
 import { mkdirSync as mkdirSync15 } from "fs";
 import { createRequire as createRequire2 } from "module";
-import * as path40 from "path";
+import * as path42 from "path";
 
 // src/memory/jsonl-migration.ts
-import { existsSync as existsSync24, renameSync as renameSync10, unlinkSync as unlinkSync6 } from "fs";
+import { existsSync as existsSync25, renameSync as renameSync10, unlinkSync as unlinkSync6 } from "fs";
 import { copyFile as copyFile2, mkdir as mkdir11, readFile as readFile13, stat as stat5, writeFile as writeFile11 } from "fs/promises";
-import * as path39 from "path";
+import * as path41 from "path";
 var LEGACY_JSONL_MIGRATION_VERSION = 2;
 var LEGACY_JSONL_MIGRATION_NAME = "legacy_jsonl_import_complete";
 function resolveMemoryStorageDir(rootDirectory, config = {}) {
@@ -19699,8 +20029,8 @@ function resolveSqliteDatabasePath(rootDirectory, config = {}) {
 async function readLegacyJsonl(rootDirectory, config = {}) {
   const resolved = resolveConfig(config);
   const storageDir = resolveMemoryStorageDir(rootDirectory, resolved);
-  const memoryLoad = await readMemoryJsonl(path39.join(storageDir, "memories.jsonl"), resolved);
-  const proposalLoad = await readProposalJsonl(path39.join(storageDir, "proposals.jsonl"), resolved);
+  const memoryLoad = await readMemoryJsonl(path41.join(storageDir, "memories.jsonl"), resolved);
+  const proposalLoad = await readProposalJsonl(path41.join(storageDir, "proposals.jsonl"), resolved);
   return {
     memories: memoryLoad.records,
     proposals: proposalLoad.records,
@@ -19710,15 +20040,15 @@ async function readLegacyJsonl(rootDirectory, config = {}) {
 }
 async function backupLegacyJsonl(rootDirectory, config = {}) {
   const storageDir = resolveMemoryStorageDir(rootDirectory, config);
-  const backupDir = path39.join(storageDir, "backups");
+  const backupDir = path41.join(storageDir, "backups");
   await mkdir11(backupDir, { recursive: true });
   const results = [];
   for (const filename of ["memories.jsonl", "proposals.jsonl"]) {
-    const source = path39.join(storageDir, filename);
-    if (!existsSync24(source))
+    const source = path41.join(storageDir, filename);
+    if (!existsSync25(source))
       continue;
-    const backup = path39.join(backupDir, `${filename}.pre-sqlite-migration`);
-    if (existsSync24(backup)) {
+    const backup = path41.join(backupDir, `${filename}.pre-sqlite-migration`);
+    if (existsSync25(backup)) {
       results.push({ source, backup, created: false });
       continue;
     }
@@ -19728,11 +20058,11 @@ async function backupLegacyJsonl(rootDirectory, config = {}) {
   return results;
 }
 async function writeJsonlExport(rootDirectory, config, memories, proposals) {
-  const exportDir = path39.join(resolveMemoryStorageDir(rootDirectory, config), "export");
+  const exportDir = path41.join(resolveMemoryStorageDir(rootDirectory, config), "export");
   await mkdir11(exportDir, { recursive: true });
-  const memoriesPath = path39.join(exportDir, "memories.jsonl");
-  const proposalsPath = path39.join(exportDir, "proposals.jsonl");
-  const memoriesTempPath = path39.join(path39.dirname(memoriesPath), `${path39.basename(memoriesPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const memoriesPath = path41.join(exportDir, "memories.jsonl");
+  const proposalsPath = path41.join(exportDir, "proposals.jsonl");
+  const memoriesTempPath = path41.join(path41.dirname(memoriesPath), `${path41.basename(memoriesPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await writeFile11(memoriesTempPath, toJsonl(memories), "utf-8");
     renameSync10(memoriesTempPath, memoriesPath);
@@ -19742,7 +20072,7 @@ async function writeJsonlExport(rootDirectory, config, memories, proposals) {
     } catch {}
     throw err;
   }
-  const proposalsTempPath = path39.join(path39.dirname(proposalsPath), `${path39.basename(proposalsPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const proposalsTempPath = path41.join(path41.dirname(proposalsPath), `${path41.basename(proposalsPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await writeFile11(proposalsTempPath, toJsonl(proposals), "utf-8");
     renameSync10(proposalsTempPath, proposalsPath);
@@ -19755,9 +20085,9 @@ async function writeJsonlExport(rootDirectory, config, memories, proposals) {
   return { directory: exportDir, memoriesPath, proposalsPath };
 }
 async function writeMigrationReport(rootDirectory, report, config = {}) {
-  const reportPath = path39.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
-  await mkdir11(path39.dirname(reportPath), { recursive: true });
-  const reportTempPath = path39.join(path39.dirname(reportPath), `${path39.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const reportPath = path41.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
+  await mkdir11(path41.dirname(reportPath), { recursive: true });
+  const reportTempPath = path41.join(path41.dirname(reportPath), `${path41.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await writeFile11(reportTempPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
@@ -19771,8 +20101,8 @@ async function writeMigrationReport(rootDirectory, report, config = {}) {
   return reportPath;
 }
 async function readMigrationReport(rootDirectory, config = {}) {
-  const reportPath = path39.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
-  if (!existsSync24(reportPath))
+  const reportPath = path41.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
+  if (!existsSync25(reportPath))
     return null;
   try {
     return JSON.parse(await readFile13(reportPath, "utf-8"));
@@ -19784,15 +20114,15 @@ async function getLegacyJsonlFileStatus(rootDirectory, config = {}) {
   const storageDir = resolveMemoryStorageDir(rootDirectory, config);
   const statuses = [];
   for (const file of ["memories.jsonl", "proposals.jsonl"]) {
-    const filePath = path39.join(storageDir, file);
+    const filePath = path41.join(storageDir, file);
     let sizeBytes = 0;
-    if (existsSync24(filePath)) {
+    if (existsSync25(filePath)) {
       sizeBytes = (await stat5(filePath)).size;
     }
     statuses.push({
       file,
       path: filePath,
-      exists: existsSync24(filePath),
+      exists: existsSync25(filePath),
       sizeBytes
     });
   }
@@ -19873,7 +20203,7 @@ async function readProposalJsonl(filePath, config) {
   return { records, invalidRows, totalRows: rows.totalRows };
 }
 async function readJsonlRows(filePath) {
-  if (!existsSync24(filePath)) {
+  if (!existsSync25(filePath)) {
     return { rows: [], invalidRows: [], totalRows: 0 };
   }
   const content = await readFile13(filePath, "utf-8");
@@ -20092,7 +20422,7 @@ class SQLiteMemoryProvider {
   }
   async doInitialize() {
     const dbPath = this.databasePath();
-    mkdirSync15(path40.dirname(dbPath), { recursive: true });
+    mkdirSync15(path42.dirname(dbPath), { recursive: true });
     const Db = loadDatabaseCtor2();
     this.db = new Db(dbPath);
     this.db.run("PRAGMA journal_mode = WAL;");
@@ -21121,7 +21451,7 @@ function resolvePoolKey(directory) {
   try {
     return realpathSync2(directory);
   } catch {
-    return path41.resolve(directory);
+    return path43.resolve(directory);
   }
 }
 
@@ -21193,7 +21523,7 @@ var DEFAULT_MODES = [
 ];
 var DEFAULT_TIMESTAMP = "2026-05-26T12:00:00.000Z";
 async function evaluateMemoryRecallFixtures(options) {
-  const fixtureDirectory = path42.resolve(options.fixtureDirectory);
+  const fixtureDirectory = path44.resolve(options.fixtureDirectory);
   const providers = options.providers ?? DEFAULT_PROVIDERS;
   const modes = options.modes ?? DEFAULT_MODES;
   const generatedAt = new Date().toISOString();
@@ -21202,7 +21532,7 @@ async function evaluateMemoryRecallFixtures(options) {
   for (const fixture of fixtures) {
     const materialized = materializeFixture(fixture);
     for (const providerName of providers) {
-      const tempRoot = await fs17.realpath(await fs17.mkdtemp(path42.join(os9.tmpdir(), "swarm-memory-eval-")));
+      const tempRoot = await fs17.realpath(await fs17.mkdtemp(path44.join(os9.tmpdir(), "swarm-memory-eval-")));
       const provider = createEvaluationProvider(providerName, tempRoot);
       try {
         await provider.initialize?.();
@@ -21246,7 +21576,7 @@ async function loadRecallEvaluationFixtures(fixtureDirectory) {
   const files = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
   const fixtures = [];
   for (const file of files) {
-    const raw = await fs17.readFile(path42.join(fixtureDirectory, file), "utf-8");
+    const raw = await fs17.readFile(path44.join(fixtureDirectory, file), "utf-8");
     fixtures.push(validateFixture(JSON.parse(raw), file));
   }
   return fixtures;
@@ -21521,8 +21851,33 @@ var AgentOutputMemorySchema = exports_external.object({
 var CuratorOutputMemoryDecisionSchema = exports_external.object({
   curatorMemoryDecisions: exports_external.array(CuratorMemoryDecisionSchema).max(20).optional()
 }).passthrough();
+// src/memory/consolidation-log.ts
+import { appendFile as appendFile4, mkdir as mkdir12, readFile as readFile15 } from "fs/promises";
+import * as path45 from "path";
+var LOG_RELATIVE_PATH = path45.join("memory", "consolidation-log.jsonl");
+async function readConsolidationLog(directory) {
+  const filePath = validateSwarmPath(directory, LOG_RELATIVE_PATH);
+  let raw;
+  try {
+    raw = await readFile15(filePath, "utf-8");
+  } catch {
+    return [];
+  }
+  const records = [];
+  for (const line of raw.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      records.push(JSON.parse(trimmed));
+    } catch {}
+  }
+  return records;
+}
+
 // src/commands/memory.ts
-var PACKAGE_ROOT = path43.resolve(resolvePackageRootFromModule(fileURLToPath2(import.meta.url)));
+var PACKAGE_ROOT = path46.resolve(resolvePackageRootFromModule(fileURLToPath2(import.meta.url)));
 async function handleMemoryCommand(_directory, _args) {
   return [
     "## Swarm Memory",
@@ -21535,10 +21890,38 @@ async function handleMemoryCommand(_directory, _args) {
     "- `/swarm memory export` - export current memory and proposals to `.swarm/memory/export/*.jsonl`",
     "- `/swarm memory import` - import `.swarm/memory/{memories,proposals}.jsonl` into SQLite",
     "- `/swarm memory migrate` - run the one-time legacy JSONL to SQLite migration",
-    "- `/swarm memory evaluate --json` - run the golden recall evaluation fixtures and emit a JSON report"
+    "- `/swarm memory evaluate --json` - run the golden recall evaluation fixtures and emit a JSON report",
+    "- `/swarm memory consolidation-log [--limit <n>]` - summarize recent episodic\u2192semantic consolidation passes (max 50 per query)"
   ].join(`
 `);
 }
+async function handleMemoryConsolidationLogCommand(directory, args) {
+  const parsed = parseMaintenanceArgs(args, {
+    usage: "Usage: /swarm memory consolidation-log [--limit <n>]  (max 50 records per query)",
+    allowConfirm: false
+  });
+  if ("error" in parsed)
+    return parsed.error;
+  const limit = Math.min(parsed.limit, 50);
+  const records = await readConsolidationLog(directory);
+  const recent = records.slice(-limit).reverse();
+  const lines = [
+    "## Swarm Memory Consolidation Log",
+    "",
+    `- Total recorded passes: \`${records.length}\``,
+    `- Showing: \`${recent.length}\``
+  ];
+  if (recent.length === 0) {
+    lines.push("", "No consolidation passes have been recorded yet.");
+    return lines.join(`
+`);
+  }
+  for (const record of recent) {
+    lines.push("", `### Phase ${record.phaseNumber} \u2014 ${record.completedAt}`, `- Run: \`${record.runId ?? "unknown"}\``, `- Clusters: \`${record.clusterCount}\` (deferred \`${record.clustersDeferred}\`)`, `- Decisions applied: \`${record.decisionsEmitted}\` (added \`${record.added}\`, superseded \`${record.superseded}\`)`, `- Contradictions: \`${record.contradictionsDetected}\` | Deduped: \`${record.deduped}\` | Proposed: \`${record.proposed}\``, `- Memories decayed: \`${record.memoriesDecayed}\` | Errored: \`${record.errored}\``, `- Processed proposals: \`${record.processedProposalIds.length}\``);
+  }
+  return lines.join(`
+`);
+}
 async function handleMemoryStatusCommand(directory, _args) {
   const config = resolveCommandMemoryConfig(directory);
   const storageDir = resolveMemoryStorageDir(directory, config);
@@ -21552,7 +21935,7 @@ async function handleMemoryStatusCommand(directory, _args) {
     `- Provider: \`${config.provider}\``,
     `- Storage: \`${storageDir}\``,
     `- SQLite path: \`${sqlitePath}\``,
-    `- SQLite database exists: \`${existsSync25(sqlitePath)}\``,
+    `- SQLite database exists: \`${existsSync26(sqlitePath)}\``,
     `- Automatic destructive cleanup: \`disabled\``,
     "",
     "### Legacy JSONL"
@@ -21751,10 +22134,11 @@ function createMaintenanceProvider(directory, config) {
   return createConfiguredMemoryProvider(directory, config);
 }
 function maintenanceReportOptions(config, limit) {
+  const { threshold, ...weights } = config.maintenance.importance;
   return {
     limit,
-    lowUtilityMaxConfidence: config.maintenance.lowUtilityMaxConfidence,
-    lowUtilityMinAgeDays: config.maintenance.lowUtilityMinAgeDays
+    importanceWeights: weights,
+    importanceThreshold: threshold
   };
 }
 async function handleMemoryEvaluateCommand(directory, args) {
@@ -21791,7 +22175,7 @@ function resolveCommandMemoryConfig(directory) {
 }
 function parseEvaluateArgs(directory, args) {
   let json = false;
-  let fixtureDirectory = path43.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall");
+  let fixtureDirectory = path46.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall");
   for (let i = 0;i < args.length; i++) {
     const arg = args[i];
     if (arg === "--json") {
@@ -21805,10 +22189,10 @@ function parseEvaluateArgs(directory, args) {
           error: "Usage: /swarm memory evaluate [--json] [--fixtures <directory>]"
         };
       }
-      const resolvedFixtures = path43.resolve(directory, next);
-      const canonical = path43.normalize(resolvedFixtures) + path43.sep;
-      const allowedRootA = path43.normalize(directory) + path43.sep;
-      const allowedRootB = path43.normalize(path43.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall")) + path43.sep;
+      const resolvedFixtures = path46.resolve(directory, next);
+      const canonical = path46.normalize(resolvedFixtures) + path46.sep;
+      const allowedRootA = path46.normalize(directory) + path46.sep;
+      const allowedRootB = path46.normalize(path46.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall")) + path46.sep;
       if (!canonical.startsWith(allowedRootA) && !canonical.startsWith(allowedRootB)) {
         return {
           error: "--fixtures <directory> must resolve under the project directory or the bundled tests/fixtures/memory-recall directory"
@@ -21847,15 +22231,15 @@ function parseMaintenanceArgs(args, options) {
   return { limit, confirm };
 }
 function resolvePackageRootFromModule(modulePath) {
-  const moduleDir = path43.dirname(modulePath);
-  const leaf = path43.basename(moduleDir);
+  const moduleDir = path46.dirname(modulePath);
+  const leaf = path46.basename(moduleDir);
   if (leaf === "commands" || leaf === "cli") {
-    return path43.resolve(moduleDir, "..", "..");
+    return path46.resolve(moduleDir, "..", "..");
   }
   if (leaf === "dist") {
-    return path43.resolve(moduleDir, "..");
+    return path46.resolve(moduleDir, "..");
   }
-  return path43.resolve(moduleDir, "..");
+  return path46.resolve(moduleDir, "..");
 }
 function formatMigrationResult(label, report) {
   if (!report) {
@@ -22550,11 +22934,11 @@ var _internals36 = {
 
 // src/services/preflight-service.ts
 import * as fs24 from "fs";
-import * as path50 from "path";
+import * as path53 from "path";
 
 // src/tools/lint.ts
 import * as fs18 from "fs";
-import * as path44 from "path";
+import * as path47 from "path";
 
 // src/utils/path-security.ts
 function containsPathTraversal(str) {
@@ -22610,9 +22994,9 @@ function validateArgs(args) {
 }
 function getLinterCommand(linter, mode, projectDir) {
   const isWindows = process.platform === "win32";
-  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");
+  const binDir = path47.join(projectDir, "node_modules", ".bin");
+  const biomeBin = isWindows ? path47.join(binDir, "biome.EXE") : path47.join(binDir, "biome");
+  const eslintBin = isWindows ? path47.join(binDir, "eslint.cmd") : path47.join(binDir, "eslint");
   switch (linter) {
     case "biome":
       if (mode === "fix") {
@@ -22628,7 +23012,7 @@ function getLinterCommand(linter, mode, projectDir) {
 }
 function getAdditionalLinterCommand(linter, mode, cwd) {
   const gradlewName = process.platform === "win32" ? "gradlew.bat" : "gradlew";
-  const gradlew = fs18.existsSync(path44.join(cwd, gradlewName)) ? path44.join(cwd, gradlewName) : null;
+  const gradlew = fs18.existsSync(path47.join(cwd, gradlewName)) ? path47.join(cwd, gradlewName) : null;
   switch (linter) {
     case "ruff":
       return mode === "fix" ? ["ruff", "check", "--fix", "."] : ["ruff", "check", "."];
@@ -22662,10 +23046,10 @@ function getAdditionalLinterCommand(linter, mode, cwd) {
   }
 }
 function detectRuff(cwd) {
-  if (fs18.existsSync(path44.join(cwd, "ruff.toml")))
+  if (fs18.existsSync(path47.join(cwd, "ruff.toml")))
     return isCommandAvailable("ruff");
   try {
-    const pyproject = path44.join(cwd, "pyproject.toml");
+    const pyproject = path47.join(cwd, "pyproject.toml");
     if (fs18.existsSync(pyproject)) {
       const content = fs18.readFileSync(pyproject, "utf-8");
       if (content.includes("[tool.ruff]"))
@@ -22675,19 +23059,19 @@ function detectRuff(cwd) {
   return false;
 }
 function detectClippy(cwd) {
-  return fs18.existsSync(path44.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
+  return fs18.existsSync(path47.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
 }
 function detectGolangciLint(cwd) {
-  return fs18.existsSync(path44.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
+  return fs18.existsSync(path47.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
 }
 function detectCheckstyle(cwd) {
-  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"));
+  const hasMaven = fs18.existsSync(path47.join(cwd, "pom.xml"));
+  const hasGradle = fs18.existsSync(path47.join(cwd, "build.gradle")) || fs18.existsSync(path47.join(cwd, "build.gradle.kts"));
+  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs18.existsSync(path47.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
   return (hasMaven || hasGradle) && hasBinary;
 }
 function detectKtlint(cwd) {
-  const hasKotlin = fs18.existsSync(path44.join(cwd, "build.gradle.kts")) || fs18.existsSync(path44.join(cwd, "build.gradle")) || (() => {
+  const hasKotlin = fs18.existsSync(path47.join(cwd, "build.gradle.kts")) || fs18.existsSync(path47.join(cwd, "build.gradle")) || (() => {
     try {
       return fs18.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
     } catch {
@@ -22706,11 +23090,11 @@ function detectDotnetFormat(cwd) {
   }
 }
 function detectCppcheck(cwd) {
-  if (fs18.existsSync(path44.join(cwd, "CMakeLists.txt"))) {
+  if (fs18.existsSync(path47.join(cwd, "CMakeLists.txt"))) {
     return isCommandAvailable("cppcheck");
   }
   try {
-    const dirsToCheck = [cwd, path44.join(cwd, "src")];
+    const dirsToCheck = [cwd, path47.join(cwd, "src")];
     const hasCpp = dirsToCheck.some((dir) => {
       try {
         return fs18.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
@@ -22724,13 +23108,13 @@ function detectCppcheck(cwd) {
   }
 }
 function detectSwiftlint(cwd) {
-  return fs18.existsSync(path44.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
+  return fs18.existsSync(path47.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
 }
 function detectDartAnalyze(cwd) {
-  return fs18.existsSync(path44.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs18.existsSync(path47.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRubocop(cwd) {
-  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"));
+  return (fs18.existsSync(path47.join(cwd, "Gemfile")) || fs18.existsSync(path47.join(cwd, "gems.rb")) || fs18.existsSync(path47.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
 }
 function detectAdditionalLinter(cwd) {
   if (detectRuff(cwd))
@@ -22758,10 +23142,10 @@ function detectAdditionalLinter(cwd) {
 function findBinInAncestors(startDir, binName) {
   let dir = startDir;
   while (true) {
-    const candidate = path44.join(dir, "node_modules", ".bin", binName);
+    const candidate = path47.join(dir, "node_modules", ".bin", binName);
     if (fs18.existsSync(candidate))
       return candidate;
-    const parent = path44.dirname(dir);
+    const parent = path47.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -22770,10 +23154,10 @@ function findBinInAncestors(startDir, binName) {
 }
 function findBinInEnvPath(binName) {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path44.delimiter)) {
+  for (const dir of searchPath.split(path47.delimiter)) {
     if (!dir)
       continue;
-    const candidate = path44.join(dir, binName);
+    const candidate = path47.join(dir, binName);
     if (fs18.existsSync(candidate))
       return candidate;
   }
@@ -22786,13 +23170,13 @@ async function detectAvailableLinter(directory) {
     return null;
   const projectDir = directory;
   const isWindows = process.platform === "win32";
-  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 biomeBin = isWindows ? path47.join(projectDir, "node_modules", ".bin", "biome.EXE") : path47.join(projectDir, "node_modules", ".bin", "biome");
+  const eslintBin = isWindows ? path47.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path47.join(projectDir, "node_modules", ".bin", "eslint");
   const localResult = await _detectAvailableLinter(projectDir, biomeBin, eslintBin);
   if (localResult)
     return localResult;
-  const biomeAncestor = findBinInAncestors(path44.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
-  const eslintAncestor = findBinInAncestors(path44.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
+  const biomeAncestor = findBinInAncestors(path47.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
+  const eslintAncestor = findBinInAncestors(path47.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
   if (biomeAncestor || eslintAncestor) {
     return _detectAvailableLinter(projectDir, biomeAncestor ?? biomeBin, eslintAncestor ?? eslintBin);
   }
@@ -22811,7 +23195,7 @@ async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
       stderr: "pipe"
     });
     const biomeExit = biomeProc.exited;
-    const timeout = new Promise((resolve13) => setTimeout(() => resolve13("timeout"), DETECT_TIMEOUT));
+    const timeout = new Promise((resolve14) => setTimeout(() => resolve14("timeout"), DETECT_TIMEOUT));
     const result = await Promise.race([biomeExit, timeout]);
     if (result === "timeout") {
       biomeProc.kill();
@@ -22825,7 +23209,7 @@ async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
       stderr: "pipe"
     });
     const eslintExit = eslintProc.exited;
-    const timeout = new Promise((resolve13) => setTimeout(() => resolve13("timeout"), DETECT_TIMEOUT));
+    const timeout = new Promise((resolve14) => setTimeout(() => resolve14("timeout"), DETECT_TIMEOUT));
     const result = await Promise.race([eslintExit, timeout]);
     if (result === "timeout") {
       eslintProc.kill();
@@ -23006,7 +23390,7 @@ var _internals37 = {
 
 // src/tools/secretscan.ts
 import * as fs19 from "fs";
-import * as path45 from "path";
+import * as path48 from "path";
 var MAX_FILE_PATH_LENGTH = 500;
 var MAX_FILE_SIZE_BYTES = 512 * 1024;
 var MAX_FILES_SCANNED = 1000;
@@ -23233,7 +23617,7 @@ function isGlobOrPathPattern(pattern) {
   return pattern.includes("/") || pattern.includes("\\") || /[*?[\]{}]/.test(pattern);
 }
 function loadSecretScanIgnore(scanDir) {
-  const ignorePath = path45.join(scanDir, ".secretscanignore");
+  const ignorePath = path48.join(scanDir, ".secretscanignore");
   try {
     if (!fs19.existsSync(ignorePath))
       return [];
@@ -23256,7 +23640,7 @@ function isExcluded(entry, relPath, exactNames, globPatterns) {
   if (exactNames.has(entry))
     return true;
   for (const pattern of globPatterns) {
-    if (path45.matchesGlob(relPath, pattern))
+    if (path48.matchesGlob(relPath, pattern))
       return true;
   }
   return false;
@@ -23277,7 +23661,7 @@ function validateDirectoryInput(dir) {
   return null;
 }
 function isBinaryFile(filePath, buffer) {
-  const ext = path45.extname(filePath).toLowerCase();
+  const ext = path48.extname(filePath).toLowerCase();
   if (DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
     return true;
   }
@@ -23414,9 +23798,9 @@ function isSymlinkLoop(realPath, visited) {
   return false;
 }
 function isPathWithinScope(realPath, scanDir) {
-  const resolvedScanDir = path45.resolve(scanDir);
-  const resolvedRealPath = path45.resolve(realPath);
-  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path45.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
+  const resolvedScanDir = path48.resolve(scanDir);
+  const resolvedRealPath = path48.resolve(realPath);
+  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path48.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
 }
 function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, stats = {
   skippedDirs: 0,
@@ -23442,8 +23826,8 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     return a.localeCompare(b);
   });
   for (const entry of entries) {
-    const fullPath = path45.join(dir, entry);
-    const relPath = path45.relative(scanDir, fullPath).replace(/\\/g, "/");
+    const fullPath = path48.join(dir, entry);
+    const relPath = path48.relative(scanDir, fullPath).replace(/\\/g, "/");
     if (isExcluded(entry, relPath, excludeExact, excludeGlobs)) {
       stats.skippedDirs++;
       continue;
@@ -23478,7 +23862,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
       const subFiles = findScannableFiles(fullPath, excludeExact, excludeGlobs, scanDir, visited, stats);
       files.push(...subFiles);
     } else if (lstat2.isFile()) {
-      const ext = path45.extname(fullPath).toLowerCase();
+      const ext = path48.extname(fullPath).toLowerCase();
       if (!DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
         files.push(fullPath);
       } else {
@@ -23544,7 +23928,7 @@ var secretscan = createSwarmTool({
       }
     }
     try {
-      const _scanDirRaw = path45.resolve(directory);
+      const _scanDirRaw = path48.resolve(directory);
       const scanDir = (() => {
         try {
           return fs19.realpathSync(_scanDirRaw);
@@ -23707,11 +24091,11 @@ var _internals38 = {
 
 // src/tools/test-runner.ts
 import * as fs23 from "fs";
-import * as path49 from "path";
+import * as path52 from "path";
 
 // src/test-impact/analyzer.ts
 import fs20 from "fs";
-import path46 from "path";
+import path49 from "path";
 var IMPORT_REGEX_ES = /import\s+[\s\S]*?\s+from\s+['"]([^'"]+)['"]/g;
 var IMPORT_REGEX_REQUIRE = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
 var IMPORT_REGEX_REEXPORT = /export\s+(?:\{[^}]*\}|\*)\s+from\s+['"]([^'"]+)['"]/g;
@@ -23752,8 +24136,8 @@ function resolveRelativeImport(fromDir, importPath) {
   if (!importPath.startsWith(".")) {
     return null;
   }
-  const resolved = path46.resolve(fromDir, importPath);
-  if (path46.extname(resolved)) {
+  const resolved = path49.resolve(fromDir, importPath);
+  if (path49.extname(resolved)) {
     if (fs20.existsSync(resolved) && fs20.statSync(resolved).isFile()) {
       return normalizePath2(resolved);
     }
@@ -23773,20 +24157,20 @@ function resolvePythonImport(fromDir, module) {
   const leadingDots = module.match(/^\.+/)?.[0].length ?? 0;
   let baseDir = fromDir;
   for (let i = 1;i < leadingDots; i++) {
-    baseDir = path46.dirname(baseDir);
+    baseDir = path49.dirname(baseDir);
   }
   const rest = module.slice(leadingDots);
   if (rest.length === 0) {
-    const initPath = path46.join(baseDir, "__init__.py");
+    const initPath = path49.join(baseDir, "__init__.py");
     if (fs20.existsSync(initPath) && fs20.statSync(initPath).isFile()) {
       return normalizePath2(initPath);
     }
     return null;
   }
-  const subpath = rest.replace(/\./g, path46.sep);
+  const subpath = rest.replace(/\./g, path49.sep);
   const candidates = [
-    `${path46.join(baseDir, subpath)}.py`,
-    path46.join(baseDir, subpath, "__init__.py")
+    `${path49.join(baseDir, subpath)}.py`,
+    path49.join(baseDir, subpath, "__init__.py")
   ];
   for (const c of candidates) {
     if (fs20.existsSync(c) && fs20.statSync(c).isFile())
@@ -23796,7 +24180,7 @@ function resolvePythonImport(fromDir, module) {
 }
 var goModuleCache = new Map;
 function findGoModule(fromDir) {
-  const resolved = path46.resolve(fromDir);
+  const resolved = path49.resolve(fromDir);
   let cur = resolved;
   const walked = [];
   for (let i = 0;i < 16; i++) {
@@ -23808,7 +24192,7 @@ function findGoModule(fromDir) {
     }
     walked.push(cur);
     try {
-      const goMod = path46.join(cur, "go.mod");
+      const goMod = path49.join(cur, "go.mod");
       const content = fs20.readFileSync(goMod, "utf-8");
       const moduleMatch = content.match(/^\s*module\s+"?([^"\s/]+(?:\/[^"\s]+)*)"?/m);
       if (moduleMatch) {
@@ -23819,10 +24203,10 @@ function findGoModule(fromDir) {
       }
     } catch {}
     try {
-      fs20.accessSync(path46.join(cur, ".git"));
+      fs20.accessSync(path49.join(cur, ".git"));
       break;
     } catch {}
-    const parent = path46.dirname(cur);
+    const parent = path49.dirname(cur);
     if (parent === cur)
       break;
     cur = parent;
@@ -23834,12 +24218,12 @@ function findGoModule(fromDir) {
 function resolveGoImport(fromDir, importPath) {
   let dir = null;
   if (importPath.startsWith(".")) {
-    dir = path46.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 = path46.join(mod.moduleRoot, subpath);
+      dir = path49.join(mod.moduleRoot, subpath);
     }
   }
   if (dir === null)
@@ -23847,7 +24231,7 @@ function resolveGoImport(fromDir, importPath) {
   if (!fs20.existsSync(dir) || !fs20.statSync(dir).isDirectory())
     return [];
   try {
-    return fs20.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath2(path46.join(dir, f)));
+    return fs20.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath2(path49.join(dir, f)));
   } catch {
     return [];
   }
@@ -23886,15 +24270,15 @@ function findTestFilesSync(cwd) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (!skipDirs.has(entry.name)) {
-          walk(path46.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(`${path46.sep}tests${path46.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(normalizePath2(path46.join(dir, entry.name)));
+          testFiles.push(normalizePath2(path49.join(dir, entry.name)));
         }
       }
     }
@@ -23919,8 +24303,8 @@ function extractImports(content) {
   ];
 }
 function addImpactEdgesForTestFile(testFile, content, impactMap) {
-  const ext = path46.extname(testFile).toLowerCase();
-  const testDir = path46.dirname(testFile);
+  const ext = path49.extname(testFile).toLowerCase();
+  const testDir = path49.dirname(testFile);
   function addEdge(source) {
     if (!impactMap[source])
       impactMap[source] = [];
@@ -23993,7 +24377,7 @@ async function buildImpactMap(cwd) {
   return impactMap;
 }
 async function loadImpactMap(cwd, options) {
-  const cachePath = path46.join(cwd, ".swarm", "cache", "impact-map.json");
+  const cachePath = path49.join(cwd, ".swarm", "cache", "impact-map.json");
   if (fs20.existsSync(cachePath)) {
     try {
       const content = fs20.readFileSync(cachePath, "utf-8");
@@ -24026,12 +24410,12 @@ async function loadImpactMap(cwd, options) {
   return _internals39.buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
-  if (!path46.isAbsolute(cwd)) {
+  if (!path49.isAbsolute(cwd)) {
     throw new Error(`saveImpactMap requires an absolute project root path, got: "${cwd}"`);
   }
   _internals39.validateProjectRoot(cwd);
-  const cacheDir2 = path46.join(cwd, ".swarm", "cache");
-  const cachePath = path46.join(cacheDir2, "impact-map.json");
+  const cacheDir2 = path49.join(cwd, ".swarm", "cache");
+  const cachePath = path49.join(cacheDir2, "impact-map.json");
   if (!fs20.existsSync(cacheDir2)) {
     fs20.mkdirSync(cacheDir2, { recursive: true });
   }
@@ -24063,7 +24447,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
       budgetExceeded = true;
       break;
     }
-    const normalizedChanged = normalizePath2(path46.resolve(changedFile));
+    const normalizedChanged = normalizePath2(path49.resolve(changedFile));
     const tests = impactMap[normalizedChanged];
     if (tests && tests.length > 0) {
       for (const test of tests) {
@@ -24077,13 +24461,13 @@ async function analyzeImpact(changedFiles, cwd, budget) {
       if (budgetExceeded)
         break;
     } else {
-      const changedDir = normalizePath2(path46.dirname(normalizedChanged));
-      const changedInputDir = normalizePath2(path46.dirname(changedFile));
+      const changedDir = normalizePath2(path49.dirname(normalizedChanged));
+      const changedInputDir = normalizePath2(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 = normalizePath2(path46.dirname(sourceA));
-        const sourceDirB = normalizePath2(path46.dirname(sourceB));
+        const sourceDirA = normalizePath2(path49.dirname(sourceA));
+        const sourceDirB = normalizePath2(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)
@@ -24410,7 +24794,7 @@ function detectFlakyTests(allHistory) {
 
 // src/test-impact/history-store.ts
 import fs21 from "fs";
-import path47 from "path";
+import path50 from "path";
 var MAX_HISTORY_PER_TEST = 20;
 var MAX_ERROR_LENGTH = 500;
 var MAX_STACK_LENGTH = 200;
@@ -24422,10 +24806,10 @@ function getHistoryPath(workingDir) {
   if (!workingDir) {
     throw new Error("getHistoryPath requires a working directory \u2014 project root must be provided by the caller");
   }
-  if (!path47.isAbsolute(workingDir)) {
+  if (!path50.isAbsolute(workingDir)) {
     throw new Error(`getHistoryPath requires an absolute project root path, got: "${workingDir}"`);
   }
-  return path47.join(workingDir, ".swarm", "cache", "test-history.jsonl");
+  return path50.join(workingDir, ".swarm", "cache", "test-history.jsonl");
 }
 function sanitizeErrorMessage(errorMessage) {
   if (errorMessage === undefined) {
@@ -24517,7 +24901,7 @@ function batchAppendTestRuns(records, workingDir) {
     }
   }
   const historyPath = getHistoryPath(workingDir);
-  const historyDir = path47.dirname(historyPath);
+  const historyDir = path50.dirname(historyPath);
   _internals40.validateProjectRoot(workingDir);
   if (!fs21.existsSync(historyDir)) {
     fs21.mkdirSync(historyDir, { recursive: true });
@@ -24647,7 +25031,7 @@ var _internals40 = {
 
 // src/tools/resolve-working-directory.ts
 import * as fs22 from "fs";
-import * as path48 from "path";
+import * as path51 from "path";
 function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (workingDirectory == null || workingDirectory === "") {
     if (typeof fallbackDirectory !== "string" || fallbackDirectory === "") {
@@ -24679,15 +25063,15 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       };
     }
   }
-  const rawPathParts = workingDirectory.split(path48.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 = path48.normalize(workingDirectory);
-  const resolvedDir = path48.resolve(normalizedDir);
+  const normalizedDir = path51.normalize(workingDirectory);
+  const resolvedDir = path51.resolve(normalizedDir);
   let statResult;
   try {
     statResult = fs22.statSync(resolvedDir);
@@ -24706,7 +25090,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (typeof fallbackDirectory !== "string" || fallbackDirectory === "") {
     return { success: true, directory: resolvedDir };
   }
-  const resolvedFallback = path48.resolve(fallbackDirectory);
+  const resolvedFallback = path51.resolve(fallbackDirectory);
   let fallbackExists = false;
   try {
     fs22.statSync(resolvedFallback);
@@ -24715,7 +25099,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
     fallbackExists = false;
   }
   if (fallbackExists) {
-    const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path48.sep);
+    const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path51.sep);
     if (isSubdirectory) {
       return {
         success: false,
@@ -24738,7 +25122,7 @@ async function estimateFanOut(sourceFiles, cwd) {
     const impactMap = await loadImpactMap(cwd, { skipRebuild: true });
     const uniqueTestFiles = new Set;
     for (const sourceFile of sourceFiles) {
-      const resolvedPath = path49.resolve(cwd, sourceFile);
+      const resolvedPath = path52.resolve(cwd, sourceFile);
       const normalizedPath = resolvedPath.replace(/\\/g, "/");
       const testFiles = impactMap[normalizedPath];
       if (testFiles) {
@@ -24823,14 +25207,14 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return fs23.existsSync(path49.join(cwd, "go.mod")) && isCommandAvailable("go");
+  return fs23.existsSync(path52.join(cwd, "go.mod")) && isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return fs23.existsSync(path49.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
+  return fs23.existsSync(path52.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  const hasBuildFile = fs23.existsSync(path49.join(cwd, "build.gradle")) || fs23.existsSync(path49.join(cwd, "build.gradle.kts"));
-  const hasGradlew = fs23.existsSync(path49.join(cwd, "gradlew")) || fs23.existsSync(path49.join(cwd, "gradlew.bat"));
+  const hasBuildFile = fs23.existsSync(path52.join(cwd, "build.gradle")) || fs23.existsSync(path52.join(cwd, "build.gradle.kts"));
+  const hasGradlew = fs23.existsSync(path52.join(cwd, "gradlew")) || fs23.existsSync(path52.join(cwd, "gradlew.bat"));
   return hasBuildFile && (hasGradlew || isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
@@ -24843,25 +25227,25 @@ function detectDotnetTest(cwd) {
   }
 }
 function detectCTest(cwd) {
-  const hasSource = fs23.existsSync(path49.join(cwd, "CMakeLists.txt"));
-  const hasBuildCache = fs23.existsSync(path49.join(cwd, "CMakeCache.txt")) || fs23.existsSync(path49.join(cwd, "build", "CMakeCache.txt"));
+  const hasSource = fs23.existsSync(path52.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = fs23.existsSync(path52.join(cwd, "CMakeCache.txt")) || fs23.existsSync(path52.join(cwd, "build", "CMakeCache.txt"));
   return (hasSource || hasBuildCache) && isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return fs23.existsSync(path49.join(cwd, "Package.swift")) && isCommandAvailable("swift");
+  return fs23.existsSync(path52.join(cwd, "Package.swift")) && isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return fs23.existsSync(path49.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs23.existsSync(path52.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  const hasRSpecFile = fs23.existsSync(path49.join(cwd, ".rspec"));
-  const hasGemfile = fs23.existsSync(path49.join(cwd, "Gemfile"));
-  const hasSpecDir = fs23.existsSync(path49.join(cwd, "spec"));
+  const hasRSpecFile = fs23.existsSync(path52.join(cwd, ".rspec"));
+  const hasGemfile = fs23.existsSync(path52.join(cwd, "Gemfile"));
+  const hasSpecDir = fs23.existsSync(path52.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
   return hasRSpec && (isCommandAvailable("bundle") || isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return fs23.existsSync(path49.join(cwd, "test")) && (fs23.existsSync(path49.join(cwd, "Gemfile")) || fs23.existsSync(path49.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
+  return fs23.existsSync(path52.join(cwd, "test")) && (fs23.existsSync(path52.join(cwd, "Gemfile")) || fs23.existsSync(path52.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
 }
 var DISPATCH_FRAMEWORK_MAP = {
   bun: "bun",
@@ -24946,7 +25330,7 @@ async function parseTestOutputViaDispatch(framework, output, baseDir) {
 async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
-    const packageJsonPath = path49.join(baseDir, "package.json");
+    const packageJsonPath = path52.join(baseDir, "package.json");
     if (fs23.existsSync(packageJsonPath)) {
       const content = fs23.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
@@ -24967,16 +25351,16 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (fs23.existsSync(path49.join(baseDir, "bun.lockb")) || fs23.existsSync(path49.join(baseDir, "bun.lock"))) {
+      if (fs23.existsSync(path52.join(baseDir, "bun.lockb")) || fs23.existsSync(path52.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
     }
   } catch {}
   try {
-    const pyprojectTomlPath = path49.join(baseDir, "pyproject.toml");
-    const setupCfgPath = path49.join(baseDir, "setup.cfg");
-    const requirementsTxtPath = path49.join(baseDir, "requirements.txt");
+    const pyprojectTomlPath = path52.join(baseDir, "pyproject.toml");
+    const setupCfgPath = path52.join(baseDir, "setup.cfg");
+    const requirementsTxtPath = path52.join(baseDir, "requirements.txt");
     if (fs23.existsSync(pyprojectTomlPath)) {
       const content = fs23.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
@@ -24996,7 +25380,7 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const cargoTomlPath = path49.join(baseDir, "Cargo.toml");
+    const cargoTomlPath = path52.join(baseDir, "Cargo.toml");
     if (fs23.existsSync(cargoTomlPath)) {
       const content = fs23.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
@@ -25007,9 +25391,9 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const pesterConfigPath = path49.join(baseDir, "pester.config.ps1");
-    const pesterConfigJsonPath = path49.join(baseDir, "pester.config.ps1.json");
-    const pesterPs1Path = path49.join(baseDir, "tests.ps1");
+    const pesterConfigPath = path52.join(baseDir, "pester.config.ps1");
+    const pesterConfigJsonPath = path52.join(baseDir, "pester.config.ps1.json");
+    const pesterPs1Path = path52.join(baseDir, "tests.ps1");
     if (fs23.existsSync(pesterConfigPath) || fs23.existsSync(pesterConfigJsonPath) || fs23.existsSync(pesterPs1Path)) {
       return "pester";
     }
@@ -25052,12 +25436,12 @@ function isTestDirectoryPath(normalizedPath) {
   return normalizedPath.split("/").some((segment) => TEST_DIRECTORY_NAMES.includes(segment));
 }
 function resolveWorkspacePath(file, workingDir) {
-  return path49.isAbsolute(file) ? path49.resolve(file) : path49.resolve(workingDir, file);
+  return path52.isAbsolute(file) ? path52.resolve(file) : path52.resolve(workingDir, file);
 }
 function toWorkspaceOutputPath(absolutePath, workingDir, preferRelative) {
   if (!preferRelative)
     return absolutePath;
-  return path49.relative(workingDir, absolutePath);
+  return path52.relative(workingDir, absolutePath);
 }
 function dedupePush(target, value) {
   if (!target.includes(value)) {
@@ -25094,18 +25478,18 @@ function buildLanguageSpecificTestNames(nameWithoutExt, ext) {
   }
 }
 function getRepoLevelCandidateDirectories(workingDir, relativePath, ext) {
-  const relativeDir = path49.dirname(relativePath);
+  const relativeDir = path52.dirname(relativePath);
   const nestedRelativeDir = relativeDir === "." ? "" : relativeDir;
   const directories = TEST_DIRECTORY_NAMES.flatMap((dirName) => {
-    const rootDir = path49.join(workingDir, dirName);
-    return nestedRelativeDir ? [rootDir, path49.join(rootDir, nestedRelativeDir)] : [rootDir];
+    const rootDir = path52.join(workingDir, dirName);
+    return nestedRelativeDir ? [rootDir, path52.join(rootDir, nestedRelativeDir)] : [rootDir];
   });
   const normalizedRelativePath = relativePath.replace(/\\/g, "/");
   if (ext === ".java" && normalizedRelativePath.startsWith("src/main/java/")) {
-    directories.push(path49.join(workingDir, "src/test/java", path49.dirname(normalizedRelativePath.slice("src/main/java/".length))));
+    directories.push(path52.join(workingDir, "src/test/java", path52.dirname(normalizedRelativePath.slice("src/main/java/".length))));
   }
   if ((ext === ".kt" || ext === ".java") && normalizedRelativePath.startsWith("src/main/kotlin/")) {
-    directories.push(path49.join(workingDir, "src/test/kotlin", path49.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
+    directories.push(path52.join(workingDir, "src/test/kotlin", path52.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
   }
   return [...new Set(directories)];
 }
@@ -25133,23 +25517,23 @@ function isLanguageSpecificTestFile(basename9) {
 }
 function isConventionTestFilePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
-  const basename9 = path49.basename(filePath);
+  const basename9 = path52.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 file of sourceFiles) {
     const absoluteFile = resolveWorkspacePath(file, workingDir);
-    const relativeFile = path49.relative(workingDir, absoluteFile);
-    const basename9 = path49.basename(absoluteFile);
-    const dirname23 = path49.dirname(absoluteFile);
-    const preferRelativeOutput = !path49.isAbsolute(file);
+    const relativeFile = path52.relative(workingDir, absoluteFile);
+    const basename9 = path52.basename(absoluteFile);
+    const dirname25 = path52.dirname(absoluteFile);
+    const preferRelativeOutput = !path52.isAbsolute(file);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
       continue;
     }
     const nameWithoutExt = basename9.replace(/\.[^.]+$/, "");
-    const ext = path49.extname(basename9);
+    const ext = path52.extname(basename9);
     const genericTestNames = [
       `${nameWithoutExt}.spec${ext}`,
       `${nameWithoutExt}.test${ext}`
@@ -25158,7 +25542,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const colocatedCandidates = [
       ...genericTestNames,
       ...languageSpecificTestNames
-    ].map((candidateName) => path49.join(dirname23, candidateName));
+    ].map((candidateName) => path52.join(dirname25, candidateName));
     const testDirectoryNames = [
       basename9,
       ...genericTestNames,
@@ -25167,8 +25551,8 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const repoLevelDirectories = getRepoLevelCandidateDirectories(workingDir, relativeFile, ext);
     const possibleTestFiles = [
       ...colocatedCandidates,
-      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path49.join(dirname23, dirName, candidateName))),
-      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path49.join(candidateDir, candidateName)))
+      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path52.join(dirname25, dirName, candidateName))),
+      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path52.join(candidateDir, candidateName)))
     ];
     for (const testFile of possibleTestFiles) {
       if (fs23.existsSync(testFile)) {
@@ -25189,7 +25573,7 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
     try {
       const absoluteTestFile = resolveWorkspacePath(testFile, workingDir);
       const content = fs23.readFileSync(absoluteTestFile, "utf-8");
-      const testDir = path49.dirname(absoluteTestFile);
+      const testDir = path52.dirname(absoluteTestFile);
       const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
       let match;
       match = importRegex.exec(content);
@@ -25197,8 +25581,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         const importPath = match[1];
         let resolvedImport;
         if (importPath.startsWith(".")) {
-          resolvedImport = path49.resolve(testDir, importPath);
-          const existingExt = path49.extname(resolvedImport);
+          resolvedImport = path52.resolve(testDir, importPath);
+          const existingExt = path52.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -25218,12 +25602,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         } else {
           continue;
         }
-        const importBasename = path49.basename(resolvedImport, path49.extname(resolvedImport));
-        const importDir = path49.dirname(resolvedImport);
+        const importBasename = path52.basename(resolvedImport, path52.extname(resolvedImport));
+        const importDir = path52.dirname(resolvedImport);
         for (const sourceFile of absoluteSourceFiles) {
-          const sourceDir = path49.dirname(sourceFile);
-          const sourceBasename = path49.basename(sourceFile, path49.extname(sourceFile));
-          const isRelatedDir = importDir === sourceDir || importDir === path49.join(sourceDir, "__tests__") || importDir === path49.join(sourceDir, "tests") || importDir === path49.join(sourceDir, "test") || importDir === path49.join(sourceDir, "spec");
+          const sourceDir = path52.dirname(sourceFile);
+          const sourceBasename = path52.basename(sourceFile, path52.extname(sourceFile));
+          const isRelatedDir = importDir === sourceDir || importDir === path52.join(sourceDir, "__tests__") || importDir === path52.join(sourceDir, "tests") || importDir === path52.join(sourceDir, "test") || importDir === path52.join(sourceDir, "spec");
           if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
             dedupePush(testFiles, testFile);
             break;
@@ -25236,8 +25620,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
       while (match !== null) {
         const importPath = match[1];
         if (importPath.startsWith(".")) {
-          let resolvedImport = path49.resolve(testDir, importPath);
-          const existingExt = path49.extname(resolvedImport);
+          let resolvedImport = path52.resolve(testDir, importPath);
+          const existingExt = path52.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -25254,12 +25638,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               }
             }
           }
-          const importDir = path49.dirname(resolvedImport);
-          const importBasename = path49.basename(resolvedImport, path49.extname(resolvedImport));
+          const importDir = path52.dirname(resolvedImport);
+          const importBasename = path52.basename(resolvedImport, path52.extname(resolvedImport));
           for (const sourceFile of absoluteSourceFiles) {
-            const sourceDir = path49.dirname(sourceFile);
-            const sourceBasename = path49.basename(sourceFile, path49.extname(sourceFile));
-            const isRelatedDir = importDir === sourceDir || importDir === path49.join(sourceDir, "__tests__") || importDir === path49.join(sourceDir, "tests") || importDir === path49.join(sourceDir, "test") || importDir === path49.join(sourceDir, "spec");
+            const sourceDir = path52.dirname(sourceFile);
+            const sourceBasename = path52.basename(sourceFile, path52.extname(sourceFile));
+            const isRelatedDir = importDir === sourceDir || importDir === path52.join(sourceDir, "__tests__") || importDir === path52.join(sourceDir, "tests") || importDir === path52.join(sourceDir, "test") || importDir === path52.join(sourceDir, "spec");
             if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
               dedupePush(testFiles, testFile);
               break;
@@ -25379,8 +25763,8 @@ function buildTestCommand(framework, scope, files, coverage, baseDir, bail) {
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs23.existsSync(path49.join(baseDir, "gradlew.bat"));
-      const hasGradlew = fs23.existsSync(path49.join(baseDir, "gradlew"));
+      const hasGradlewBat = fs23.existsSync(path52.join(baseDir, "gradlew.bat"));
+      const hasGradlew = fs23.existsSync(path52.join(baseDir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -25397,7 +25781,7 @@ function buildTestCommand(framework, scope, files, coverage, baseDir, bail) {
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs23.existsSync(path49.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs23.existsSync(path52.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -25831,11 +26215,11 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
     };
   }
   const startTime = Date.now();
-  const vitestJsonOutputPath = framework === "vitest" ? path49.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
+  const vitestJsonOutputPath = framework === "vitest" ? path52.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
   try {
     if (vitestJsonOutputPath) {
       try {
-        fs23.mkdirSync(path49.dirname(vitestJsonOutputPath), { recursive: true });
+        fs23.mkdirSync(path52.dirname(vitestJsonOutputPath), { recursive: true });
         if (fs23.existsSync(vitestJsonOutputPath)) {
           fs23.unlinkSync(vitestJsonOutputPath);
         }
@@ -25846,9 +26230,9 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
       stderr: "pipe",
       cwd
     });
-    const timeoutPromise = new Promise((resolve16) => setTimeout(() => {
+    const timeoutPromise = new Promise((resolve17) => setTimeout(() => {
       proc.kill();
-      resolve16(-1);
+      resolve17(-1);
     }, timeout_ms));
     const [exitCode, stdoutResult, stderrResult] = await Promise.all([
       Promise.race([proc.exited, timeoutPromise]),
@@ -26003,10 +26387,10 @@ var SKIP_DIRECTORIES = new Set([
 ]);
 function normalizeHistoryTestFile(testFile, workingDir) {
   const normalized = testFile.replace(/\\/g, "/");
-  if (!path49.isAbsolute(testFile))
+  if (!path52.isAbsolute(testFile))
     return normalized;
-  const relative8 = path49.relative(workingDir, testFile);
-  if (relative8.startsWith("..") || path49.isAbsolute(relative8)) {
+  const relative8 = path52.relative(workingDir, testFile);
+  if (relative8.startsWith("..") || path52.isAbsolute(relative8)) {
     return normalized;
   }
   return relative8.replace(/\\/g, "/");
@@ -26245,7 +26629,7 @@ var test_runner = createSwarmTool({
       const sourceFiles = args.files.filter((file) => {
         if (directTestFiles.includes(file))
           return false;
-        const ext = path49.extname(file).toLowerCase();
+        const ext = path52.extname(file).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       const invalidFiles = args.files.filter((file) => !directTestFiles.includes(file) && !sourceFiles.includes(file));
@@ -26291,7 +26675,7 @@ var test_runner = createSwarmTool({
         if (isConventionTestFilePath(f)) {
           return false;
         }
-        const ext = path49.extname(f).toLowerCase();
+        const ext = path52.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -26341,7 +26725,7 @@ var test_runner = createSwarmTool({
         if (isConventionTestFilePath(f)) {
           return false;
         }
-        const ext = path49.extname(f).toLowerCase();
+        const ext = path52.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -26393,8 +26777,8 @@ var test_runner = createSwarmTool({
         }
         if (impactResult.impactedTests.length > 0) {
           testFiles = impactResult.impactedTests.map((absPath) => {
-            const relativePath = path49.relative(workingDir, absPath);
-            return path49.isAbsolute(relativePath) ? absPath : relativePath;
+            const relativePath = path52.relative(workingDir, absPath);
+            return path52.isAbsolute(relativePath) ? absPath : relativePath;
           });
         } else {
           graphFallbackReason = "no impacted tests found via impact analysis, falling back to graph";
@@ -26489,8 +26873,8 @@ function validateDirectoryPath(dir) {
   if (dir.includes("..")) {
     throw new Error("Directory path must not contain path traversal sequences");
   }
-  const normalized = path50.normalize(dir);
-  const absolutePath = path50.isAbsolute(normalized) ? normalized : path50.resolve(normalized);
+  const normalized = path53.normalize(dir);
+  const absolutePath = path53.isAbsolute(normalized) ? normalized : path53.resolve(normalized);
   return absolutePath;
 }
 function validateTimeout(timeoutMs, defaultValue) {
@@ -26513,7 +26897,7 @@ function validateTimeout(timeoutMs, defaultValue) {
 }
 function getPackageVersion(dir) {
   try {
-    const packagePath = path50.join(dir, "package.json");
+    const packagePath = path53.join(dir, "package.json");
     if (fs24.existsSync(packagePath)) {
       const content = fs24.readFileSync(packagePath, "utf-8");
       const pkg = JSON.parse(content);
@@ -26524,7 +26908,7 @@ function getPackageVersion(dir) {
 }
 function getChangelogVersion(dir) {
   try {
-    const changelogPath = path50.join(dir, "CHANGELOG.md");
+    const changelogPath = path53.join(dir, "CHANGELOG.md");
     if (fs24.existsSync(changelogPath)) {
       const content = fs24.readFileSync(changelogPath, "utf-8");
       const match = content.match(/^##\s*\[?(\d+\.\d+\.\d+)\]?/m);
@@ -26538,7 +26922,7 @@ function getChangelogVersion(dir) {
 function getVersionFileVersion(dir) {
   const possibleFiles = ["VERSION.txt", "version.txt", "VERSION", "version"];
   for (const file of possibleFiles) {
-    const filePath = path50.join(dir, file);
+    const filePath = path53.join(dir, file);
     if (fs24.existsSync(filePath)) {
       try {
         const content = fs24.readFileSync(filePath, "utf-8").trim();
@@ -27276,7 +27660,7 @@ async function handleQaGatesCommand(directory, args, sessionID) {
 
 // src/commands/reset.ts
 import * as fs25 from "fs";
-import * as path51 from "path";
+import * as path54 from "path";
 
 // src/background/circuit-breaker.ts
 class CircuitBreaker {
@@ -27328,13 +27712,13 @@ class CircuitBreaker {
     if (this.config.callTimeoutMs <= 0) {
       return fn();
     }
-    return new Promise((resolve17, reject) => {
+    return new Promise((resolve18, reject) => {
       const timeout = setTimeout(() => {
         reject(new Error(`Call timeout after ${this.config.callTimeoutMs}ms`));
       }, this.config.callTimeoutMs);
       fn().then((result) => {
         clearTimeout(timeout);
-        resolve17(result);
+        resolve18(result);
       }).catch((error2) => {
         clearTimeout(timeout);
         reject(error2);
@@ -27618,7 +28002,7 @@ class AutomationQueue {
 
 // src/background/worker.ts
 function sleep(ms) {
-  return new Promise((resolve17) => setTimeout(resolve17, ms));
+  return new Promise((resolve18) => setTimeout(resolve18, ms));
 }
 
 class WorkerManager {
@@ -27993,7 +28377,7 @@ async function handleResetCommand(directory, args) {
   }
   for (const filename of ["SWARM_PLAN.md", "SWARM_PLAN.json"]) {
     try {
-      const rootPath = path51.join(directory, filename);
+      const rootPath = path54.join(directory, filename);
       if (fs25.existsSync(rootPath)) {
         fs25.unlinkSync(rootPath);
         results.push(`- \u2705 Deleted ${filename} (root)`);
@@ -28031,7 +28415,7 @@ async function handleResetCommand(directory, args) {
 
 // src/commands/reset-session.ts
 import * as fs27 from "fs";
-import * as path53 from "path";
+import * as path56 from "path";
 
 // src/hooks/trajectory-logger.ts
 var callStartTimes = new Map;
@@ -28438,16 +28822,16 @@ function detectPatterns(trajectory, config, lastProcessedStep = 0) {
 }
 // src/prm/replay.ts
 import { promises as fs26 } from "fs";
-import path52 from "path";
+import path55 from "path";
 function isPathSafe(targetPath, basePath) {
-  const resolvedTarget = path52.resolve(targetPath);
-  const resolvedBase = path52.resolve(basePath);
-  const rel = path52.relative(resolvedBase, resolvedTarget);
-  return !rel.startsWith("..") && !path52.isAbsolute(rel);
+  const resolvedTarget = path55.resolve(targetPath);
+  const resolvedBase = path55.resolve(basePath);
+  const rel = path55.relative(resolvedBase, resolvedTarget);
+  return !rel.startsWith("..") && !path55.isAbsolute(rel);
 }
 function isWithinReplaysDir(targetPath) {
-  const resolved = path52.resolve(targetPath);
-  const parts = resolved.split(path52.sep);
+  const resolved = path55.resolve(targetPath);
+  const parts = resolved.split(path55.sep);
   for (let i = 0;i < parts.length - 1; i++) {
     if (parts[i] === ".swarm" && parts[i + 1] === "replays") {
       return true;
@@ -28460,10 +28844,10 @@ function sanitizeFilename(input) {
 }
 async function startReplayRecording(sessionID, directory) {
   try {
-    const replayDir = path52.join(directory, ".swarm", "replays");
+    const replayDir = path55.join(directory, ".swarm", "replays");
     const safeSessionID = sanitizeFilename(sessionID);
     const filename = `${safeSessionID}-${Date.now()}.jsonl`;
-    const filepath = path52.join(replayDir, filename);
+    const filepath = path55.join(replayDir, filename);
     if (!isPathSafe(filepath, replayDir)) {
       console.warn(`[replay] Invalid path detected - path traversal attempt blocked for session ${sessionID}`);
       return null;
@@ -28541,7 +28925,7 @@ async function handleResetSessionCommand(directory, _args) {
   } catch {
     results.push("\u274C Failed to delete state.json");
   }
-  const sessionDir = path53.dirname(validateSwarmPath(directory, "session/state.json"));
+  const sessionDir = path56.dirname(validateSwarmPath(directory, "session/state.json"));
   let sessionFiles = [];
   if (fs27.existsSync(sessionDir)) {
     try {
@@ -28553,7 +28937,7 @@ async function handleResetSessionCommand(directory, _args) {
   for (const file of sessionFiles) {
     if (file === "state.json")
       continue;
-    const filePath = path53.join(sessionDir, file);
+    const filePath = path56.join(sessionDir, file);
     try {
       if (!fs27.existsSync(filePath))
         continue;
@@ -28588,7 +28972,7 @@ async function handleResetSessionCommand(directory, _args) {
 }
 
 // src/summaries/manager.ts
-import * as path54 from "path";
+import * as path57 from "path";
 var SUMMARY_ID_REGEX = /^S\d+$/;
 function sanitizeSummaryId(id) {
   if (!id || id.length === 0) {
@@ -28612,7 +28996,7 @@ function sanitizeSummaryId(id) {
 }
 async function loadFullOutput(directory, id) {
   const sanitizedId = sanitizeSummaryId(id);
-  const relativePath = path54.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path57.join("summaries", `${sanitizedId}.json`);
   validateSwarmPath(directory, relativePath);
   const content = await readSwarmFileAsync(directory, relativePath);
   if (content === null) {
@@ -28665,7 +29049,7 @@ ${error2 instanceof Error ? error2.message : String(error2)}`;
 
 // src/commands/rollback.ts
 import * as fs28 from "fs";
-import * as path55 from "path";
+import * as path58 from "path";
 async function handleRollbackCommand(directory, args) {
   const phaseArg = args[0];
   if (!phaseArg) {
@@ -28731,8 +29115,8 @@ async function handleRollbackCommand(directory, args) {
     if (EXCLUDE_FILES.has(file) || file.startsWith("plan-ledger.archived-")) {
       continue;
     }
-    const src = path55.join(checkpointDir, file);
-    const dest = path55.join(swarmDir, file);
+    const src = path58.join(checkpointDir, file);
+    const dest = path58.join(swarmDir, file);
     try {
       fs28.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file);
@@ -28751,7 +29135,7 @@ async function handleRollbackCommand(directory, args) {
     ].join(`
 `);
   }
-  const existingLedgerPath = path55.join(swarmDir, "plan-ledger.jsonl");
+  const existingLedgerPath = path58.join(swarmDir, "plan-ledger.jsonl");
   let ledgerDeletionFailed = false;
   if (fs28.existsSync(existingLedgerPath)) {
     try {
@@ -28764,7 +29148,7 @@ async function handleRollbackCommand(directory, args) {
   }
   if (!ledgerDeletionFailed) {
     try {
-      const planJsonPath = path55.join(swarmDir, "plan.json");
+      const planJsonPath = path58.join(swarmDir, "plan.json");
       if (fs28.existsSync(planJsonPath)) {
         const planRaw = fs28.readFileSync(planJsonPath, "utf-8");
         const plan = PlanSchema.parse(JSON.parse(planRaw));
@@ -29025,10 +29409,10 @@ Ensure this is a git repository with commit history.`;
 `);
   try {
     const fs29 = await import("fs/promises");
-    const path56 = await import("path");
-    const reportPath = path56.join(directory, ".swarm", "simulate-report.md");
-    await fs29.mkdir(path56.dirname(reportPath), { recursive: true });
-    const reportTempPath = path56.join(path56.dirname(reportPath), `${path56.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const path59 = await import("path");
+    const reportPath = path59.join(directory, ".swarm", "simulate-report.md");
+    await fs29.mkdir(path59.dirname(reportPath), { recursive: true });
+    const reportTempPath = path59.join(path59.dirname(reportPath), `${path59.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
       await fs29.writeFile(reportTempPath, report, "utf-8");
       renameSync11(reportTempPath, reportPath);
@@ -29056,19 +29440,19 @@ async function handleSpecifyCommand(_directory, args) {
 
 // src/services/status-service.ts
 import * as fsSync3 from "fs";
-import { readFile as readFile15 } from "fs/promises";
-import * as path57 from "path";
+import { readFile as readFile16 } from "fs/promises";
+import * as path60 from "path";
 
 // src/turbo/lean/state.ts
 init_logger();
 import * as fs29 from "fs";
-import * as path56 from "path";
+import * as path59 from "path";
 var STATE_FILE3 = "turbo-state.json";
 function nowISO3() {
   return new Date().toISOString();
 }
 function ensureSwarmDir2(directory) {
-  const swarmDir = path56.resolve(directory, ".swarm");
+  const swarmDir = path59.resolve(directory, ".swarm");
   if (!fs29.existsSync(swarmDir)) {
     fs29.mkdirSync(swarmDir, { recursive: true });
   }
@@ -29113,7 +29497,7 @@ function markStateUnreadable2(directory, reason) {
 }
 function readPersisted2(directory) {
   try {
-    const filePath = path56.join(directory, ".swarm", STATE_FILE3);
+    const filePath = path59.join(directory, ".swarm", STATE_FILE3);
     if (!fs29.existsSync(filePath)) {
       const seed = emptyPersisted2();
       try {
@@ -29149,7 +29533,7 @@ function writePersisted2(directory, persisted) {
   let payload;
   try {
     ensureSwarmDir2(directory);
-    filePath = path56.join(directory, ".swarm", STATE_FILE3);
+    filePath = path59.join(directory, ".swarm", STATE_FILE3);
     tmpPath = `${filePath}.tmp.${Date.now()}`;
     persisted.updatedAt = nowISO3();
     payload = `${JSON.stringify(persisted, null, 2)}
@@ -29267,7 +29651,7 @@ var _internals43 = {
 };
 function readSpecStalenessSnapshot(directory) {
   try {
-    const p = path57.join(directory, ".swarm", "spec-staleness.json");
+    const p = path60.join(directory, ".swarm", "spec-staleness.json");
     if (!fsSync3.existsSync(p))
       return { stale: false };
     const raw = fsSync3.readFileSync(p, "utf-8");
@@ -29359,7 +29743,7 @@ async function getStatusData(directory, agents) {
   }
   status.recentEscalations = await readRecentEscalations(directory);
   status.pendingProposals = await countProposals(directory);
-  status.unactionableQueueDepth = await safeLineCount(validateSwarmPath(directory, "knowledge-unactionable.jsonl"));
+  status.unactionableQueueDepth = await safeLineCount(resolveUnactionablePath(directory));
   status.insightCandidatesPending = await safeLineCount(validateSwarmPath(directory, "insight-candidates.jsonl"));
   return enrichWithLeanTurbo(status, directory);
 }
@@ -29520,7 +29904,7 @@ async function safeLineCount(filePath) {
   try {
     if (!fsSync3.existsSync(filePath))
       return 0;
-    const content = await readFile15(filePath, "utf-8");
+    const content = await readFile16(filePath, "utf-8");
     let n = 0;
     for (const line of content.split(`
 `)) {
@@ -29798,6 +30182,66 @@ function buildStatusMessage2(session, directory, sessionID) {
 `);
 }
 
+// src/commands/unlink.ts
+import { existsSync as existsSync36 } from "fs";
+import * as path61 from "path";
+var DEDUP_THRESHOLD2 = 0.6;
+async function copySharedKnowledgeToLocal(linkDir, localSwarmDir) {
+  const sharedPath = path61.join(linkDir, "knowledge.jsonl");
+  const localPath = path61.join(localSwarmDir, "knowledge.jsonl");
+  if (!existsSync36(sharedPath))
+    return 0;
+  const sharedEntries = await readKnowledge(sharedPath);
+  if (sharedEntries.length === 0)
+    return 0;
+  let copied = 0;
+  await transactKnowledge(localPath, (localEntries) => {
+    const result = [...localEntries];
+    const seenIds = new Set(result.map((e) => e.id));
+    let changed = false;
+    for (const entry of sharedEntries) {
+      if (seenIds.has(entry.id))
+        continue;
+      if (findNearDuplicate(entry.lesson, result, DEDUP_THRESHOLD2))
+        continue;
+      result.push(entry);
+      seenIds.add(entry.id);
+      copied++;
+      changed = true;
+    }
+    return changed ? result : null;
+  });
+  return copied;
+}
+async function handleUnlinkCommand(directory, args) {
+  const pointer = readLinkPointer(directory);
+  if (!pointer) {
+    return "\u2139\uFE0F This worktree is not linked. Nothing to unlink.";
+  }
+  const copyBack = !args.includes("--no-copy");
+  const linkDir = resolveLinkDir(pointer.linkId);
+  let copied = 0;
+  if (copyBack) {
+    try {
+      copied = await copySharedKnowledgeToLocal(linkDir, path61.join(directory, ".swarm"));
+    } catch (error2) {
+      return `\u274C Failed to copy shared knowledge back to local: ${error2 instanceof Error ? error2.message : String(error2)}`;
+    }
+  }
+  try {
+    await removeLinkPointer(directory);
+  } catch (error2) {
+    return `\u274C Failed to remove link pointer: ${error2 instanceof Error ? error2.message : String(error2)}`;
+  }
+  const copyNote = copyBack ? `  copied ${copied} shared lesson(s) back into local \`.swarm/knowledge.jsonl\`.` : "  shared lessons were NOT copied back (--no-copy).";
+  return [
+    `\uD83D\uDD13 Unlinked this worktree from shared knowledge store "${pointer.linkId}".`,
+    copyNote,
+    "This worktree now uses its local `.swarm/` knowledge again."
+  ].join(`
+`);
+}
+
 // src/commands/write-retro.ts
 async function handleWriteRetroCommand(directory, args) {
   if (args.length === 0 || !args[0] || args[0].trim() === "") {
@@ -29934,7 +30378,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-0rt5aamg.js");
+    const { buildHelpText } = await import("./index-dprk5c5f.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -29943,7 +30387,7 @@ async function handleHelpCommand(ctx) {
     return _internals45.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals45.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-0rt5aamg.js");
+  const { buildHelpText: fullHelp } = await import("./index-dprk5c5f.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -30076,7 +30520,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-eqypvw60.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-hy0zz0p6.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -30086,7 +30530,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-c7egm5km.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-m3285thy.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",
@@ -30539,6 +30983,29 @@ Subcommands:
     category: "config",
     toolPolicy: "none"
   },
+  link: {
+    handler: (ctx) => handleLinkCommand(ctx.directory, ctx.args),
+    description: "Tie this worktree to a shared swarm knowledge store [name]",
+    details: "Links the current worktree to a shared knowledge store so multiple swarms working on the same project (e.g. separate git worktrees) pool their lessons instead of each keeping an isolated .swarm/knowledge.jsonl. With no name, ties all worktrees of the same repo via the project hash; with a name, ties any worktrees/repos that use the same name. Existing local lessons are merged (deduped) into the shared store. Use `/swarm link status` to inspect.",
+    args: "[<name> | status]",
+    category: "utility",
+    toolPolicy: "none"
+  },
+  "link status": {
+    handler: (ctx) => handleLinkCommand(ctx.directory, ["status"]),
+    description: "Show whether this worktree shares knowledge via a link",
+    subcommandOf: "link",
+    category: "utility",
+    toolPolicy: "none"
+  },
+  unlink: {
+    handler: (ctx) => handleUnlinkCommand(ctx.directory, ctx.args),
+    description: "Stop sharing swarm knowledge for this worktree [--no-copy]",
+    details: "Unlinks the current worktree from its shared knowledge store and returns it to a local .swarm/knowledge.jsonl. By default the shared lessons are copied back into the local store (deduped) so nothing is lost; pass --no-copy to skip the copy-back.",
+    args: "[--no-copy]",
+    category: "utility",
+    toolPolicy: "none"
+  },
   promote: {
     handler: (ctx) => handlePromoteCommand(ctx.directory, ctx.args),
     description: "Manually promote lesson to hive knowledge",
@@ -30764,6 +31231,14 @@ Subcommands:
     category: "utility",
     toolPolicy: "human-only"
   },
+  "memory consolidation-log": {
+    handler: (ctx) => handleMemoryConsolidationLogCommand(ctx.directory, ctx.args),
+    description: "Summarize recent memory consolidation passes and metrics",
+    subcommandOf: "memory",
+    args: "--limit <n>",
+    category: "diagnostics",
+    toolPolicy: "agent"
+  },
   "memory-status": {
     handler: (ctx) => handleMemoryStatusCommand(ctx.directory, ctx.args),
     description: "Show Swarm memory provider, JSONL, and migration status",
@@ -30816,24 +31291,24 @@ function validateAliases() {
       }
       aliasTargets.get(target).push(name);
       const visited = new Set;
-      const path58 = [];
+      const path62 = [];
       let current = target;
       while (current) {
         const currentEntry = COMMAND_REGISTRY[current];
         if (!currentEntry)
           break;
         if (visited.has(current)) {
-          const cycleStart = path58.indexOf(current);
+          const cycleStart = path62.indexOf(current);
           const fullChain = [
             name,
-            ...path58.slice(0, cycleStart > 0 ? cycleStart : path58.length),
+            ...path62.slice(0, cycleStart > 0 ? cycleStart : path62.length),
             current
           ].join(" \u2192 ");
           errors.push(`Circular alias detected: ${fullChain}`);
           break;
         }
         visited.add(current);
-        path58.push(current);
+        path62.push(current);
         current = currentEntry.aliasOf || "";
       }
     }
@@ -30999,4 +31474,4 @@ ${text}`;
   };
 }
 
-export { package_default, handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, handleArchiveCommand, DC_SAFE_TARGETS, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcValidateTargets, dcCheckJunctionCreation, dcExtractWindowsCmdTargets, dcExtractPowerShellTargets, normalizeSwarmCommandInput, canonicalCommandKey, formatCommandNotFound, executeSwarmCommand, SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, classifySwarmCommandToolUse, classifySwarmCommandChatFallbackUse, detectPosixWrites, detectWindowsWrites, resolveWriteTargets, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleClarifyCommand, handleCloseCommand, handleCodebaseReviewCommand, handleConcurrencyCommand, handleConfigCommand, handleConsolidateCommand, handleCouncilCommand, handleCurateCommand, handleDarkMatterCommand, handleDeepDiveCommand, handleDeepResearchCommand, getPluginConfigDir, getPluginCachePaths, getPluginLockFilePaths, handleDiagnoseCommand, handleDoctorCommand, handleEvidenceCommand, handleEvidenceSummaryCommand, handleExportCommand, handleFullAutoCommand, handleHandoffCommand, handleHistoryCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, handleKnowledgeMigrateCommand, handleKnowledgeListCommand, handleKnowledgeUnactionableCommand, handleKnowledgeRetryHardeningCommand, handleLearningCommand, handleMemoryCommand, handleMemoryStatusCommand, handleMemoryMigrateCommand, handleMemoryImportCommand, handleMemoryExportCommand, handlePlanCommand, handlePreflightCommand, handlePromoteCommand, handleQaGatesCommand, handleResetCommand, handleResetSessionCommand, handleRetrieveCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals45 as _internals, resolveCommand };
+export { package_default, handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, handleArchiveCommand, DC_SAFE_TARGETS, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcValidateTargets, dcCheckJunctionCreation, dcExtractWindowsCmdTargets, dcExtractPowerShellTargets, normalizeSwarmCommandInput, canonicalCommandKey, formatCommandNotFound, executeSwarmCommand, SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, classifySwarmCommandToolUse, classifySwarmCommandChatFallbackUse, detectPosixWrites, detectWindowsWrites, resolveWriteTargets, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleClarifyCommand, handleCloseCommand, handleCodebaseReviewCommand, handleConcurrencyCommand, handleConfigCommand, handleConsolidateCommand, handleCouncilCommand, handleCurateCommand, handleDarkMatterCommand, handleDeepDiveCommand, handleDeepResearchCommand, getPluginConfigDir, getPluginCachePaths, getPluginLockFilePaths, handleDiagnoseCommand, handleDoctorCommand, handleEvidenceCommand, handleEvidenceSummaryCommand, handleExportCommand, handleFullAutoCommand, handleHandoffCommand, handleHistoryCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, handleKnowledgeMigrateCommand, handleKnowledgeListCommand, handleKnowledgeUnactionableCommand, handleKnowledgeRetryHardeningCommand, handleLearningCommand, handleLinkCommand, handleMemoryCommand, handleMemoryStatusCommand, handleMemoryMigrateCommand, handleMemoryImportCommand, handleMemoryExportCommand, handlePlanCommand, handlePreflightCommand, handlePromoteCommand, handleQaGatesCommand, handleResetCommand, handleResetSessionCommand, handleRetrieveCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleUnlinkCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals45 as _internals, resolveCommand };