opencode-swarm 7.87.3 → 7.88.1

package/dist/memory/config.d.ts

@@ -28,6 +28,7 @@ export interface MemoryConfig {
     maintenance: {
         lowUtilityMaxConfidence: number;
         lowUtilityMinAgeDays: number;
+        autoCompactEveryNRecalls?: number;
     };
     hardDelete: boolean;
 }

package/dist/memory/gateway.d.ts

@@ -32,6 +32,7 @@ export declare class MemoryGateway {
     private readonly config;
     private readonly provider;
     private readonly now;
+    private disposed;
     constructor(context: MemoryContext, options?: MemoryGatewayOptions);
     isEnabled(): boolean;
     dispose(): Promise<void>;

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

@@ -0,0 +1,50 @@
+import type { MemoryConfig } from './config';
+import type { MemoryProposalStore, MemoryProvider } from './provider';
+/**
+ * Return true if the provider is currently managed by the pool.
+ *
+ * Pooled providers have a `close()` that delegates to `releaseProvider`.
+ * Any caller (gateway, commands, tools) can safely call `close()` to release
+ * its reference; the pool handles refcount tracking and real close on drain.
+ */
+export declare function isPooledProvider(provider: MemoryProvider & Partial<MemoryProposalStore>): boolean;
+/**
+ * Return an existing provider for `directory`, or create and cache a new one.
+ *
+ * The pool key is the canonical absolute path returned by `realpathSync(directory)`.
+ * If `realpathSync` fails (broken symlink, permission error, etc.) the resolved
+ * absolute path is used as a fallback key.
+ *
+ * Every access (hit or miss) updates the LRU ordering so the most-used entries
+ * survive eviction. Cache hits increment the reference count so the pool knows
+ * how many active callers are using the provider.
+ *
+ * Note: this function returns synchronously. The provider's actual database
+ * open happens lazily inside `provider.initialize()`, which callers await
+ * separately (and which is protected by the provider's own init mutex).
+ */
+export declare function getOrCreateProvider(directory: string, config: MemoryConfig): MemoryProvider & MemoryProposalStore;
+/**
+ * Release a pooled provider back to the pool by decrementing its refCount.
+ *
+ * **Lifecycle contract:** refCount is per-PROVIDER, not per-ACQUISITION.
+ * Each acquisition (getOrCreateProvider call) MUST be released exactly once
+ * via provider.close() (which calls releaseProvider internally) or
+ * MemoryGateway.dispose() (which is one-shot via a `disposed` flag).
+ *
+ * Calling close() MORE THAN ONCE per acquisition may corrupt refCount.
+ * MemoryGateway prevents this with its one-shot dispose flag. Callers that
+ * use provider.close() directly (e.g., commands/memory.ts) must ensure
+ * they call it exactly once per acquisition — typically by using the
+ * provider in a single synchronous or try/finally block.
+ *
+ * Idle entries (refCount=0) remain in the pool for reuse until LRU eviction.
+ * Active entries (refCount>0) are deferred-closed on eviction until all
+ * references release.
+ */
+export declare function releaseProvider(provider: MemoryProvider & Partial<MemoryProposalStore>): void;
+/**
+ * Evict and close every cached provider. Intended for test teardown only —
+ * production code should rely on LRU eviction.
+ */
+export declare function clearPool(): void;

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

@@ -26,6 +26,8 @@ export declare class SQLiteMemoryProvider implements MemoryProvider, MemoryPropo
     private memories;
     private proposals;
     private lastAutomaticJsonlMigration;
+    private recallCountSinceLastCompaction;
+    private isCompacting;
     constructor(rootDirectory: string, config?: Partial<MemoryConfig>);
     private databasePath;
     initialize(): Promise<void>;
@@ -61,6 +63,7 @@ export declare class SQLiteMemoryProvider implements MemoryProvider, MemoryPropo
     markMigration(version: number, name: string): void;
     private selectRecallCandidates;
     private runMigrations;
+    private backfillScopeKeys;
     private initializeFtsIndex;
     private recreateFtsIndex;
     private rebuildFtsIndex;

package/dist/tools/index.d.ts

@@ -39,6 +39,7 @@ export { knowledge_recall } from './knowledge-recall';
 export { knowledge_receipt } from './knowledge-receipt';
 export { knowledge_remove } from './knowledge-remove';
 export { lint } from './lint';
+export { parse_lane_candidates } from './parse-lane-candidates';
 export { phase_complete } from './phase-complete';
 export { pkg_audit } from './pkg-audit';
 export { type PlaceholderFinding, type PlaceholderScanInput, type PlaceholderScanResult, placeholder_scan, placeholderScan, } from './placeholder-scan';

package/dist/tools/manifest.d.ts

@@ -48,6 +48,7 @@ export declare const TOOL_MANIFEST: {
     sbom_generate: () => ToolDefinition;
     checkpoint: () => ToolDefinition;
     pkg_audit: () => ToolDefinition;
+    parse_lane_candidates: () => ToolDefinition;
     test_runner: () => ToolDefinition;
     test_impact: () => ToolDefinition;
     mutation_test: () => ToolDefinition;

package/dist/tools/parse-lane-candidates.d.ts

@@ -0,0 +1,2 @@
+import { createSwarmTool } from './create-tool';
+export declare const parse_lane_candidates: ReturnType<typeof createSwarmTool>;

package/dist/tools/tool-metadata.d.ts

@@ -123,6 +123,10 @@ export declare const TOOL_METADATA: {
         description: string;
         agents: ("reviewer" | "test_engineer" | "critic_hallucination_verifier" | "critic_oversight" | "architect")[];
     };
+    parse_lane_candidates: {
+        description: string;
+        agents: "architect"[];
+    };
     test_runner: {
         description: string;
         agents: ("reviewer" | "test_engineer" | "architect")[];

package/package.json

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