opencode-swarm 7.79.5 → 7.79.7

package/dist/cli/index.js

@@ -52,7 +52,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.79.5",
+    version: "7.79.7",
     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",
@@ -39424,6 +39424,51 @@ import * as path18 from "path";
 function normalizeText(text) {
   return text.normalize("NFKC").toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
 }
+function extractContextWords(text, word, contextWindow = 3) {
+  const words = text.split(" ");
+  const context = new Set;
+  if (!word.includes(" ")) {
+    let from = 0;
+    let idx = words.indexOf(word, from);
+    while (idx !== -1) {
+      const start = Math.max(0, idx - contextWindow);
+      const end = Math.min(words.length, idx + contextWindow + 1);
+      for (let i2 = start;i2 < end; i2++) {
+        if (i2 !== idx && words[i2] && words[i2].length > 0) {
+          context.add(words[i2]);
+        }
+      }
+      from = idx + 1;
+      idx = words.indexOf(word, from);
+    }
+    return context;
+  }
+  const termLen = word.split(" ").length;
+  let i = 0;
+  while (i <= words.length - termLen) {
+    const slice = words.slice(i, i + termLen).join(" ");
+    if (slice === word) {
+      const start = Math.max(0, i - contextWindow);
+      const end = Math.min(words.length, i + termLen + contextWindow);
+      for (let j = start;j < end; j++) {
+        if (j < i || j >= i + termLen) {
+          if (words[j] && words[j].length > 0) {
+            context.add(words[j]);
+          }
+        }
+      }
+      i += termLen;
+    } else {
+      i += 1;
+    }
+  }
+  return context;
+}
+function hasSignificantOverlap(set1, set22) {
+  if (set1.size === 0 || set22.size === 0)
+    return false;
+  return [...set1].some((word) => set22.has(word));
+}
 function detectContradiction(candidate, existingLessons) {
   const candidateTags = inferTags(candidate);
   if (candidateTags.length === 0)
@@ -39436,10 +39481,20 @@ function detectContradiction(candidate, existingLessons) {
       continue;
     const existingNorm = normalizeText(existing);
     for (const [wordA, wordB] of NEGATION_PAIRS) {
-      const hasA = candidateNorm.includes(wordA) && existingNorm.includes(wordB);
-      const hasB = candidateNorm.includes(wordB) && existingNorm.includes(wordA);
-      if (hasA || hasB)
-        return true;
+      if (candidateNorm.includes(wordA) && existingNorm.includes(wordB)) {
+        const contextA = extractContextWords(candidateNorm, wordA);
+        const contextB = extractContextWords(existingNorm, wordB);
+        if (hasSignificantOverlap(contextA, contextB)) {
+          return true;
+        }
+      }
+      if (candidateNorm.includes(wordB) && existingNorm.includes(wordA)) {
+        const contextB = extractContextWords(candidateNorm, wordB);
+        const contextA = extractContextWords(existingNorm, wordA);
+        if (hasSignificantOverlap(contextA, contextB)) {
+          return true;
+        }
+      }
     }
   }
   return false;
@@ -40435,10 +40490,12 @@ function isSkillMaturityEligible(entry, opts, outcomes = entry.retrieval_outcome
   if (outcomeSignal < 0)
     return false;
   const strongOutcomes = hasStrongSkillOutcomeRecord(outcomes);
+  if (outcomeSignal > 0 && strongOutcomes)
+    return true;
   if (entry.confidence < opts.minConfidence && !strongOutcomes)
     return false;
-  const confirmations = (entry.confirmed_by ?? []).length;
-  return confirmations >= opts.minConfirmations || strongOutcomes;
+  const distinctPhases = new Set((entry.confirmed_by ?? []).map((c) => c.phase_number).filter((p) => typeof p === "number")).size;
+  return distinctPhases >= opts.minConfirmations || strongOutcomes;
 }
 function jaccardSimilarity(setA, setB) {
   const normA = setA.map((s) => s.toLowerCase());
@@ -41771,12 +41828,52 @@ function pruneSkillUsageLog(directory, maxEntriesPerSkill = 500) {
   if (!_internals17.existsSync(resolved)) {
     return { pruned: 0, remaining: 0 };
   }
-  const allEntries = readSkillUsageEntries(directory);
-  if (allEntries.length === 0) {
+  const raw = _internals17.readFileSync(resolved, "utf-8");
+  const lines = raw.split(`
+`);
+  const entries = [];
+  const preservedMarkers = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      const marker = parseFeedbackMarker(parsed);
+      if (marker) {
+        preservedMarkers.push(trimmed);
+        continue;
+      }
+      const entry = parseSkillUsageEntry(parsed);
+      if (entry) {
+        entries.push(entry);
+      }
+    } catch {}
+  }
+  if (entries.length === 0) {
+    if (preservedMarkers.length > 0) {
+      const dir2 = path23.dirname(resolved);
+      const tmpPath2 = path23.join(dir2, `skill-usage-${Date.now()}.tmp`);
+      const content2 = preservedMarkers.join(`
+`).concat(preservedMarkers.length > 0 ? `
+` : "");
+      try {
+        _internals17.writeFileSync(tmpPath2, content2, "utf-8");
+        _internals17.renameSync(tmpPath2, resolved);
+      } catch (writeErr) {
+        const msg = writeErr instanceof Error ? writeErr.message : String(writeErr);
+        try {
+          if (_internals17.existsSync(tmpPath2)) {
+            _internals17.writeFileSync(tmpPath2, "", "utf-8");
+          }
+        } catch {}
+        return { pruned: 0, remaining: 0, error: msg };
+      }
+    }
     return { pruned: 0, remaining: 0 };
   }
   const groups = new Map;
-  for (const entry of allEntries) {
+  for (const entry of entries) {
     const list = groups.get(entry.skillPath);
     if (list)
       list.push(entry);
@@ -41785,22 +41882,24 @@ function pruneSkillUsageLog(directory, maxEntriesPerSkill = 500) {
   }
   let pruned = 0;
   const surviving = [];
-  groups.forEach((entries) => {
-    if (entries.length <= maxEntriesPerSkill) {
-      surviving.push(...entries);
+  groups.forEach((skillEntries) => {
+    if (skillEntries.length <= maxEntriesPerSkill) {
+      surviving.push(...skillEntries);
       return;
     }
-    entries.sort((a, b) => b.timestamp > a.timestamp ? 1 : b.timestamp < a.timestamp ? -1 : 0);
-    const kept = entries.slice(0, maxEntriesPerSkill);
-    pruned += entries.length - kept.length;
+    skillEntries.sort((a, b) => b.timestamp > a.timestamp ? 1 : b.timestamp < a.timestamp ? -1 : 0);
+    const kept = skillEntries.slice(0, maxEntriesPerSkill);
+    pruned += skillEntries.length - kept.length;
     surviving.push(...kept);
   });
   if (pruned === 0) {
-    return { pruned: 0, remaining: allEntries.length };
+    return { pruned: 0, remaining: entries.length };
   }
   const dir = path23.dirname(resolved);
   const tmpPath = path23.join(dir, `skill-usage-${Date.now()}.tmp`);
-  const content = surviving.map((e) => JSON.stringify(e)).join(`
+  const entryLines = surviving.map((e) => JSON.stringify(e));
+  const allLines = [...entryLines, ...preservedMarkers];
+  const content = allLines.join(`
 `).concat(`
 `);
   try {
@@ -41813,7 +41912,7 @@ function pruneSkillUsageLog(directory, maxEntriesPerSkill = 500) {
         _internals17.writeFileSync(tmpPath, "", "utf-8");
       }
     } catch {}
-    return { pruned: 0, remaining: allEntries.length, error: msg };
+    return { pruned: 0, remaining: entries.length, error: msg };
   }
   return { pruned, remaining: surviving.length };
 }

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

@@ -12,6 +12,20 @@ export declare const DANGEROUS_COMMAND_PATTERNS: RegExp[];
 export declare const SECURITY_DEGRADING_PATTERNS: RegExp[];
 export declare const INVISIBLE_FORMAT_CHARS: RegExp;
 export declare const INJECTION_PATTERNS: RegExp[];
+/**
+ * Extract context words around each occurrence of a target word (single tokens within a window).
+ * Context window is 3 words before and after, excluding the target word itself.
+ * Handles multi-word terms (e.g. "must not", "don't use") by scanning word slices.
+ *
+ * Note: this is an exact-word-match heuristic. Synonyms (e.g. "use" / "utilize")
+ * will not match across lessons. The 3-token window is bounded; more distant
+ * negation attachments will not be detected as contradictions.
+ */
+declare function extractContextWords(text: string, word: string, contextWindow?: number): Set<string>;
+/**
+ * Check if two sets of words have significant overlap (at least one word in common).
+ */
+declare function hasSignificantOverlap(set1: Set<string>, set2: Set<string>): boolean;
 export declare function validateLesson(candidate: string, existingLessons: string[], meta: {
     category: KnowledgeCategory;
     scope: string;
@@ -90,4 +104,6 @@ export declare const _internals: {
     auditEntryHealth: typeof auditEntryHealth;
     quarantineEntry: typeof quarantineEntry;
     restoreEntry: typeof restoreEntry;
+    extractContextWords: typeof extractContextWords;
+    hasSignificantOverlap: typeof hasSignificantOverlap;
 };

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.79.5",
+    version: "7.79.7",
     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",
@@ -61771,6 +61771,51 @@ import * as path36 from "node:path";
 function normalizeText(text) {
   return text.normalize("NFKC").toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
 }
+function extractContextWords(text, word, contextWindow = 3) {
+  const words = text.split(" ");
+  const context = new Set;
+  if (!word.includes(" ")) {
+    let from = 0;
+    let idx = words.indexOf(word, from);
+    while (idx !== -1) {
+      const start2 = Math.max(0, idx - contextWindow);
+      const end = Math.min(words.length, idx + contextWindow + 1);
+      for (let i3 = start2;i3 < end; i3++) {
+        if (i3 !== idx && words[i3] && words[i3].length > 0) {
+          context.add(words[i3]);
+        }
+      }
+      from = idx + 1;
+      idx = words.indexOf(word, from);
+    }
+    return context;
+  }
+  const termLen = word.split(" ").length;
+  let i2 = 0;
+  while (i2 <= words.length - termLen) {
+    const slice = words.slice(i2, i2 + termLen).join(" ");
+    if (slice === word) {
+      const start2 = Math.max(0, i2 - contextWindow);
+      const end = Math.min(words.length, i2 + termLen + contextWindow);
+      for (let j = start2;j < end; j++) {
+        if (j < i2 || j >= i2 + termLen) {
+          if (words[j] && words[j].length > 0) {
+            context.add(words[j]);
+          }
+        }
+      }
+      i2 += termLen;
+    } else {
+      i2 += 1;
+    }
+  }
+  return context;
+}
+function hasSignificantOverlap(set1, set22) {
+  if (set1.size === 0 || set22.size === 0)
+    return false;
+  return [...set1].some((word) => set22.has(word));
+}
 function detectContradiction(candidate, existingLessons) {
   const candidateTags = inferTags(candidate);
   if (candidateTags.length === 0)
@@ -61783,10 +61828,20 @@ function detectContradiction(candidate, existingLessons) {
       continue;
     const existingNorm = normalizeText(existing);
     for (const [wordA, wordB] of NEGATION_PAIRS) {
-      const hasA = candidateNorm.includes(wordA) && existingNorm.includes(wordB);
-      const hasB = candidateNorm.includes(wordB) && existingNorm.includes(wordA);
-      if (hasA || hasB)
-        return true;
+      if (candidateNorm.includes(wordA) && existingNorm.includes(wordB)) {
+        const contextA = extractContextWords(candidateNorm, wordA);
+        const contextB = extractContextWords(existingNorm, wordB);
+        if (hasSignificantOverlap(contextA, contextB)) {
+          return true;
+        }
+      }
+      if (candidateNorm.includes(wordB) && existingNorm.includes(wordA)) {
+        const contextB = extractContextWords(candidateNorm, wordB);
+        const contextA = extractContextWords(existingNorm, wordA);
+        if (hasSignificantOverlap(contextA, contextB)) {
+          return true;
+        }
+      }
     }
   }
   return false;
@@ -62806,10 +62861,12 @@ function isSkillMaturityEligible(entry, opts, outcomes = entry.retrieval_outcome
   if (outcomeSignal < 0)
     return false;
   const strongOutcomes = hasStrongSkillOutcomeRecord(outcomes);
+  if (outcomeSignal > 0 && strongOutcomes)
+    return true;
   if (entry.confidence < opts.minConfidence && !strongOutcomes)
     return false;
-  const confirmations = (entry.confirmed_by ?? []).length;
-  return confirmations >= opts.minConfirmations || strongOutcomes;
+  const distinctPhases = new Set((entry.confirmed_by ?? []).map((c) => c.phase_number).filter((p) => typeof p === "number")).size;
+  return distinctPhases >= opts.minConfirmations || strongOutcomes;
 }
 function jaccardSimilarity(setA, setB) {
   const normA = setA.map((s) => s.toLowerCase());
@@ -64410,12 +64467,52 @@ function pruneSkillUsageLog(directory, maxEntriesPerSkill = 500) {
   if (!_internals27.existsSync(resolved)) {
     return { pruned: 0, remaining: 0 };
   }
-  const allEntries = readSkillUsageEntries(directory);
-  if (allEntries.length === 0) {
+  const raw = _internals27.readFileSync(resolved, "utf-8");
+  const lines = raw.split(`
+`);
+  const entries = [];
+  const preservedMarkers = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      const marker = parseFeedbackMarker(parsed);
+      if (marker) {
+        preservedMarkers.push(trimmed);
+        continue;
+      }
+      const entry = parseSkillUsageEntry(parsed);
+      if (entry) {
+        entries.push(entry);
+      }
+    } catch {}
+  }
+  if (entries.length === 0) {
+    if (preservedMarkers.length > 0) {
+      const dir2 = path41.dirname(resolved);
+      const tmpPath2 = path41.join(dir2, `skill-usage-${Date.now()}.tmp`);
+      const content2 = preservedMarkers.join(`
+`).concat(preservedMarkers.length > 0 ? `
+` : "");
+      try {
+        _internals27.writeFileSync(tmpPath2, content2, "utf-8");
+        _internals27.renameSync(tmpPath2, resolved);
+      } catch (writeErr) {
+        const msg = writeErr instanceof Error ? writeErr.message : String(writeErr);
+        try {
+          if (_internals27.existsSync(tmpPath2)) {
+            _internals27.writeFileSync(tmpPath2, "", "utf-8");
+          }
+        } catch {}
+        return { pruned: 0, remaining: 0, error: msg };
+      }
+    }
     return { pruned: 0, remaining: 0 };
   }
   const groups = new Map;
-  for (const entry of allEntries) {
+  for (const entry of entries) {
     const list = groups.get(entry.skillPath);
     if (list)
       list.push(entry);
@@ -64424,22 +64521,24 @@ function pruneSkillUsageLog(directory, maxEntriesPerSkill = 500) {
   }
   let pruned = 0;
   const surviving = [];
-  groups.forEach((entries) => {
-    if (entries.length <= maxEntriesPerSkill) {
-      surviving.push(...entries);
+  groups.forEach((skillEntries) => {
+    if (skillEntries.length <= maxEntriesPerSkill) {
+      surviving.push(...skillEntries);
       return;
     }
-    entries.sort((a, b) => b.timestamp > a.timestamp ? 1 : b.timestamp < a.timestamp ? -1 : 0);
-    const kept = entries.slice(0, maxEntriesPerSkill);
-    pruned += entries.length - kept.length;
+    skillEntries.sort((a, b) => b.timestamp > a.timestamp ? 1 : b.timestamp < a.timestamp ? -1 : 0);
+    const kept = skillEntries.slice(0, maxEntriesPerSkill);
+    pruned += skillEntries.length - kept.length;
     surviving.push(...kept);
   });
   if (pruned === 0) {
-    return { pruned: 0, remaining: allEntries.length };
+    return { pruned: 0, remaining: entries.length };
   }
   const dir = path41.dirname(resolved);
   const tmpPath = path41.join(dir, `skill-usage-${Date.now()}.tmp`);
-  const content = surviving.map((e) => JSON.stringify(e)).join(`
+  const entryLines = surviving.map((e) => JSON.stringify(e));
+  const allLines = [...entryLines, ...preservedMarkers];
+  const content = allLines.join(`
 `).concat(`
 `);
   try {
@@ -64452,7 +64551,7 @@ function pruneSkillUsageLog(directory, maxEntriesPerSkill = 500) {
         _internals27.writeFileSync(tmpPath, "", "utf-8");
       }
     } catch {}
-    return { pruned: 0, remaining: allEntries.length, error: msg };
+    return { pruned: 0, remaining: entries.length, error: msg };
   }
   return { pruned, remaining: surviving.length };
 }
@@ -65362,7 +65461,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config3, know
       try {
         const skillModule = await Promise.resolve().then(() => (init_skill_generator(), exports_skill_generator));
         for (const cand of skillCandidates) {
-          if (cand.confidence < (config3.min_skill_confidence ?? 0.85)) {
+          if (cand.confidence < (config3.min_skill_confidence ?? DEFAULT_SKILL_MIN_CONFIDENCE)) {
             continue;
           }
           await skillModule.generateSkills({
@@ -98327,6 +98426,11 @@ Every listed directive ID MUST appear exactly once. If a directive carries a ver
 FIXES: required changes if rejected
 Use INFO only inside ISSUES for non-blocking suggestions. RISK reflects the highest blocking severity, so it never uses INFO.
 
+## OUTPUT ORDER FOR SKILL COMPLIANCE (when applicable)
+When SKILLS_USED_BY_CODER is provided, output TASK: immediately followed by SKILL_COMPLIANCE to ensure proper attribution:
+TASK: <task-id-or-unknown>
+SKILL_COMPLIANCE: <verdict> — <details>
+
 ## RULES
 - Be specific with line numbers
 - Only flag real issues, not theoretical
@@ -131064,7 +131168,7 @@ async function withTurboStateLock(directory, sessionID, fn2, timeoutMs = 30000)
     } catch (acquireErr) {
       console.warn(`[lean-turbo] state lock acquisition error for ${sessionID} (${lockPath}), will retry: ${acquireErr instanceof Error ? acquireErr.message : String(acquireErr)}`);
     }
-    if (result && result.acquired) {
+    if (result?.acquired) {
       const lock = result.lock;
       try {
         return await fn2();
@@ -134666,18 +134770,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
     safeWarn("[phase_complete] Design-doc drift check error (non-blocking):", docDriftError);
   }
   try {
-    const markerPath = validateSwarmPath(dir, "skill-usage-last-processed.json");
-    let sinceTimestamp;
-    try {
-      const markerData = JSON.parse(fs111.readFileSync(markerPath, "utf-8"));
-      sinceTimestamp = markerData.lastProcessedTimestamp;
-    } catch {}
-    const feedbackResult = await applySkillUsageFeedback(dir, {
-      sinceTimestamp
-    });
-    try {
-      fs111.writeFileSync(markerPath, JSON.stringify({ lastProcessedTimestamp: new Date().toISOString() }), "utf-8");
-    } catch {}
+    const feedbackResult = await applySkillUsageFeedback(dir);
     if (feedbackResult.processed > 0) {
       const sessionState = swarmState.agentSessions.get(sessionID);
       if (sessionState) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.79.5",
+	"version": "7.79.7",
 	"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",