opencode-swarm 7.32.2 → 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.2",
+    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/index.js

@@ -48,7 +48,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.32.2",
+    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" }),
@@ -97574,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"
@@ -97605,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,
@@ -97887,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;
@@ -97924,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
@@ -98030,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();
@@ -98241,7 +98368,8 @@ function toRecallBundle(input) {
     generatedAt: input.generatedAt,
     items: block.items,
     tokenEstimate: block.tokenEstimate,
-    promptBlock: block.promptBlock
+    promptBlock: block.promptBlock,
+    diagnostics: input.diagnostics
   };
 }
 
@@ -98302,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,
@@ -98503,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,
@@ -98897,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),
@@ -98909,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",
@@ -98924,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, {
@@ -98940,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;
@@ -114893,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.2",
+	"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",