opencode-swarm 7.51.1 → 7.51.3

package/dist/cli/index.js

@@ -52,7 +52,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",
@@ -99,7 +99,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: {
@@ -35916,7 +35916,7 @@ var init_task_file = __esm(() => {
 
 // src/hooks/knowledge-store.ts
 import { existsSync as existsSync7 } from "fs";
-import { appendFile as appendFile2, mkdir as mkdir2, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir2, readFile as readFile3 } from "fs/promises";
 import * as os3 from "os";
 import * as path11 from "path";
 function resolveSwarmKnowledgePath(directory) {
@@ -36079,23 +36079,25 @@ async function rewriteKnowledge(filePath, entries) {
     }
   }
 }
-async function enforceKnowledgeCap(filePath, maxEntries) {
-  let release = null;
+async function transactFile(filePath, read, write, mutate) {
+  const dir = path11.dirname(filePath);
   try {
-    const dir = path11.dirname(filePath);
     await mkdir2(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 {
@@ -36104,17 +36106,31 @@ 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 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 normalize2(text) {
   const s = typeof text === "string" ? text : String(text ?? "");
@@ -36243,7 +36259,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 (err) {
     console.warn(`[knowledge-store] applyConfidenceDeltas failed on ${filePath} (fail-open):`, err instanceof Error ? err.message : String(err));
@@ -36262,7 +36278,7 @@ var init_knowledge_store = __esm(() => {
 });
 
 // src/hooks/knowledge-validator.ts
-import { appendFile as appendFile3, mkdir as mkdir3, writeFile as writeFile4 } from "fs/promises";
+import { appendFile as appendFile3, mkdir as mkdir3 } from "fs/promises";
 import * as path12 from "path";
 function normalizeText(text) {
   return text.normalize("NFKC").toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
@@ -36439,7 +36455,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);
@@ -36458,7 +36475,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 appendFile3(quarantinePath, `${JSON.stringify(quarantined)}
 `, "utf-8");
     const quarantinedEntries = await readKnowledge(quarantinePath);
@@ -36467,7 +36484,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,
@@ -36502,7 +36519,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);
@@ -36531,7 +36549,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 appendFile3(knowledgePath, `${JSON.stringify(original)}
 `, "utf-8");
     const rejectedEntries = await readKnowledge(rejectedPath);
@@ -36539,7 +36557,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();
@@ -36548,6 +36566,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);
@@ -36666,7 +36685,7 @@ var init_knowledge_validator = __esm(() => {
 
 // src/services/skill-generator.ts
 import { existsSync as existsSync8, unlinkSync as unlinkSync5 } from "fs";
-import { mkdir as mkdir4, readFile as readFile4, rename as rename3, writeFile as writeFile5 } from "fs/promises";
+import { mkdir as mkdir4, readFile as readFile4, rename as rename3, writeFile as writeFile3 } from "fs/promises";
 import * as path13 from "path";
 function sanitizeSlug(input) {
   const lc = input.toLowerCase().trim();
@@ -36858,7 +36877,7 @@ function escapeMarkdown(s) {
 async function atomicWrite(p, content) {
   await mkdir4(path13.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) {
@@ -37446,7 +37465,7 @@ var init_hive_promoter = __esm(() => {
 
 // src/hooks/knowledge-events.ts
 import { existsSync as existsSync10 } from "fs";
-import { appendFile as appendFile4, mkdir as mkdir5, readFile as readFile5, writeFile as writeFile6 } from "fs/promises";
+import { appendFile as appendFile4, mkdir as mkdir5, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
 import * as path16 from "path";
 function resolveKnowledgeEventsPath(directory) {
   return path16.join(directory, ".swarm", "knowledge-events.jsonl");
@@ -37781,8 +37800,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([
@@ -37797,6 +37815,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";
@@ -37811,7 +37831,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(),
@@ -37824,7 +37844,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;
@@ -37856,9 +37876,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) {
@@ -38100,7 +38131,7 @@ var init_skill_improver_llm_factory = __esm(() => {
 
 // src/services/skill-improver-quota.ts
 import { existsSync as existsSync11 } from "fs";
-import { mkdir as mkdir6, readFile as readFile6, rename as rename4, writeFile as writeFile7 } from "fs/promises";
+import { mkdir as mkdir6, readFile as readFile6, rename as rename4, writeFile as writeFile5 } from "fs/promises";
 import * as path17 from "path";
 async function acquireLock(dir) {
   const acquire = import_proper_lockfile6.default.lock(dir, LOCK_RETRY_OPTS);
@@ -38147,7 +38178,7 @@ async function readState(filePath) {
 async function writeState(filePath, state) {
   await mkdir6(path17.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) {
@@ -38234,7 +38265,7 @@ var init_skill_improver_quota = __esm(() => {
 
 // src/services/skill-improver.ts
 import { existsSync as existsSync12 } from "fs";
-import { mkdir as mkdir7, rename as rename5, writeFile as writeFile8 } from "fs/promises";
+import { mkdir as mkdir7, rename as rename5, writeFile as writeFile6 } from "fs/promises";
 import * as path18 from "path";
 function timestampSlug(d) {
   return d.toISOString().replace(/[:.]/g, "-");
@@ -38242,7 +38273,7 @@ function timestampSlug(d) {
 async function atomicWrite2(p, content) {
   await mkdir7(path18.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) {
@@ -45945,7 +45976,7 @@ var KNOWLEDGE_SCHEMA_VERSION = 2;
 // src/hooks/knowledge-migrator.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import { existsSync as existsSync19, readFileSync as readFileSync13 } from "fs";
-import { mkdir as mkdir8, readFile as readFile9, writeFile as writeFile9 } from "fs/promises";
+import { mkdir as mkdir8, readFile as readFile9, writeFile as writeFile7 } from "fs/promises";
 import * as path29 from "path";
 async function migrateKnowledgeToExternal(_directory, _config) {
   return {
@@ -46176,7 +46207,7 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     migration_tool: "knowledge-migrator.ts"
   };
   await mkdir8(path29.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 _internals19;
 var init_knowledge_migrator = __esm(() => {
@@ -47229,7 +47260,7 @@ import {
   mkdir as mkdir9,
   readFile as readFile10,
   rename as rename6,
-  writeFile as writeFile10
+  writeFile as writeFile8
 } from "fs/promises";
 import * as path30 from "path";
 
@@ -47640,7 +47671,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(() => {
@@ -47661,7 +47692,7 @@ var init_prompt_block = __esm(() => {
 
 // src/memory/jsonl-migration.ts
 import { existsSync as existsSync21 } from "fs";
-import { copyFile, mkdir as mkdir10, readFile as readFile11, stat as stat3, writeFile as writeFile11 } from "fs/promises";
+import { copyFile, mkdir as mkdir10, readFile as readFile11, stat as stat3, writeFile as writeFile9 } from "fs/promises";
 import * as path31 from "path";
 function resolveMemoryStorageDir(rootDirectory, config3 = {}) {
   const resolved = resolveConfig(config3);
@@ -47709,14 +47740,14 @@ async function writeJsonlExport(rootDirectory, config3, memories, proposals) {
   await mkdir10(exportDir, { recursive: true });
   const memoriesPath = path31.join(exportDir, "memories.jsonl");
   const proposalsPath = path31.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 = path31.join(resolveMemoryStorageDir(rootDirectory, config3), "migration-report.json");
   await mkdir10(path31.dirname(reportPath), { recursive: true });
-  await writeFile11(reportPath, `${JSON.stringify(report, null, 2)}
+  await writeFile9(reportPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
   return reportPath;
 }

package/dist/hooks/context-sanitizer.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Shared context sanitizer for architect-context injection blocks.
+ *
+ * Any text that enters the architect context from untrusted sources (run-memory
+ * failure reasons, drift reports, curator briefings, rejected-pattern warnings,
+ * or knowledge lessons) MUST pass through sanitizeContextText() before injection.
+ *
+ * Threat model:
+ * - Control characters (except tab/LF/CR) that can produce invisible payloads
+ * - Zero-width characters used to hide injected instructions
+ * - BiDi override characters used for visual spoofing
+ * - Triple-backtick sequences used to break out of code blocks
+ * - `system:` / `SYSTEM:` prefix lines that mimic system-prompt directives
+ * - XML-style `<system>`, `<tool_call>` tags and all `</tag>` closing tags used for structured prompt injection
+ */
+/**
+ * Sanitizes arbitrary context text to prevent prompt injection into LLM context.
+ *
+ * Preserves human-readable formatting (spaces, newlines, tabs) while neutralizing
+ * instruction-like payloads. Idempotent: applying twice yields the same result.
+ *
+ * @param text - The raw text to sanitize
+ * @returns Sanitized text safe for LLM context injection
+ */
+export declare function sanitizeContextText(text: string): string;

package/dist/hooks/curator.d.ts

@@ -158,7 +158,7 @@ export declare function runCuratorPhase(directory: string, phase: number, agents
 }, llmDelegate?: CuratorLLMDelegate): Promise<CuratorPhaseResult>;
 /**
  * Apply curator knowledge recommendations: promote, archive, or flag contradictions.
- * Uses readKnowledge + rewriteKnowledge pattern for atomic updates.
+ * Uses transactKnowledge for atomic locked read-modify-write updates.
  * @param directory - The workspace directory
  * @param recommendations - Array of knowledge recommendations to apply
  * @param knowledgeConfig - Knowledge configuration (for path resolution)

package/dist/hooks/knowledge-reader.d.ts

@@ -18,6 +18,7 @@ export interface RankedEntry extends KnowledgeEntryBase {
     };
     finalScore: number;
 }
+declare function transactShownFile(shownFile: string, mutate: (data: Record<string, string[]>) => Record<string, string[]> | null): Promise<boolean>;
 export declare function readMergedKnowledge(directory: string, config: KnowledgeConfig, context?: ProjectContext, opts?: {
     skipScopeFilter?: boolean;
 }): Promise<RankedEntry[]>;
@@ -33,4 +34,6 @@ export declare const _internals: {
     readMergedKnowledge: typeof readMergedKnowledge;
     updateRetrievalOutcome: typeof updateRetrievalOutcome;
     scoreDirectiveAgainstContext: typeof scoreDirectiveAgainstContext;
+    transactShownFile: typeof transactShownFile;
 };
+export {};

package/dist/hooks/knowledge-store.d.ts

@@ -22,6 +22,8 @@ export declare function readRetractionRecords(directory: string): Promise<Knowle
 export declare function appendRetractionRecord(directory: string, record: KnowledgeRetractionRecord): Promise<void>;
 export declare function appendKnowledge<T>(filePath: string, entry: T): Promise<void>;
 export declare function rewriteKnowledge<T>(filePath: string, entries: T[]): Promise<void>;
+export declare function transactFile<T>(filePath: string, read: (filePath: string) => Promise<T>, write: (filePath: string, data: T) => Promise<void>, mutate: (data: T) => T | null): Promise<boolean>;
+export declare function transactKnowledge<T>(filePath: string, mutate: (entries: T[]) => T[] | null): Promise<boolean>;
 export declare function enforceKnowledgeCap<T>(filePath: string, maxEntries: number): Promise<void>;
 export interface SweepResult {
     scanned: number;
@@ -73,6 +75,7 @@ export declare const _internals: {
     readRejectedLessons: typeof readRejectedLessons;
     appendKnowledge: typeof appendKnowledge;
     rewriteKnowledge: typeof rewriteKnowledge;
+    transactKnowledge: typeof transactKnowledge;
     enforceKnowledgeCap: typeof enforceKnowledgeCap;
     sweepAgedEntries: typeof sweepAgedEntries;
     sweepStaleTodos: typeof sweepStaleTodos;