opencode-swarm 7.99.7 → 7.100.1

package/dist/lang/runtime.d.ts

@@ -1,3 +1,4 @@
+import { existsSync } from 'node:fs';
 import type { Parser as ParserType } from 'web-tree-sitter';
 export type Parser = ParserType;
 /**
@@ -21,6 +22,8 @@ export declare const _internals: {
     parserInit: (opts?: {
         locateFile: (scriptName: string) => string;
     }) => Promise<void>;
+    getModuleDir: () => string;
+    fileExists: typeof existsSync;
 };
 /**
  * Pure path resolver for the grammars directory given a base directory.

package/dist/memory/config.d.ts

@@ -37,6 +37,26 @@ export interface MemoryConfig {
     /** Reflection / consolidation pass (issue #1464, Phase 3). */
     consolidation: ConsolidationConfig;
     hardDelete: boolean;
+    embeddings: {
+        enabled: boolean;
+        model: string;
+        dimension: number;
+        version?: string;
+        cacheSize: number;
+    };
+    retrieval: {
+        rrfK: number;
+        weights: {
+            lexical: number;
+            dense: number;
+            metadata: number;
+        };
+        rerank: {
+            enabled: boolean;
+            model?: string;
+        };
+        latencyBudgetMs: number;
+    };
 }
 export interface ImportanceConfig {
     wRecency: number;
@@ -67,6 +87,24 @@ export interface ConsolidationConfig {
 export declare const DEFAULT_DECAY_HALF_LIFE_DAYS: Record<MemoryKind, number>;
 export declare const DEFAULT_IMPORTANCE_CONFIG: ImportanceConfig;
 export declare const DEFAULT_CONSOLIDATION_CONFIG: ConsolidationConfig;
+export declare const DEFAULT_EMBEDDINGS_CONFIG: {
+    enabled: boolean;
+    model: string;
+    dimension: number;
+    cacheSize: number;
+};
+export declare const DEFAULT_RETRIEVAL_CONFIG: {
+    rrfK: number;
+    weights: {
+        lexical: number;
+        dense: number;
+        metadata: number;
+    };
+    rerank: {
+        enabled: boolean;
+    };
+    latencyBudgetMs: number;
+};
 export declare const DEFAULT_MEMORY_CONFIG: MemoryConfig;
 export declare const DURABLE_MEMORY_KINDS: ReadonlySet<MemoryKind>;
 export declare const EVIDENCE_REQUIRED_KINDS: ReadonlySet<MemoryKind>;

package/dist/memory/embeddings/cache.d.ts

@@ -0,0 +1,25 @@
+import type { EmbeddingCacheEntry } from './types';
+export declare class EmbeddingCache {
+    private readonly cache;
+    private readonly maxSize;
+    constructor(maxSize?: number);
+    /** Number of entries currently in the cache. */
+    get size(): number;
+    /**
+     * Retrieve a cached entry, marking it as recently used.
+     * Returns undefined if the key is not present.
+     */
+    get(modelVersion: string, query: string): EmbeddingCacheEntry | undefined;
+    /**
+     * Store an entry in the cache. Evicts the least-recently-used entry
+     * if the cache is at capacity before inserting.
+     */
+    set(modelVersion: string, query: string, entry: EmbeddingCacheEntry): void;
+    /**
+     * Check whether an entry exists for the given modelVersion and query,
+     * without altering LRU ordering.
+     */
+    has(modelVersion: string, query: string): boolean;
+    /** Remove all entries from the cache. Called on store reset / reindex. */
+    clear(): void;
+}

package/dist/memory/embeddings/fusion.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Reciprocal Rank Fusion (RRF) + score normalization for multi-channel
+ * memory recall. Pure functions — no I/O, no side effects.
+ *
+ * RRF formula per channel:
+ *   contribution = weight * (1 / (rrfK + rank))
+ *
+ * where rank is 1-indexed (position + 1) for ids present in that channel;
+ * ids absent from a channel contribute 0 from it. Contributions are summed
+ * across the three channels for each unique id.
+ *
+ * The raw fused score is bounded by construction (each RRF term is ≤ 1/rrfK
+ * when weight ≤ 1). The final output is min-max normalised across the result
+ * set so the top result is always 1.0 and all scores fall in [0, 1].
+ *
+ * Lexical raw-score normalisation: the lexical channel produces an unnormalised
+ * weighted sum whose maximum is the sum of SCORING_WEIGHTS (1.13, see
+ * src/memory/scoring.ts:27-37). Callers that need to mix raw lexical scores
+ * with other [0,1] signals can use `normalizeLexicalScore`.
+ */
+/**
+ * Sum of all scoring weight coefficients in src/memory/scoring.ts.
+ * Dividing a raw lexical score by this value maps it to [0, 1].
+ *
+ * Derived from SCORING_WEIGHTS:
+ *   0.38 + 0.16 + 0.12 + 0.08 + 0.08 + 0.12 + 0.06 + 0.05 + 0.08 = 1.13
+ */
+export declare const LEXICAL_WEIGHT_SUM = 1.13;
+export interface FusedCandidate {
+    id: string;
+    fusedScore: number;
+    lexicalRank: number | null;
+    denseRank: number | null;
+    metadataRank: number | null;
+}
+export interface FusionWeights {
+    lexical: number;
+    dense: number;
+    metadata: number;
+}
+/**
+ * Normalise a raw lexical score to [0, 1] by dividing by LEXICAL_WEIGHT_SUM.
+ * The result is clamped so callers never receive an out-of-range value.
+ */
+export declare function normalizeLexicalScore(raw: number): number;
+/**
+ * Reciprocal Rank Fusion across three ranked id lists.
+ *
+ * @param lexicalRankedIds   best-first list; position 0 → rank 1
+ * @param denseRankedIds     best-first list; position 0 → rank 1
+ * @param metadataRankedIds  best-first list; position 0 → rank 1
+ * @param weights            per-channel weights
+ * @param rrfK               rank-smoothing constant (default 60 in config)
+ * @returns FusedCandidate[] sorted by fusedScore descending, scores in [0, 1]
+ */
+export declare function fuseRankings(lexicalRankedIds: string[], denseRankedIds: string[], metadataRankedIds: string[], weights: FusionWeights, rrfK: number): FusedCandidate[];

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

@@ -0,0 +1,57 @@
+import type { EmbeddingProvider } from './types';
+export declare const _internals: {
+    /**
+     * Exposed for direct unit testing — do not call from production code.
+     * Verifies .swarm containment by checking path segments post-resolution.
+     */
+    resolveEmbeddingCacheDir(): string;
+};
+/**
+ * Embedding provider backed by @xenova/transformers (ONNX Runtime WASM).
+ *
+ * The transformers dependency is loaded lazily on first embed()/embedBatch()
+ * via createRequire(import.meta.url) — never at module scope — so the plugin
+ * bundle remains Node-ESM-loadable even when @xenova/transformers is not installed.
+ *
+ * Graceful degradation (FR-003): if the package is missing or the model fails
+ * to load, available is set to false and embed() rejects with EmbeddingUnavailableError.
+ */
+export declare class LocalEmbeddingProvider implements EmbeddingProvider {
+    private readonly modelName;
+    /** The dimension of vectors this provider emits (e.g. 384 for all-MiniLM-L6-v2). */
+    readonly dimension: number;
+    /** The pinned model+dimension version identifier this provider produces. */
+    readonly modelVersion: string;
+    private _available;
+    /** Cached failure flag — prevents repeated failed require() calls on every embed(). */
+    private loadFailed;
+    private pipeline;
+    /** One-time download notice guard — prints once per process. */
+    private static downloadNoticePrinted;
+    constructor(config: {
+        model: string;
+        dimension: number;
+        version?: string;
+    });
+    /** false until the model pipeline loads successfully; true after. */
+    get available(): boolean;
+    /**
+     * Lazily load @xenova/transformers and initialize the feature-extraction pipeline.
+     * Returns the pipeline function, or null if loading failed (graceful degradation).
+     */
+    private ensurePipeline;
+    /**
+     * Compute an embedding vector for a single text.
+     * Rejects with EmbeddingUnavailableError if the provider is not available.
+     */
+    embed(text: string): Promise<Float32Array>;
+    /**
+     * Compute embeddings for a batch of texts. Order preserved.
+     * Rejects with EmbeddingUnavailableError if the provider is not available.
+     */
+    embedBatch(texts: string[]): Promise<Float32Array[]>;
+    /** Convert a @xenova/transformers output tensor to a Float32Array. */
+    private tensorToFloat32Array;
+    /** Split a batch tensor [batchSize, dim] into an array of Float32Array. */
+    private tensorToFloat32ArrayBatch;
+}

package/dist/memory/embeddings/reranker.d.ts

@@ -0,0 +1,42 @@
+export interface RerankCandidate {
+    id: string;
+    text: string;
+    score?: number;
+}
+/**
+ * Latency gate: skip reranking when the previous recall step already
+ * exceeded the caller's latency budget.
+ */
+export declare function shouldRerank(previousRecallElapsedMs: number, latencyBudgetMs: number): boolean;
+/**
+ * Cross-encoder reranker backed by @xenova/transformers (ONNX Runtime WASM).
+ *
+ * The transformers dependency is loaded lazily on first rerank() via
+ * createRequire(import.meta.url) — never at module scope — so importing
+ * this module does not pull in @xenova/transformers at load time.
+ *
+ * Graceful degradation: if the package is missing or the model fails to
+ * load, `available` is false and rerank() returns candidates unchanged.
+ */
+export declare class CrossEncoderReranker {
+    private readonly options;
+    private loadFailed;
+    private _available;
+    private pipeline;
+    constructor(options: {
+        model?: string;
+    });
+    get available(): boolean;
+    /**
+     * Lazily load @xenova/transformers and initialise the text-classification
+     * (cross-encoder) pipeline. Returns the pipeline, or null on failure.
+     */
+    private ensurePipeline;
+    /**
+     * Reorder candidates by cross-encoder relevance to the query.
+     *
+     * Returns the top `topN` candidates sorted descending by cross-encoder
+     * score. If the model is unavailable, returns candidates unchanged.
+     */
+    rerank(candidates: RerankCandidate[], query: string, topN?: number): Promise<RerankCandidate[]>;
+}

package/dist/memory/embeddings/types.d.ts

@@ -0,0 +1,27 @@
+export interface EmbeddingProvider {
+    /** Compute an embedding vector for a single text. Reject if the provider is unavailable. */
+    embed(text: string): Promise<Float32Array>;
+    /** Compute embeddings for a batch of texts. Order preserved. Reject if unavailable. */
+    embedBatch(texts: string[]): Promise<Float32Array[]>;
+    /** The pinned model+dimension version identifier this provider produces. Used for cross-version mismatch detection. */
+    readonly modelVersion: string;
+    /** The dimension of vectors this provider emits (e.g. 384 for all-MiniLM-L6-v2). */
+    readonly dimension: number;
+    /** false when the underlying dependency/model is not installed or failed to load — caller must fall back to lexical-only. */
+    readonly available: boolean;
+}
+/** A pinned model+dimension identifier string (e.g. "Xenova/all-MiniLM-L6-v2:384"). */
+export type EmbeddingVersion = string;
+export interface EmbeddingCacheEntry {
+    vector: Float32Array;
+    modelVersion: string;
+    queryHash: string;
+}
+export declare class EmbeddingUnavailableError extends Error {
+    constructor(message?: string);
+}
+export declare class EmbeddingVersionMismatchError extends Error {
+    readonly queryVersion: string;
+    readonly storedVersion: string;
+    constructor(queryVersion: string, storedVersion: string);
+}

package/dist/memory/scoring.d.ts

@@ -6,6 +6,7 @@ export interface RecallScoringDiagnostics {
     returnedCount: number;
     noSignalCount: number;
     belowThresholdCount: number;
+    fusionActive?: boolean;
 }
 /**
  * Recall scoring weight coefficients. Sum is 1.13 (scores are an unnormalised

package/dist/memory/sqlite-provider.d.ts

@@ -23,6 +23,10 @@ export declare class SQLiteMemoryProvider implements MemoryProvider, MemoryPropo
     private initPromise;
     private db;
     private ftsAvailable;
+    private vecAvailable;
+    private embeddingProvider;
+    private embeddingCache;
+    private reranker;
     private memories;
     private proposals;
     private lastAutomaticJsonlMigration;
@@ -50,6 +54,16 @@ export declare class SQLiteMemoryProvider implements MemoryProvider, MemoryPropo
     }): Promise<MemoryProposal[]>;
     applyCuratorDecision(decision: ResolvedCuratorMemoryDecision): Promise<AppliedMemoryChange>;
     close(): void;
+    /**
+     * Re-embed all durable memory records with the current embedding provider
+     * model, update the stored global model_version, and clear the embedding
+     * cache. This is the recovery path for EmbeddingVersionMismatchError.
+     *
+     * No-op (with a warning) when vec or the embedding provider is unavailable.
+     * Individual record failures are caught per-record so one bad embedding
+     * does not abort the whole rebuild.
+     */
+    rebuildEmbeddingIndex(): Promise<void>;
     importJsonl(): Promise<SQLiteJsonlImportResult>;
     exportJsonl(): Promise<{
         directory: string;
@@ -62,9 +76,12 @@ export declare class SQLiteMemoryProvider implements MemoryProvider, MemoryPropo
     hasMigration(name: string): boolean;
     markMigration(version: number, name: string): void;
     private selectRecallCandidates;
+    private getStoredModelVersion;
+    private selectDenseCandidates;
     private runMigrations;
     private backfillScopeKeys;
     private initializeFtsIndex;
+    private initializeVecExtension;
     private recreateFtsIndex;
     private rebuildFtsIndex;
     private countValidMemoryRows;
@@ -74,7 +91,9 @@ export declare class SQLiteMemoryProvider implements MemoryProvider, MemoryPropo
     private loadProposals;
     private writeMemory;
     private writeMemoryFts;
+    private writeMemoryVec;
     private deleteMemoryFts;
+    private deleteMemoryVec;
     private writeProposal;
     private applyDecisionToStorage;
     private readPendingProposal;

package/package.json

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

package/tests/fixtures/memory-recall/paraphrase-auth.json

@@ -0,0 +1,64 @@
+{
+	"name": "paraphrase-auth",
+	"query": "how do I handle a failed login",
+	"task": "Handle failed login authentication securely.",
+	"agentRole": "security-engineer",
+	"scopes": [
+		{
+			"type": "repository",
+			"repoId": "opencode-swarm"
+		}
+	],
+	"kinds": ["security_note", "code_pattern"],
+	"k": 2,
+	"maxItems": 2,
+	"tokenBudget": 1000,
+	"expectedLabels": ["auth-failure-bcrypt"],
+	"records": [
+		{
+			"label": "auth-failure-bcrypt",
+			"scope": {
+				"type": "repository",
+				"repoId": "opencode-swarm"
+			},
+			"kind": "security_note",
+			"text": "bcrypt session invalidation on authentication failure",
+			"tags": ["session", "invalidation", "bcrypt"],
+			"confidence": 0.95,
+			"source": {
+				"type": "manual",
+				"ref": "auth-failure-bcrypt"
+			}
+		},
+		{
+			"label": "auth-noise-1",
+			"scope": {
+				"type": "repository",
+				"repoId": "opencode-swarm"
+			},
+			"kind": "code_pattern",
+			"text": "Handle failed login by clearing active user tokens.",
+			"tags": ["login", "token", "clear"],
+			"confidence": 0.9,
+			"source": {
+				"type": "file",
+				"filePath": "src/auth/token.ts"
+			}
+		},
+		{
+			"label": "auth-noise-2",
+			"scope": {
+				"type": "repository",
+				"repoId": "opencode-swarm"
+			},
+			"kind": "code_pattern",
+			"text": "Login failures should redirect to the password reset page.",
+			"tags": ["login", "failure", "redirect"],
+			"confidence": 0.85,
+			"source": {
+				"type": "file",
+				"filePath": "src/auth/redirect.ts"
+			}
+		}
+	]
+}

package/tests/fixtures/memory-recall/paraphrase-concurrency.json

@@ -0,0 +1,64 @@
+{
+	"name": "paraphrase-concurrency",
+	"query": "running tasks in parallel safely",
+	"task": "Run tasks in parallel without race conditions.",
+	"agentRole": "backend-engineer",
+	"scopes": [
+		{
+			"type": "repository",
+			"repoId": "opencode-swarm"
+		}
+	],
+	"kinds": ["code_pattern", "failure_pattern"],
+	"k": 2,
+	"maxItems": 2,
+	"tokenBudget": 1000,
+	"expectedLabels": ["concurrency-mutex-deadlock"],
+	"records": [
+		{
+			"label": "concurrency-mutex-deadlock",
+			"scope": {
+				"type": "repository",
+				"repoId": "opencode-swarm"
+			},
+			"kind": "code_pattern",
+			"text": "mutex lock contention deadlock avoidance",
+			"tags": ["concurrency", "mutex", "deadlock"],
+			"confidence": 0.95,
+			"source": {
+				"type": "manual",
+				"ref": "concurrency-mutex-deadlock"
+			}
+		},
+		{
+			"label": "concurrency-noise-1",
+			"scope": {
+				"type": "repository",
+				"repoId": "opencode-swarm"
+			},
+			"kind": "code_pattern",
+			"text": "Parallel tasks should use mutex locks to avoid race conditions.",
+			"tags": ["parallel", "mutex", "race"],
+			"confidence": 0.9,
+			"source": {
+				"type": "file",
+				"filePath": "src/concurrency/mutex.ts"
+			}
+		},
+		{
+			"label": "concurrency-noise-2",
+			"scope": {
+				"type": "repository",
+				"repoId": "opencode-swarm"
+			},
+			"kind": "failure_pattern",
+			"text": "Running tasks in parallel caused data corruption due to unsynchronized access.",
+			"tags": ["parallel", "corruption", "unsynchronized"],
+			"confidence": 0.85,
+			"source": {
+				"type": "file",
+				"filePath": "src/concurrency/race.ts"
+			}
+		}
+	]
+}

package/tests/fixtures/memory-recall/paraphrase-deployment.json

@@ -0,0 +1,64 @@
+{
+	"name": "paraphrase-deployment",
+	"query": "ship code to production",
+	"task": "Deploy code to production safely.",
+	"agentRole": "devops-engineer",
+	"scopes": [
+		{
+			"type": "repository",
+			"repoId": "opencode-swarm"
+		}
+	],
+	"kinds": ["repo_convention", "code_pattern"],
+	"k": 2,
+	"maxItems": 2,
+	"tokenBudget": 1000,
+	"expectedLabels": ["deployment-cicd-pipeline"],
+	"records": [
+		{
+			"label": "deployment-cicd-pipeline",
+			"scope": {
+				"type": "repository",
+				"repoId": "opencode-swarm"
+			},
+			"kind": "repo_convention",
+			"text": "continuous integration deployment pipeline release",
+			"tags": ["deployment", "ci", "cd"],
+			"confidence": 0.95,
+			"source": {
+				"type": "manual",
+				"ref": "deployment-cicd-pipeline"
+			}
+		},
+		{
+			"label": "deployment-noise-1",
+			"scope": {
+				"type": "repository",
+				"repoId": "opencode-swarm"
+			},
+			"kind": "code_pattern",
+			"text": "Ship code to production through the CI/CD pipeline.",
+			"tags": ["ship", "production", "pipeline"],
+			"confidence": 0.9,
+			"source": {
+				"type": "file",
+				"filePath": "src/deploy/pipeline.ts"
+			}
+		},
+		{
+			"label": "deployment-noise-2",
+			"scope": {
+				"type": "repository",
+				"repoId": "opencode-swarm"
+			},
+			"kind": "repo_convention",
+			"text": "Production deployments require manual approval before release.",
+			"tags": ["production", "deployment", "approval"],
+			"confidence": 0.85,
+			"source": {
+				"type": "file",
+				"filePath": "docs/deployment.md"
+			}
+		}
+	]
+}