opencode-swarm 7.154.3 → 7.155.0

package/dist/memory/reflection-service.d.ts

@@ -1,7 +1,9 @@
+import { queryNodeByFile, resolveGraphStorageMode } from '../tools/repo-graph/indexed-storage';
+import type { RepoGraph } from '../tools/repo-graph/types';
 import { type MemoryConfig } from './config';
 import { type MemoryGateway, type RecordMemoryOutcomeInput } from './gateway';
-import { type ReflectionDigest } from './reflection';
-import type { MemoryOutcome, MemoryRecord } from './types';
+import { type ReflectionAnchorStatus, type ReflectionDigest } from './reflection';
+import type { MemoryAnchor, MemoryOutcome, MemoryRecord } from './types';
 interface OutcomeWriteThroughBase {
     record: MemoryRecord;
     eventId: string;
@@ -49,12 +51,16 @@ export declare const _test_exports: {
     isReflectionEligible: typeof isReflectionEligible;
     prepareWriteThroughEntry: typeof prepareWriteThroughEntry;
     sanitizeReflectionRecord: typeof sanitizeReflectionRecord;
+    createAnchorResolver: typeof createAnchorResolver;
 };
 export declare const _internals: {
     withReflectionLock: typeof withReflectionLock;
     serializeDigestArtifacts: typeof serializeDigestArtifacts;
     boundDigest: typeof boundDigest;
+    resolveGraphStorageMode: typeof resolveGraphStorageMode;
+    queryNodeByFile: typeof queryNodeByFile;
 };
+declare function createAnchorResolver(directory: string, graph: RepoGraph | null): (anchor: MemoryAnchor) => ReflectionAnchorStatus;
 declare function withReflectionLock<T>(directory: string, fn: () => Promise<T>): Promise<T>;
 interface ReflectionArtifactPair {
     markdown: string;

package/dist/memory/schema.d.ts

@@ -10,8 +10,8 @@ export declare const MemoryScopeTypeSchema: z.ZodEnum<{
     project: "project";
     workspace: "workspace";
     run: "run";
-    global_user: "global_user";
     repository: "repository";
+    global_user: "global_user";
     cohort: "cohort";
 }>;
 export declare const MemoryScopeRefSchema: z.ZodObject<{
@@ -20,8 +20,8 @@ export declare const MemoryScopeRefSchema: z.ZodObject<{
         project: "project";
         workspace: "workspace";
         run: "run";
-        global_user: "global_user";
         repository: "repository";
+        global_user: "global_user";
         cohort: "cohort";
     }>;
     userId: z.ZodOptional<z.ZodString>;
@@ -77,8 +77,8 @@ export declare const MemoryRecordSchema: z.ZodObject<{
             project: "project";
             workspace: "workspace";
             run: "run";
-            global_user: "global_user";
             repository: "repository";
+            global_user: "global_user";
             cohort: "cohort";
         }>;
         userId: z.ZodOptional<z.ZodString>;
@@ -171,8 +171,8 @@ export declare const MemoryProposalSchema: z.ZodObject<{
                 project: "project";
                 workspace: "workspace";
                 run: "run";
-                global_user: "global_user";
                 repository: "repository";
+                global_user: "global_user";
                 cohort: "cohort";
             }>;
             userId: z.ZodOptional<z.ZodString>;

package/dist/tools/repo-graph/indexed-storage.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Derived SQLite index for the repo dependency graph (issue #1534).
+ *
+ * `.swarm/repo-graph.json` stays the single authoritative document in BOTH
+ * storage modes. When `repo_graph.storage === 'indexed'`, `saveGraph` also
+ * maintains `.swarm/repo-memory.sqlite`, a *derived accelerator* whose only job
+ * is to answer "give me the neighbourhood of these files" without parsing the
+ * whole JSON document. It returns an ordinary `RepoGraph` value that is fed to
+ * the existing, unmodified `getGraphNode` / `getLocalizationContext` /
+ * `getBlastRadius`, so no query logic is duplicated here.
+ *
+ * Every read verifies, before returning anything:
+ *   (a) the persisted `graph_meta.workspace_root` realpath-matches the ACTIVE
+ *       workspace (same trust boundary as `bindGraphToWorkspace`,
+ *       `storage.ts:100-127`), and
+ *   (b) `graph_meta.source_size` / `source_mtime_ms` equal a live stat of
+ *       `repo-graph.json`.
+ * Any mismatch, absence, or error returns null and the caller uses its
+ * existing JSON path. The index is never a second source of truth.
+ *
+ * Runtime portability (AGENTS.md invariant 2): the SQLite driver is resolved
+ * ONLY through `src/db/sqlite-loader.ts`. The `import type` below is erased at
+ * build time, so this module contributes no `bun:` runtime resolution.
+ * `node:sqlite` is stricter than `bun:sqlite` about bound parameters, so every
+ * statement's placeholder count equals its argument count exactly and
+ * no-placeholder statements are issued as `db.run(sql)` with no array.
+ */
+import type { GraphNode, RepoGraph } from './types';
+/** Filename of the derived index inside `.swarm/`. */
+export declare const REPO_MEMORY_FILENAME = "repo-memory.sqlite";
+/**
+ * Validated absolute path to `.swarm/repo-memory.sqlite`.
+ * Mirrors `getGraphPath`: validateWorkspace → validateSwarmPath →
+ * validateSymlinkBoundary.
+ */
+export declare function getRepoMemoryPath(workspace: string): string;
+/**
+ * Close the cached connection for a workspace. Called by the `/swarm close`
+ * clean stage before unlinking the store (Windows holds a WAL-mode file open,
+ * so `unlink` would fail with EBUSY — same guard as
+ * `closeProjectDb`, `project-db.ts:232-234`) and from test teardown.
+ */
+export declare function closeRepoMemory(workspace: string): void;
+/**
+ * Close every cached connection. Test-teardown only: `/swarm close` uses the
+ * singular `closeRepoMemory` (src/commands/close.ts); this export has no
+ * other production caller.
+ */
+export declare function closeAllRepoMemory(): void;
+/**
+ * Delete the derived store and its WAL sidecars.
+ *
+ * The cached handle is closed FIRST on every delete path — a live WAL-mode
+ * connection keeps the file open and Windows `unlink` fails with EBUSY
+ * otherwise.
+ */
+export declare function deleteRepoMemory(workspace: string): void;
+/** Whether a SQLite driver is resolvable in this runtime. */
+export declare function isIndexedStorageAvailable(): boolean;
+/**
+ * Effective storage mode for a workspace.
+ *
+ * Config is the kill switch: flipping `repo_graph.storage` back to `'json'`
+ * stops every reader from consulting the index immediately, even while a valid
+ * store with a matching stamp is still on disk. Falls back to `'json'` on any
+ * config error and whenever no SQLite driver is available.
+ */
+export declare function resolveGraphStorageMode(workspace: string): 'json' | 'indexed';
+/**
+ * Test seam (invariant 7: DI over mock.module) so the driver-unavailable
+ * fallback of {@link resolveGraphStorageMode} is exercisable without patching
+ * the module graph. Tests swap and restore the property; production reads it
+ * unchanged.
+ */
+export declare const _internals: {
+    isIndexedStorageAvailable: typeof isIndexedStorageAvailable;
+};
+/**
+ * Replace the whole index from `graph` in one transaction.
+ *
+ * `stamp` MUST be a stat of the TEMP FILE, taken inside the save lock
+ * immediately BEFORE this writer's rename publishes it — not a stat of
+ * `repo-graph.json` at any point. `rename(2)` leaves the inode's mtime and size
+ * untouched, so the temp-file stat identifies THIS writer's own bytes. Any stat
+ * of the published path instead describes whatever is at that path by then: a
+ * concurrent writer that failed the lock renames unlocked (the JSON write is
+ * never lock-gated), so a post-rename stat would let ITS bytes validate an index
+ * holding THIS writer's superseded content. See `saveGraph`.
+ *
+ * Returns false — never throws — on every failure; the JSON write is the
+ * durability point and has already succeeded.
+ */
+export declare function syncIndexFromGraph(workspace: string, graph: RepoGraph, stamp: {
+    size: number;
+    mtimeMs: number;
+    ino: string;
+}): Promise<boolean>;
+/**
+ * Resolve a single file to its `GraphNode` using the index.
+ *
+ * Implements closure rule steps 1-2 in full, so an anchor whose `moduleName`
+ * diverges from `path.relative(root, filePath)` resolves exactly as it would
+ * through `getGraphNode` on the full graph. Returns null whenever the index is
+ * absent, stale, foreign, or unusable — the caller keeps its existing path.
+ */
+export declare function queryNodeByFile(workspace: string, file: string): GraphNode | null;
+/**
+ * Build a bounded subgraph covering `files` and their neighbourhood, suitable
+ * for feeding the unmodified `getLocalizationContext` / `getBlastRadius`.
+ *
+ * Closure rule (normative, from the approved plan):
+ *  1-2. resolve every requested file the way `getGraphNode` would;
+ *  3.   `T` = the union of resolved targets across ALL requested files in this
+ *       ONE call (`getBlastRadius` seeds `visited` with every target at once,
+ *       query.ts:623-625, so per-file subgraphs merged afterwards would produce
+ *       a different `totalDependents` and therefore a different `riskLevel`);
+ *       `N = T ∪ R_1..R_D ∪ F_1`, where `R` is the reverse closure to depth `D`
+ *       and `F_1` is the 1-hop forward set from the targets only
+ *       (`getDependencies`, query.ts:398-406);
+ *  4.   `E = { edge : source ∈ N AND target ∈ N }` — AND, not incidence. An OR
+ *       rule would admit frontier edges whose counterpart node is absent, and
+ *       `moduleNameForEdgePath` (query.ts:83-88) silently degrades to a
+ *       different string for those, changing `importers` / `dependencies` /
+ *       `directDependents`. No asset/kind filtering happens in SQL:
+ *       `buildReverseIndex` and `collectExternallyUsedSymbols` re-apply
+ *       `isAssetEdge` downstream, so over-inclusion is harmless while
+ *       under-inclusion is fatal;
+ *  5.   the returned `workspaceRoot` is the realpath-bound ACTIVE workspace,
+ *       never the persisted `graph_meta.workspace_root`.
+ *
+ * `depth` is clamped to at least 1: `getLocalizationContext` calls
+ * `getImporters` unconditionally, which needs `R_1` even when it passes
+ * `maxDepth = 0` to `getBlastRadius`. Over-inclusion of nodes is safe (a
+ * `maxDepth = 0` blast radius early-returns, query.ts:613-621).
+ */
+export declare function loadSubgraphForFiles(workspace: string, files: string[], depth: number): RepoGraph | null;

package/dist/tools/repo-graph/query.d.ts

@@ -1,6 +1,13 @@
 import type { FreshnessProbe } from './freshness';
 import type { BlastRadiusResult, CallerReference, ContextPackResult, ContextPackSourceMode, DeadExportsResult, FileOntology, FileReference, GraphHealthResult, GraphNode, LocalizationBlock, PackageBoundarySummary, RepoGraph, SymbolReference } from './types';
 export declare function getGraphNode(graph: RepoGraph, input: string): GraphNode | undefined;
+/**
+ * Drop every cached query index. Required after any in-place mutation of a
+ * graph's `nodes` or `edges` (see the {@link queryIndexCache} contract note),
+ * and retained as the test seam for index-staleness assertions. Reassigns a
+ * fresh `WeakMap` rather than deleting keys, so it invalidates graphs this
+ * module can no longer enumerate.
+ */
 export declare function resetQueryCache(): void;
 /**
  * @deprecated Graph age is not a content-freshness signal. Internal consumers

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.154.3",
+	"version": "7.155.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",
@@ -124,6 +124,7 @@
 		"check:gate-portability": "bun run scripts/check-gate-portability.ts",
 		"check:bare-spawn": "bun run scripts/check-bare-executable-spawn.ts",
 		"check:error-channel-discard": "bun run scripts/check-error-channel-discard.ts",
+		"check:registry-citations": "bun run scripts/check-registry-citations.ts",
 		"check:memory-recall": "bun run scripts/memory-recall-regression.ts"
 	},
 	"dependencies": {