opencode-swarm 7.39.0 → 7.41.0

package/dist/index.js

@@ -48,7 +48,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.39.0",
+    version: "7.41.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",
@@ -15581,6 +15581,13 @@ var init_schema = __esm(() => {
     redaction: exports_external.object({
       rejectDurableSecrets: exports_external.boolean().default(true)
     }).default({ rejectDurableSecrets: true }),
+    maintenance: exports_external.object({
+      lowUtilityMaxConfidence: exports_external.number().min(0).max(1).default(0.45),
+      lowUtilityMinAgeDays: exports_external.number().int().min(1).max(3650).default(30)
+    }).default({
+      lowUtilityMaxConfidence: 0.45,
+      lowUtilityMinAgeDays: 30
+    }),
     hardDelete: exports_external.boolean().default(false)
   });
   CuratorConfigSchema = exports_external.object({
@@ -55884,6 +55891,7 @@ RULES:
 - Output under 2000 chars
 - No code modifications
 - Flag contradictions explicitly with CONTRADICTION: prefix
+- Memory proposals are for concise durable facts only. Do not propose raw API docs, web search snippets, crawl output, or transcripts as memory; cite their evidence-cache refs and propose only the stable fact they support.
 - If no prior summary exists, state "First session — no prior context"
 
 OUTPUT FORMAT:
@@ -55930,6 +55938,7 @@ RULES:
 - Compliance observations are READ-ONLY — report, do not enforce
 - OBSERVATIONS should not contain directives — report what is observed, do not instruct the architect what to do
 - Extend the digest, never replace it
+- Memory proposals are for concise durable facts only. Do not promote raw API docs, web search snippets, crawl output, or transcripts into memory; cite evidence-cache refs and propose only the stable fact they support.
 
 OUTPUT FORMAT:
 PHASE_DIGEST:
@@ -66897,6 +66906,10 @@ function resolveMemoryConfig(input) {
     redaction: {
       ...DEFAULT_MEMORY_CONFIG.redaction,
       ...input?.redaction ?? {}
+    },
+    maintenance: {
+      ...DEFAULT_MEMORY_CONFIG.maintenance,
+      ...input?.maintenance ?? {}
     }
   };
 }
@@ -66928,6 +66941,10 @@ var init_config3 = __esm(() => {
     redaction: {
       rejectDurableSecrets: true
     },
+    maintenance: {
+      lowUtilityMaxConfidence: 0.45,
+      lowUtilityMinAgeDays: 30
+    },
     hardDelete: false
   };
   DURABLE_MEMORY_KINDS = new Set([
@@ -67278,6 +67295,17 @@ function validateDecisionMatchesProposal(decision, proposal) {
     throw new MemoryValidationError("curator supersede decision target does not match proposal target");
   }
 }
+function validateCuratorPromotableMemory(record3) {
+  if (record3.stability !== "durable") {
+    throw new MemoryValidationError("curator memory promotions must be durable facts");
+  }
+  if (!DURABLE_MEMORY_KINDS.has(record3.kind)) {
+    throw new MemoryValidationError("curator memory promotions must use durable fact kinds; store raw docs, search results, and other bulky source material as evidence records instead");
+  }
+  if (normalizeMemoryText(record3.text).length > CURATOR_PROMOTED_MEMORY_MAX_TEXT_LENGTH) {
+    throw new MemoryValidationError(`curator memory promotions must be concise durable facts under ${CURATOR_PROMOTED_MEMORY_MAX_TEXT_LENGTH} characters`);
+  }
+}
 function applyPatchToMemory(existing, patch, updatedAt) {
   const base = {
     scope: patch.scope ?? existing.scope,
@@ -67335,11 +67363,174 @@ function buildCuratorDecisionEvent(change, proposal) {
 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);
 }
+var CURATOR_PROMOTED_MEMORY_MAX_TEXT_LENGTH = 500;
 var init_curator_decision_helpers = __esm(() => {
+  init_config3();
   init_errors6();
   init_schema2();
 });
 
+// src/memory/maintenance.ts
+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);
+}
+var DEFAULT_LOW_UTILITY_MAX_CONFIDENCE = 0.45, DEFAULT_LOW_UTILITY_MIN_AGE_DAYS = 30;
+var init_maintenance = __esm(() => {
+  init_schema2();
+});
+
 // src/memory/role-profiles.ts
 function resolveMemoryRecallProfile(agentRole) {
   const role = normalizeMemoryAgentRole(agentRole);
@@ -67727,16 +67918,21 @@ class LocalJsonlMemoryProvider {
   }
   async recordRecallUsage(event) {
     await this.initialize();
-    await this.audit("recall", event.bundleId, JSON.stringify({
-      query: event.query,
-      scopes: event.scopes,
-      kinds: event.kinds,
-      memoryIds: event.memoryIds,
-      scores: event.scores,
-      tokenEstimate: event.tokenEstimate,
-      agentRole: event.agentRole,
-      runId: event.runId
-    }));
+    await this.audit("recall", event.bundleId, undefined, event);
+  }
+  async listRecallUsage(filter = {}) {
+    await this.initialize();
+    const events = await readAuditEvents(this.pathFor("audit"));
+    const usage = [];
+    for (const event of events) {
+      if (event.operation !== "recall")
+        continue;
+      const parsed = parseRecallUsageEvent(event);
+      if (parsed)
+        usage.push(parsed);
+    }
+    usage.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+    return usage.slice(0, filter.limit ?? usage.length);
   }
   async list(filter = {}) {
     await this.initialize();
@@ -67756,7 +67952,9 @@ class LocalJsonlMemoryProvider {
         return !Number.isFinite(expires) || expires > now;
       });
     }
-    records = records.filter((record3) => !record3.supersededBy && record3.metadata.deleted !== true);
+    if (!filter.includeInactive) {
+      records = records.filter((record3) => !record3.supersededBy && record3.metadata.deleted !== true);
+    }
     records.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
     return records.slice(0, filter.limit ?? records.length);
   }
@@ -67797,12 +67995,14 @@ class LocalJsonlMemoryProvider {
         ...decision.memory,
         updatedAt: appliedAt
       });
+      validateCuratorPromotableMemory(memory);
       this.memories.set(memory.id, memory);
       await appendJsonl(this.pathFor("memories"), memory);
       memoryId = memory.id;
     } else if (decision.action === "update") {
       const existing = this.activeMemory(decision.targetMemoryId);
       const updated = this.validateDecisionMemory(applyPatchToMemory(existing, decision.patch, appliedAt));
+      validateCuratorPromotableMemory(updated);
       if (updated.id !== existing.id) {
         const tombstone = this.validateDecisionMemory({
           ...existing,
@@ -67828,6 +68028,7 @@ class LocalJsonlMemoryProvider {
         updatedAt: appliedAt,
         supersedes: Array.from(new Set([...decision.replacement.supersedes ?? [], oldMemory.id]))
       });
+      validateCuratorPromotableMemory(replacement);
       const superseded = this.validateDecisionMemory({
         ...oldMemory,
         updatedAt: appliedAt,
@@ -67868,6 +68069,41 @@ class LocalJsonlMemoryProvider {
     await writeJsonlAtomic(this.pathFor("memories"), Array.from(this.memories.values()));
     await this.audit("compact", "memories");
   }
+  async compactMaintenance(options = {}) {
+    await this.initialize();
+    const now = options.now ? new Date(options.now) : new Date;
+    const kept = [];
+    const result = {
+      dryRun: options.dryRun !== false,
+      removedDeleted: 0,
+      removedSuperseded: 0,
+      removedExpiredScratch: 0,
+      remaining: 0
+    };
+    for (const memory of this.memories.values()) {
+      const compactReason = shouldCompactMemory(memory, now);
+      if (compactReason === "deleted") {
+        result.removedDeleted++;
+        continue;
+      }
+      if (compactReason === "superseded") {
+        result.removedSuperseded++;
+        continue;
+      }
+      if (compactReason === "expired_scratch") {
+        result.removedExpiredScratch++;
+        continue;
+      }
+      kept.push(memory);
+    }
+    result.remaining = kept.length;
+    if (result.dryRun)
+      return result;
+    this.memories = new Map(kept.map((memory) => [memory.id, memory]));
+    await writeJsonlAtomic(this.pathFor("memories"), kept);
+    await this.audit("compact", "memories", "removed deleted, superseded, and expired scratch memories", result);
+    return result;
+  }
   async audit(operation, targetId, reason, eventJson) {
     const event = {
       id: randomUUID4(),
@@ -67946,6 +68182,46 @@ async function readJsonl(filePath) {
   }
   return records;
 }
+async function readAuditEvents(filePath) {
+  const values = await readJsonl(filePath);
+  const events = [];
+  for (const value of values) {
+    if (!value || typeof value !== "object")
+      continue;
+    const candidate = value;
+    if (typeof candidate.id !== "string" || typeof candidate.operation !== "string" || typeof candidate.targetId !== "string" || typeof candidate.timestamp !== "string") {
+      continue;
+    }
+    events.push(candidate);
+  }
+  return events;
+}
+function parseRecallUsageEvent(event) {
+  const raw = event.eventJson ?? event.reason;
+  if (typeof raw !== "string" && (!raw || typeof raw !== "object")) {
+    return null;
+  }
+  try {
+    const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+    if (!Array.isArray(parsed.memoryIds) || typeof parsed.query !== "string") {
+      return null;
+    }
+    return {
+      bundleId: typeof parsed.bundleId === "string" ? parsed.bundleId : event.targetId,
+      query: parsed.query,
+      scopes: Array.isArray(parsed.scopes) ? parsed.scopes : [],
+      kinds: Array.isArray(parsed.kinds) ? parsed.kinds : undefined,
+      memoryIds: parsed.memoryIds.filter((memoryId) => typeof memoryId === "string"),
+      scores: Array.isArray(parsed.scores) ? parsed.scores.filter((score) => typeof score === "number" && Number.isFinite(score)) : [],
+      tokenEstimate: typeof parsed.tokenEstimate === "number" ? parsed.tokenEstimate : 0,
+      agentRole: typeof parsed.agentRole === "string" ? parsed.agentRole : undefined,
+      runId: typeof parsed.runId === "string" ? parsed.runId : undefined,
+      timestamp: typeof parsed.timestamp === "string" ? parsed.timestamp : event.timestamp
+    };
+  } catch {
+    return null;
+  }
+}
 async function appendJsonl(filePath, value) {
   await mkdir9(path39.dirname(filePath), { recursive: true });
   await appendFile5(filePath, `${JSON.stringify(value)}
@@ -67965,6 +68241,7 @@ var init_local_jsonl_provider = __esm(() => {
   init_config3();
   init_curator_decision_helpers();
   init_errors6();
+  init_maintenance();
   init_schema2();
   init_scoring();
 });
@@ -68296,6 +68573,10 @@ class SQLiteMemoryProvider {
       redaction: {
         ...DEFAULT_MEMORY_CONFIG.redaction,
         ...config3.redaction ?? {}
+      },
+      maintenance: {
+        ...DEFAULT_MEMORY_CONFIG.maintenance,
+        ...config3.maintenance ?? {}
       }
     };
   }
@@ -68401,6 +68682,26 @@ class SQLiteMemoryProvider {
 			) VALUES (?, ?, ?, ?)`, [randomUUID5(), event.bundleId, event.timestamp, JSON.stringify(event)]);
     await this.event("recall", event.bundleId, JSON.stringify(event));
   }
+  async listRecallUsage(filter = {}) {
+    await this.initialize();
+    const rows = typeof filter.limit === "number" ? this.requireDb().query(`SELECT usage_json
+				FROM memory_recall_usage
+				ORDER BY timestamp DESC
+				LIMIT ?`).all(Math.max(1, Math.trunc(filter.limit))) : this.requireDb().query(`SELECT usage_json
+				FROM memory_recall_usage
+				ORDER BY timestamp DESC
+				`).all();
+    const events = [];
+    for (const row of rows) {
+      try {
+        const parsed = JSON.parse(row.usage_json);
+        if (Array.isArray(parsed.memoryIds) && typeof parsed.query === "string") {
+          events.push(parsed);
+        }
+      } catch {}
+    }
+    return events;
+  }
   async list(filter = {}) {
     await this.initialize();
     let records = Array.from(this.memories.values());
@@ -68419,7 +68720,9 @@ class SQLiteMemoryProvider {
         return !Number.isFinite(expires) || expires > now;
       });
     }
-    records = records.filter((record3) => !record3.supersededBy && record3.metadata.deleted !== true);
+    if (!filter.includeInactive) {
+      records = records.filter((record3) => !record3.supersededBy && record3.metadata.deleted !== true);
+    }
     records.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
     return records.slice(0, filter.limit ?? records.length);
   }
@@ -68500,6 +68803,52 @@ class SQLiteMemoryProvider {
       proposals: proposals.length
     };
   }
+  async compactMaintenance(options = {}) {
+    await this.initialize();
+    const now = options.now ? new Date(options.now) : new Date;
+    const kept = [];
+    const removeIds = [];
+    const result = {
+      dryRun: options.dryRun !== false,
+      removedDeleted: 0,
+      removedSuperseded: 0,
+      removedExpiredScratch: 0,
+      remaining: 0
+    };
+    for (const memory of this.memories.values()) {
+      const compactReason = shouldCompactMemory(memory, now);
+      if (compactReason === "deleted") {
+        result.removedDeleted++;
+        removeIds.push(memory.id);
+        continue;
+      }
+      if (compactReason === "superseded") {
+        result.removedSuperseded++;
+        removeIds.push(memory.id);
+        continue;
+      }
+      if (compactReason === "expired_scratch") {
+        result.removedExpiredScratch++;
+        removeIds.push(memory.id);
+        continue;
+      }
+      kept.push(memory);
+    }
+    result.remaining = kept.length;
+    if (result.dryRun)
+      return result;
+    const db = this.requireDb();
+    const compact = db.transaction(() => {
+      for (const id of removeIds) {
+        db.run("DELETE FROM memory_items WHERE id = ?", [id]);
+        this.deleteMemoryFts(id);
+      }
+      this.insertEvent("compact", "memory_items", "removed deleted, superseded, and expired scratch memories", JSON.stringify(result));
+    });
+    compact();
+    this.memories = new Map(kept.map((memory) => [memory.id, memory]));
+    return result;
+  }
   hasMigration(name2) {
     const row = this.requireDb().query("SELECT version, name FROM schema_migrations WHERE name = ? LIMIT 1").get(name2);
     return Boolean(row);
@@ -68733,12 +69082,14 @@ class SQLiteMemoryProvider {
         ...decision.memory,
         updatedAt: appliedAt
       });
+      validateCuratorPromotableMemory(memory);
       this.writeMemory(memory);
       memories.push(memory);
       memoryId = memory.id;
     } else if (decision.action === "update") {
       const existing = this.readActiveMemory(decision.targetMemoryId);
       const updated = this.validateDecisionMemory(applyPatchToMemory(existing, decision.patch, appliedAt));
+      validateCuratorPromotableMemory(updated);
       if (updated.id !== existing.id) {
         const tombstone = this.validateDecisionMemory({
           ...existing,
@@ -68764,6 +69115,7 @@ class SQLiteMemoryProvider {
         updatedAt: appliedAt,
         supersedes: Array.from(new Set([...decision.replacement.supersedes ?? [], oldMemory.id]))
       });
+      validateCuratorPromotableMemory(replacement);
       const superseded = this.validateDecisionMemory({
         ...oldMemory,
         updatedAt: appliedAt,
@@ -68976,6 +69328,7 @@ var init_sqlite_provider = __esm(() => {
   init_curator_decision_helpers();
   init_errors6();
   init_jsonl_migration();
+  init_maintenance();
   init_schema2();
   init_scoring();
   FTS_INDEX_COLUMNS = [
@@ -70391,6 +70744,7 @@ var init_memory = __esm(() => {
   init_injector();
   init_jsonl_migration();
   init_local_jsonl_provider();
+  init_maintenance();
   init_prompt_block();
   init_recall_planner();
   init_redaction();
@@ -70409,6 +70763,10 @@ async function handleMemoryCommand(_directory, _args) {
     "## Swarm Memory",
     "",
     "- `/swarm memory status` - show provider, SQLite path, JSONL files, and last migration report",
+    "- `/swarm memory pending` - show pending proposals and recent rejection reasons",
+    "- `/swarm memory recall-log` - summarize recall usage by agent role and memory ID",
+    "- `/swarm memory stale` - list expired scratch, superseded, deleted, and low-utility memories",
+    "- `/swarm memory compact` - dry-run compaction; pass `--confirm` to remove deleted, superseded, and expired scratch records",
     "- `/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",
@@ -70430,6 +70788,7 @@ async function handleMemoryStatusCommand(directory, _args) {
     `- Storage: \`${storageDir}\``,
     `- SQLite path: \`${sqlitePath}\``,
     `- SQLite database exists: \`${existsSync25(sqlitePath)}\``,
+    `- Automatic destructive cleanup: \`disabled\``,
     "",
     "### Legacy JSONL"
   ];
@@ -70454,6 +70813,119 @@ async function handleMemoryStatusCommand(directory, _args) {
   return lines.join(`
 `);
 }
+async function handleMemoryPendingCommand(directory, args2) {
+  const parsed = parseMaintenanceArgs(args2, {
+    usage: "Usage: /swarm memory pending [--limit <n>]",
+    allowConfirm: false
+  });
+  if ("error" in parsed)
+    return parsed.error;
+  const config3 = resolveCommandMemoryConfig(directory);
+  const provider = createMaintenanceProvider(directory, config3);
+  try {
+    await provider.initialize?.();
+    const report = await buildMemoryMaintenanceReport(provider, {
+      ...maintenanceReportOptions(config3, parsed.limit)
+    });
+    const lines = [
+      "## Swarm Memory Pending",
+      "",
+      `- Pending proposals shown: \`${report.pendingProposals.length}\``,
+      `- Rejected proposal reasons shown: \`${report.rejectedProposalReasons.length}\``
+    ];
+    appendProposalLines(lines, "Pending proposals", report.pendingProposals);
+    appendProposalLines(lines, "Rejected proposal reasons", report.rejectedProposalReasons);
+    return lines.join(`
+`);
+  } finally {
+    await provider.close?.();
+  }
+}
+async function handleMemoryRecallLogCommand(directory, args2) {
+  const parsed = parseMaintenanceArgs(args2, {
+    usage: "Usage: /swarm memory recall-log [--limit <n>]",
+    allowConfirm: false
+  });
+  if ("error" in parsed)
+    return parsed.error;
+  const config3 = resolveCommandMemoryConfig(directory);
+  const provider = createMaintenanceProvider(directory, config3);
+  try {
+    await provider.initialize?.();
+    const report = await buildMemoryMaintenanceReport(provider, {
+      ...maintenanceReportOptions(config3, parsed.limit)
+    });
+    const lines = [
+      "## Swarm Memory Recall Log",
+      "",
+      `- Recall events scanned: \`${report.recallEventCount}\``,
+      `- Most-recalled memories shown: \`${report.mostRecalledMemories.length}\``,
+      `- Never-recalled memories shown: \`${report.neverRecalledMemories.length}\``
+    ];
+    appendRecallRoleLines(lines, report.recallByAgentRole);
+    appendRecallMemoryLines(lines, report.mostRecalledMemories);
+    appendMemoryLines(lines, "Never-recalled memories", report.neverRecalledMemories);
+    return lines.join(`
+`);
+  } finally {
+    await provider.close?.();
+  }
+}
+async function handleMemoryStaleCommand(directory, args2) {
+  const parsed = parseMaintenanceArgs(args2, {
+    usage: "Usage: /swarm memory stale [--limit <n>]",
+    allowConfirm: false
+  });
+  if ("error" in parsed)
+    return parsed.error;
+  const config3 = resolveCommandMemoryConfig(directory);
+  const provider = createMaintenanceProvider(directory, config3);
+  try {
+    await provider.initialize?.();
+    const report = await buildMemoryMaintenanceReport(provider, {
+      ...maintenanceReportOptions(config3, parsed.limit)
+    });
+    const lines = [
+      "## Swarm Memory Stale",
+      "",
+      `- Active memories: \`${report.activeMemories}\``,
+      `- Expired scratch memories shown: \`${report.expiredScratchMemories.length}\``,
+      `- Deleted tombstones shown: \`${report.deletedMemories.length}\``,
+      `- Superseded memories shown: \`${report.supersededMemories.length}\``,
+      `- Low-utility memories shown: \`${report.lowUtilityMemories.length}\``
+    ];
+    appendMemoryLines(lines, "Expired scratch memories", report.expiredScratchMemories);
+    appendMemoryLines(lines, "Deleted tombstones", report.deletedMemories);
+    appendSupersededChains(lines, report);
+    appendMemoryLines(lines, "Low-utility memories", report.lowUtilityMemories);
+    return lines.join(`
+`);
+  } finally {
+    await provider.close?.();
+  }
+}
+async function handleMemoryCompactCommand(directory, args2) {
+  const parsed = parseMaintenanceArgs(args2, {
+    usage: "Usage: /swarm memory compact [--confirm]",
+    allowConfirm: true,
+    allowLimit: false
+  });
+  if ("error" in parsed)
+    return parsed.error;
+  const provider = createMaintenanceProvider(directory, resolveCommandMemoryConfig(directory));
+  try {
+    await provider.initialize?.();
+    if (!provider.compactMaintenance) {
+      return "Memory provider does not support compaction.";
+    }
+    const result = await provider.compactMaintenance({
+      dryRun: !parsed.confirm
+    });
+    return formatCompactResult(result, parsed.confirm);
+  } finally {
+    await provider.close?.();
+  }
+}
 async function handleMemoryMigrateCommand(directory, _args) {
   const config3 = {
     ...resolveCommandMemoryConfig(directory),
@@ -70510,6 +70982,16 @@ async function handleMemoryExportCommand(directory, _args) {
     await provider.close?.();
   }
 }
+function createMaintenanceProvider(directory, config3) {
+  return createConfiguredMemoryProvider(directory, config3);
+}
+function maintenanceReportOptions(config3, limit) {
+  return {
+    limit,
+    lowUtilityMaxConfidence: config3.maintenance.lowUtilityMaxConfidence,
+    lowUtilityMinAgeDays: config3.maintenance.lowUtilityMinAgeDays
+  };
+}
 async function handleMemoryEvaluateCommand(directory, args2) {
   const parsed = parseEvaluateArgs(directory, args2);
   if ("error" in parsed)
@@ -70568,6 +71050,28 @@ function parseEvaluateArgs(directory, args2) {
   }
   return { json: json3, fixtureDirectory };
 }
+function parseMaintenanceArgs(args2, options) {
+  let limit = 20;
+  let confirm = false;
+  const allowLimit = options.allowLimit ?? true;
+  for (let i2 = 0;i2 < args2.length; i2++) {
+    const arg = args2[i2];
+    if (arg === "--confirm" && options.allowConfirm) {
+      confirm = true;
+      continue;
+    }
+    if (arg === "--limit" && allowLimit) {
+      const next = args2[i2 + 1];
+      if (!next || !/^\d+$/.test(next))
+        return { error: options.usage };
+      limit = Math.min(100, Math.max(1, Number(next)));
+      i2++;
+      continue;
+    }
+    return { error: options.usage };
+  }
+  return { limit, confirm };
+}
 function resolvePackageRootFromModule(modulePath) {
   const moduleDir = path45.dirname(modulePath);
   const leaf = path45.basename(moduleDir);
@@ -70618,6 +71122,80 @@ function appendInvalidRows(lines, invalidRows) {
     lines.push(`- ... ${invalidRows.length - 20} more`);
   }
 }
+function appendProposalLines(lines, title, proposals) {
+  lines.push("", `### ${title}`);
+  if (proposals.length === 0) {
+    lines.push("- none");
+    return;
+  }
+  for (const proposal of proposals) {
+    const reason = proposal.status === "rejected" ? ` - ${proposal.rejectionReason ?? "no reason recorded"}` : "";
+    lines.push(`- \`${proposal.id}\` ${proposal.operation} ${proposal.targetMemoryId ?? proposal.proposedRecord?.id ?? "new"} (${proposal.status})${reason}`);
+  }
+}
+function appendMemoryLines(lines, title, memories) {
+  lines.push("", `### ${title}`);
+  if (memories.length === 0) {
+    lines.push("- none");
+    return;
+  }
+  for (const memory of memories) {
+    lines.push(`- \`${memory.id}\` ${memory.kind} confidence=${memory.confidence.toFixed(2)} updated=${memory.updatedAt} - ${truncate(memory.text, 100)}`);
+  }
+}
+function appendRecallRoleLines(lines, roles) {
+  lines.push("", "### Recall by agent role");
+  if (roles.length === 0) {
+    lines.push("- none");
+    return;
+  }
+  for (const role of roles) {
+    const memoryCount = Object.keys(role.memoryIds).length;
+    lines.push(`- \`${role.agentRole}\`: ${role.count} recall event(s), ${memoryCount} memory ID(s)`);
+  }
+}
+function appendRecallMemoryLines(lines, memories) {
+  lines.push("", "### Most-recalled memories");
+  if (memories.length === 0) {
+    lines.push("- none");
+    return;
+  }
+  for (const memory of memories) {
+    lines.push(`- \`${memory.memoryId}\`: ${memory.count} hit(s), last=${memory.lastRecalledAt}, avgScore=${memory.averageScore.toFixed(3)}`);
+  }
+}
+function appendSupersededChains(lines, report) {
+  lines.push("", "### Superseded chains");
+  if (report.supersededChains.length === 0) {
+    lines.push("- none");
+    return;
+  }
+  for (const chain of report.supersededChains) {
+    const reason = chain.reason ? ` - ${chain.reason}` : "";
+    lines.push(`- ${chain.chain.map((id) => `\`${id}\``).join(" -> ")}${reason}`);
+  }
+}
+function formatCompactResult(result, confirmed) {
+  const lines = [
+    "## Swarm Memory Compact",
+    "",
+    `- Mode: \`${confirmed ? "confirmed" : "dry-run"}\``,
+    `- Deleted tombstones: \`${result.removedDeleted}\``,
+    `- Superseded records: \`${result.removedSuperseded}\``,
+    `- Expired scratch records: \`${result.removedExpiredScratch}\``,
+    `- Remaining memories: \`${result.remaining}\``
+  ];
+  if (!confirmed) {
+    lines.push("", "No records were removed. Re-run `/swarm memory compact --confirm` to apply this compaction.");
+  }
+  return lines.join(`
+`);
+}
+function truncate(value, maxLength) {
+  if (value.length <= maxLength)
+    return value;
+  return `${value.slice(0, maxLength - 3)}...`;
+}
 var PACKAGE_ROOT;
 var init_memory2 = __esm(() => {
   init_loader();
@@ -79002,7 +79580,7 @@ function classifySwarmCommandToolUse(resolved) {
       return { allowed: true };
     return {
       allowed: false,
-      message: "Use `/swarm memory status`, `/swarm memory export`, or `/swarm memory evaluate --json` through swarm_command. Memory import and migrate are intentionally excluded from chat-tool execution."
+      message: "Use `/swarm memory status`, `/swarm memory pending`, `/swarm memory recall-log`, `/swarm memory stale`, `/swarm memory export`, or `/swarm memory evaluate --json` through swarm_command. Memory import, migrate, and compact are intentionally excluded from chat-tool execution."
     };
   }
   if (canonicalKey === "memory evaluate") {
@@ -79015,6 +79593,17 @@ function classifySwarmCommandToolUse(resolved) {
       message: "Usage through swarm_command: `/swarm memory evaluate --json`. Custom fixture directories are only available through direct user command execution."
     };
   }
+  if (canonicalKey === "memory pending" || canonicalKey === "memory recall-log" || canonicalKey === "memory stale") {
+    if (args2.length === 0)
+      return { allowed: true };
+    if (args2.length === 2 && args2[0] === "--limit" && /^\d+$/.test(args2[1])) {
+      return { allowed: true };
+    }
+    return {
+      allowed: false,
+      message: `Usage through swarm_command: \`/swarm ${canonicalKey}\` or ` + `\`/swarm ${canonicalKey} --limit <n>\`.`
+    };
+  }
   if (canonicalKey === "retrieve") {
     if (args2.length !== 1 || !SUMMARY_ID_PATTERN.test(args2[0])) {
       return {
@@ -79066,7 +79655,7 @@ function classifySwarmCommandChatFallbackUse(resolved) {
       message: "/swarm config doctor --fix is not available through chat fallback because it can modify configuration files. Run the CLI command directly when you intend to apply fixes."
     };
   }
-  if (canonicalKey === "knowledge migrate" || canonicalKey === "knowledge quarantine" || canonicalKey === "knowledge restore" || canonicalKey === "memory import" || canonicalKey === "memory migrate") {
+  if (canonicalKey === "knowledge migrate" || canonicalKey === "knowledge quarantine" || canonicalKey === "knowledge restore" || canonicalKey === "memory import" || canonicalKey === "memory migrate" || canonicalKey === "memory compact") {
     return {
       allowed: false,
       message: `/swarm ${canonicalKey} is not available through chat fallback because it mutates .swarm state. ` + "Run the CLI command directly after confirming the intended state change."
@@ -79099,6 +79688,10 @@ var init_tool_policy = __esm(() => {
     "knowledge",
     "memory",
     "memory status",
+    "memory pending",
+    "memory recall-log",
+    "memory compact",
+    "memory stale",
     "memory export",
     "memory evaluate",
     "memory import",
@@ -79125,6 +79718,9 @@ var init_tool_policy = __esm(() => {
     "knowledge",
     "memory",
     "memory status",
+    "memory pending",
+    "memory recall-log",
+    "memory stale",
     "memory export",
     "memory evaluate",
     "sync-plan",
@@ -79137,7 +79733,8 @@ var init_tool_policy = __esm(() => {
     "rollback",
     "checkpoint",
     "memory import",
-    "memory migrate"
+    "memory migrate",
+    "memory compact"
   ]);
   NO_ARGS = new Set([
     "agents",
@@ -80132,6 +80729,34 @@ Subcommands:
       args: "",
       category: "diagnostics"
     },
+    "memory pending": {
+      handler: (ctx) => handleMemoryPendingCommand(ctx.directory, ctx.args),
+      description: "Show pending Swarm memory proposals and rejection reasons",
+      subcommandOf: "memory",
+      args: "--limit <n>",
+      category: "diagnostics"
+    },
+    "memory recall-log": {
+      handler: (ctx) => handleMemoryRecallLogCommand(ctx.directory, ctx.args),
+      description: "Summarize Swarm memory recall usage",
+      subcommandOf: "memory",
+      args: "--limit <n>",
+      category: "diagnostics"
+    },
+    "memory compact": {
+      handler: (ctx) => handleMemoryCompactCommand(ctx.directory, ctx.args),
+      description: "Compact deleted, superseded, and expired scratch memories",
+      subcommandOf: "memory",
+      args: "--confirm",
+      category: "utility"
+    },
+    "memory stale": {
+      handler: (ctx) => handleMemoryStaleCommand(ctx.directory, ctx.args),
+      description: "List stale and low-utility Swarm memories",
+      subcommandOf: "memory",
+      args: "--limit <n>",
+      category: "diagnostics"
+    },
     "memory export": {
       handler: (ctx) => handleMemoryExportCommand(ctx.directory, ctx.args),
       description: "Export current Swarm memory to JSONL files",
@@ -83887,6 +84512,7 @@ API: [exact names/signatures/versions to use]
 PLATFORM: [cross-platform notes if OS-interaction APIs]
 GOTCHAS: [common pitfalls or edge cases]
 DEPS: [required dependencies/tools]
+EVIDENCE_REFS: [cite evidence-cache:<id>, URL, file, or doc refs used; use "none" if no external evidence was available]
 
 ## DOMAIN CHECKLISTS
 Apply the relevant checklist when the DOMAIN matches:
@@ -83925,7 +84551,8 @@ Cache lookup steps:
 1. If \`.swarm/context.md\` does not exist: proceed with fresh research.
 2. If the \`## Research Sources\` section is absent: proceed with fresh research.
 3. If URL/topic IS listed in ## Research Sources: reuse cached summary — no re-fetch needed.
-4. If cache miss (URL/topic not listed): fetch URL, then append this line at the end of your response:
+4. If fresh search/API-doc/crawl evidence is provided, cite its \`evidence-cache:<id>\` refs in EVIDENCE_REFS. Raw docs/search snippets are evidence, not memory.
+5. If cache miss (URL/topic not listed): fetch URL, then append this line at the end of your response:
    CACHE-UPDATE: [YYYY-MM-DD] | [URL or topic] | [one-line summary of finding]
    The Architect will save this line to .swarm/context.md ## Research Sources. Do NOT write to any file yourself.
 
@@ -89644,11 +90271,11 @@ var init_curator_drift = __esm(() => {
 var exports_project_context = {};
 __export(exports_project_context, {
   buildProjectContext: () => buildProjectContext,
-  _internals: () => _internals64,
+  _internals: () => _internals65,
   LANG_BACKEND_DETECTION_TIMEOUT_MS: () => LANG_BACKEND_DETECTION_TIMEOUT_MS
 });
 import * as fs115 from "node:fs";
-import * as path154 from "node:path";
+import * as path155 from "node:path";
 function detectFileExists2(directory, pattern) {
   if (pattern.includes("*") || pattern.includes("?")) {
     try {
@@ -89660,7 +90287,7 @@ function detectFileExists2(directory, pattern) {
     }
   }
   try {
-    fs115.accessSync(path154.join(directory, pattern));
+    fs115.accessSync(path155.join(directory, pattern));
     return true;
   } catch {
     return false;
@@ -89669,7 +90296,7 @@ function detectFileExists2(directory, pattern) {
 function selectTestCommandFromScriptsTest(backend, directory) {
   let pkgRaw;
   try {
-    pkgRaw = fs115.readFileSync(path154.join(directory, "package.json"), "utf-8");
+    pkgRaw = fs115.readFileSync(path155.join(directory, "package.json"), "utf-8");
   } catch {
     return null;
   }
@@ -89728,7 +90355,7 @@ function selectLintCommand(backend, directory) {
   return null;
 }
 async function buildProjectContext(directory) {
-  const backend = await _internals64.pickBackend(directory);
+  const backend = await _internals65.pickBackend(directory);
   if (!backend)
     return null;
   const ctx = emptyProjectContext();
@@ -89759,16 +90386,16 @@ async function buildProjectContext(directory) {
   if (backend.prompts.reviewerChecklist.length > 0) {
     ctx.REVIEWER_CHECKLIST = bulletList(backend.prompts.reviewerChecklist);
   }
-  const profiles = _internals64.pickedProfiles(directory);
+  const profiles = _internals65.pickedProfiles(directory);
   if (profiles.length > 1) {
     ctx.PROJECT_CONTEXT_SECONDARY_LANGUAGES = profiles.slice(1).map((p) => p.id).join(", ");
   }
   return ctx;
 }
-var LANG_BACKEND_DETECTION_TIMEOUT_MS = 300, _internals64;
+var LANG_BACKEND_DETECTION_TIMEOUT_MS = 300, _internals65;
 var init_project_context = __esm(() => {
   init_dispatch();
-  _internals64 = {
+  _internals65 = {
     pickBackend,
     pickedProfiles
   };
@@ -89778,7 +90405,7 @@ var init_project_context = __esm(() => {
 init_package();
 init_agents2();
 init_critic();
-import * as path155 from "node:path";
+import * as path156 from "node:path";
 
 // src/background/index.ts
 init_event_bus();
@@ -122958,6 +123585,83 @@ function createWebSearchProvider(config3) {
   }
 }
 
+// src/evidence/documents.ts
+init_utils2();
+init_redaction();
+import { createHash as createHash12 } from "node:crypto";
+import { appendFile as appendFile13, mkdir as mkdir24 } from "node:fs/promises";
+import * as path150 from "node:path";
+var EVIDENCE_CACHE_FILE = "evidence-cache/documents.jsonl";
+var MAX_EVIDENCE_TEXT_LENGTH = 4000;
+async function writeEvidenceDocuments(directory, inputs, now = () => new Date) {
+  const filePath = validateSwarmPath(directory, EVIDENCE_CACHE_FILE);
+  const capturedAt = now().toISOString();
+  const records = inputs.map((input) => createEvidenceDocumentRecord(input, capturedAt)).filter((record3) => record3 !== null);
+  if (records.length > 0) {
+    await mkdir24(path150.dirname(filePath), { recursive: true });
+    await appendFile13(filePath, `${records.map((record3) => JSON.stringify(record3)).join(`
+`)}
+`, "utf-8");
+  }
+  return {
+    path: ".swarm/evidence-cache/documents.jsonl",
+    records,
+    refs: records.map((record3) => record3.ref)
+  };
+}
+function createEvidenceDocumentRecord(input, defaultCapturedAt) {
+  const text = normalizeEvidenceText(input.text ?? input.snippet ?? "");
+  if (!text)
+    return null;
+  const capturedAt = input.capturedAt ?? defaultCapturedAt;
+  const base = {
+    sourceType: input.sourceType,
+    query: normalizeOptional(input.query),
+    title: normalizeOptional(input.title),
+    url: normalizeOptional(input.url),
+    text
+  };
+  const id = createEvidenceDocumentId(base);
+  return {
+    id,
+    ref: `evidence-cache:${id}`,
+    ...base,
+    capturedAt,
+    createdBy: normalizeOptional(input.createdBy),
+    metadata: input.metadata ?? {}
+  };
+}
+function createEvidenceDocumentId(input) {
+  const hash3 = createHash12("sha256").update([
+    input.sourceType,
+    input.query ?? "",
+    input.title ?? "",
+    input.url ?? "",
+    input.text
+  ].join(`
+`)).digest("hex");
+  return `evd_${hash3.slice(0, 16)}`;
+}
+function normalizeEvidenceText(text) {
+  const normalized = redactSecrets(text.replace(/\s+/g, " ").trim());
+  return truncateEvidenceText(normalized, MAX_EVIDENCE_TEXT_LENGTH);
+}
+function truncateEvidenceText(text, maxLength) {
+  if (text.length <= maxLength)
+    return text;
+  const truncated = text.slice(0, maxLength);
+  const lastPlaceholderStart = truncated.lastIndexOf("[REDACTED:");
+  const lastPlaceholderEnd = truncated.lastIndexOf("]");
+  if (lastPlaceholderStart > lastPlaceholderEnd) {
+    return truncated.slice(0, lastPlaceholderStart).trimEnd();
+  }
+  return truncated;
+}
+function normalizeOptional(value) {
+  const normalized = value?.replace(/\s+/g, " ").trim();
+  return normalized ? redactSecrets(normalized) : undefined;
+}
+
 // src/tools/web-search.ts
 init_create_tool();
 init_resolve_working_directory();
@@ -123018,6 +123722,7 @@ var web_search = createSwarmTool({
     }
     try {
       const results = await provider.search(parsed.data.query, maxResults);
+      const evidence = await captureSearchEvidence(dirResult.directory, parsed.data.query, results);
       const ok2 = {
         success: true,
         query: parsed.data.query,
@@ -123025,8 +123730,15 @@ var web_search = createSwarmTool({
         results: results.map(({ title, url: url3, snippet }) => ({
           title,
           url: url3,
-          snippet
-        }))
+          snippet,
+          evidenceRef: evidence.refByUrl.get(url3)
+        })),
+        evidence: {
+          stored: evidence.stored,
+          path: evidence.path,
+          refs: evidence.refs,
+          error: evidence.error
+        }
       };
       return JSON.stringify(ok2, null, 2);
     } catch (err3) {
@@ -123039,6 +123751,39 @@ var web_search = createSwarmTool({
     }
   }
 });
+async function captureSearchEvidence(directory, query, results) {
+  try {
+    const written = await _internals64.writeEvidenceDocuments(directory, results.map((result) => ({
+      sourceType: "web_search",
+      query,
+      title: result.title,
+      url: result.url,
+      snippet: result.snippet,
+      createdBy: "web_search"
+    })));
+    const refByUrl = new Map;
+    for (const record3 of written.records) {
+      if (record3.url)
+        refByUrl.set(record3.url, record3.ref);
+    }
+    return {
+      stored: written.records.length > 0,
+      path: written.path,
+      refs: written.refs,
+      refByUrl
+    };
+  } catch (err3) {
+    return {
+      stored: false,
+      refs: [],
+      refByUrl: new Map,
+      error: err3 instanceof Error ? err3.message : String(err3)
+    };
+  }
+}
+var _internals64 = {
+  writeEvidenceDocuments
+};
 // src/tools/write-drift-evidence.ts
 init_zod();
 init_qa_gate_profile();
@@ -123047,7 +123792,7 @@ init_ledger();
 init_manager();
 init_create_tool();
 import fs111 from "node:fs";
-import path150 from "node:path";
+import path151 from "node:path";
 function normalizeVerdict(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -123095,7 +123840,7 @@ async function executeWriteDriftEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "drift-verifier.json";
-  const relativePath = path150.join("evidence", String(phase), filename);
+  const relativePath = path151.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -123106,10 +123851,10 @@ async function executeWriteDriftEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path150.dirname(validatedPath);
+  const evidenceDir = path151.dirname(validatedPath);
   try {
     await fs111.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path150.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path151.join(evidenceDir, `.${filename}.tmp`);
     await fs111.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs111.promises.rename(tempPath, validatedPath);
     let snapshotInfo;
@@ -123205,7 +123950,7 @@ var write_drift_evidence = createSwarmTool({
 init_zod();
 init_loader();
 import fs112 from "node:fs";
-import path151 from "node:path";
+import path152 from "node:path";
 init_utils2();
 init_manager();
 init_create_tool();
@@ -123293,7 +124038,7 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
     timestamp: synthesis.timestamp
   };
   const filename = "final-council.json";
-  const relativePath = path151.join("evidence", filename);
+  const relativePath = path152.join("evidence", filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -123307,10 +124052,10 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
   const evidenceContent = {
     entries: [evidenceEntry]
   };
-  const evidenceDir = path151.dirname(validatedPath);
+  const evidenceDir = path152.dirname(validatedPath);
   try {
     await fs112.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path151.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path152.join(evidenceDir, `.${filename}.tmp`);
     await fs112.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs112.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -123369,7 +124114,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs113 from "node:fs";
-import path152 from "node:path";
+import path153 from "node:path";
 function normalizeVerdict2(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -123417,7 +124162,7 @@ async function executeWriteHallucinationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "hallucination-guard.json";
-  const relativePath = path152.join("evidence", String(phase), filename);
+  const relativePath = path153.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -123428,10 +124173,10 @@ async function executeWriteHallucinationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path152.dirname(validatedPath);
+  const evidenceDir = path153.dirname(validatedPath);
   try {
     await fs113.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path152.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path153.join(evidenceDir, `.${filename}.tmp`);
     await fs113.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs113.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -123480,7 +124225,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs114 from "node:fs";
-import path153 from "node:path";
+import path154 from "node:path";
 function normalizeVerdict3(verdict) {
   switch (verdict) {
     case "PASS":
@@ -123554,7 +124299,7 @@ async function executeWriteMutationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "mutation-gate.json";
-  const relativePath = path153.join("evidence", String(phase), filename);
+  const relativePath = path154.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -123565,10 +124310,10 @@ async function executeWriteMutationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path153.dirname(validatedPath);
+  const evidenceDir = path154.dirname(validatedPath);
   try {
     await fs114.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path153.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path154.join(evidenceDir, `.${filename}.tmp`);
     await fs114.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs114.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -123918,7 +124663,7 @@ async function initializeOpenCodeSwarm(ctx) {
     const { PreflightTriggerManager: PTM } = await Promise.resolve().then(() => (init_trigger(), exports_trigger));
     preflightTriggerManager = new PTM(automationConfig);
     const { AutomationStatusArtifact: ASA } = await Promise.resolve().then(() => (init_status_artifact(), exports_status_artifact));
-    const swarmDir = path155.resolve(ctx.directory, ".swarm");
+    const swarmDir = path156.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {
@@ -124522,7 +125267,7 @@ ${promptRaw}`;
                   "ci-failure-resolver": "CI/CD failure resolution"
                 };
                 const skillPaths = topSkills.map((s) => {
-                  const dirName = path155.basename(path155.dirname(s.skillPath));
+                  const dirName = path156.basename(path156.dirname(s.skillPath));
                   const desc = SKILL_DESCRIPTIONS[dirName] ?? dirName;
                   return `file:${s.skillPath} (-- ${desc})`;
                 }).join(", ");
@@ -124531,7 +125276,7 @@ ${promptRaw}`;
 
 ${promptRaw}`;
                 argsRecord.prompt = newPrompt;
-                const skillNames = topSkills.map((s) => `${path155.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
+                const skillNames = topSkills.map((s) => `${path156.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
                 console.warn(`[skill-propagation-gate] Injected skills: ${skillNames}`);
                 for (const skill of topSkills) {
                   try {