opencode-swarm 7.79.7 → 7.80.0

package/dist/cli/index.js

@@ -52,7 +52,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.79.7",
+    version: "7.80.0",
     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",
@@ -17760,6 +17760,14 @@ var init_tool_metadata = __esm(() => {
       description: "dispatch multiple read-only exploration/review lanes concurrently and return a structured join result",
       agents: ["architect"]
     },
+    dispatch_lanes_async: {
+      description: "launch multiple read-only advisory lanes asynchronously and return a batch id for later collection",
+      agents: ["architect"]
+    },
+    collect_lane_results: {
+      description: "collect or poll results for a dispatch_lanes_async advisory batch without advancing workflow gates",
+      agents: ["architect"]
+    },
     summarize_work: {
       description: "emit a short structured summary of completed work (key decisions, assumptions, risks, constraints) at task completion; rolls up per phase for architecture-supervisor review. Advisory, never blocks.",
       agents: [
@@ -18787,7 +18795,8 @@ var init_schema = __esm(() => {
     }).optional(),
     enrichment: exports_external.object({
       max_calls_per_day: exports_external.number().int().min(0).max(1000).default(30),
-      quota_window: exports_external.enum(["utc", "local"]).default("utc")
+      quota_window: exports_external.enum(["utc", "local"]).default("utc"),
+      batch_size: exports_external.number().int().min(1).max(100).optional()
     }).default({ max_calls_per_day: 30, quota_window: "utc" })
   });
   MemoryConfigSchema = exports_external.object({
@@ -43829,6 +43838,35 @@ function buildV3EnrichmentPrompt(lesson, category, tags) {
   ].join(`
 `);
 }
+function buildV3BatchEnrichmentPrompt(lessons) {
+  const lessonLines = lessons.map((item, idx) => `${idx + 1}. LESSON: ${item.lesson}
+   CATEGORY: ${item.category}
+   TAGS: ${item.tags.join(", ")}`).join(`
+`);
+  return [
+    "Convert each prose lesson below into an actionable knowledge directive.",
+    "Output ONLY a JSON array (no code fences, no commentary).",
+    `The array length MUST be exactly ${lessons.length}.`,
+    "Each array element at position i maps to lesson i (1-indexed above).",
+    "",
+    "For EACH element, mandatory requirements:",
+    "- At least ONE scope field non-empty:",
+    '  "applies_to_agents": string[] \u2014 roles from: architect, coder, reviewer, test_engineer, sme, docs, designer, critic, curator',
+    '  "applies_to_tools": string[] \u2014 tool names from: edit, write, patch, bash, read, grep, glob',
+    "- At least ONE predicate field non-empty:",
+    '  "forbidden_actions": string[] | "required_actions": string[] | "verification_checks": string[]',
+    "",
+    "Optional per element:",
+    '"triggers": string[], "directive_priority": "low" | "medium" | "high" | "critical"',
+    "",
+    "Example array:",
+    '[{"applies_to_agents":["coder"],"required_actions":["run focused tests before commit"],"directive_priority":"high"}]',
+    "",
+    "LESSONS:",
+    lessonLines
+  ].join(`
+`);
+}
 function parseV3EnrichmentResponse(text) {
   if (!text || typeof text !== "string") {
     return { missing: ["valid JSON object"] };
@@ -43869,6 +43907,109 @@ function parseV3EnrichmentResponse(text) {
   }
   return { fields };
 }
+function parseV3BatchEnrichmentResponse(text, expectedLength) {
+  const empty = Array.from({ length: expectedLength }, () => null);
+  if (!text || typeof text !== "string") {
+    return { fields: empty, missing: ["valid JSON array"] };
+  }
+  const start = text.indexOf("[");
+  const end = text.lastIndexOf("]");
+  if (start < 0 || end <= start) {
+    return { fields: empty, missing: ["valid JSON array"] };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text.slice(start, end + 1));
+  } catch {
+    return { fields: empty, missing: ["valid JSON array"] };
+  }
+  if (!Array.isArray(parsed)) {
+    return { fields: empty, missing: ["valid JSON array"] };
+  }
+  const fields = Array.from({ length: expectedLength }, () => null);
+  const missing = [];
+  for (let i = 0;i < expectedLength; i++) {
+    const item = parsed[i];
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      missing.push(`item ${i + 1}: valid JSON object`);
+      continue;
+    }
+    const raw = item;
+    const candidate = {};
+    for (const key of ENRICHMENT_ALLOWED_FIELDS) {
+      if (raw[key] !== undefined) {
+        candidate[key] = raw[key];
+      }
+    }
+    const shape = validateActionableFields(candidate);
+    if (!shape.valid) {
+      missing.push(`item ${i + 1}: ${shape.errors.join("; ")}`);
+      continue;
+    }
+    const actionability = validateActionability(candidate);
+    if (!actionability.actionable) {
+      const expected = [];
+      if (actionability.reason === "missing_predicate" || actionability.reason === "missing_predicate_and_scope") {
+        expected.push("a non-empty predicate field (forbidden_actions, required_actions, or verification_checks)");
+      }
+      if (actionability.reason === "missing_scope" || actionability.reason === "missing_predicate_and_scope") {
+        expected.push("a non-empty scope field (applies_to_agents or applies_to_tools)");
+      }
+      missing.push(`item ${i + 1}: ${expected.join("; ")}`);
+      continue;
+    }
+    fields[i] = candidate;
+  }
+  if (parsed.length < expectedLength) {
+    missing.push(`expected ${expectedLength} items but got ${parsed.length}`);
+  } else if (parsed.length > expectedLength) {
+    warn(`[knowledge-curator] parseV3BatchEnrichmentResponse received ${parsed.length} items but expected ${expectedLength}; extras will be discarded`);
+    missing.push(`got ${parsed.length} items but only first ${expectedLength} will be used; extras discarded`);
+  }
+  return { fields, missing };
+}
+async function enrichLessonsToV3Batched(params) {
+  const quota = params.quota ?? { maxCalls: 10, window: "utc" };
+  const out = Array.from({ length: params.lessons.length }, () => null);
+  const batchSize = params.batchSize ?? ENRICHMENT_BATCH_SIZE;
+  for (let start = 0;start < params.lessons.length; start += batchSize) {
+    const batch = params.lessons.slice(start, start + batchSize);
+    const prompt = buildV3BatchEnrichmentPrompt(batch);
+    let userInput = prompt;
+    let best = Array.from({ length: batch.length }, () => null);
+    let retryHint = "";
+    for (let attempt = 0;attempt < 2; attempt++) {
+      try {
+        const reservation = await reserveQuota(params.directory, {
+          nCalls: 1,
+          maxCalls: quota.maxCalls,
+          window: quota.window,
+          scope: "knowledge-enrichment"
+        });
+        if (!reservation.allowed)
+          break;
+        const response = await params.llmDelegate("", userInput, AbortSignal.timeout(ENRICHMENT_LLM_TIMEOUT_MS));
+        const parsed = parseV3BatchEnrichmentResponse(response, batch.length);
+        best = best.map((current, idx) => current ?? parsed.fields[idx]);
+        const unresolved = best.map((fields, idx) => ({ fields, idx })).filter((item) => item.fields === null).map((item) => item.idx + 1);
+        if (unresolved.length === 0)
+          break;
+        retryHint = parsed.missing.join("; ");
+        const resolvedList = best.map((fields, idx) => ({ fields, idx })).filter((item) => item.fields !== null).map((item) => item.idx + 1);
+        const preserveClause = resolvedList.length > 0 ? `Preserve the already-valid entries for items ${resolvedList.join(", ")} exactly as you returned them previously. ` : "";
+        userInput = `${prompt}
+
+RETRY: your last output still missed valid directives for items ${unresolved.join(", ")}. ${retryHint} ${preserveClause}Return a full JSON array with valid entries for every item.`;
+      } catch (err) {
+        warn(`[knowledge-curator] v3 batch enrichment attempt ${attempt + 1} failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    for (let i = 0;i < best.length; i++) {
+      out[start + i] = best[i];
+    }
+  }
+  return out;
+}
 async function enrichLessonToV3(params) {
   const quota = params.quota ?? { maxCalls: 10, window: "utc" };
   const prompt = buildV3EnrichmentPrompt(params.lesson, params.category, params.tags);
@@ -44006,6 +44147,7 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
   const snapshotPlusNew = [...snapshot];
   const toAdd = [];
   const pendingReinforcementIds = new Set;
+  const pendingBatchEnrichment = [];
   for (const lesson of lessons) {
     const tags = inferTags(lesson);
     let category = "process";
@@ -44068,20 +44210,10 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
       project_name: projectName,
       auto_generated: true
     };
-    let actionability = validateActionability(entry);
+    const actionability = validateActionability(entry);
     if (!actionability.actionable && options?.llmDelegate) {
-      const enriched = await enrichLessonToV3({
-        directory,
-        llmDelegate: options.llmDelegate,
-        lesson,
-        category,
-        tags,
-        quota: options.enrichmentQuota
-      });
-      if (enriched) {
-        Object.assign(entry, enriched);
-        actionability = validateActionability(entry);
-      }
+      pendingBatchEnrichment.push({ entry, lesson, category, tags });
+      continue;
     }
     if (!actionability.actionable) {
       quarantined++;
@@ -44098,6 +44230,41 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
     toAdd.push(entry);
     snapshotPlusNew.push(entry);
   }
+  if (pendingBatchEnrichment.length > 0 && options?.llmDelegate) {
+    const enrichedBatch = await enrichLessonsToV3Batched({
+      directory,
+      llmDelegate: options.llmDelegate,
+      lessons: pendingBatchEnrichment.map((item) => ({
+        lesson: item.lesson,
+        category: item.category,
+        tags: item.tags
+      })),
+      quota: options.enrichmentQuota,
+      batchSize: config3.enrichment?.batch_size
+    });
+    for (let i = 0;i < pendingBatchEnrichment.length; i++) {
+      const pending = pendingBatchEnrichment[i];
+      const enriched = enrichedBatch[i];
+      if (enriched) {
+        Object.assign(pending.entry, enriched);
+      }
+      const actionability = validateActionability(pending.entry);
+      if (!actionability.actionable) {
+        quarantined++;
+        try {
+          await appendUnactionable(directory, pending.entry, actionability.reason ?? "unactionable");
+        } catch {}
+        await appendCuratorSkippedEvent(directory, {
+          entry_id: pending.entry.id,
+          lesson: pending.lesson,
+          reason: actionability.reason ?? "unactionable"
+        });
+        continue;
+      }
+      toAdd.push(pending.entry);
+      snapshotPlusNew.push(pending.entry);
+    }
+  }
   try {
     const insights = await consumeInsightCandidates(directory);
     for (const cand of insights) {
@@ -44301,7 +44468,7 @@ function createKnowledgeCuratorHook(directory, config3, options = {}) {
   };
   return safeHook(handler);
 }
-var seenRetroSections, MAX_TRACKED_RETRO_SECTIONS = 500, ENRICHMENT_ALLOWED_FIELDS, ENRICHMENT_LLM_TIMEOUT_MS = 60000, MESO_INSIGHT_BATCH_LIMIT = 20, KNOWLEDGE_CATEGORIES, OUTCOME_PROMOTION_BLOCK = -0.3, _internals20;
+var seenRetroSections, MAX_TRACKED_RETRO_SECTIONS = 500, ENRICHMENT_ALLOWED_FIELDS, ENRICHMENT_LLM_TIMEOUT_MS = 60000, ENRICHMENT_BATCH_SIZE = 6, MESO_INSIGHT_BATCH_LIMIT = 20, KNOWLEDGE_CATEGORIES, OUTCOME_PROMOTION_BLOCK = -0.3, _internals20;
 var init_knowledge_curator = __esm(() => {
   init_skill_improver_quota();
   init_synonym_map();

package/dist/config/schema.d.ts

@@ -592,6 +592,7 @@ export declare const KnowledgeConfigSchema: z.ZodObject<{
             utc: "utc";
             local: "local";
         }>>;
+        batch_size: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type KnowledgeConfig = z.infer<typeof KnowledgeConfigSchema>;
@@ -1597,6 +1598,7 @@ export declare const PluginConfigSchema: z.ZodObject<{
                 utc: "utc";
                 local: "local";
             }>>;
+            batch_size: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     memory: z.ZodOptional<z.ZodObject<{

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

@@ -35,6 +35,8 @@ export declare function parseV3EnrichmentResponse(text: string): {
 } | {
     missing: string[];
 };
+/** Max lessons enriched per LLM call (batch mode). */
+export declare const ENRICHMENT_BATCH_SIZE = 6;
 export interface EnrichmentQuotaOptions {
     maxCalls: number;
     window: 'utc' | 'local';

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

@@ -216,6 +216,7 @@ export interface KnowledgeConfig {
     enrichment: {
         max_calls_per_day: number;
         quota_window: 'utc' | 'local';
+        batch_size?: number;
     };
 }
 export interface MessageInfo {