opencode-swarm 7.32.2 → 7.33.0

package/dist/memory/config.d.ts

@@ -1,12 +1,23 @@
 import type { MemoryKind } from './types';
 export interface MemoryConfig {
     enabled: boolean;
-    provider: 'local-jsonl';
+    provider: 'local-jsonl' | 'sqlite';
     storageDir: string;
+    sqlite: {
+        path: string;
+        busyTimeoutMs: number;
+    };
     recall: {
         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 {
@@ -32,6 +34,7 @@ export declare class MemoryGateway {
     private readonly now;
     constructor(context: MemoryContext, options?: MemoryGatewayOptions);
     isEnabled(): boolean;
+    dispose(): Promise<void>;
     deriveAllowedScopes(): MemoryScopeRef[];
     recall(input: RecallMemoryInput): Promise<RecallBundle>;
     propose(input: ProposeMemoryInput): Promise<MemoryProposal>;
@@ -50,3 +53,4 @@ export declare class MemoryGateway {
     private assertEnabled;
 }
 export declare function createMemoryGateway(context: MemoryContext, options?: MemoryGatewayOptions): MemoryGateway;
+export declare function createConfiguredMemoryProvider(directory: string, config: MemoryConfig): MemoryProvider & MemoryProposalStore;

package/dist/memory/index.d.ts

@@ -2,7 +2,7 @@ export type { MemoryConfig } from './config';
 export { DEFAULT_MEMORY_CONFIG, resolveMemoryConfig } from './config';
 export { MemoryDisabledError, MemoryValidationError } from './errors';
 export type { MemoryGatewayOptions, ProposeMemoryInput, RecallMemoryInput, } from './gateway';
-export { createMemoryGateway, MemoryGateway } from './gateway';
+export { createConfiguredMemoryProvider, createMemoryGateway, MemoryGateway, } from './gateway';
 export { createMemoryLifecycleHooks, type MemoryLifecycleHookOptions, type MemoryLifecycleHooks, } from './injector';
 export { LocalJsonlMemoryProvider } from './local-jsonl-provider';
 export { buildRecallPromptBlock } from './prompt-block';
@@ -12,4 +12,5 @@ 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 { SQLiteMemoryProvider } from './sqlite-provider';
+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;
@@ -14,10 +19,12 @@ export interface MemoryRecallUsageEvent {
 export interface MemoryProvider {
     readonly name: string;
     initialize?(): Promise<void>;
+    close?(): Promise<void> | void;
     upsert(record: MemoryRecord): Promise<MemoryRecord>;
     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/sqlite-provider.d.ts

@@ -0,0 +1,39 @@
+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 SQLiteMemoryProvider implements MemoryProvider, MemoryProposalStore {
+    readonly name = "sqlite";
+    private readonly rootDirectory;
+    private readonly config;
+    private initialized;
+    private db;
+    private memories;
+    private proposals;
+    constructor(rootDirectory: string, config?: Partial<MemoryConfig>);
+    private databasePath;
+    initialize(): Promise<void>;
+    upsert(record: MemoryRecord): Promise<MemoryRecord>;
+    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>;
+    listProposals(filter?: {
+        status?: MemoryProposal['status'];
+        limit?: number;
+    }): Promise<MemoryProposal[]>;
+    close(): void;
+    private runMigrations;
+    private loadMemories;
+    private loadProposals;
+    private writeMemory;
+    private event;
+    private insertEvent;
+    private requireDb;
+}

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.33.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",