opencode-swarm 7.73.0 → 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.0",
+    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",
@@ -18752,7 +18752,8 @@ var init_schema = __esm(() => {
     allowedPrefix: exports_external.array(exports_external.string()).optional(),
     blockedZones: exports_external.array(exports_external.enum(["production", "test", "config", "generated", "docs", "build"])).optional(),
     blockedGlobs: exports_external.array(exports_external.string()).optional(),
-    allowedGlobs: exports_external.array(exports_external.string()).optional()
+    allowedGlobs: exports_external.array(exports_external.string()).optional(),
+    allowedCaseSensitiveGlobs: exports_external.array(exports_external.string()).optional()
   });
   AuthorityConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(true),
@@ -40920,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";
@@ -42243,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";
@@ -42272,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;
     }
@@ -42354,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;
       }
@@ -42363,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);
@@ -42389,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);
@@ -42502,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/config/schema.d.ts

@@ -762,6 +762,7 @@ export declare const AgentAuthorityRuleSchema: z.ZodObject<{
     }>>>;
     blockedGlobs: z.ZodOptional<z.ZodArray<z.ZodString>>;
     allowedGlobs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    allowedCaseSensitiveGlobs: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type AgentAuthorityRule = z.infer<typeof AgentAuthorityRuleSchema>;
 export declare const AuthorityConfigSchema: z.ZodObject<{
@@ -782,6 +783,7 @@ export declare const AuthorityConfigSchema: z.ZodObject<{
         }>>>;
         blockedGlobs: z.ZodOptional<z.ZodArray<z.ZodString>>;
         allowedGlobs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        allowedCaseSensitiveGlobs: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>>;
     universal_deny_prefixes: z.ZodDefault<z.ZodArray<z.ZodString>>;
     verifier_config_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -1405,6 +1407,7 @@ export declare const PluginConfigSchema: z.ZodObject<{
             }>>>;
             blockedGlobs: z.ZodOptional<z.ZodArray<z.ZodString>>;
             allowedGlobs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            allowedCaseSensitiveGlobs: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>>;
         universal_deny_prefixes: z.ZodDefault<z.ZodArray<z.ZodString>>;
         verifier_config_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/hooks/guardrails/file-authority.d.ts

@@ -76,6 +76,7 @@ export type AgentRule = {
     blockedZones?: FileZone[];
     blockedGlobs?: string[];
     allowedGlobs?: string[];
+    allowedCaseSensitiveGlobs?: string[];
 };
 export declare const DEFAULT_AGENT_AUTHORITY_RULES: Record<string, AgentRule>;
 /**

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.0",
+    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",
@@ -16085,7 +16085,8 @@ var init_schema = __esm(() => {
     allowedPrefix: exports_external.array(exports_external.string()).optional(),
     blockedZones: exports_external.array(exports_external.enum(["production", "test", "config", "generated", "docs", "build"])).optional(),
     blockedGlobs: exports_external.array(exports_external.string()).optional(),
-    allowedGlobs: exports_external.array(exports_external.string()).optional()
+    allowedGlobs: exports_external.array(exports_external.string()).optional(),
+    allowedCaseSensitiveGlobs: exports_external.array(exports_external.string()).optional()
   });
   AuthorityConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(true),
@@ -25482,7 +25483,8 @@ function normalizePathWithCache(filePath, cwd) {
   }
 }
 function getGlobMatcher(pattern, caseInsensitive = process.platform === "win32" || process.platform === "darwin") {
-  const cached2 = globMatcherCache.get(pattern);
+  const cacheKey = `${caseInsensitive ? "nocase" : "case"}\x00${pattern}`;
+  const cached2 = globMatcherCache.get(cacheKey);
   if (cached2 !== undefined) {
     return cached2;
   }
@@ -25491,7 +25493,7 @@ function getGlobMatcher(pattern, caseInsensitive = process.platform === "win32"
       dot: true,
       nocase: caseInsensitive
     });
-    globMatcherCache.set(pattern, matcher);
+    globMatcherCache.set(cacheKey, matcher);
     return matcher;
   } catch (err2) {
     warn(`picomatch error for pattern "${pattern}": ${err2}`);
@@ -25553,7 +25555,8 @@ function buildEffectiveRules(authorityConfig) {
       allowedPrefix: userRule.allowedPrefix ?? existing.allowedPrefix,
       blockedZones: userRule.blockedZones ?? existing.blockedZones,
       blockedGlobs: userRule.blockedGlobs ?? existing.blockedGlobs,
-      allowedGlobs: userRule.allowedGlobs ?? existing.allowedGlobs
+      allowedGlobs: userRule.allowedGlobs ?? existing.allowedGlobs,
+      allowedCaseSensitiveGlobs: userRule.allowedCaseSensitiveGlobs ?? existing.allowedCaseSensitiveGlobs
     };
   }
   return merged;
@@ -25657,6 +25660,15 @@ function checkFileAuthorityWithRules(agentName, filePath, cwd, effectiveRules, o
       return { allowed: true };
     }
   }
+  if (rules.allowedCaseSensitiveGlobs && rules.allowedCaseSensitiveGlobs.length > 0) {
+    const isCaseSensitiveGlobAllowed = rules.allowedCaseSensitiveGlobs.some((glob) => {
+      const matcher = getGlobMatcher(glob, false);
+      return matcher(normalizedPath);
+    });
+    if (isCaseSensitiveGlobAllowed) {
+      return { allowed: true };
+    }
+  }
   if (rules.blockedPrefix && rules.blockedPrefix.length > 0) {
     for (const prefix of rules.blockedPrefix) {
       if (normalizedPath.startsWith(prefix)) {
@@ -25745,7 +25757,25 @@ var init_file_authority = __esm(() => {
         "**/test/**",
         "**/__tests__/**",
         "**/*.test.*",
-        "**/*.spec.*"
+        "**/*.spec.*",
+        "test_*.py",
+        "**/test_*.py",
+        "*_test.py",
+        "**/*_test.py",
+        "*_test.go",
+        "**/*_test.go",
+        "*_spec.rb",
+        "**/*_spec.rb",
+        "*.Tests.ps1",
+        "**/*.Tests.ps1"
+      ],
+      allowedCaseSensitiveGlobs: [
+        "*Test.java",
+        "**/*Test.java",
+        "*Test.kt",
+        "**/*Test.kt",
+        "*Tests.cs",
+        "**/*Tests.cs"
       ],
       blockedZones: ["generated"]
     },
@@ -64255,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";
@@ -65808,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";
@@ -65837,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;
     }
@@ -65919,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;
       }
@@ -65928,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);
@@ -65954,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);
@@ -66067,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();
@@ -124912,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 = [
@@ -125007,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(),
@@ -125054,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 {
@@ -125082,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({
@@ -130167,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);
@@ -141926,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);
@@ -141942,6 +142093,7 @@ var write_architecture_supervisor_evidence = createSwarmTool({
           }
         });
         knowledgeProposed = result.stored;
+        knowledgeReinforced = result.reinforced;
         knowledgeQuarantined = result.quarantined;
       }
     } catch {}
@@ -141963,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.0",
+	"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",