opencode-swarm 7.73.1 → 7.73.2

package/dist/cli/index.js

@@ -52,7 +52,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.73.1",
+    version: "7.73.2",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -40921,6 +40921,49 @@ var init_synonym_map = __esm(() => {
   MIN_READ_CEILING_BYTES = 64 * 1024;
 });
 
+// src/hooks/knowledge-reinforcement.ts
+function isActiveSwarmKnowledgeEntry(entry) {
+  return !INACTIVE_STATUSES.has(entry.status);
+}
+function findActiveSwarmNearDuplicate(lesson, entries, threshold) {
+  return findNearDuplicate(lesson, entries.filter(isActiveSwarmKnowledgeEntry), threshold);
+}
+function distinctPhaseCount(records) {
+  const phases = new Set;
+  for (const record3 of records ?? []) {
+    if (Number.isInteger(record3.phase_number)) {
+      phases.add(record3.phase_number);
+    }
+  }
+  return phases.size;
+}
+function reinforceSwarmKnowledgeEntry(entry, confirmation) {
+  if (!isActiveSwarmKnowledgeEntry(entry)) {
+    return { entryId: entry.id, reinforced: false, reason: "inactive" };
+  }
+  if ((entry.confirmed_by ?? []).some((record3) => record3.phase_number === confirmation.phase_number)) {
+    return {
+      entryId: entry.id,
+      reinforced: false,
+      reason: "already_confirmed_phase"
+    };
+  }
+  entry.confirmed_by = [...entry.confirmed_by ?? [], confirmation];
+  entry.updated_at = confirmation.confirmed_at;
+  entry.phases_alive = 0;
+  entry.confidence = computeConfidence(distinctPhaseCount(entry.confirmed_by), entry.auto_generated ?? false);
+  return { entryId: entry.id, reinforced: true, reason: "reinforced" };
+}
+var INACTIVE_STATUSES;
+var init_knowledge_reinforcement = __esm(() => {
+  init_knowledge_store();
+  INACTIVE_STATUSES = new Set([
+    "archived",
+    "quarantined",
+    "quarantined_unactionable"
+  ]);
+});
+
 // src/hooks/skill-scoring.ts
 import * as fs10 from "fs";
 import * as path22 from "path";
@@ -42244,6 +42287,7 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
   ]);
   const snapshotPlusNew = [...snapshot];
   const toAdd = [];
+  const pendingReinforcementIds = new Set;
   for (const lesson of lessons) {
     const tags = inferTags(lesson);
     let category = "process";
@@ -42273,8 +42317,9 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
         continue;
       }
     }
-    const duplicate = findNearDuplicate(lesson, snapshotPlusNew, config3.dedup_threshold);
+    const duplicate = findActiveSwarmNearDuplicate(lesson, snapshotPlusNew, config3.dedup_threshold);
     if (duplicate) {
+      pendingReinforcementIds.add(duplicate.id);
       skipped++;
       continue;
     }
@@ -42355,7 +42400,9 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
         } catch {}
         continue;
       }
-      if (findNearDuplicate(entry.lesson, snapshotPlusNew, config3.dedup_threshold)) {
+      const duplicate = findActiveSwarmNearDuplicate(entry.lesson, snapshotPlusNew, config3.dedup_threshold);
+      if (duplicate) {
+        pendingReinforcementIds.add(duplicate.id);
         skipped++;
         continue;
       }
@@ -42364,15 +42411,48 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
     }
   } catch {}
   let stored = 0;
-  if (toAdd.length > 0) {
+  let reinforced = 0;
+  if (toAdd.length > 0 || pendingReinforcementIds.size > 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];
+      let changed = false;
+      for (const id of pendingReinforcementIds) {
+        const existing = current.find((entry) => entry.id === id);
+        if (!existing)
+          continue;
+        const result = reinforceSwarmKnowledgeEntry(existing, {
+          phase_number: phaseInfo.phase_number,
+          confirmed_at: new Date().toISOString(),
+          project_name: projectName
+        });
+        if (result.reinforced) {
+          reinforced++;
+          changed = true;
+        }
+      }
+      const trulyNew = [];
+      for (const entry of toAdd) {
+        const duplicate = findActiveSwarmNearDuplicate(entry.lesson, current, config3.dedup_threshold);
+        if (duplicate) {
+          skipped++;
+          const result = reinforceSwarmKnowledgeEntry(duplicate, {
+            phase_number: phaseInfo.phase_number,
+            confirmed_at: new Date().toISOString(),
+            project_name: projectName
+          });
+          if (result.reinforced) {
+            reinforced++;
+            changed = true;
+          }
+          continue;
+        }
+        trulyNew.push(entry);
+      }
+      if (trulyNew.length > 0) {
+        current.push(...trulyNew);
+        stored = trulyNew.length;
+        changed = true;
+      }
+      return changed ? current : null;
     });
   }
   await enforceKnowledgeCap(knowledgePath, config3.swarm_max_entries);
@@ -42390,7 +42470,7 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
   if (!options?.skipAutoPromotion) {
     await _internals19.runAutoPromotion(directory, config3);
   }
-  return { stored, skipped, rejected, quarantined };
+  return { stored, reinforced, skipped, rejected, quarantined };
 }
 async function runAutoPromotion(directory, config3) {
   const knowledgePath = resolveSwarmKnowledgePath(directory);
@@ -42503,6 +42583,7 @@ var init_knowledge_curator = __esm(() => {
   init_synonym_map();
   init_logger();
   init_knowledge_events();
+  init_knowledge_reinforcement();
   init_knowledge_store();
   init_knowledge_validator();
   init_micro_reflector();

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

@@ -81,6 +81,7 @@ export declare function curateAndStoreSwarm(lessons: string[], projectName: stri
     enrichmentQuota?: EnrichmentQuotaOptions;
 }): Promise<{
     stored: number;
+    reinforced: number;
     skipped: number;
     rejected: number;
     quarantined: number;

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

@@ -0,0 +1,10 @@
+import type { PhaseConfirmationRecord, SwarmKnowledgeEntry } from './knowledge-types.js';
+export type ReinforcementReason = 'reinforced' | 'already_confirmed_phase' | 'inactive';
+export interface ReinforcementResult {
+    entryId: string;
+    reinforced: boolean;
+    reason: ReinforcementReason;
+}
+export declare function isActiveSwarmKnowledgeEntry(entry: SwarmKnowledgeEntry): boolean;
+export declare function findActiveSwarmNearDuplicate(lesson: string, entries: SwarmKnowledgeEntry[], threshold: number): SwarmKnowledgeEntry | undefined;
+export declare function reinforceSwarmKnowledgeEntry(entry: SwarmKnowledgeEntry, confirmation: PhaseConfirmationRecord): ReinforcementResult;

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.73.1",
+    version: "7.73.2",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -64285,6 +64285,49 @@ var init_synonym_map = __esm(() => {
   MIN_READ_CEILING_BYTES = 64 * 1024;
 });
 
+// src/hooks/knowledge-reinforcement.ts
+function isActiveSwarmKnowledgeEntry(entry) {
+  return !INACTIVE_STATUSES.has(entry.status);
+}
+function findActiveSwarmNearDuplicate(lesson, entries, threshold) {
+  return findNearDuplicate(lesson, entries.filter(isActiveSwarmKnowledgeEntry), threshold);
+}
+function distinctPhaseCount(records) {
+  const phases = new Set;
+  for (const record3 of records ?? []) {
+    if (Number.isInteger(record3.phase_number)) {
+      phases.add(record3.phase_number);
+    }
+  }
+  return phases.size;
+}
+function reinforceSwarmKnowledgeEntry(entry, confirmation) {
+  if (!isActiveSwarmKnowledgeEntry(entry)) {
+    return { entryId: entry.id, reinforced: false, reason: "inactive" };
+  }
+  if ((entry.confirmed_by ?? []).some((record3) => record3.phase_number === confirmation.phase_number)) {
+    return {
+      entryId: entry.id,
+      reinforced: false,
+      reason: "already_confirmed_phase"
+    };
+  }
+  entry.confirmed_by = [...entry.confirmed_by ?? [], confirmation];
+  entry.updated_at = confirmation.confirmed_at;
+  entry.phases_alive = 0;
+  entry.confidence = computeConfidence(distinctPhaseCount(entry.confirmed_by), entry.auto_generated ?? false);
+  return { entryId: entry.id, reinforced: true, reason: "reinforced" };
+}
+var INACTIVE_STATUSES;
+var init_knowledge_reinforcement = __esm(() => {
+  init_knowledge_store();
+  INACTIVE_STATUSES = new Set([
+    "archived",
+    "quarantined",
+    "quarantined_unactionable"
+  ]);
+});
+
 // src/hooks/skill-scoring.ts
 import * as fs21 from "node:fs";
 import * as path41 from "node:path";
@@ -65838,6 +65881,7 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
   ]);
   const snapshotPlusNew = [...snapshot];
   const toAdd = [];
+  const pendingReinforcementIds = new Set;
   for (const lesson of lessons) {
     const tags = inferTags(lesson);
     let category = "process";
@@ -65867,8 +65911,9 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
         continue;
       }
     }
-    const duplicate = findNearDuplicate(lesson, snapshotPlusNew, config3.dedup_threshold);
+    const duplicate = findActiveSwarmNearDuplicate(lesson, snapshotPlusNew, config3.dedup_threshold);
     if (duplicate) {
+      pendingReinforcementIds.add(duplicate.id);
       skipped++;
       continue;
     }
@@ -65949,7 +65994,9 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
         } catch {}
         continue;
       }
-      if (findNearDuplicate(entry.lesson, snapshotPlusNew, config3.dedup_threshold)) {
+      const duplicate = findActiveSwarmNearDuplicate(entry.lesson, snapshotPlusNew, config3.dedup_threshold);
+      if (duplicate) {
+        pendingReinforcementIds.add(duplicate.id);
         skipped++;
         continue;
       }
@@ -65958,15 +66005,48 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
     }
   } catch {}
   let stored = 0;
-  if (toAdd.length > 0) {
+  let reinforced = 0;
+  if (toAdd.length > 0 || pendingReinforcementIds.size > 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];
+      let changed = false;
+      for (const id of pendingReinforcementIds) {
+        const existing = current.find((entry) => entry.id === id);
+        if (!existing)
+          continue;
+        const result = reinforceSwarmKnowledgeEntry(existing, {
+          phase_number: phaseInfo.phase_number,
+          confirmed_at: new Date().toISOString(),
+          project_name: projectName
+        });
+        if (result.reinforced) {
+          reinforced++;
+          changed = true;
+        }
+      }
+      const trulyNew = [];
+      for (const entry of toAdd) {
+        const duplicate = findActiveSwarmNearDuplicate(entry.lesson, current, config3.dedup_threshold);
+        if (duplicate) {
+          skipped++;
+          const result = reinforceSwarmKnowledgeEntry(duplicate, {
+            phase_number: phaseInfo.phase_number,
+            confirmed_at: new Date().toISOString(),
+            project_name: projectName
+          });
+          if (result.reinforced) {
+            reinforced++;
+            changed = true;
+          }
+          continue;
+        }
+        trulyNew.push(entry);
+      }
+      if (trulyNew.length > 0) {
+        current.push(...trulyNew);
+        stored = trulyNew.length;
+        changed = true;
+      }
+      return changed ? current : null;
     });
   }
   await enforceKnowledgeCap(knowledgePath, config3.swarm_max_entries);
@@ -65984,7 +66064,7 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
   if (!options?.skipAutoPromotion) {
     await _internals30.runAutoPromotion(directory, config3);
   }
-  return { stored, skipped, rejected, quarantined };
+  return { stored, reinforced, skipped, rejected, quarantined };
 }
 async function runAutoPromotion(directory, config3) {
   const knowledgePath = resolveSwarmKnowledgePath(directory);
@@ -66097,6 +66177,7 @@ var init_knowledge_curator = __esm(() => {
   init_synonym_map();
   init_logger();
   init_knowledge_events();
+  init_knowledge_reinforcement();
   init_knowledge_store();
   init_knowledge_validator();
   init_micro_reflector();
@@ -124942,10 +125023,10 @@ var knowledge_ack = createSwarmTool({
 // src/tools/knowledge-add.ts
 init_zod();
 init_config();
+init_knowledge_reinforcement();
 init_knowledge_store();
 init_knowledge_validator();
 init_manager();
-init_utils();
 init_create_tool();
 import { randomUUID as randomUUID15 } from "node:crypto";
 var VALID_CATEGORIES2 = [
@@ -125037,9 +125118,13 @@ var knowledge_add = createSwarmTool({
       });
     }
     let project_name = "";
+    let phase_number = 1;
     try {
       const plan = await loadPlan(directory);
       project_name = plan?.title ?? "";
+      if (typeof plan?.current_phase === "number") {
+        phase_number = plan.current_phase;
+      }
     } catch {}
     const entry = {
       id: randomUUID15(),
@@ -125084,19 +125169,6 @@ var knowledge_add = createSwarmTool({
         }
       }
     } catch {}
-    try {
-      const existingEntries = await readKnowledge(resolveSwarmKnowledgePath(directory));
-      const duplicate = findNearDuplicate(lesson, existingEntries, dedupThreshold);
-      if (duplicate) {
-        return JSON.stringify({
-          success: false,
-          id: duplicate.id,
-          message: "near-duplicate of existing entry"
-        });
-      }
-    } catch (err2) {
-      warn("knowledge_add: dedup check failed — skipping near-duplicate detection", err2);
-    }
     const actionability = validateActionability(entry);
     if (!actionability.actionable) {
       try {
@@ -125112,7 +125184,55 @@ var knowledge_add = createSwarmTool({
     }
     try {
       const maxEntries = config3?.knowledge?.swarm_max_entries ?? 100;
-      await appendKnowledgeWithCapEnforcement(resolveSwarmKnowledgePath(directory), entry, maxEntries);
+      let duplicateResponse;
+      await transactKnowledge(resolveSwarmKnowledgePath(directory), (existingEntries) => {
+        const activeDuplicate = findActiveSwarmNearDuplicate(lesson, existingEntries, dedupThreshold);
+        if (activeDuplicate) {
+          const result = reinforceSwarmKnowledgeEntry(activeDuplicate, {
+            phase_number,
+            confirmed_at: new Date().toISOString(),
+            project_name
+          });
+          duplicateResponse = {
+            id: activeDuplicate.id,
+            reinforced: result.reinforced,
+            idempotent: result.reason === "already_confirmed_phase",
+            inactive: false
+          };
+          return result.reinforced ? existingEntries : null;
+        }
+        const inactiveDuplicate = findNearDuplicate(lesson, existingEntries, dedupThreshold);
+        if (inactiveDuplicate) {
+          duplicateResponse = {
+            id: inactiveDuplicate.id,
+            reinforced: false,
+            idempotent: false,
+            inactive: true
+          };
+          return null;
+        }
+        const updated = [...existingEntries, entry];
+        if (updated.length > maxEntries) {
+          return updated.slice(updated.length - maxEntries);
+        }
+        return updated;
+      });
+      if (duplicateResponse) {
+        if (duplicateResponse.inactive) {
+          return JSON.stringify({
+            success: false,
+            id: duplicateResponse.id,
+            message: "near-duplicate of inactive existing entry"
+          });
+        }
+        return JSON.stringify({
+          success: true,
+          id: duplicateResponse.id,
+          reinforced: duplicateResponse.reinforced,
+          idempotent: duplicateResponse.idempotent,
+          message: duplicateResponse.reinforced ? "near-duplicate reinforced existing entry" : "near-duplicate already confirmed for this phase"
+        });
+      }
     } catch (err2) {
       const message = err2 instanceof Error ? err2.message : "Unknown error";
       return JSON.stringify({
@@ -130197,7 +130317,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
         const sessionState = swarmState.agentSessions.get(sessionID);
         if (sessionState) {
           sessionState.pendingAdvisoryMessages ??= [];
-          sessionState.pendingAdvisoryMessages.push(`[CURATOR] Knowledge curation: ${curationResult.stored} stored, ${curationResult.skipped} skipped, ${curationResult.rejected} rejected, ${curationResult.quarantined} quarantined (unactionable).`);
+          sessionState.pendingAdvisoryMessages.push(`[CURATOR] Knowledge curation: ${curationResult.stored} stored, ${curationResult.reinforced} reinforced, ${curationResult.skipped} skipped, ${curationResult.rejected} rejected, ${curationResult.quarantined} quarantined (unactionable).`);
         }
       }
       await updateRetrievalOutcome(dir, `Phase ${phase}`, true);
@@ -141956,6 +142076,7 @@ var write_architecture_supervisor_evidence = createSwarmTool({
     };
     const evidencePath = writeSupervisorReport(dirResult.directory, report);
     let knowledgeProposed = 0;
+    let knowledgeReinforced = 0;
     let knowledgeQuarantined = 0;
     try {
       const config3 = loadPluginConfig(dirResult.directory);
@@ -141972,6 +142093,7 @@ var write_architecture_supervisor_evidence = createSwarmTool({
           }
         });
         knowledgeProposed = result.stored;
+        knowledgeReinforced = result.reinforced;
         knowledgeQuarantined = result.quarantined;
       }
     } catch {}
@@ -141993,6 +142115,7 @@ var write_architecture_supervisor_evidence = createSwarmTool({
       verdict: args2.verdict,
       findings_count: args2.findings.length,
       knowledge_proposed: knowledgeProposed,
+      knowledge_reinforced: knowledgeReinforced,
       knowledge_quarantined: knowledgeQuarantined,
       skills_proposed: skillsProposed,
       evidence_path: evidencePath

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.73.1",
+	"version": "7.73.2",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",