opencode-swarm 7.32.1 → 7.32.3

package/dist/cli/index.js

@@ -34,7 +34,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.32.1",
+    version: "7.32.3",
     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",
@@ -17331,8 +17331,32 @@ var init_schema = __esm(() => {
     recall: exports_external.object({
       defaultMaxItems: exports_external.number().int().min(1).max(20).default(8),
       defaultTokenBudget: exports_external.number().int().min(100).max(5000).default(1200),
-      minScore: exports_external.number().min(0).max(1).default(0.05)
-    }).default({ defaultMaxItems: 8, defaultTokenBudget: 1200, minScore: 0.05 }),
+      minScore: exports_external.number().min(0).max(1).default(0.05),
+      injection: exports_external.object({
+        enabled: exports_external.boolean().default(true),
+        minScore: exports_external.number().min(0).max(1).default(0.25),
+        requireQuerySignal: exports_external.boolean().default(true),
+        maxItems: exports_external.number().int().min(1).max(20).default(6),
+        tokenBudget: exports_external.number().int().min(100).max(5000).default(1000)
+      }).default({
+        enabled: true,
+        minScore: 0.25,
+        requireQuerySignal: true,
+        maxItems: 6,
+        tokenBudget: 1000
+      })
+    }).default({
+      defaultMaxItems: 8,
+      defaultTokenBudget: 1200,
+      minScore: 0.05,
+      injection: {
+        enabled: true,
+        minScore: 0.25,
+        requireQuerySignal: true,
+        maxItems: 6,
+        tokenBudget: 1000
+      }
+    }),
     writes: exports_external.object({
       mode: exports_external.literal("propose").default("propose")
     }).default({ mode: "propose" }),

package/dist/config/schema.d.ts

@@ -510,6 +510,13 @@ export declare const MemoryConfigSchema: z.ZodObject<{
         defaultMaxItems: z.ZodDefault<z.ZodNumber>;
         defaultTokenBudget: z.ZodDefault<z.ZodNumber>;
         minScore: z.ZodDefault<z.ZodNumber>;
+        injection: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            minScore: z.ZodDefault<z.ZodNumber>;
+            requireQuerySignal: z.ZodDefault<z.ZodBoolean>;
+            maxItems: z.ZodDefault<z.ZodNumber>;
+            tokenBudget: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     writes: z.ZodDefault<z.ZodObject<{
         mode: z.ZodDefault<z.ZodLiteral<"propose">>;
@@ -1161,6 +1168,13 @@ export declare const PluginConfigSchema: z.ZodObject<{
             defaultMaxItems: z.ZodDefault<z.ZodNumber>;
             defaultTokenBudget: z.ZodDefault<z.ZodNumber>;
             minScore: z.ZodDefault<z.ZodNumber>;
+            injection: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                minScore: z.ZodDefault<z.ZodNumber>;
+                requireQuerySignal: z.ZodDefault<z.ZodBoolean>;
+                maxItems: z.ZodDefault<z.ZodNumber>;
+                tokenBudget: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>;
         writes: z.ZodDefault<z.ZodObject<{
             mode: z.ZodDefault<z.ZodLiteral<"propose">>;

package/dist/full-auto/critic-response-parser.d.ts

@@ -0,0 +1,30 @@
+export interface ParsedCriticResponse {
+    verdict: string;
+    reasoning: string;
+    evidenceChecked: string[];
+    antiPatternsDetected: string[];
+    escalationNeeded: boolean;
+    rawResponse: string;
+}
+interface ParseCriticResponseOptions {
+    validVerdicts?: readonly string[];
+    onUnknownVerdict?: (value: string) => void;
+}
+/**
+ * Parses a structured critic response into a `ParsedCriticResponse`.
+ *
+ * Expected format (one field per line, value may span multiple lines until the next field):
+ *   VERDICT: <value>
+ *   REASONING: <text>
+ *   EVIDENCE_CHECKED: <comma-separated list or "none">
+ *   ANTI_PATTERNS_DETECTED: <comma-separated list or "none">
+ *   ESCALATION_NEEDED: YES | NO
+ *
+ * @param rawResponse - The raw text response from the critic agent.
+ * @param options.validVerdicts - Override the default verdict allowlist. Unknown verdicts
+ *   (those not in this list) default to `NEEDS_REVISION` and trigger `onUnknownVerdict`.
+ * @param options.onUnknownVerdict - Called with the raw verdict string when it is not
+ *   in `validVerdicts`. Use for logging or metrics. Does not affect parsing outcome.
+ */
+export declare function parseCriticResponseFields(rawResponse: string, options?: ParseCriticResponseOptions): ParsedCriticResponse;
+export {};

package/dist/full-auto/oversight.d.ts

@@ -1,10 +1,5 @@
-export interface FullAutoCriticResult {
-    verdict: string;
-    reasoning: string;
-    evidenceChecked: string[];
-    antiPatternsDetected: string[];
-    escalationNeeded: boolean;
-    rawResponse: string;
+import { type ParsedCriticResponse } from './critic-response-parser';
+export interface FullAutoCriticResult extends ParsedCriticResponse {
 }
 export type FullAutoTriggerSource = 'text_pattern' | 'tool_action' | 'cadence' | 'subagent_return' | 'phase_boundary' | 'task_completion' | 'risk';
 export interface FullAutoOversightEvent {

package/dist/hooks/full-auto-intercept.d.ts

@@ -8,6 +8,7 @@
  * and injects the critic's autonomous oversight response when escalation is detected.
  */
 import type { PluginConfig } from '../config';
+import { type ParsedCriticResponse } from '../full-auto/critic-response-parser';
 interface MessageWithParts {
     info: {
         role: string;
@@ -24,13 +25,7 @@ interface MessageWithParts {
 /**
  * Result from critic dispatch — used to inject verdict into message stream.
  */
-interface CriticDispatchResult {
-    verdict: string;
-    reasoning: string;
-    evidenceChecked: string[];
-    antiPatternsDetected: string[];
-    escalationNeeded: boolean;
-    rawResponse: string;
+interface CriticDispatchResult extends ParsedCriticResponse {
 }
 /**
  * Parses the critic's structured text response into a CriticDispatchResult.

package/dist/index.js

@@ -48,7 +48,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.32.1",
+    version: "7.32.3",
     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",
@@ -15544,8 +15544,32 @@ var init_schema = __esm(() => {
     recall: exports_external.object({
       defaultMaxItems: exports_external.number().int().min(1).max(20).default(8),
       defaultTokenBudget: exports_external.number().int().min(100).max(5000).default(1200),
-      minScore: exports_external.number().min(0).max(1).default(0.05)
-    }).default({ defaultMaxItems: 8, defaultTokenBudget: 1200, minScore: 0.05 }),
+      minScore: exports_external.number().min(0).max(1).default(0.05),
+      injection: exports_external.object({
+        enabled: exports_external.boolean().default(true),
+        minScore: exports_external.number().min(0).max(1).default(0.25),
+        requireQuerySignal: exports_external.boolean().default(true),
+        maxItems: exports_external.number().int().min(1).max(20).default(6),
+        tokenBudget: exports_external.number().int().min(100).max(5000).default(1000)
+      }).default({
+        enabled: true,
+        minScore: 0.25,
+        requireQuerySignal: true,
+        maxItems: 6,
+        tokenBudget: 1000
+      })
+    }).default({
+      defaultMaxItems: 8,
+      defaultTokenBudget: 1200,
+      minScore: 0.05,
+      injection: {
+        enabled: true,
+        minScore: 0.25,
+        requireQuerySignal: true,
+        maxItems: 6,
+        tokenBudget: 1000
+      }
+    }),
     writes: exports_external.object({
       mode: exports_external.literal("propose").default("propose")
     }).default({ mode: "propose" }),
@@ -85071,11 +85095,18 @@ init_utils2();
 init_file_locks();
 init_state();
 init_logger();
-init_state2();
 import * as fs40 from "node:fs";
 import * as path62 from "node:path";
-var oversightSequenceCounter = 0;
-var VALID_VERDICTS = [
+
+// src/full-auto/critic-response-parser.ts
+var KNOWN_FIELDS = new Set([
+  "VERDICT",
+  "REASONING",
+  "EVIDENCE_CHECKED",
+  "ANTI_PATTERNS_DETECTED",
+  "ESCALATION_NEEDED"
+]);
+var DEFAULT_VALID_VERDICTS = [
   "APPROVED",
   "NEEDS_REVISION",
   "REJECTED",
@@ -85085,7 +85116,8 @@ var VALID_VERDICTS = [
   "REPHRASE",
   "PENDING"
 ];
-function parseFullAutoCriticResponse(rawResponse) {
+function parseCriticResponseFields(rawResponse, options = {}) {
+  const validVerdicts = options.validVerdicts ?? DEFAULT_VALID_VERDICTS;
   const result = {
     verdict: "NEEDS_REVISION",
     reasoning: "",
@@ -85102,10 +85134,10 @@ function parseFullAutoCriticResponse(rawResponse) {
     switch (key) {
       case "VERDICT": {
         const normalized = value.trim().toUpperCase().replace(/[`*]/g, "");
-        if (VALID_VERDICTS.includes(normalized)) {
+        if (validVerdicts.includes(normalized)) {
           res.verdict = normalized;
         } else {
-          warn(`[full-auto/oversight] Unknown verdict '${value}' — defaulting to NEEDS_REVISION`);
+          options.onUnknownVerdict?.(value);
           res.verdict = "NEEDS_REVISION";
         }
         break;
@@ -85132,13 +85164,7 @@ function parseFullAutoCriticResponse(rawResponse) {
     const colonIndex = line.indexOf(":");
     if (colonIndex !== -1) {
       const key = line.slice(0, colonIndex).trim().toUpperCase();
-      if ([
-        "VERDICT",
-        "REASONING",
-        "EVIDENCE_CHECKED",
-        "ANTI_PATTERNS_DETECTED",
-        "ESCALATION_NEEDED"
-      ].includes(key)) {
+      if (KNOWN_FIELDS.has(key)) {
         if (currentKey)
           commitField(result, currentKey, currentValue);
         currentKey = key;
@@ -85156,6 +85182,17 @@ ${line}`;
     commitField(result, currentKey, currentValue);
   return result;
 }
+
+// src/full-auto/oversight.ts
+init_state2();
+var oversightSequenceCounter = 0;
+function parseFullAutoCriticResponse(rawResponse) {
+  return parseCriticResponseFields(rawResponse, {
+    onUnknownVerdict: (value) => {
+      warn(`[full-auto/oversight] Unknown verdict '${value}' — defaulting to NEEDS_REVISION`);
+    }
+  });
+}
 function buildOversightPrompt(input) {
   const {
     trigger,
@@ -86674,88 +86711,11 @@ function extractMessageText3(message) {
 `);
 }
 function parseCriticResponse(rawResponse) {
-  const result = {
-    verdict: "NEEDS_REVISION",
-    reasoning: "",
-    evidenceChecked: [],
-    antiPatternsDetected: [],
-    escalationNeeded: false,
-    rawResponse
-  };
-  const lines = rawResponse.split(`
-`);
-  let currentKey = "";
-  let currentValue = "";
-  const commitField = (res, key, value) => {
-    switch (key) {
-      case "VERDICT": {
-        const validVerdicts = [
-          "APPROVED",
-          "NEEDS_REVISION",
-          "REJECTED",
-          "BLOCKED",
-          "ANSWER",
-          "ESCALATE_TO_HUMAN",
-          "REPHRASE"
-        ];
-        const normalized = value.trim().toUpperCase().replace(/[`*]/g, "");
-        if (validVerdicts.includes(normalized)) {
-          res.verdict = normalized;
-        } else {
-          warn(`[full-auto-intercept] Unknown verdict '${value}' — defaulting to NEEDS_REVISION`);
-          res.verdict = "NEEDS_REVISION";
-        }
-        break;
-      }
-      case "REASONING":
-        res.reasoning = value.trim();
-        break;
-      case "EVIDENCE_CHECKED":
-        if (value && value !== "none" && value !== '"none"') {
-          res.evidenceChecked = value.split(",").map((s) => s.trim()).filter(Boolean);
-        }
-        break;
-      case "ANTI_PATTERNS_DETECTED":
-        if (value && value !== "none" && value !== '"none"') {
-          res.antiPatternsDetected = value.split(",").map((s) => s.trim()).filter(Boolean);
-        }
-        break;
-      case "ESCALATION_NEEDED":
-        res.escalationNeeded = value.trim().toUpperCase() === "YES";
-        break;
-    }
-  };
-  for (const line of lines) {
-    const colonIndex = line.indexOf(":");
-    if (colonIndex !== -1) {
-      const key = line.slice(0, colonIndex).trim().toUpperCase();
-      if ([
-        "VERDICT",
-        "REASONING",
-        "EVIDENCE_CHECKED",
-        "ANTI_PATTERNS_DETECTED",
-        "ESCALATION_NEEDED"
-      ].includes(key)) {
-        if (currentKey) {
-          commitField(result, currentKey, currentValue);
-        }
-        currentKey = key;
-        currentValue = line.slice(colonIndex + 1).trim();
-      } else {
-        currentValue += `
-${line}`;
-      }
-    } else {
-      if (line.trim()) {
-        currentValue += `
-${line}`;
-      }
+  return parseCriticResponseFields(rawResponse, {
+    onUnknownVerdict: (value) => {
+      warn(`[full-auto-intercept] Unknown verdict '${value}' — defaulting to NEEDS_REVISION`);
     }
-  }
-  if (currentKey) {
-    commitField(result, currentKey, currentValue);
-  }
-  return result;
+  });
 }
 function escalationTypeToInteractionMode(escalationType) {
   return escalationType === "phase_completion" ? "phase_completion" : "question_resolution";
@@ -86789,7 +86749,8 @@ async function writeAutoOversightEvent(directory, architectOutput, criticVerdict
     fs43.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
   } catch (writeError) {
-    error48(`[full-auto-intercept] Warning: failed to write auto_oversight event: ${writeError instanceof Error ? writeError.message : String(writeError)}`);
+    error48(`[full-auto-intercept] Failed to write auto_oversight event: ${writeError instanceof Error ? writeError.message : String(writeError)}`);
+    throw writeError;
   } finally {
     if (lockResult?.acquired && lockResult.lock._release) {
       try {
@@ -86974,11 +86935,7 @@ ESCALATION_NEEDED: NO`;
       rawResponse: criticResponse
     };
   }
-  try {
-    await writeAutoOversightEvent(directory, architectOutput, parsed.verdict, parsed.reasoning, parsed.evidenceChecked, interactionCount, deadlockCount, escalationType);
-  } catch (writeError) {
-    error48(`[full-auto-intercept] Failed to write auto_oversight event: ${writeError instanceof Error ? writeError.message : String(writeError)}`);
-  }
+  await writeAutoOversightEvent(directory, architectOutput, parsed.verdict, parsed.reasoning, parsed.evidenceChecked, interactionCount, deadlockCount, escalationType);
   try {
     await mirrorReactiveVerdictToV2({
       directory,
@@ -93958,6 +93915,7 @@ async function writeDelegationEvent(directory, event) {
 `, "utf-8");
   } catch (error93) {
     error48(`[full-auto/delegation] failed to write event: ${error93 instanceof Error ? error93.message : String(error93)}`);
+    throw error93;
   } finally {
     if (lockResult?.acquired && lockResult.lock._release) {
       try {
@@ -97640,7 +97598,14 @@ var DEFAULT_MEMORY_CONFIG = {
   recall: {
     defaultMaxItems: 8,
     defaultTokenBudget: 1200,
-    minScore: 0.05
+    minScore: 0.05,
+    injection: {
+      enabled: true,
+      minScore: 0.25,
+      requireQuerySignal: true,
+      maxItems: 6,
+      tokenBudget: 1000
+    }
   },
   writes: {
     mode: "propose"
@@ -97671,7 +97636,11 @@ function resolveMemoryConfig(input) {
     ...input ?? {},
     recall: {
       ...DEFAULT_MEMORY_CONFIG.recall,
-      ...input?.recall ?? {}
+      ...input?.recall ?? {},
+      injection: {
+        ...DEFAULT_MEMORY_CONFIG.recall.injection,
+        ...input?.recall?.injection ?? {}
+      }
     },
     writes: {
       ...DEFAULT_MEMORY_CONFIG.writes,
@@ -97953,6 +97922,24 @@ function validateMemoryProposal(proposal) {
 function tokenize(text) {
   return new Set(text.toLowerCase().replace(/[^\w\s-]/g, " ").split(/\s+/).map((token) => token.trim()).filter(Boolean));
 }
+function normalizeKindText(kind) {
+  return kind.replace(/_/g, " ");
+}
+function collectMetadataStrings(metadata2, keys) {
+  const values = [];
+  for (const key of keys) {
+    const value = metadata2[key];
+    if (typeof value === "string")
+      values.push(value);
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (typeof item === "string")
+          values.push(item);
+      }
+    }
+  }
+  return values;
+}
 function overlap(a, b) {
   if (a.size === 0 || b.size === 0)
     return 0;
@@ -97990,37 +97977,101 @@ function sameScope(a, b) {
 function scopeAllowed(recordScope, allowedScopes) {
   return allowedScopes.some((scope) => sameScope(recordScope, scope));
 }
-function scoreMemoryRecord(record3, request) {
-  if (!request.includeExpired && isExpired2(record3))
-    return null;
+function scoreMemoryRecordDetailed(record3, request) {
+  if (!request.includeExpired && isExpired2(record3)) {
+    return { item: null, skipReason: "filtered" };
+  }
   if (record3.supersededBy)
-    return null;
-  if (record3.metadata.deleted === true)
-    return null;
-  if (!scopeAllowed(record3.scope, request.scopes))
-    return null;
-  if (request.kinds && !request.kinds.includes(record3.kind))
-    return null;
-  const queryTokens = tokenize(request.query);
+    return { item: null, skipReason: "filtered" };
+  if (record3.metadata.deleted === true) {
+    return { item: null, skipReason: "filtered" };
+  }
+  if (!scopeAllowed(record3.scope, request.scopes)) {
+    return { item: null, skipReason: "filtered" };
+  }
+  if (request.kinds && !request.kinds.includes(record3.kind)) {
+    return { item: null, skipReason: "filtered" };
+  }
+  const queryTokens = request.mode === "injection" && request.task ? tokenize(request.task) : tokenize(request.query);
   const textTokens = tokenize(record3.text);
   const tagTokens = tokenize(record3.tags.join(" "));
+  const fileTokens = tokenize([
+    record3.source.filePath,
+    ...collectMetadataStrings(record3.metadata, [
+      "file",
+      "filePath",
+      "files",
+      "touchedFiles"
+    ])
+  ].filter((value) => typeof value === "string").join(" "));
+  const symbolTokens = tokenize(collectMetadataStrings(record3.metadata, ["symbol", "symbols"]).join(" "));
+  const kindQueryOverlap = overlap(queryTokens, tokenize(normalizeKindText(record3.kind)));
   const textOverlap = overlap(queryTokens, textTokens);
   const tagOverlap = overlap(queryTokens, tagTokens);
-  const score = textOverlap * 0.45 + tagOverlap * 0.2 + scopeSpecificityBoost(record3.scope) * 0.15 + kindProfileBoost(record3.kind, request) * 0.1 + record3.confidence * 0.1;
+  const fileOverlap = overlap(queryTokens, fileTokens);
+  const symbolOverlap = overlap(queryTokens, symbolTokens);
+  const kindMatch = request.kinds?.includes(record3.kind) ?? false;
+  const scopeMatch = scopeAllowed(record3.scope, request.scopes);
+  const hasQuerySignal = textOverlap > 0 || tagOverlap > 0 || fileOverlap > 0 || symbolOverlap > 0 || kindQueryOverlap > 0;
+  if (request.mode === "injection" && request.requireQuerySignal !== false && !hasQuerySignal) {
+    return { item: null, skipReason: "no_signal" };
+  }
+  const score = textOverlap * 0.45 + tagOverlap * 0.2 + fileOverlap * 0.05 + symbolOverlap * 0.05 + scopeSpecificityBoost(record3.scope) * 0.15 + kindProfileBoost(record3.kind, request) * 0.1 + record3.confidence * 0.1;
   const reasonParts = [
     textOverlap > 0 ? `text_overlap=${textOverlap.toFixed(2)}` : null,
     tagOverlap > 0 ? `tag_overlap=${tagOverlap.toFixed(2)}` : null,
+    fileOverlap > 0 ? `file_overlap=${fileOverlap.toFixed(2)}` : null,
+    symbolOverlap > 0 ? `symbol_overlap=${symbolOverlap.toFixed(2)}` : null,
+    kindQueryOverlap > 0 ? `kind_query=${kindQueryOverlap.toFixed(2)}` : null,
     `scope=${record3.scope.type}`,
     `confidence=${record3.confidence.toFixed(2)}`
   ].filter(Boolean);
   return {
-    record: record3,
-    score,
-    reason: reasonParts.join(", ")
+    item: {
+      record: record3,
+      score,
+      reason: reasonParts.join(", "),
+      signals: {
+        textOverlap,
+        tagOverlap,
+        fileOverlap,
+        symbolOverlap,
+        kindMatch,
+        scopeMatch
+      }
+    }
   };
 }
-function scoreMemoryRecords(records, request) {
-  return records.map((record3) => scoreMemoryRecord(record3, request)).filter((item) => item !== null).filter((item) => item.score >= (request.minScore ?? 0)).sort((a, b) => b.score - a.score || a.record.id.localeCompare(b.record.id));
+function scoreMemoryRecordsWithDiagnostics(records, request) {
+  const minScore = request.minScore ?? 0;
+  const diagnostics = {
+    candidateCount: records.length,
+    preScoredFilteredCount: 0,
+    scoredCount: 0,
+    returnedCount: 0,
+    noSignalCount: 0,
+    belowThresholdCount: 0
+  };
+  const items = [];
+  for (const record3 of records) {
+    const result = scoreMemoryRecordDetailed(record3, request);
+    if (!result.item) {
+      if (result.skipReason === "filtered")
+        diagnostics.preScoredFilteredCount++;
+      if (result.skipReason === "no_signal")
+        diagnostics.noSignalCount++;
+      continue;
+    }
+    diagnostics.scoredCount++;
+    if (result.item.score < minScore) {
+      diagnostics.belowThresholdCount++;
+      continue;
+    }
+    items.push(result.item);
+  }
+  items.sort((a, b) => b.score - a.score || a.record.id.localeCompare(b.record.id));
+  diagnostics.returnedCount = items.length;
+  return { items, diagnostics };
 }
 
 // src/memory/local-jsonl-provider.ts
@@ -98096,13 +98147,23 @@ class LocalJsonlMemoryProvider {
     await this.audit("delete", id, reason);
   }
   async recall(request) {
+    return (await this.recallWithDiagnostics(request)).items;
+  }
+  async recallWithDiagnostics(request) {
     await this.initialize();
     const records = await this.list({
       scopes: request.scopes,
       kinds: request.kinds,
       includeExpired: request.includeExpired
     });
-    return scoreMemoryRecords(records, request).slice(0, request.maxItems);
+    const result = scoreMemoryRecordsWithDiagnostics(records, request);
+    return {
+      items: result.items.slice(0, request.maxItems),
+      diagnostics: {
+        ...result.diagnostics,
+        returnedCount: Math.min(result.diagnostics.returnedCount, request.maxItems)
+      }
+    };
   }
   async recordRecallUsage(event) {
     await this.initialize();
@@ -98307,7 +98368,8 @@ function toRecallBundle(input) {
     generatedAt: input.generatedAt,
     items: block.items,
     tokenEstimate: block.tokenEstimate,
-    promptBlock: block.promptBlock
+    promptBlock: block.promptBlock,
+    diagnostics: input.diagnostics
   };
 }
 
@@ -98368,20 +98430,29 @@ class MemoryGateway {
       query,
       task: input.task,
       agentRole: this.context.agentRole,
+      mode: input.mode ?? "manual",
       scopes,
       kinds: input.kinds,
       maxItems,
       tokenBudget,
       minScore: input.minScore ?? this.config.recall.minScore,
+      requireQuerySignal: input.requireQuerySignal,
       includeExpired: input.includeExpired
     };
-    const results = await this.provider.recall(request);
+    const recallResult = this.provider.recallWithDiagnostics ? await this.provider.recallWithDiagnostics(request) : { items: await this.provider.recall(request) };
     const bundle = toRecallBundle({
       id: createBundleId(query, generatedAt),
       query,
       generatedAt,
-      items: results,
-      tokenBudget
+      items: recallResult.items,
+      tokenBudget,
+      diagnostics: recallResult.diagnostics ? {
+        injectionSkipReason: input.mode === "injection" ? resolveInjectionSkipReason(recallResult.diagnostics) : undefined,
+        candidateCount: recallResult.diagnostics.candidateCount,
+        preScoredFilteredCount: recallResult.diagnostics.preScoredFilteredCount,
+        noSignalCount: recallResult.diagnostics.noSignalCount,
+        belowThresholdCount: recallResult.diagnostics.belowThresholdCount
+      } : undefined
     });
     await this.provider.recordRecallUsage?.({
       bundleId: bundle.id,
@@ -98569,6 +98640,19 @@ function validateRequestedScopes(requested, allowed) {
   }
   return requested;
 }
+function resolveInjectionSkipReason(diagnostics) {
+  if (diagnostics.returnedCount > 0)
+    return;
+  if (diagnostics.candidateCount === 0)
+    return "no_results";
+  const signalEligibleCount = diagnostics.candidateCount - diagnostics.preScoredFilteredCount;
+  if (signalEligibleCount > 0 && diagnostics.noSignalCount > 0 && diagnostics.noSignalCount >= signalEligibleCount) {
+    return "no_signal";
+  }
+  if (diagnostics.belowThresholdCount > 0)
+    return "below_threshold";
+  return "no_results";
+}
 function scopeKey(scope) {
   return JSON.stringify({
     type: scope.type,
@@ -98963,8 +99047,15 @@ async function recallForAgent(input) {
     agentId: input.agentId,
     runId: input.sessionID
   }, { config: input.config });
-  if (!gateway.isEnabled())
+  const resolvedConfig = resolveMemoryConfig(input.config);
+  if (!gateway.isEnabled()) {
+    await logInjectionSkipped(input, "disabled");
+    return null;
+  }
+  if (!resolvedConfig.recall.injection.enabled) {
+    await logInjectionSkipped(input, "disabled");
     return null;
+  }
   const scopes = gateway.deriveAllowedScopes();
   const planInput = {
     userGoal: compactText(input.userGoal),
@@ -98975,6 +99066,8 @@ async function recallForAgent(input) {
     touchedFiles: extractTouchedFiles(input.agentTask)
   };
   const plan = buildMemoryRecallPlan(planInput, { scopes });
+  plan.maxItems = resolvedConfig.recall.injection.maxItems;
+  plan.tokenBudget = resolvedConfig.recall.injection.tokenBudget;
   await input.appendRunLog(input.directory, input.sessionID, {
     event: "recall_requested",
     runId: input.sessionID ?? "unknown",
@@ -98990,10 +99083,13 @@ async function recallForAgent(input) {
   const recallInput = {
     query: plan.query,
     task: planInput.agentTask,
+    mode: "injection",
     scopes: plan.scopes,
     kinds: plan.kinds,
     maxItems: plan.maxItems,
-    tokenBudget: plan.tokenBudget
+    tokenBudget: plan.tokenBudget,
+    minScore: resolvedConfig.recall.injection.minScore,
+    requireQuerySignal: resolvedConfig.recall.injection.requireQuerySignal
   };
   const bundle = await gateway.recall(recallInput);
   await input.appendRunLog(input.directory, input.sessionID, {
@@ -99006,8 +99102,31 @@ async function recallForAgent(input) {
     scores: bundle.items.map((item) => item.score),
     tokenEstimate: bundle.tokenEstimate
   });
+  if (bundle.items.length === 0) {
+    await logInjectionSkipped(input, bundle.diagnostics?.injectionSkipReason ?? "no_results", bundle);
+  }
   return { bundle, scopes };
 }
+async function logInjectionSkipped(input, reason, bundle) {
+  await input.appendRunLog(input.directory, input.sessionID, {
+    event: "prompt_injection_skipped",
+    runId: input.sessionID ?? "unknown",
+    agentRole: input.agentRole,
+    agentId: input.agentId,
+    bundleId: bundle?.id,
+    memoryIds: bundle?.items.map((item) => item.record.id),
+    scores: bundle?.items.map((item) => item.score),
+    tokenEstimate: bundle?.tokenEstimate,
+    rejectionReason: reason,
+    metadata: {
+      reason,
+      candidateCount: bundle?.diagnostics?.candidateCount,
+      preScoredFilteredCount: bundle?.diagnostics?.preScoredFilteredCount,
+      noSignalCount: bundle?.diagnostics?.noSignalCount,
+      belowThresholdCount: bundle?.diagnostics?.belowThresholdCount
+    }
+  });
+}
 function parseTaskToolInput(input) {
   const record3 = input;
   const rawTool = typeof record3.tool === "string" ? record3.tool : undefined;
@@ -105260,7 +105379,7 @@ function verifyFullAutoPhaseApproval(directory, sessionID, phase, config3) {
     };
   }
   const events = files.map((f) => parseEvidence(f)).filter((e) => Boolean(e));
-  const phaseBoundary = events.filter((e) => (e.phase === phase || e.phase === undefined) && e.trigger_source === "phase_boundary" && (e.verdict ?? "").toUpperCase() === "APPROVED");
+  const phaseBoundary = events.filter((e) => e.phase === phase && e.trigger_source === "phase_boundary" && (e.verdict ?? "").toUpperCase() === "APPROVED");
   if (phaseBoundary.length === 0) {
     return failClosed ? {
       ok: false,
@@ -114959,6 +115078,10 @@ var swarm_memory_recall = createSwarmTool({
       memory_ids: bundle.items.map((item) => item.record.id),
       total: bundle.items.length,
       token_estimate: bundle.tokenEstimate,
+      signals: bundle.items.map((item) => ({
+        memory_id: item.record.id,
+        ...item.signals
+      })),
       prompt_block: bundle.promptBlock
     }, null, 2);
   }

package/dist/memory/config.d.ts

@@ -7,6 +7,13 @@ export interface MemoryConfig {
         defaultMaxItems: number;
         defaultTokenBudget: number;
         minScore: number;
+        injection: {
+            enabled: boolean;
+            minScore: number;
+            requireQuerySignal: boolean;
+            maxItems: number;
+            tokenBudget: number;
+        };
     };
     writes: {
         mode: 'propose';

package/dist/memory/gateway.d.ts

@@ -1,6 +1,6 @@
 import { type MemoryConfig } from './config';
 import type { MemoryProposalStore, MemoryProvider } from './provider';
-import type { MemoryContext, MemoryKind, MemoryProposal, MemoryRecord, MemoryScopeRef, MemorySource, RecallBundle } from './types';
+import type { MemoryContext, MemoryKind, MemoryProposal, MemoryRecord, MemoryScopeRef, MemorySource, RecallBundle, RecallMode } from './types';
 export interface MemoryGatewayOptions {
     config?: Partial<MemoryConfig>;
     provider?: MemoryProvider & Partial<MemoryProposalStore>;
@@ -18,11 +18,13 @@ export interface ProposeMemoryInput {
 export interface RecallMemoryInput {
     query: string;
     task?: string;
+    mode?: RecallMode;
     scopes?: MemoryScopeRef[];
     kinds?: MemoryKind[];
     maxItems?: number;
     tokenBudget?: number;
     minScore?: number;
+    requireQuerySignal?: boolean;
     includeExpired?: boolean;
 }
 export declare class MemoryGateway {

package/dist/memory/index.d.ts

@@ -12,4 +12,4 @@ export { findSecrets, redactSecrets } from './redaction';
 export { MEMORY_RECALL_PROFILES, type MemoryRecallProfile, normalizeMemoryAgentRole, resolveMemoryRecallProfile, } from './role-profiles';
 export { appendMemoryRunLog, sanitizeRunId } from './run-log';
 export { computeMemoryContentHash, createBundleId, createMemoryId, createProposalId, isExpired, normalizeMemoryText, validateMemoryProposal, validateMemoryRecordRules, } from './schema';
-export type { MemoryContext, MemoryKind, MemoryListFilter, MemoryProposal, MemoryRecord, MemoryScopeRef, MemoryScopeType, RecallBundle, RecallRequest, RecallResultItem, } from './types';
+export type { MemoryContext, MemoryKind, MemoryListFilter, MemoryProposal, MemoryRecord, MemoryScopeRef, MemoryScopeType, RecallBundle, RecallInjectionSkipReason, RecallMode, RecallRequest, RecallResultItem, } from './types';

package/dist/memory/injector.d.ts

@@ -1,4 +1,4 @@
-import type { MemoryConfig } from './config';
+import { type MemoryConfig } from './config';
 import type { MemoryGateway, ProposeMemoryInput } from './gateway';
 import { appendMemoryRunLog } from './run-log';
 import type { MemoryKind } from './types';

package/dist/memory/local-jsonl-provider.d.ts

@@ -1,5 +1,6 @@
 import { type MemoryConfig } from './config';
 import type { MemoryProposalStore, MemoryProvider, MemoryRecallUsageEvent } from './provider';
+import type { RecallScoringDiagnostics } from './scoring';
 import type { MemoryListFilter, MemoryProposal, MemoryRecord, RecallRequest, RecallResultItem } from './types';
 export declare class LocalJsonlMemoryProvider implements MemoryProvider, MemoryProposalStore {
     readonly name = "local-jsonl";
@@ -15,6 +16,10 @@ export declare class LocalJsonlMemoryProvider implements MemoryProvider, MemoryP
     get(id: string): Promise<MemoryRecord | null>;
     delete(id: string, reason?: string): Promise<void>;
     recall(request: RecallRequest): Promise<RecallResultItem[]>;
+    recallWithDiagnostics(request: RecallRequest): Promise<{
+        items: RecallResultItem[];
+        diagnostics: RecallScoringDiagnostics;
+    }>;
     recordRecallUsage(event: MemoryRecallUsageEvent): Promise<void>;
     list(filter?: MemoryListFilter): Promise<MemoryRecord[]>;
     createProposal(proposal: MemoryProposal): Promise<MemoryProposal>;

package/dist/memory/prompt-block.d.ts

@@ -10,4 +10,5 @@ export declare function toRecallBundle(input: {
     generatedAt: string;
     items: RecallResultItem[];
     tokenBudget: number;
+    diagnostics?: RecallBundle['diagnostics'];
 }): RecallBundle;

package/dist/memory/provider.d.ts

@@ -1,4 +1,9 @@
+import type { RecallScoringDiagnostics } from './scoring';
 import type { MemoryListFilter, MemoryProposal, MemoryRecord, RecallRequest, RecallResultItem } from './types';
+export interface MemoryRecallResult {
+    items: RecallResultItem[];
+    diagnostics?: RecallScoringDiagnostics;
+}
 export interface MemoryRecallUsageEvent {
     bundleId: string;
     query: string;
@@ -18,6 +23,7 @@ export interface MemoryProvider {
     get(id: string): Promise<MemoryRecord | null>;
     delete(id: string, reason?: string): Promise<void>;
     recall(request: RecallRequest): Promise<RecallResultItem[]>;
+    recallWithDiagnostics?(request: RecallRequest): Promise<MemoryRecallResult>;
     recordRecallUsage?(event: MemoryRecallUsageEvent): Promise<void>;
     list(filter: MemoryListFilter): Promise<MemoryRecord[]>;
 }

package/dist/memory/run-log.d.ts

@@ -1,4 +1,4 @@
-export type MemoryRunLogEventName = 'recall_requested' | 'recall_returned' | 'prompt_injected' | 'proposal_created' | 'proposal_rejected_by_validation';
+export type MemoryRunLogEventName = 'recall_requested' | 'recall_returned' | 'prompt_injection_skipped' | 'prompt_injected' | 'proposal_created' | 'proposal_rejected_by_validation';
 export interface MemoryRunLogEvent {
     event: MemoryRunLogEventName;
     runId: string;

package/dist/memory/scoring.d.ts

@@ -1,5 +1,17 @@
 import type { MemoryRecord, MemoryScopeRef, RecallRequest, RecallResultItem } from './types';
+export interface RecallScoringDiagnostics {
+    candidateCount: number;
+    preScoredFilteredCount: number;
+    scoredCount: number;
+    returnedCount: number;
+    noSignalCount: number;
+    belowThresholdCount: number;
+}
 export declare function sameScope(a: MemoryScopeRef, b: MemoryScopeRef): boolean;
 export declare function scopeAllowed(recordScope: MemoryScopeRef, allowedScopes: MemoryScopeRef[]): boolean;
 export declare function scoreMemoryRecord(record: MemoryRecord, request: RecallRequest): RecallResultItem | null;
 export declare function scoreMemoryRecords(records: MemoryRecord[], request: RecallRequest): RecallResultItem[];
+export declare function scoreMemoryRecordsWithDiagnostics(records: MemoryRecord[], request: RecallRequest): {
+    items: RecallResultItem[];
+    diagnostics: RecallScoringDiagnostics;
+};

package/dist/memory/types.d.ts

@@ -56,15 +56,19 @@ export interface MemoryProposal {
     createdAt: string;
     metadata: Record<string, unknown>;
 }
+export type RecallMode = 'manual' | 'injection' | 'curator' | 'evaluation';
+export type RecallInjectionSkipReason = 'disabled' | 'no_signal' | 'below_threshold' | 'no_results';
 export interface RecallRequest {
     query: string;
     task?: string;
     agentRole?: string;
+    mode?: RecallMode;
     scopes: MemoryScopeRef[];
     kinds?: MemoryKind[];
     maxItems: number;
     tokenBudget: number;
     minScore?: number;
+    requireQuerySignal?: boolean;
     includeExpired?: boolean;
     includePendingProposals?: boolean;
 }
@@ -72,6 +76,14 @@ export interface RecallResultItem {
     record: MemoryRecord;
     score: number;
     reason: string;
+    signals: {
+        textOverlap: number;
+        tagOverlap: number;
+        fileOverlap?: number;
+        symbolOverlap?: number;
+        kindMatch: boolean;
+        scopeMatch: boolean;
+    };
 }
 export interface RecallBundle {
     id: string;
@@ -80,6 +92,13 @@ export interface RecallBundle {
     items: RecallResultItem[];
     tokenEstimate: number;
     promptBlock: string;
+    diagnostics?: {
+        injectionSkipReason?: RecallInjectionSkipReason;
+        candidateCount?: number;
+        preScoredFilteredCount?: number;
+        noSignalCount?: number;
+        belowThresholdCount?: number;
+    };
 }
 export interface MemoryContext {
     directory: string;

package/package.json

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