opencode-swarm 7.121.2 → 7.121.4

package/dist/cli/index.js

@@ -7,7 +7,7 @@ import {
   getPluginLockFilePaths,
   package_default,
   resolveCommand
-} from "./index-y0qa3xf0.js";
+} from "./index-q0fv0xec.js";
 import"./index-kyvg2cmp.js";
 import"./index-vqcgmy4y.js";
 import"./index-emkb0bbe.js";

package/dist/commands/design-docs.d.ts

@@ -3,4 +3,8 @@
  * Sanitizes the description, parses flags, and emits a DESIGN_DOCS mode signal
  * that routes the architect into the design-doc generation/sync workflow.
  */
+import { loadPluginConfigWithMeta } from '../config';
+export declare const _internals: {
+    loadPluginConfigWithMeta: typeof loadPluginConfigWithMeta;
+};
 export declare function handleDesignDocsCommand(directory: string, args: string[]): Promise<string>;

package/dist/commands/pr-feedback.d.ts

@@ -1,22 +1,22 @@
 /**
  * Handle /swarm pr-feedback command.
  *
- * Triggers the architect to enter MODE: PR_FEEDBACK — the swarm workflow for
+ * Triggers the architect to enter MODE: PR_FEEDBACK — the swarm workflow for
  * ingesting and closing KNOWN pull-request feedback (review comments, requested
  * changes, CI failures, merge conflicts, stale branches, pasted notes). This is
  * distinct from /swarm pr-review, which discovers NEW findings.
  *
  * Input contract (PR reference is optional):
- *   /swarm pr-feedback 155                         → feedback pass on PR 155
- *   /swarm pr-feedback 155 also fix the lint errors → PR 155 + extra instructions
+ *   /swarm pr-feedback 155                         → feedback pass on PR 155
+ *   /swarm pr-feedback 155 also fix the lint errors → PR 155 + extra instructions
  *   /swarm pr-feedback 155 continue from .swarm/pr-review/<run_id>/feedback-handoff.md
  *                                                   -> PR 155 + handoff path instructions
- *   /swarm pr-feedback owner/repo#155               → shorthand
+ *   /swarm pr-feedback owner/repo#155               → shorthand
  *   /swarm pr-feedback https://github.com/.../pull/155
- *   /swarm pr-feedback                              → bare signal; architect builds
+ *   /swarm pr-feedback                              → bare signal; architect builds
  *                                                     the ledger from current PR/branch
  *   /swarm pr-feedback address the review notes about error handling
- *                                                   → no parseable PR ref ⇒ the whole
+ *                                                   → no parseable PR ref ⇒ the whole
  *                                                     input is forwarded as instructions
  *
  * PR-reference parsing and injection-hardening are shared with /swarm pr-review

package/dist/db/index.d.ts

@@ -7,7 +7,11 @@
  *   normalized directory path.
  * - `qa-gate-profile`: service layer for per-plan QA gate profiles stored
  *   in the project DB.
+ * - `sqlite-loader`: runtime-portable SQLite `Database` constructor resolver
+ *   (native `bun:sqlite` under Bun, a `node:sqlite` adapter under Node — issue
+ *   #1873). Used by `global-db`, `project-db`, and the memory SQLite provider.
  */
 export { closeGlobalDb, getGlobalDb, runGlobalMigrations, } from './global-db.js';
 export { closeAllProjectDbs, closeProjectDb, getProjectDb, projectDbExists, projectDbPath, runProjectMigrations, } from './project-db.js';
 export { computeProfileHash, DEFAULT_QA_GATES, getEffectiveGates, getOrCreateProfile, getProfile, lockProfile, type QaGateProfile, type QaGates, setGates, } from './qa-gate-profile.js';
+export { loadDatabaseCtor } from './sqlite-loader.js';

package/dist/db/sqlite-loader.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Runtime-portable SQLite driver loader for opencode-swarm.
+ *
+ * Why this exists (issue #1873): the published plugin bundle (`dist/index.js`) is
+ * built `--target node` and OpenCode Desktop loads it inside a **Node.js** Electron
+ * `utilityProcess` sidecar. The previous DB layer resolved the driver with a lazy
+ * `createRequire(import.meta.url)('bun:sqlite')` and **no fallback**. `bun:sqlite` is
+ * a Bun-only built-in, so under Node every SQLite-backed tool threw
+ * `Error: Cannot find module 'bun:sqlite'` (`swarm_memory_recall`, the QA-gate tools,
+ * `get_approved_plan`, …).
+ *
+ * The lazy require kept `bun:sqlite` out of the bundle's top-level ESM imports (which
+ * is what invariant #2 / issue #675 requires — a static `import … from 'bun:…'` breaks
+ * Node's ESM resolver with `ERR_UNSUPPORTED_ESM_URL_SCHEME`), but it still assumed a
+ * Bun runtime at call time.
+ *
+ * This module is the single, sanctioned place that resolves a `bun:sqlite`-shaped
+ * `Database` constructor:
+ *   1. Under Bun: return the native `bun:sqlite` `Database` (behaviour unchanged).
+ *   2. Under Node: wrap `node:sqlite`'s `DatabaseSync` (flag-free in Node 22.13+; added
+ *      behind `--experimental-sqlite` in 22.5; shipped by Electron 42+) in a small
+ *      adapter that presents the exact `Database` subset the
+ *      codebase uses — `run(sql, params?)`, `query(sql).{get,all,iterate}`,
+ *      `transaction(fn)`, `inTransaction`, `loadExtension(path)`, `close()`. A bare
+ *      constructor swap is NOT enough: `DatabaseSync` has none of
+ *      `run/query/transaction/inTransaction`.
+ *   3. If neither driver is available: throw one clear, combined diagnostic.
+ *
+ * Portability contract (invariant #2): all three former call sites
+ * (`project-db.ts`, `global-db.ts`, `memory/sqlite-provider.ts`) now import
+ * `loadDatabaseCtor` from here. No new lazy `require('bun:…')` may be added elsewhere —
+ * `tests/unit/build/bundle-portability.test.ts` enforces this statically, and
+ * `scripts/repro-1873.mjs` exercises the real Node driver end-to-end in CI.
+ */
+import type { Database } from 'bun:sqlite';
+interface NodeStatementSync {
+    get(...params: unknown[]): unknown;
+    all(...params: unknown[]): unknown[];
+    iterate(...params: unknown[]): IterableIterator<unknown>;
+    run(...params: unknown[]): {
+        changes: number | bigint;
+        lastInsertRowid: number | bigint;
+    };
+}
+interface NodeDatabaseSync {
+    exec(sql: string): void;
+    prepare(sql: string): NodeStatementSync;
+    readonly isTransaction: boolean;
+    enableLoadExtension(enable: boolean): void;
+    loadExtension(path: string): void;
+    close(): void;
+}
+type NodeDatabaseSyncCtor = new (filename: string, options?: {
+    allowExtension?: boolean;
+}) => NodeDatabaseSync;
+/**
+ * Build a `bun:sqlite`-`Database`-compatible constructor backed by `node:sqlite`'s
+ * `DatabaseSync`. Exported for direct unit testing under Bun (which lacks
+ * `node:sqlite`) via an injected fake `DatabaseSync`.
+ */
+export declare function createNodeDatabaseCtor(DatabaseSyncCtor: NodeDatabaseSyncCtor): typeof Database;
+/**
+ * Internal seam for tests: `requireModule` is dependency-injected so a Bun test can
+ * force the Node fallback path with a fake `node:sqlite`, and `reset()` clears the
+ * module-level cache between cases. Not part of the public API.
+ */
+export declare const _internals: {
+    requireModule(id: string): unknown;
+    reset(): void;
+};
+/**
+ * Resolve a `bun:sqlite`-`Database`-compatible constructor for the current runtime.
+ * Cached after first resolution.
+ *
+ * Order: native `bun:sqlite` (Bun) → `node:sqlite` adapter (Node) → clear error.
+ */
+export declare function loadDatabaseCtor(): typeof Database;
+export {};

package/dist/hooks/knowledge-curator.d.ts

@@ -55,7 +55,7 @@ export interface EnrichmentQuotaOptions {
  * One retry on schema failure (with a RETRY message naming the missing
  * fields). Quota-gated per call via the dedicated knowledge-enrichment quota.
  * Returns null when
- * enrichment is unavailable (quota exhausted) or fails twice — the caller
+ * enrichment is unavailable (quota exhausted) or fails twice — the caller
  * quarantines the entry. Never throws.
  */
 export declare function enrichLessonToV3(params: {
@@ -106,15 +106,15 @@ export declare function runAutoPromotion(directory: string, config: KnowledgeCon
 /**
  * G7 (#1716): Auto-demote swarm entries that have sustained a net-negative
  * outcome signal over consecutive phase EVALUATIONS (i.e. consecutive
- * `runAutoDemotion` invocations with distinct phase numbers — a skipped phase
- * in between still counts, matching the issue's "≥3 consecutive" intent as
+ * `runAutoDemotion` invocations with distinct phase numbers — a skipped phase
+ * in between still counts, matching the issue's "≥3 consecutive" intent as
  * implemented against evaluation cadence, not wall-clock phase contiguity).
  *
  * Companion to {@link runAutoPromotion}. For each `promoted` entry:
  *  1. Dedupe by phase: if `entry.last_demotion_phase === phaseNumber`, this
  *     entry has already been processed for this phase (handles the case where
  *     `curateAndStoreSwarm` is invoked multiple times in the same logical
- *     phase — e.g. phase-complete + close). Skip the counter update.
+ *     phase — e.g. phase-complete + close). Skip the counter update.
  *  2. Otherwise compute the outcome signal. If at/below
  *     `config.promoted_demotion_signal_threshold`, increment
  *     `recent_negative_phase_count`; else reset it to 0.