opencode-swarm 7.51.1 → 7.51.3

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.51.1",
+    version: "7.51.3",
     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",
@@ -116,7 +116,7 @@ var init_package = __esm(() => {
       check: "biome check --write .",
       dev: "bun run build && opencode",
       "package:smoke": "node scripts/package-smoke.mjs",
-      prepublishOnly: "bun run build",
+      prepare: "bun run build",
       "repro:704": "node scripts/repro-704.mjs"
     },
     dependencies: {
@@ -56604,7 +56604,7 @@ var init_event_bus = __esm(() => {
 
 // src/hooks/knowledge-store.ts
 import { existsSync as existsSync12 } from "node:fs";
-import { appendFile as appendFile3, mkdir as mkdir3, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
+import { appendFile as appendFile3, mkdir as mkdir3, readFile as readFile5 } from "node:fs/promises";
 import * as os8 from "node:os";
 import * as path22 from "node:path";
 function resolveSwarmKnowledgePath(directory) {
@@ -56767,23 +56767,25 @@ async function rewriteKnowledge(filePath, entries) {
     }
   }
 }
-async function enforceKnowledgeCap(filePath, maxEntries) {
-  let release = null;
+async function transactFile(filePath, read, write, mutate) {
+  const dir = path22.dirname(filePath);
   try {
-    const dir = path22.dirname(filePath);
     await mkdir3(dir, { recursive: true });
+  } catch {
+    return false;
+  }
+  let release = null;
+  try {
     release = await import_proper_lockfile3.default.lock(dir, {
       retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
       stale: 5000
     });
-    const entries = await readKnowledge(filePath);
-    if (entries.length > maxEntries) {
-      const trimmed = entries.slice(entries.length - maxEntries);
-      const content = trimmed.map((e) => JSON.stringify(e)).join(`
-`) + (trimmed.length > 0 ? `
-` : "");
-      await writeFile3(filePath, content, "utf-8");
-    }
+    const data = await read(filePath);
+    const result = mutate(data);
+    if (result === null)
+      return false;
+    await write(filePath, result);
+    return true;
   } finally {
     if (release) {
       try {
@@ -56792,25 +56794,33 @@ async function enforceKnowledgeCap(filePath, maxEntries) {
     }
   }
 }
+async function transactKnowledge(filePath, mutate) {
+  return transactFile(filePath, readKnowledge, async (fp, entries) => {
+    const content = entries.map((e) => JSON.stringify(e)).join(`
+`) + (entries.length > 0 ? `
+` : "");
+    await atomicWriteFile(fp, content);
+  }, mutate);
+}
+async function enforceKnowledgeCap(filePath, maxEntries) {
+  await transactKnowledge(filePath, (entries) => {
+    if (entries.length <= maxEntries)
+      return null;
+    return entries.slice(entries.length - maxEntries);
+  });
+}
 async function sweepAgedEntries(filePath, defaultMaxPhases) {
-  let release = null;
-  try {
-    const dir = path22.dirname(filePath);
-    await mkdir3(dir, { recursive: true });
-    release = await import_proper_lockfile3.default.lock(dir, {
-      retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
-      stale: 5000
-    });
-    const entries = await readKnowledge(filePath);
-    const result = {
-      scanned: entries.length,
-      aged: 0,
-      archived: 0,
-      removed: 0,
-      skipped_promoted: 0
-    };
+  const result = {
+    scanned: 0,
+    aged: 0,
+    archived: 0,
+    removed: 0,
+    skipped_promoted: 0
+  };
+  await transactKnowledge(filePath, (entries) => {
+    result.scanned = entries.length;
     if (entries.length === 0)
-      return result;
+      return null;
     const now = new Date().toISOString();
     let mutated = false;
     for (const entry of entries) {
@@ -56830,40 +56840,22 @@ async function sweepAgedEntries(filePath, defaultMaxPhases) {
         result.archived++;
       }
     }
-    if (mutated) {
-      const content = entries.map((e) => JSON.stringify(e)).join(`
-`) + (entries.length > 0 ? `
-` : "");
-      await writeFile3(filePath, content, "utf-8");
-    }
-    return result;
-  } finally {
-    if (release) {
-      try {
-        await release();
-      } catch {}
-    }
-  }
+    return mutated ? entries : null;
+  });
+  return result;
 }
 async function sweepStaleTodos(filePath, todoMaxPhases) {
-  let release = null;
-  try {
-    const dir = path22.dirname(filePath);
-    await mkdir3(dir, { recursive: true });
-    release = await import_proper_lockfile3.default.lock(dir, {
-      retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
-      stale: 5000
-    });
-    const entries = await readKnowledge(filePath);
-    const result = {
-      scanned: entries.length,
-      aged: 0,
-      archived: 0,
-      removed: 0,
-      skipped_promoted: 0
-    };
+  const result = {
+    scanned: 0,
+    aged: 0,
+    archived: 0,
+    removed: 0,
+    skipped_promoted: 0
+  };
+  await transactKnowledge(filePath, (entries) => {
+    result.scanned = entries.length;
     if (entries.length === 0)
-      return result;
+      return null;
     const kept = entries.filter((e) => {
       if (e.category !== "todo" || e.status === "promoted")
         return true;
@@ -56874,32 +56866,20 @@ async function sweepStaleTodos(filePath, todoMaxPhases) {
       }
       return true;
     });
-    if (result.removed > 0) {
-      const content = kept.map((e) => JSON.stringify(e)).join(`
-`) + (kept.length > 0 ? `
-` : "");
-      await writeFile3(filePath, content, "utf-8");
-    }
-    return result;
-  } finally {
-    if (release) {
-      try {
-        await release();
-      } catch {}
-    }
-  }
+    return result.removed > 0 ? kept : null;
+  });
+  return result;
 }
 async function appendRejectedLesson(directory, lesson) {
   const filePath = resolveSwarmRejectedPath(directory);
-  const existing = await readRejectedLessons(directory);
   const MAX = 20;
-  const updated = [...existing, lesson];
-  if (updated.length > MAX) {
-    const trimmed = updated.slice(updated.length - MAX);
-    await rewriteKnowledge(filePath, trimmed);
-  } else {
-    await appendKnowledge(filePath, lesson);
-  }
+  await transactKnowledge(filePath, (existing) => {
+    const updated = [...existing, lesson];
+    if (updated.length > MAX) {
+      return updated.slice(updated.length - MAX);
+    }
+    return updated;
+  });
 }
 function normalize4(text) {
   const s = typeof text === "string" ? text : String(text ?? "");
@@ -57028,7 +57008,7 @@ async function applyConfidenceDeltas(filePath, deltas) {
       const content = entries.map((e) => JSON.stringify(e)).join(`
 `) + (entries.length > 0 ? `
 ` : "");
-      await writeFile3(filePath, content, "utf-8");
+      await atomicWriteFile(filePath, content);
     }
   } catch (err2) {
     console.warn(`[knowledge-store] applyConfidenceDeltas failed on ${filePath} (fail-open):`, err2 instanceof Error ? err2.message : String(err2));
@@ -57047,7 +57027,7 @@ var init_knowledge_store = __esm(() => {
 });
 
 // src/hooks/knowledge-validator.ts
-import { appendFile as appendFile4, mkdir as mkdir4, writeFile as writeFile4 } from "node:fs/promises";
+import { appendFile as appendFile4, mkdir as mkdir4 } from "node:fs/promises";
 import * as path23 from "node:path";
 function normalizeText(text) {
   return text.normalize("NFKC").toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
@@ -57224,7 +57204,8 @@ async function quarantineEntry(directory, entryId, reason, reportedBy) {
   let release;
   try {
     release = await import_proper_lockfile4.default.lock(swarmDir, {
-      retries: { retries: 3, minTimeout: 100 }
+      retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
+      stale: 5000
     });
     const entries = await readKnowledge(knowledgePath);
     const entry = entries.find((e) => e.id === entryId);
@@ -57243,7 +57224,7 @@ async function quarantineEntry(directory, entryId, reason, reportedBy) {
     const jsonlContent = remaining.length > 0 ? `${remaining.map((e) => JSON.stringify(e)).join(`
 `)}
 ` : "";
-    await writeFile4(knowledgePath, jsonlContent, "utf-8");
+    await atomicWriteFile(knowledgePath, jsonlContent);
     await appendFile4(quarantinePath, `${JSON.stringify(quarantined)}
 `, "utf-8");
     const quarantinedEntries = await readKnowledge(quarantinePath);
@@ -57252,7 +57233,7 @@ async function quarantineEntry(directory, entryId, reason, reportedBy) {
       const capContent = trimmed.length > 0 ? `${trimmed.map((e) => JSON.stringify(e)).join(`
 `)}
 ` : "";
-      await writeFile4(quarantinePath, capContent, "utf-8");
+      await atomicWriteFile(quarantinePath, capContent);
     }
     const rejectedRecord = {
       id: entryId,
@@ -57287,7 +57268,8 @@ async function restoreEntry(directory, entryId) {
   let release;
   try {
     release = await import_proper_lockfile4.default.lock(swarmDir, {
-      retries: { retries: 3, minTimeout: 100 }
+      retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
+      stale: 5000
     });
     const quarantinedEntries = await readKnowledge(quarantinePath);
     const entryToRestore = quarantinedEntries.find((e) => e.id === entryId);
@@ -57316,7 +57298,7 @@ async function restoreEntry(directory, entryId) {
     const jsonlContent = remaining.length > 0 ? `${remaining.map((e) => JSON.stringify(e)).join(`
 `)}
 ` : "";
-    await writeFile4(quarantinePath, jsonlContent, "utf-8");
+    await atomicWriteFile(quarantinePath, jsonlContent);
     await appendFile4(knowledgePath, `${JSON.stringify(original)}
 `, "utf-8");
     const rejectedEntries = await readKnowledge(rejectedPath);
@@ -57324,7 +57306,7 @@ async function restoreEntry(directory, entryId) {
     const rejectedContent = filtered.length > 0 ? `${filtered.map((e) => JSON.stringify(e)).join(`
 `)}
 ` : "";
-    await writeFile4(rejectedPath, rejectedContent, "utf-8");
+    await atomicWriteFile(rejectedPath, rejectedContent);
   } finally {
     if (release) {
       await release();
@@ -57333,6 +57315,7 @@ async function restoreEntry(directory, entryId) {
 }
 var import_proper_lockfile4, DANGEROUS_COMMAND_PATTERNS, SECURITY_DEGRADING_PATTERNS, INVISIBLE_FORMAT_CHARS, INJECTION_PATTERNS, VALID_CATEGORIES, TECH_REFERENCE_WORDS, ACTION_VERB_WORDS, NEGATION_PAIRS, ALLOWED_SKILL_PATH_PREFIXES, VALID_DIRECTIVE_PRIORITIES;
 var init_knowledge_validator = __esm(() => {
+  init_task_file();
   init_logger();
   init_knowledge_store();
   import_proper_lockfile4 = __toESM(require_proper_lockfile(), 1);
@@ -57470,7 +57453,7 @@ __export(exports_skill_generator, {
   _internals: () => _internals18
 });
 import { existsSync as existsSync13, unlinkSync as unlinkSync5 } from "node:fs";
-import { mkdir as mkdir5, readFile as readFile6, rename as rename3, writeFile as writeFile5 } from "node:fs/promises";
+import { mkdir as mkdir5, readFile as readFile6, rename as rename3, writeFile as writeFile3 } from "node:fs/promises";
 import * as path24 from "node:path";
 function sanitizeSlug(input) {
   const lc = input.toLowerCase().trim();
@@ -57662,7 +57645,7 @@ function escapeMarkdown(s) {
 async function atomicWrite2(p, content) {
   await mkdir5(path24.dirname(p), { recursive: true });
   const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
-  await writeFile5(tmp, content, "utf-8");
+  await writeFile3(tmp, content, "utf-8");
   await rename3(tmp, p);
 }
 async function generateSkills(req) {
@@ -57976,7 +57959,7 @@ async function retireSkill(directory, slug, reason) {
     reason: reason ?? "manual_retire"
   });
   await mkdir5(markerDir, { recursive: true });
-  await writeFile5(markerPath, markerContent, "utf-8");
+  await writeFile3(markerPath, markerContent, "utf-8");
   return {
     retired: true,
     path: skillPath,
@@ -59195,77 +59178,83 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
   }
   const validRecommendations = recommendations.filter((rec) => rec != null);
   const knowledgePath = resolveSwarmKnowledgePath(directory);
-  const entries = await readKnowledge(knowledgePath);
-  let modified = false;
   const appliedIds = new Set;
-  const updatedEntries = entries.map((entry) => {
-    const rec = validRecommendations.find((r) => r.entry_id === entry.id);
-    if (!rec)
-      return entry;
-    switch (rec.action) {
-      case "promote":
-        appliedIds.add(entry.id);
-        applied++;
-        modified = true;
-        return {
-          ...entry,
-          hive_eligible: true,
-          confidence: Math.min(1, (entry.confidence ?? 0) + 0.1),
-          updated_at: new Date().toISOString()
-        };
-      case "archive":
-        appliedIds.add(entry.id);
-        applied++;
-        modified = true;
-        return {
-          ...entry,
-          status: "archived",
-          updated_at: new Date().toISOString()
-        };
-      case "flag_contradiction":
-        appliedIds.add(entry.id);
-        applied++;
-        modified = true;
-        return {
-          ...entry,
-          tags: [
-            ...entry.tags ?? [],
-            `contradiction:${(rec.reason ?? "").slice(0, 50)}`
-          ],
-          updated_at: new Date().toISOString()
-        };
-      case "rewrite": {
-        const newLesson = (rec.lesson ?? "").trim();
-        if (newLesson.length < 15 || newLesson.length > 280) {
-          return entry;
+  const foundIds = new Set;
+  await transactKnowledge(knowledgePath, (entries) => {
+    appliedIds.clear();
+    foundIds.clear();
+    let txApplied = 0;
+    let modified = false;
+    for (const e of entries)
+      foundIds.add(e.id);
+    const updatedEntries = entries.map((entry) => {
+      const rec = validRecommendations.find((r) => r.entry_id === entry.id);
+      if (!rec)
+        return entry;
+      switch (rec.action) {
+        case "promote":
+          appliedIds.add(entry.id);
+          txApplied++;
+          modified = true;
+          return {
+            ...entry,
+            hive_eligible: true,
+            confidence: Math.min(1, (entry.confidence ?? 0) + 0.1),
+            updated_at: new Date().toISOString()
+          };
+        case "archive":
+          appliedIds.add(entry.id);
+          txApplied++;
+          modified = true;
+          return {
+            ...entry,
+            status: "archived",
+            updated_at: new Date().toISOString()
+          };
+        case "flag_contradiction":
+          appliedIds.add(entry.id);
+          txApplied++;
+          modified = true;
+          return {
+            ...entry,
+            tags: [
+              ...entry.tags ?? [],
+              `contradiction:${(rec.reason ?? "").slice(0, 50)}`
+            ],
+            updated_at: new Date().toISOString()
+          };
+        case "rewrite": {
+          const newLesson = (rec.lesson ?? "").trim();
+          if (newLesson.length < 15 || newLesson.length > 280) {
+            return entry;
+          }
+          appliedIds.add(entry.id);
+          txApplied++;
+          modified = true;
+          return {
+            ...entry,
+            lesson: newLesson,
+            updated_at: new Date().toISOString(),
+            confidence: Math.max(0.1, (entry.confidence ?? 0.5) - 0.05)
+          };
         }
-        appliedIds.add(entry.id);
-        applied++;
-        modified = true;
-        return {
-          ...entry,
-          lesson: newLesson,
-          updated_at: new Date().toISOString(),
-          confidence: Math.max(0.1, (entry.confidence ?? 0.5) - 0.05)
-        };
+        default:
+          return entry;
       }
-      default:
-        return entry;
-    }
+    });
+    applied += txApplied;
+    return modified ? updatedEntries : null;
   });
   for (const rec of validRecommendations) {
     if (rec.entry_id !== undefined && !appliedIds.has(rec.entry_id)) {
-      const found = entries.some((e) => e.id === rec.entry_id);
-      if (!found) {
+      if (!foundIds.has(rec.entry_id)) {
         warn(`[curator] applyCuratorKnowledgeUpdates: entry_id '${rec.entry_id}' not found — skipping`);
       }
       skipped++;
     }
   }
-  if (modified) {
-    await rewriteKnowledge(knowledgePath, updatedEntries);
-  }
-  const existingLessons = entries.map((e) => e.lesson);
+  const currentEntries = await readKnowledge(knowledgePath);
+  const currentLessons = currentEntries.map((e) => e.lesson);
   for (const rec of validRecommendations) {
     if (rec.entry_id !== undefined)
       continue;
@@ -59278,12 +59267,12 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
       skipped++;
       continue;
     }
-    if (existingLessons.some((el) => el.toLowerCase() === lesson.toLowerCase())) {
+    if (currentLessons.some((el) => el.toLowerCase() === lesson.toLowerCase())) {
       skipped++;
       continue;
     }
     if (knowledgeConfig.validation_enabled !== false) {
-      const validation = validateLesson(lesson, existingLessons, {
+      const validation = validateLesson(lesson, currentLessons, {
         category: rec.category ?? "other",
         scope: "global",
         confidence: rec.confidence ?? 0.5
@@ -59317,7 +59306,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     };
     await appendKnowledge(knowledgePath, newEntry);
     applied++;
-    existingLessons.push(lesson);
+    currentLessons.push(lesson);
   }
   return { applied, skipped };
 }
@@ -59613,7 +59602,7 @@ var init_hive_promoter = __esm(() => {
 // src/hooks/knowledge-events.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { existsSync as existsSync16 } from "node:fs";
-import { appendFile as appendFile5, mkdir as mkdir6, readFile as readFile7, writeFile as writeFile6 } from "node:fs/promises";
+import { appendFile as appendFile5, mkdir as mkdir6, readFile as readFile7, writeFile as writeFile4 } from "node:fs/promises";
 import * as path28 from "node:path";
 function resolveKnowledgeEventsPath(directory) {
   return path28.join(directory, ".swarm", "knowledge-events.jsonl");
@@ -59653,7 +59642,7 @@ async function appendKnowledgeEvent(directory, event) {
 `).filter((line) => line.trim().length > 0);
       if (lines.length > MAX_EVENT_LOG_ENTRIES) {
         const trimmed = lines.slice(lines.length - MAX_EVENT_LOG_ENTRIES);
-        await writeFile6(filePath, `${trimmed.join(`
+        await writeFile4(filePath, `${trimmed.join(`
 `)}
 `, "utf-8");
       }
@@ -60001,8 +59990,7 @@ async function processRetractions(retractions, directory) {
 }
 async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, config3, options) {
   const knowledgePath = resolveSwarmKnowledgePath(directory);
-  const existingEntries = await readKnowledge(knowledgePath) ?? [];
-  let stored = 0;
+  const snapshot = await readKnowledge(knowledgePath) ?? [];
   let skipped = 0;
   let rejected = 0;
   const categoryByTag = new Map([
@@ -60017,6 +60005,8 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
     ["other", "other"],
     ["todo", "todo"]
   ]);
+  const snapshotPlusNew = [...snapshot];
+  const toAdd = [];
   for (const lesson of lessons) {
     const tags = inferTags(lesson);
     let category = "process";
@@ -60031,7 +60021,7 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
       scope: "global",
       confidence: computeConfidence(0, true)
     };
-    const result = validateLesson(lesson, existingEntries.map((e) => e.lesson), meta3);
+    const result = validateLesson(lesson, snapshotPlusNew.map((e) => e.lesson), meta3);
     if (result.valid === false || result.severity === "error") {
       const rejectedLesson = {
         id: crypto.randomUUID(),
@@ -60044,7 +60034,7 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
       rejected++;
       continue;
     }
-    const duplicate = findNearDuplicate(lesson, existingEntries, config3.dedup_threshold);
+    const duplicate = findNearDuplicate(lesson, snapshotPlusNew, config3.dedup_threshold);
     if (duplicate) {
       skipped++;
       continue;
@@ -60076,9 +60066,20 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
       project_name: projectName,
       auto_generated: true
     };
-    await appendKnowledge(knowledgePath, entry);
-    stored++;
-    existingEntries.push(entry);
+    toAdd.push(entry);
+    snapshotPlusNew.push(entry);
+  }
+  let stored = 0;
+  if (toAdd.length > 0) {
+    await transactKnowledge(knowledgePath, (current) => {
+      const trulyNew = toAdd.filter((e) => !findNearDuplicate(e.lesson, current, config3.dedup_threshold));
+      const extraDups = toAdd.length - trulyNew.length;
+      skipped += extraDups;
+      if (trulyNew.length === 0)
+        return null;
+      stored = trulyNew.length;
+      return [...current, ...trulyNew];
+    });
   }
   await enforceKnowledgeCap(knowledgePath, config3.swarm_max_entries);
   if (!options?.skipAutoPromotion) {
@@ -60320,7 +60321,7 @@ var init_skill_improver_llm_factory = __esm(() => {
 
 // src/services/skill-improver-quota.ts
 import { existsSync as existsSync17 } from "node:fs";
-import { mkdir as mkdir7, readFile as readFile8, rename as rename4, writeFile as writeFile7 } from "node:fs/promises";
+import { mkdir as mkdir7, readFile as readFile8, rename as rename4, writeFile as writeFile5 } from "node:fs/promises";
 import * as path29 from "node:path";
 async function acquireLock(dir) {
   const acquire = import_proper_lockfile6.default.lock(dir, LOCK_RETRY_OPTS);
@@ -60367,7 +60368,7 @@ async function readState(filePath) {
 async function writeState(filePath, state) {
   await mkdir7(path29.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}`;
-  await writeFile7(tmp, JSON.stringify(state, null, 2), "utf-8");
+  await writeFile5(tmp, JSON.stringify(state, null, 2), "utf-8");
   await rename4(tmp, filePath);
 }
 async function getQuotaState(directory, opts) {
@@ -60454,7 +60455,7 @@ var init_skill_improver_quota = __esm(() => {
 
 // src/services/skill-improver.ts
 import { existsSync as existsSync18 } from "node:fs";
-import { mkdir as mkdir8, rename as rename5, writeFile as writeFile8 } from "node:fs/promises";
+import { mkdir as mkdir8, rename as rename5, writeFile as writeFile6 } from "node:fs/promises";
 import * as path30 from "node:path";
 function timestampSlug(d) {
   return d.toISOString().replace(/[:.]/g, "-");
@@ -60462,7 +60463,7 @@ function timestampSlug(d) {
 async function atomicWrite3(p, content) {
   await mkdir8(path30.dirname(p), { recursive: true });
   const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
-  await writeFile8(tmp, content, "utf-8");
+  await writeFile6(tmp, content, "utf-8");
   await rename5(tmp, p);
 }
 async function gatherInventory(directory) {
@@ -68292,7 +68293,7 @@ var KNOWLEDGE_SCHEMA_VERSION = 2;
 // src/hooks/knowledge-migrator.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { existsSync as existsSync25, readFileSync as readFileSync13 } from "node:fs";
-import { mkdir as mkdir9, readFile as readFile11, writeFile as writeFile9 } from "node:fs/promises";
+import { mkdir as mkdir9, readFile as readFile11, writeFile as writeFile7 } from "node:fs/promises";
 import * as path41 from "node:path";
 async function migrateKnowledgeToExternal(_directory, _config) {
   return {
@@ -68523,7 +68524,7 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     migration_tool: "knowledge-migrator.ts"
   };
   await mkdir9(path41.dirname(sentinelPath), { recursive: true });
-  await writeFile9(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
+  await writeFile7(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
 var _internals29;
 var init_knowledge_migrator = __esm(() => {
@@ -69605,7 +69606,7 @@ import {
   mkdir as mkdir10,
   readFile as readFile12,
   rename as rename6,
-  writeFile as writeFile10
+  writeFile as writeFile8
 } from "node:fs/promises";
 import * as path42 from "node:path";
 
@@ -70016,7 +70017,7 @@ async function writeJsonlAtomic(filePath, values) {
   const content = values.map((value) => JSON.stringify(value)).join(`
 `) + (values.length > 0 ? `
 ` : "");
-  await writeFile10(tmp, content, "utf-8");
+  await writeFile8(tmp, content, "utf-8");
   await rename6(tmp, filePath);
 }
 var init_local_jsonl_provider = __esm(() => {
@@ -70111,7 +70112,7 @@ var init_prompt_block = __esm(() => {
 
 // src/memory/jsonl-migration.ts
 import { existsSync as existsSync27 } from "node:fs";
-import { copyFile, mkdir as mkdir11, readFile as readFile13, stat as stat4, writeFile as writeFile11 } from "node:fs/promises";
+import { copyFile, mkdir as mkdir11, readFile as readFile13, stat as stat4, writeFile as writeFile9 } from "node:fs/promises";
 import * as path43 from "node:path";
 function resolveMemoryStorageDir(rootDirectory, config3 = {}) {
   const resolved = resolveConfig(config3);
@@ -70159,14 +70160,14 @@ async function writeJsonlExport(rootDirectory, config3, memories, proposals) {
   await mkdir11(exportDir, { recursive: true });
   const memoriesPath = path43.join(exportDir, "memories.jsonl");
   const proposalsPath = path43.join(exportDir, "proposals.jsonl");
-  await writeFile11(memoriesPath, toJsonl(memories), "utf-8");
-  await writeFile11(proposalsPath, toJsonl(proposals), "utf-8");
+  await writeFile9(memoriesPath, toJsonl(memories), "utf-8");
+  await writeFile9(proposalsPath, toJsonl(proposals), "utf-8");
   return { directory: exportDir, memoriesPath, proposalsPath };
 }
 async function writeMigrationReport(rootDirectory, report, config3 = {}) {
   const reportPath = path43.join(resolveMemoryStorageDir(rootDirectory, config3), "migration-report.json");
   await mkdir11(path43.dirname(reportPath), { recursive: true });
-  await writeFile11(reportPath, `${JSON.stringify(report, null, 2)}
+  await writeFile9(reportPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
   return reportPath;
 }
@@ -86306,7 +86307,7 @@ COVERAGE REPORTING:
 `;
 
 // src/agents/index.ts
-import { mkdir as mkdir13, writeFile as writeFile12 } from "node:fs/promises";
+import { mkdir as mkdir13, writeFile as writeFile10 } from "node:fs/promises";
 import * as path70 from "node:path";
 function stripSwarmPrefix(agentName, swarmPrefix) {
   if (!swarmPrefix || !agentName)
@@ -86728,7 +86729,7 @@ function getAgentConfigs(config3, directory, sessionId, projectContext) {
       generatedAt: new Date().toISOString(),
       agents: agentToolSnapshot
     }, null, 2);
-    mkdir13(evidenceDir, { recursive: true }).then(() => writeFile12(path70.join(evidenceDir, filename), snapshotData)).catch(() => {});
+    mkdir13(evidenceDir, { recursive: true }).then(() => writeFile10(path70.join(evidenceDir, filename), snapshotData)).catch(() => {});
   }
   return result;
 }
@@ -91269,7 +91270,7 @@ import {
   readFile as readFile16,
   realpath as realpath3,
   stat as stat7,
-  writeFile as writeFile14
+  writeFile as writeFile12
 } from "node:fs/promises";
 import * as path94 from "node:path";
 function normalizeSeparators(filePath) {
@@ -91467,7 +91468,7 @@ async function scanDocIndex(directory) {
   };
   try {
     await mkdir16(path94.dirname(manifestPath), { recursive: true });
-    await writeFile14(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+    await writeFile12(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   } catch {}
   return { manifest, cached: false };
 }
@@ -91681,7 +91682,7 @@ var init_doc_scan = __esm(() => {
 
 // src/hooks/knowledge-reader.ts
 import { existsSync as existsSync51 } from "node:fs";
-import { mkdir as mkdir17, readFile as readFile17, writeFile as writeFile15 } from "node:fs/promises";
+import { readFile as readFile17 } from "node:fs/promises";
 import * as path95 from "node:path";
 function inferCategoriesFromPhase(phaseDescription) {
   const lower = phaseDescription.toLowerCase();
@@ -91726,19 +91727,32 @@ function inferCategoriesFromPhase(phaseDescription) {
   }
   return ["process", "tooling"];
 }
+async function transactShownFile(shownFile, mutate) {
+  return transactFile(shownFile, async (filePath) => {
+    if (!existsSync51(filePath))
+      return {};
+    try {
+      const content = await readFile17(filePath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return {};
+    }
+  }, async (filePath, data) => {
+    await atomicWriteFile(filePath, JSON.stringify(data, null, 2));
+  }, mutate);
+}
 async function recordLessonsShown(directory, lessonIds, currentPhase) {
   const shownFile = path95.join(directory, ".swarm", ".knowledge-shown.json");
   try {
-    let shownData = {};
-    if (existsSync51(shownFile)) {
-      const content = await readFile17(shownFile, "utf-8");
-      shownData = JSON.parse(content);
-    }
     const phaseMatch = /^Phase\s+(\d+)/i.exec(currentPhase);
     const canonicalKey = phaseMatch ? `Phase ${phaseMatch[1]}` : currentPhase;
-    shownData[canonicalKey] = lessonIds;
-    await mkdir17(path95.dirname(shownFile), { recursive: true });
-    await writeFile15(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
+    const ok = await transactShownFile(shownFile, (shownData) => {
+      shownData[canonicalKey] = lessonIds;
+      return shownData;
+    });
+    if (!ok) {
+      warn("[swarm] Knowledge: failed to record shown lessons");
+    }
   } catch {
     warn("[swarm] Knowledge: failed to record shown lessons");
   }
@@ -91843,56 +91857,58 @@ async function updateRetrievalOutcome(directory, phaseInfo, phaseSucceeded) {
     if (!existsSync51(shownFile)) {
       return;
     }
-    const content = await readFile17(shownFile, "utf-8");
-    const shownData = JSON.parse(content);
-    const shownIds = shownData[phaseInfo];
+    let shownIds;
+    try {
+      const content = await readFile17(shownFile, "utf-8");
+      const shownData = JSON.parse(content);
+      shownIds = shownData[phaseInfo];
+    } catch {
+      return;
+    }
     if (!shownIds || shownIds.length === 0) {
       return;
     }
     const swarmPath = resolveSwarmKnowledgePath(directory);
-    const entries = await readKnowledge(swarmPath);
-    let updated = false;
     const foundInSwarm = new Set;
-    for (const entry of entries) {
-      if (shownIds.includes(entry.id)) {
-        const ro = entry.retrieval_outcomes;
-        if (phaseSucceeded) {
-          ro.succeeded_after_shown_count = (ro.succeeded_after_shown_count ?? 0) + 1;
-        } else {
-          ro.failed_after_shown_count = (ro.failed_after_shown_count ?? 0) + 1;
+    await transactKnowledge(swarmPath, (entries) => {
+      let mutated = false;
+      for (const entry of entries) {
+        if (shownIds.includes(entry.id)) {
+          const ro = entry.retrieval_outcomes;
+          if (phaseSucceeded) {
+            ro.succeeded_after_shown_count = (ro.succeeded_after_shown_count ?? 0) + 1;
+          } else {
+            ro.failed_after_shown_count = (ro.failed_after_shown_count ?? 0) + 1;
+          }
+          mutated = true;
+          foundInSwarm.add(entry.id);
         }
-        updated = true;
-        foundInSwarm.add(entry.id);
       }
-    }
-    if (updated) {
-      await rewriteKnowledge(swarmPath, entries);
-    }
+      return mutated ? entries : null;
+    });
     const remainingIds = shownIds.filter((id) => !foundInSwarm.has(id));
-    if (remainingIds.length === 0) {
-      delete shownData[phaseInfo];
-      await writeFile15(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
-      return;
-    }
-    const hivePath = resolveHiveKnowledgePath();
-    const hiveEntries = await readKnowledge(hivePath);
-    let hiveUpdated = false;
-    for (const entry of hiveEntries) {
-      if (remainingIds.includes(entry.id)) {
-        const ro = entry.retrieval_outcomes;
-        if (phaseSucceeded) {
-          ro.succeeded_after_shown_count = (ro.succeeded_after_shown_count ?? 0) + 1;
-        } else {
-          ro.failed_after_shown_count = (ro.failed_after_shown_count ?? 0) + 1;
+    if (remainingIds.length > 0) {
+      const hivePath = resolveHiveKnowledgePath();
+      await transactKnowledge(hivePath, (hiveEntries) => {
+        let mutated = false;
+        for (const entry of hiveEntries) {
+          if (remainingIds.includes(entry.id)) {
+            const ro = entry.retrieval_outcomes;
+            if (phaseSucceeded) {
+              ro.succeeded_after_shown_count = (ro.succeeded_after_shown_count ?? 0) + 1;
+            } else {
+              ro.failed_after_shown_count = (ro.failed_after_shown_count ?? 0) + 1;
+            }
+            mutated = true;
+          }
         }
-        hiveUpdated = true;
-      }
-    }
-    if (hiveUpdated) {
-      await rewriteKnowledge(hivePath, hiveEntries);
+        return mutated ? hiveEntries : null;
+      });
     }
-    delete shownData[phaseInfo];
-    await writeFile15(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
+    await transactShownFile(shownFile, (data) => {
+      delete data[phaseInfo];
+      return data;
+    });
   } catch {
     warn("[swarm] Knowledge: failed to update retrieval outcomes");
   }
@@ -91956,6 +91972,7 @@ function scoreDirectiveAgainstContext(entry, ctx) {
 }
 var JACCARD_THRESHOLD2 = 0.6, HIVE_TIER_BOOST = 0.05, SAME_PROJECT_PENALTY = -0.05, NORMAL_RETRIEVAL_STATUSES;
 var init_knowledge_reader = __esm(() => {
+  init_task_file();
   init_logger();
   init_knowledge_store();
   NORMAL_RETRIEVAL_STATUSES = new Set(["established", "promoted"]);
@@ -95318,9 +95335,9 @@ function createPhaseMonitorHook(directory, preflightManager, curatorRunner, dele
           const initResult = await runner(directory, curatorConfig, llmDelegate);
           if (initResult.briefing) {
             const briefingPath = path78.join(directory, ".swarm", "curator-briefing.md");
-            const { mkdir: mkdir14, writeFile: writeFile13 } = await import("node:fs/promises");
+            const { mkdir: mkdir14, writeFile: writeFile11 } = await import("node:fs/promises");
             await mkdir14(path78.dirname(briefingPath), { recursive: true });
-            await writeFile13(briefingPath, initResult.briefing, "utf-8");
+            await writeFile11(briefingPath, initResult.briefing, "utf-8");
             const { buildApprovedReceipt: buildApprovedReceipt2, persistReviewReceipt: persistReviewReceipt2 } = await Promise.resolve().then(() => (init_review_receipt(), exports_review_receipt));
             const initReceipt = buildApprovedReceipt2({
               agent: "curator",
@@ -102948,7 +102965,7 @@ ${errorSummary}`);
 init_schema();
 init_state();
 init_logger();
-import { appendFile as appendFile10, mkdir as mkdir19 } from "node:fs/promises";
+import { appendFile as appendFile10, mkdir as mkdir18 } from "node:fs/promises";
 import * as path100 from "node:path";
 
 // src/hooks/knowledge-application.ts
@@ -102956,7 +102973,7 @@ init_logger();
 init_knowledge_store();
 var import_proper_lockfile8 = __toESM(require_proper_lockfile(), 1);
 import { existsSync as existsSync55 } from "node:fs";
-import { appendFile as appendFile9, mkdir as mkdir18, readFile as readFile18 } from "node:fs/promises";
+import { appendFile as appendFile9, mkdir as mkdir17, readFile as readFile18 } from "node:fs/promises";
 import * as path99 from "node:path";
 function resolveApplicationLogPath(directory) {
   return path99.join(directory, ".swarm", "knowledge-application.jsonl");
@@ -102977,7 +102994,7 @@ function parseAcknowledgments(text) {
 }
 async function appendAudit(directory, record3) {
   const filePath = resolveApplicationLogPath(directory);
-  await mkdir18(path99.dirname(filePath), { recursive: true });
+  await mkdir17(path99.dirname(filePath), { recursive: true });
   await appendFile9(filePath, `${JSON.stringify(record3)}
 `, "utf-8");
 }
@@ -103158,7 +103175,7 @@ async function knowledgeApplicationGateBefore(directory, input, config3) {
 }
 async function writeWarnEvent(directory, record3) {
   const filePath = path100.join(directory, ".swarm", "events.jsonl");
-  await mkdir19(path100.dirname(filePath), { recursive: true });
+  await mkdir18(path100.dirname(filePath), { recursive: true });
   await appendFile10(filePath, `${JSON.stringify(record3)}
 `, "utf-8");
 }
@@ -103214,10 +103231,20 @@ init_manager();
 import { createHash as createHash9 } from "node:crypto";
 
 // src/services/run-memory.ts
-init_utils2();
-init_path_security();
 import * as crypto10 from "node:crypto";
 import * as fs63 from "node:fs/promises";
+
+// src/hooks/context-sanitizer.ts
+function sanitizeContextText(text) {
+  return text.split("").filter((char) => {
+    const code = char.charCodeAt(0);
+    return code === 9 || code === 10 || code === 13 || code > 31 && code !== 127;
+  }).join("").replace(/[\u200B-\u200D\uFEFF]/g, "").replace(/[\u202A-\u202E\u2066-\u2069]/g, "").replace(/```/g, "` ` `").replace(/^system\s*:/gim, "[BLOCKED]:").replace(/<system\b[^>]*>/gi, "[BLOCKED-TAG]").replace(/<\/system>/gi, "[/BLOCKED-TAG]").replace(/<tool_call\b[^>]*>/gi, "[BLOCKED-TOOL]").replace(/<\/tool_call>/gi, "[/BLOCKED-TOOL]").replace(/<\/\w+>/g, "[/BLOCKED-TAG]");
+}
+
+// src/services/run-memory.ts
+init_utils2();
+init_path_security();
 var RUN_MEMORY_FILENAME = "run-memory.jsonl";
 var MAX_SUMMARY_TOKENS = 500;
 function generateTaskFingerprint(taskId, fileTargets) {
@@ -103297,9 +103324,11 @@ function summarizeTask(taskId, entries) {
   if (lastPass) {
     const passAttempt = lastPass.attemptNumber;
     const failAttempt = lastFailure.attemptNumber;
-    return `Task ${taskId}: FAILED attempt ${failAttempt} — ${lastFailure.failureReason || "unknown"}. Passed on attempt ${passAttempt}.`;
+    const reason = sanitizeContextText(lastFailure.failureReason || "unknown");
+    return `Task ${taskId}: FAILED attempt ${failAttempt} — ${reason}. Passed on attempt ${passAttempt}.`;
   } else {
-    return `Task ${taskId}: FAILED ${failCount} times — last: ${lastFailure.failureReason || "unknown"}. Still failing.`;
+    const reason = sanitizeContextText(lastFailure.failureReason || "unknown");
+    return `Task ${taskId}: FAILED ${failCount} times — last: ${reason}. Still failing.`;
   }
 }
 async function getRunMemorySummary(directory) {
@@ -103458,12 +103487,7 @@ function buildDirectiveBlock(entries, charBudget, cfg) {
     return null;
   return block;
 }
-function sanitizeLessonForContext(text) {
-  return text.split("").filter((char) => {
-    const code = char.charCodeAt(0);
-    return code === 9 || code === 10 || code === 13 || code > 31 && code !== 127;
-  }).join("").replace(/[\u200B-\u200D\uFEFF]/g, "").replace(/[\u202A-\u202E\u2066-\u2069]/g, "").replace(/```/g, "` ` `").replace(/^system\s*:/gim, "[BLOCKED]:");
-}
+var sanitizeLessonForContext = sanitizeContextText;
 function isOrchestratorAgent(agentName) {
   const stripped = stripKnownSwarmPrefix(agentName);
   return stripped.toLowerCase() === "architect";
@@ -103576,14 +103600,14 @@ function createKnowledgeInjectorHook(directory, config3) {
         const latestReport = driftReports[driftReports.length - 1];
         const driftText = buildDriftInjectionText(latestReport, 500);
         if (driftText) {
-          freshPreamble = driftText;
+          freshPreamble = sanitizeContextText(driftText);
         }
       }
     } catch {}
     try {
       const briefingContent = await readSwarmFileAsync(directory, "curator-briefing.md");
       if (briefingContent) {
-        const truncatedBriefing = briefingContent.slice(0, 500);
+        const truncatedBriefing = sanitizeContextText(briefingContent).slice(0, 500);
         freshPreamble = freshPreamble ? `<curator_briefing>${truncatedBriefing}</curator_briefing>
 
 ${freshPreamble}` : `<curator_briefing>${truncatedBriefing}</curator_briefing>`;
@@ -103614,8 +103638,9 @@ ${freshPreamble}` : `<curator_briefing>${truncatedBriefing}</curator_briefing>`;
       remaining -= lessonBlock.length;
     }
     if (runMemory && remaining > 300) {
-      parts2.push(runMemory);
-      remaining -= runMemory.length;
+      const sanitizedRunMemory = sanitizeContextText(runMemory);
+      parts2.push(sanitizedRunMemory);
+      remaining -= sanitizedRunMemory.length;
     }
     if (freshPreamble && remaining > 200) {
       let preambleToUse = freshPreamble;
@@ -113186,9 +113211,17 @@ var knowledge_remove = createSwarmTool({
     }
     const id = idInput;
     const swarmPath = resolveSwarmKnowledgePath(directory);
-    let entries;
+    let found = false;
+    let remaining = 0;
     try {
-      entries = await readKnowledge(swarmPath);
+      await transactKnowledge(swarmPath, (entries) => {
+        const filtered = entries.filter((entry) => entry.id !== id);
+        if (filtered.length === entries.length)
+          return null;
+        found = true;
+        remaining = filtered.length;
+        return filtered;
+      });
     } catch (err2) {
       const message = err2 instanceof Error ? err2.message : "Unknown error";
       return JSON.stringify({
@@ -113196,27 +113229,16 @@ var knowledge_remove = createSwarmTool({
         error: message
       });
     }
-    const originalCount = entries.length;
-    entries = entries.filter((entry) => entry.id !== id);
-    if (entries.length === originalCount) {
+    if (!found) {
       return JSON.stringify({
         success: false,
         message: "entry not found"
       });
     }
-    try {
-      await rewriteKnowledge(swarmPath, entries);
-    } catch (err2) {
-      const message = err2 instanceof Error ? err2.message : "Unknown error";
-      return JSON.stringify({
-        success: false,
-        error: message
-      });
-    }
     return JSON.stringify({
       success: true,
       removed: 1,
-      remaining: entries.length
+      remaining
     });
   }
 });
@@ -125063,7 +125085,7 @@ init_zod();
 init_config();
 init_schema();
 init_create_tool();
-import { mkdir as mkdir24, rename as rename10, writeFile as writeFile19 } from "node:fs/promises";
+import { mkdir as mkdir23, rename as rename10, writeFile as writeFile16 } from "node:fs/promises";
 import * as path152 from "node:path";
 var MAX_SPEC_BYTES = 256 * 1024;
 var spec_write = createSwarmTool({
@@ -125106,7 +125128,7 @@ var spec_write = createSwarmTool({
       }, null, 2);
     }
     const target = path152.join(directory, ".swarm", "spec.md");
-    await mkdir24(path152.dirname(target), { recursive: true });
+    await mkdir23(path152.dirname(target), { recursive: true });
     const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
     let finalContent = content;
     if (mode === "append") {
@@ -125125,7 +125147,7 @@ ${content}
         }
       } catch {}
     }
-    await writeFile19(tmp, finalContent, "utf-8");
+    await writeFile16(tmp, finalContent, "utf-8");
     await rename10(tmp, target);
     return JSON.stringify({ written: true, path: target, bytes: finalContent.length }, null, 2);
   }
@@ -127798,7 +127820,7 @@ function createWebSearchProvider(config3) {
 init_utils2();
 init_redaction();
 import { createHash as createHash12 } from "node:crypto";
-import { appendFile as appendFile14, mkdir as mkdir25 } from "node:fs/promises";
+import { appendFile as appendFile14, mkdir as mkdir24 } from "node:fs/promises";
 import * as path161 from "node:path";
 var EVIDENCE_CACHE_FILE = "evidence-cache/documents.jsonl";
 var MAX_EVIDENCE_TEXT_LENGTH = 4000;
@@ -127807,7 +127829,7 @@ async function writeEvidenceDocuments(directory, inputs, now = () => new Date) {
   const capturedAt = now().toISOString();
   const records = inputs.map((input) => createEvidenceDocumentRecord(input, capturedAt)).filter((record3) => record3 !== null);
   if (records.length > 0) {
-    await mkdir25(path161.dirname(filePath), { recursive: true });
+    await mkdir24(path161.dirname(filePath), { recursive: true });
     await appendFile14(filePath, `${records.map((record3) => JSON.stringify(record3)).join(`
 `)}
 `, "utf-8");