opencode-swarm 7.79.7 → 7.81.0

package/dist/background/pending-delegations.d.ts

@@ -3,17 +3,17 @@
  *
  * Append-only JSONL event log under project-root `.swarm/background-delegations.jsonl`.
  * Each line is a full record snapshot; readers fold to the latest snapshot per
- * `correlationId`. This tracks background swarm `Task` dispatches so a later (Stage B)
- * trusted completion can be correlated to a real dispatch. The stale sweep bounds the
- * number of permanently-running (unresolved) entries by transitioning them to `stale`, so
- * the folded in-memory view stays bounded by distinct correlationIds. Note: the on-disk
- * log itself is append-only and is NOT compacted in Stage A — each dispatch leaves a small,
- * fixed number of lines; on-disk compaction of dropped/stale records is a future stage.
+ * `correlationId`. This tracks native background `Task` dispatches and deterministic
+ * async advisory lanes so trusted completions can be correlated to a real dispatch.
+ * The stale sweep bounds the number of permanently-running entries by transitioning
+ * them to `stale`, so the folded in-memory view stays bounded by distinct correlationIds.
+ * The on-disk log itself is append-only and is NOT compacted; each dispatch leaves a
+ * small, fixed number of lines.
  *
- * Stage A scope: dispatch records a `pending` snapshot and the stale sweep records
- * `stale` snapshots. There is NO gate advancement and NO completion mutation here — the
- * completion observer (Stage A) is read-only. Gate-affecting completion ingestion is
- * Stage B, gated on runtime confirmation of the upstream completion signal.
+ * Scope: dispatch records `pending`/`running` snapshots, collection or trusted synthetic
+ * completions record terminal snapshots, and the stale sweep records `stale` snapshots.
+ * This store still has NO gate advancement and NO gate evidence side effect; it is an
+ * advisory result ledger only.
  *
  * Concurrency: all writes (append, sweep) run under a single project-scoped lock via
  * `withEvidenceLock`, so concurrent dispatches/sweeps cannot interleave appends. Reads are
@@ -23,9 +23,9 @@
  * `.swarm/` (Invariant 4).
  */
 export declare const BACKGROUND_DELEGATIONS_FILE = "background-delegations.jsonl";
-export type BackgroundDelegationStatus = 'pending' | 'completed' | 'error' | 'stale';
+export type BackgroundDelegationStatus = 'pending' | 'running' | 'completed' | 'error' | 'cancelled' | 'stale' | 'consumed';
 export interface BackgroundDelegationRecord {
-    schemaVersion: 1;
+    schemaVersion: 1 | 2;
     /** Subagent session id from the dispatch envelope — the correlation key. */
     correlationId: string;
     /** Structured jobId from dispatch metadata when available, else null. */
@@ -46,6 +46,33 @@ export interface BackgroundDelegationRecord {
     status: BackgroundDelegationStatus;
     createdAt: number;
     updatedAt: number;
+    /** Async advisory lane batch id. Present for dispatch_lanes_async records. */
+    batchId?: string;
+    /** Stable lane id within batchId. */
+    laneId?: string;
+    /** Advisory workflow/mode that launched the lane. */
+    mode?: string;
+    /** Canonical hash of prompt/provenance inputs captured at dispatch time. */
+    promptHash?: string;
+    /** Project/root provenance captured at dispatch time. */
+    workspace?: BackgroundWorkspaceSnapshot;
+    generation?: number;
+    result?: BackgroundDelegationResult;
+    completedAt?: number;
+}
+export interface BackgroundWorkspaceSnapshot {
+    directory: string;
+    gitHead: string | null;
+    dirtyHash: string | null;
+    prHeadSha: string | null;
+    scope: string | null;
+}
+export interface BackgroundDelegationResult {
+    text?: string;
+    error?: string;
+    chars: number;
+    truncated: boolean;
+    digest: string;
 }
 /**
  * Read and fold the store to the latest snapshot per correlationId. Lock-free and
@@ -53,10 +80,8 @@ export interface BackgroundDelegationRecord {
  * (never throws). Records are returned in first-seen correlationId order.
  *
  * Cost: O(lines on disk) per call — a full read + parse + fold with no in-memory cache.
- * This is intentionally simple and acceptable at Stage A volumes (a swarm has few concurrent
- * background delegations, and the on-disk log is small). If sustained high-throughput
- * background load ever makes this hot, a future stage should add a stat-invalidated in-memory
- * cache and/or JSONL compaction (the same future-compaction work noted in the module header).
+ * This is intentionally simple and acceptable at advisory-lane volumes (a swarm has few
+ * concurrent background delegations, and the on-disk log is small).
  */
 export declare function readDelegations(directory: string): BackgroundDelegationRecord[];
 /** Returns the folded record for a correlationId, or null. Lock-free read. */
@@ -71,16 +96,32 @@ export interface RecordPendingInput {
     swarmPrefixedAgent: string;
     planTaskId: string | null;
     evidenceTaskId: string | null;
+    batchId?: string;
+    laneId?: string;
+    mode?: string;
+    promptHash?: string;
+    workspace?: BackgroundWorkspaceSnapshot;
+    generation?: number;
 }
 /**
  * Record a `pending` background delegation. Runs the stale sweep first (lazy maintenance,
  * no plugin-init cost), then appends the pending snapshot — all under one lock acquisition
  * so concurrent dispatches cannot interleave. Best-effort: returns null on lock timeout or
- * write failure (Stage A has no gate effects, so a missed record is non-fatal).
+ * write failure. Async advisory launchers must treat null as a launch failure so they do
+ * not create untracked background work.
  */
 export declare function recordPendingDelegation(directory: string, input: RecordPendingInput, options?: {
     staleTimeoutMs?: number;
 }): Promise<BackgroundDelegationRecord | null>;
+export declare function appendDelegationTransition(directory: string, correlationId: string, transition: {
+    status: BackgroundDelegationStatus;
+    result?: BackgroundDelegationResult;
+    completedAt?: number;
+}): Promise<BackgroundDelegationRecord | null>;
+export declare function findByBatchId(directory: string, batchId: string, opts?: {
+    parentSessionId?: string;
+}): BackgroundDelegationRecord[];
+export declare function findOpenAsyncLaneBatches(directory: string): BackgroundDelegationRecord[];
 /**
  * Public stale sweep: acquires the store lock and marks overdue pendings as `stale`.
  * Best-effort; returns the number swept (0 on lock timeout / error).

package/dist/background/task-envelope.d.ts

@@ -21,6 +21,11 @@ export interface TaskEnvelope {
     /** The subagent session id from `<task id="...">` — the cross-event correlation key. */
     sessionId: string;
     state: TaskEnvelopeState;
+    summary?: string;
+    resultText?: string;
+    errorText?: string;
+    resultChars?: number;
+    resultTruncated?: boolean;
 }
 /**
  * Parse a task envelope from arbitrary text. Returns null when the text does not contain

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.81.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/commands/pr-feedback.d.ts

@@ -1,20 +1,22 @@
 /**
  * Handle /swarm pr-feedback command.
  *
- * Triggers the architect to enter MODE: PR_FEEDBACK — the swarm workflow for
+ * Triggers the architect to enter MODE: PR_FEEDBACK — the swarm workflow for
  * ingesting and closing KNOWN pull-request feedback (review comments, requested
  * changes, CI failures, merge conflicts, stale branches, pasted notes). This is
  * distinct from /swarm pr-review, which discovers NEW findings.
  *
  * Input contract (PR reference is optional):
- *   /swarm pr-feedback 155                         → feedback pass on PR 155
- *   /swarm pr-feedback 155 also fix the lint errors → PR 155 + extra instructions
- *   /swarm pr-feedback owner/repo#155               → shorthand
+ *   /swarm pr-feedback 155                         → feedback pass on PR 155
+ *   /swarm pr-feedback 155 also fix the lint errors → PR 155 + extra instructions
+ *   /swarm pr-feedback 155 continue from .swarm/pr-review/<run_id>/feedback-handoff.md
+ *                                                   -> PR 155 + handoff path instructions
+ *   /swarm pr-feedback owner/repo#155               → shorthand
  *   /swarm pr-feedback https://github.com/.../pull/155
- *   /swarm pr-feedback                              → bare signal; architect builds
+ *   /swarm pr-feedback                              → bare signal; architect builds
  *                                                     the ledger from current PR/branch
  *   /swarm pr-feedback address the review notes about error handling
- *                                                   → no parseable PR ref ⇒ the whole
+ *                                                   → no parseable PR ref ⇒ the whole
  *                                                     input is forwarded as instructions
  *
  * PR-reference parsing and injection-hardening are shared with /swarm pr-review

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 {