@stackmemoryai/stackmemory 1.10.5 → 1.14.0

package/dist/src/{integrations/diffmem → core/cache}/index.js

@@ -2,10 +2,10 @@ import { fileURLToPath as __fileURLToPath } from 'url';
 import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
-import { DEFAULT_DIFFMEM_CONFIG } from "./config.js";
-import { DiffMemClient, DiffMemClientError } from "./client.js";
+import { ContentCache } from "./content-cache.js";
+import { estimateTokens, hashContent } from "./token-estimator.js";
 export {
-  DEFAULT_DIFFMEM_CONFIG,
-  DiffMemClient,
-  DiffMemClientError
+  ContentCache,
+  estimateTokens,
+  hashContent
 };

package/dist/src/core/cache/token-estimator.js

@@ -0,0 +1,39 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { createHash } from "crypto";
+import { createRequire } from "module";
+let encoder = null;
+let initAttempted = false;
+function getEncoder() {
+  if (initAttempted) return encoder;
+  initAttempted = true;
+  try {
+    const require2 = createRequire(import.meta.url);
+    const tiktoken = require2("js-tiktoken");
+    encoder = tiktoken.getEncoding("cl100k_base");
+  } catch {
+    encoder = null;
+  }
+  return encoder;
+}
+function estimateTokens(content) {
+  if (!content) return 0;
+  const enc = getEncoder();
+  if (enc) {
+    return enc.encode(content).length;
+  }
+  return Math.ceil(content.length / 4);
+}
+function isTiktokenActive() {
+  return getEncoder() !== null;
+}
+function hashContent(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+export {
+  estimateTokens,
+  hashContent,
+  isTiktokenActive
+};

package/dist/src/core/config/feature-flags.js

@@ -15,8 +15,7 @@ function isFeatureEnabled(feature) {
       return process.env["STACKMEMORY_AI"] !== "false" && (!!process.env["ANTHROPIC_API_KEY"] || !!process.env["OPENAI_API_KEY"]);
     case "skills":
       return process.env["STACKMEMORY_SKILLS"] === "true" || process.env["STACKMEMORY_SKILLS"] === "1";
-    case "ralph":
-      return process.env["STACKMEMORY_RALPH"] !== "false";
+    // For npm package users, must be explicitly enabled
     case "multiProvider":
       return process.env["STACKMEMORY_MULTI_PROVIDER"] === "true" || process.env["STACKMEMORY_MULTI_PROVIDER"] === "1";
     default:
@@ -29,7 +28,6 @@ function getFeatureFlags() {
     linear: isFeatureEnabled("linear"),
     aiSummaries: isFeatureEnabled("aiSummaries"),
     skills: isFeatureEnabled("skills"),
-    ralph: isFeatureEnabled("ralph"),
     multiProvider: isFeatureEnabled("multiProvider")
   };
 }
@@ -49,9 +47,7 @@ function logFeatureStatus() {
     console.log(
       `  Skills: ${flags.skills ? "enabled" : "disabled (set STACKMEMORY_SKILLS=true)"}`
     );
-    console.log(
-      `  Ralph: ${flags.ralph ? "enabled" : "disabled (set STACKMEMORY_RALPH=true)"}`
-    );
+    console.log();
     console.log(
       `  MultiProvider: ${flags.multiProvider ? "enabled" : "disabled (set STACKMEMORY_MULTI_PROVIDER=true)"}`
     );

package/dist/src/core/context/frame-database.js

@@ -97,6 +97,26 @@ class FrameDatabase {
         );
       } catch {
       }
+      const provenanceCols = [
+        { table: "frames", col: "prov_source", def: "TEXT DEFAULT ''" },
+        { table: "frames", col: "prov_derivation", def: "TEXT DEFAULT '[]'" },
+        { table: "frames", col: "prov_confidence", def: "REAL DEFAULT 1.0" },
+        { table: "frames", col: "prov_superseded_by", def: "TEXT" },
+        {
+          table: "frames",
+          col: "prov_program_version",
+          def: "TEXT DEFAULT ''"
+        },
+        { table: "anchors", col: "prov_source", def: "TEXT DEFAULT ''" },
+        { table: "anchors", col: "prov_confidence", def: "REAL DEFAULT 1.0" },
+        { table: "anchors", col: "prov_superseded_by", def: "TEXT" }
+      ];
+      for (const { table, col, def } of provenanceCols) {
+        try {
+          this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${col} ${def}`);
+        } catch {
+        }
+      }
       this.db.exec(`
         CREATE INDEX IF NOT EXISTS idx_frames_run ON frames(run_id);
         CREATE INDEX IF NOT EXISTS idx_frames_project ON frames(project_id);
@@ -189,28 +209,48 @@ class FrameDatabase {
           ON entity_states(entity_name, valid_from DESC);
       `);
       this.db.exec(`
-        CREATE TABLE IF NOT EXISTS cord_tasks (
-          task_id TEXT PRIMARY KEY,
-          parent_id TEXT,
-          project_id TEXT NOT NULL,
-          run_id TEXT NOT NULL,
-          goal TEXT NOT NULL,
-          prompt TEXT NOT NULL DEFAULT '',
-          result TEXT,
-          status TEXT NOT NULL DEFAULT 'pending'
-            CHECK (status IN ('pending','active','completed','blocked','asked')),
-          context_mode TEXT NOT NULL DEFAULT 'spawn'
-            CHECK (context_mode IN ('spawn','fork','ask')),
-          blocked_by TEXT NOT NULL DEFAULT '[]',
-          depth INTEGER NOT NULL DEFAULT 0,
-          created_at INTEGER NOT NULL DEFAULT (unixepoch()),
-          completed_at INTEGER,
-          FOREIGN KEY (parent_id) REFERENCES cord_tasks(task_id)
+        CREATE TABLE IF NOT EXISTS cloud_sync_state (
+          table_name TEXT NOT NULL,
+          row_id TEXT NOT NULL,
+          last_pushed_at INTEGER,
+          last_pushed_version INTEGER,
+          last_pulled_at INTEGER,
+          last_pulled_version INTEGER,
+          sync_status TEXT NOT NULL DEFAULT 'pending',
+          push_error TEXT,
+          push_attempts INTEGER DEFAULT 0,
+          PRIMARY KEY (table_name, row_id)
         );
-        CREATE INDEX IF NOT EXISTS idx_cord_tasks_project ON cord_tasks(project_id);
-        CREATE INDEX IF NOT EXISTS idx_cord_tasks_parent ON cord_tasks(parent_id);
-        CREATE INDEX IF NOT EXISTS idx_cord_tasks_status ON cord_tasks(status);
-        CREATE INDEX IF NOT EXISTS idx_cord_tasks_project_status ON cord_tasks(project_id, status);
+        CREATE INDEX IF NOT EXISTS idx_cloud_sync_status ON cloud_sync_state(sync_status);
+        CREATE INDEX IF NOT EXISTS idx_cloud_sync_pushed ON cloud_sync_state(last_pushed_at);
+
+        CREATE TABLE IF NOT EXISTS cloud_sync_cursors (
+          direction TEXT PRIMARY KEY,
+          cursor_value TEXT NOT NULL,
+          updated_at INTEGER NOT NULL
+        );
+
+        -- Learned behavioral patterns (observe \u2192 learn \u2192 apply)
+        CREATE TABLE IF NOT EXISTS patterns (
+          id TEXT PRIMARY KEY,
+          domain TEXT NOT NULL,
+          trigger TEXT NOT NULL,
+          action TEXT NOT NULL,
+          evidence TEXT DEFAULT '[]',
+          confidence REAL DEFAULT 0.3,
+          observation_count INTEGER DEFAULT 0,
+          scope TEXT DEFAULT 'project',
+          project_id TEXT,
+          status TEXT DEFAULT 'pending',
+          source TEXT DEFAULT 'observed',
+          created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+          updated_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+          last_matched_at INTEGER,
+          superseded_by TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_patterns_project ON patterns(project_id, status);
+        CREATE INDEX IF NOT EXISTS idx_patterns_domain ON patterns(domain, confidence DESC);
+        CREATE INDEX IF NOT EXISTS idx_patterns_status ON patterns(status, confidence DESC);
       `);
       logger.info("Frame database schema initialized");
     } catch (error) {
@@ -228,8 +268,8 @@ class FrameDatabase {
   insertFrame(frame) {
     try {
       const stmt = this.db.prepare(`
-        INSERT INTO frames (frame_id, run_id, project_id, parent_frame_id, depth, type, name, state, inputs, outputs, digest_json)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        INSERT INTO frames (frame_id, run_id, project_id, parent_frame_id, depth, type, name, state, inputs, outputs, digest_json, prov_source, prov_derivation, prov_confidence, prov_program_version)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       `);
       const result = stmt.run(
         frame.frame_id,
@@ -242,7 +282,15 @@ class FrameDatabase {
         frame.state,
         JSON.stringify(frame.inputs),
         JSON.stringify(frame.outputs),
-        JSON.stringify(frame.digest_json)
+        JSON.stringify(frame.digest_json),
+        frame.type,
+        // prov_source: frame type as source
+        JSON.stringify([`frame:${frame.type}`]),
+        // prov_derivation
+        1,
+        // prov_confidence: default full confidence
+        process.env["npm_package_version"] || ""
+        // prov_program_version
       );
       if (result.changes === 0) {
         throw new DatabaseError(
@@ -473,8 +521,8 @@ class FrameDatabase {
   insertAnchor(anchor) {
     try {
       const stmt = this.db.prepare(`
-        INSERT INTO anchors (anchor_id, frame_id, project_id, type, text, priority, metadata)
-        VALUES (?, ?, ?, ?, ?, ?, ?)
+        INSERT INTO anchors (anchor_id, frame_id, project_id, type, text, priority, metadata, prov_source, prov_confidence)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
       `);
       const result = stmt.run(
         anchor.anchor_id,
@@ -483,7 +531,11 @@ class FrameDatabase {
         anchor.type,
         anchor.text,
         anchor.priority,
-        JSON.stringify(anchor.metadata)
+        JSON.stringify(anchor.metadata),
+        anchor.type,
+        // prov_source: anchor type (DECISION, EVENT, etc.)
+        1
+        // prov_confidence: default full confidence
       );
       if (result.changes === 0) {
         throw new DatabaseError(

package/dist/src/core/context/recursive-context-manager.js

@@ -3,6 +3,7 @@ import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { logger } from "../monitoring/logger.js";
+import { estimateTokens } from "../cache/token-estimator.js";
 import { ValidationError, ErrorCode } from "../errors/index.js";
 import * as fs from "fs";
 import * as path from "path";
@@ -381,7 +382,6 @@ class RecursiveContextManager {
   fitChunksToTokenBudget(chunks, _maxTokens) {
     const selected = [];
     let totalTokens = 0;
-    const estimateTokens = (text) => Math.ceil(text.length / 4);
     for (const chunk of chunks) {
       const chunkTokens = estimateTokens(chunk.content);
       if (totalTokens + chunkTokens <= maxTokens) {

package/dist/src/core/context/rehydration.js

@@ -5,6 +5,7 @@ const __dirname = __pathDirname(__filename);
 import * as fs from "fs/promises";
 import * as path from "path";
 import { logger } from "../monitoring/logger.js";
+import { estimateTokens } from "../cache/token-estimator.js";
 import {
   getModelTokenLimit
 } from "../models/model-router.js";
@@ -44,7 +45,7 @@ class CompactionHandler {
    * Track token usage from a message
    */
   trackTokens(content) {
-    const estimatedTokens = Math.ceil(content.length / 4);
+    const estimatedTokens = estimateTokens(content);
     this.tokenAccumulator += estimatedTokens;
     this.metrics.estimatedTokens += estimatedTokens;
     if (this.isApproachingCompaction()) {

package/dist/src/core/cross-search/cross-project-search.js

@@ -0,0 +1,269 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import Database from "better-sqlite3";
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  readdirSync
+} from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { logger } from "../monitoring/logger.js";
+function sanitizeFtsQuery(query) {
+  const wantsPrefix = query.trimEnd().endsWith("*");
+  const cleaned = query.replace(/['"(){}[\]^~*\\,]/g, " ").replace(/\b(AND|OR|NOT|NEAR)\b/gi, "").trim();
+  const terms = cleaned.split(/\s+/).filter((t) => t.length > 0);
+  if (terms.length === 0) return '""';
+  const quoted = terms.map((t) => `"${t}"`);
+  if (wantsPrefix) {
+    quoted[quoted.length - 1] = quoted[quoted.length - 1] + "*";
+  }
+  return quoted.join(" ");
+}
+class CrossProjectSearch {
+  registryPath;
+  constructor(registryDir) {
+    const dir = registryDir || join(homedir(), ".stackmemory");
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    this.registryPath = join(dir, "projects.json");
+  }
+  // --- Project Registry CRUD ---
+  loadRegistry() {
+    if (!existsSync(this.registryPath)) {
+      return { projects: [] };
+    }
+    try {
+      const raw = readFileSync(this.registryPath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      logger.warn("Failed to parse projects.json, returning empty registry");
+      return { projects: [] };
+    }
+  }
+  saveRegistry(registry) {
+    writeFileSync(this.registryPath, JSON.stringify(registry, null, 2));
+  }
+  registerProject(entry) {
+    const registry = this.loadRegistry();
+    const idx = registry.projects.findIndex(
+      (p) => p.path === entry.path || p.dbPath === entry.dbPath
+    );
+    if (idx >= 0) {
+      registry.projects[idx] = entry;
+    } else {
+      registry.projects.push(entry);
+    }
+    this.saveRegistry(registry);
+  }
+  unregisterProject(pathOrName) {
+    const registry = this.loadRegistry();
+    const before = registry.projects.length;
+    registry.projects = registry.projects.filter(
+      (p) => p.path !== pathOrName && p.name !== pathOrName
+    );
+    if (registry.projects.length < before) {
+      this.saveRegistry(registry);
+      return true;
+    }
+    return false;
+  }
+  listProjects() {
+    return this.loadRegistry().projects;
+  }
+  /**
+   * Auto-discover projects by scanning common directories for .stackmemory/context.db
+   */
+  discoverProjects(basePaths) {
+    const paths = basePaths || [
+      join(homedir(), "Dev"),
+      join(homedir(), "dev"),
+      join(homedir(), "Projects"),
+      join(homedir(), "projects"),
+      join(homedir(), "Work"),
+      join(homedir(), "work"),
+      join(homedir(), "code"),
+      join(homedir(), "Code")
+    ];
+    const homeDb = join(homedir(), ".stackmemory", "context.db");
+    const discovered = [];
+    if (existsSync(homeDb)) {
+      discovered.push({
+        name: "global",
+        path: homedir(),
+        dbPath: homeDb,
+        lastAccessed: Date.now()
+      });
+    }
+    for (const basePath of paths) {
+      if (!existsSync(basePath)) continue;
+      try {
+        this.scanForDatabases(basePath, 0, 3, discovered);
+      } catch {
+      }
+    }
+    const registry = this.loadRegistry();
+    for (const entry of discovered) {
+      const existing = registry.projects.find((p) => p.dbPath === entry.dbPath);
+      if (!existing) {
+        registry.projects.push(entry);
+      }
+    }
+    this.saveRegistry(registry);
+    return discovered;
+  }
+  scanForDatabases(dir, depth, maxDepth, results) {
+    if (depth > maxDepth) return;
+    const dbPath = join(dir, ".stackmemory", "context.db");
+    if (existsSync(dbPath)) {
+      const name = dir.split("/").pop() || dir;
+      results.push({
+        name,
+        path: dir,
+        dbPath,
+        lastAccessed: Date.now()
+      });
+      return;
+    }
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules" && entry.name !== "dist" && entry.name !== "build") {
+          this.scanForDatabases(
+            join(dir, entry.name),
+            depth + 1,
+            maxDepth,
+            results
+          );
+        }
+      }
+    } catch {
+    }
+  }
+  // --- Cross-Project Search ---
+  /**
+   * Search across all registered project databases using FTS5/BM25.
+   * Opens read-only connections. Skips missing/locked databases gracefully.
+   */
+  async search(options) {
+    const { query, limit = 20, excludeProject } = options;
+    const registry = this.loadRegistry();
+    if (registry.projects.length === 0) {
+      return [];
+    }
+    const allResults = [];
+    const perDbLimit = Math.max(limit, 10);
+    for (const project of registry.projects) {
+      if (excludeProject && project.name === excludeProject) continue;
+      if (!existsSync(project.dbPath)) {
+        logger.debug(`Skipping missing database: ${project.dbPath}`);
+        continue;
+      }
+      try {
+        const results = this.searchSingleDb(project, query, perDbLimit);
+        allResults.push(...results);
+      } catch (error) {
+        logger.debug(
+          `Skipping database ${project.dbPath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    allResults.sort((a, b) => b.score - a.score);
+    return allResults.slice(0, limit);
+  }
+  /**
+   * Search a single project database (read-only connection).
+   */
+  searchSingleDb(project, query, limit) {
+    let db = null;
+    try {
+      db = new Database(project.dbPath, {
+        readonly: true,
+        fileMustExist: true
+      });
+      const hasFts = db.prepare(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='frames_fts'"
+      ).get();
+      if (hasFts) {
+        return this.searchFts(db, project, query, limit);
+      } else {
+        return this.searchLike(db, project, query, limit);
+      }
+    } finally {
+      if (db) {
+        try {
+          db.close();
+        } catch {
+        }
+      }
+    }
+  }
+  searchFts(db, project, query, limit) {
+    const sanitized = sanitizeFtsQuery(query);
+    const sql = `
+      SELECT f.frame_id, f.name, f.type, f.state, f.digest_text, f.created_at,
+             -bm25(frames_fts, 10.0, 5.0, 2.0, 1.0) as score
+      FROM frames_fts fts
+      JOIN frames f ON f.rowid = fts.rowid
+      WHERE frames_fts MATCH ?
+      ORDER BY score DESC
+      LIMIT ?
+    `;
+    const rows = db.prepare(sql).all(sanitized, limit);
+    return rows.map((row) => ({
+      projectName: project.name,
+      projectPath: project.path,
+      frameId: row.frame_id,
+      name: row.name,
+      type: row.type,
+      state: row.state,
+      digestText: row.digest_text,
+      score: row.score,
+      createdAt: row.created_at
+    }));
+  }
+  searchLike(db, project, query, limit) {
+    const likeParam = `%${query}%`;
+    const sql = `
+      SELECT frame_id, name, type, state, digest_text, created_at,
+        CASE
+          WHEN name LIKE ? THEN 1.0
+          WHEN digest_text LIKE ? THEN 0.8
+          WHEN inputs LIKE ? THEN 0.6
+          ELSE 0.5
+        END as score
+      FROM frames
+      WHERE (name LIKE ? OR digest_text LIKE ? OR inputs LIKE ?)
+      ORDER BY score DESC
+      LIMIT ?
+    `;
+    const rows = db.prepare(sql).all(
+      likeParam,
+      likeParam,
+      likeParam,
+      likeParam,
+      likeParam,
+      likeParam,
+      limit
+    );
+    return rows.map((row) => ({
+      projectName: project.name,
+      projectPath: project.path,
+      frameId: row.frame_id,
+      name: row.name,
+      type: row.type,
+      state: row.state,
+      digestText: row.digest_text,
+      score: row.score,
+      createdAt: row.created_at
+    }));
+  }
+}
+export {
+  CrossProjectSearch
+};

package/dist/src/core/cross-search/index.js

@@ -0,0 +1,10 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import {
+  CrossProjectSearch
+} from "./cross-project-search.js";
+export {
+  CrossProjectSearch
+};

package/dist/src/core/database/sqlite-adapter.js

@@ -44,7 +44,20 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
     const config = this.config;
     const dir = path.dirname(this.dbPath);
     await fs.mkdir(dir, { recursive: true });
-    this.db = new Database(this.dbPath);
+    try {
+      this.db = new Database(this.dbPath);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("NODE_MODULE_VERSION") || msg.includes("was compiled against a different Node.js version")) {
+        const nodeVersion = process.version;
+        throw new Error(
+          `better-sqlite3 was compiled for a different Node.js version than the one currently running (${nodeVersion}).
+Fix: cd ${process.cwd()} && npm rebuild better-sqlite3
+If that fails: npm install`
+        );
+      }
+      throw err;
+    }
     this.db.pragma("foreign_keys = ON");
     if (config.walMode !== false) {
       this.db.pragma("journal_mode = WAL");
@@ -1530,89 +1543,6 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
     }
     return Buffer.from(JSON.stringify(data, null, 2));
   }
-  /**
-   * Get recent frames from other run_ids within the same project.
-   * Used by team tools to read cross-agent context.
-   */
-  async getRecentFramesExcludingRun(projectId, excludeRunId, opts) {
-    if (!this.db)
-      throw new DatabaseError(
-        "Database not connected",
-        ErrorCode.DB_CONNECTION_FAILED
-      );
-    const limit = opts?.limit ?? 10;
-    const params = [projectId, excludeRunId];
-    let whereExtra = "";
-    if (opts?.since) {
-      whereExtra += " AND created_at > ?";
-      params.push(Math.floor(opts.since / 1e3));
-    }
-    if (opts?.types && opts.types.length > 0) {
-      const placeholders = opts.types.map(() => "?").join(",");
-      whereExtra += ` AND type IN (${placeholders})`;
-      params.push(...opts.types);
-    }
-    params.push(limit);
-    const rows = this.db.prepare(
-      `SELECT * FROM frames
-         WHERE project_id = ? AND run_id != ?${whereExtra}
-         ORDER BY created_at DESC
-         LIMIT ?`
-    ).all(...params);
-    const frameIds = rows.map((r) => r.frame_id);
-    const anchorsByFrame = /* @__PURE__ */ new Map();
-    if (frameIds.length > 0) {
-      const placeholders = frameIds.map(() => "?").join(",");
-      const anchorRows = this.db.prepare(
-        `SELECT * FROM anchors WHERE frame_id IN (${placeholders})
-           ORDER BY priority DESC, created_at ASC`
-      ).all(...frameIds);
-      for (const row of anchorRows) {
-        const list = anchorsByFrame.get(row.frame_id) || [];
-        list.push({ ...row, metadata: JSON.parse(row.metadata || "{}") });
-        anchorsByFrame.set(row.frame_id, list);
-      }
-    }
-    return rows.map((row) => ({
-      ...row,
-      inputs: JSON.parse(row.inputs || "{}"),
-      outputs: JSON.parse(row.outputs || "{}"),
-      digest_json: JSON.parse(row.digest_json || "{}"),
-      anchors: anchorsByFrame.get(row.frame_id) || []
-    }));
-  }
-  /**
-   * Get anchors explicitly shared for team visibility.
-   * Finds anchors where metadata contains `"shared":true`.
-   */
-  async getSharedAnchors(projectId, opts) {
-    if (!this.db)
-      throw new DatabaseError(
-        "Database not connected",
-        ErrorCode.DB_CONNECTION_FAILED
-      );
-    const limit = opts?.limit ?? 20;
-    const params = [projectId];
-    let whereExtra = "";
-    if (opts?.since) {
-      whereExtra += " AND a.created_at > ?";
-      params.push(Math.floor(opts.since / 1e3));
-    }
-    params.push(limit);
-    const rows = this.db.prepare(
-      `SELECT a.*, f.name as frame_name, f.run_id
-         FROM anchors a
-         JOIN frames f ON a.frame_id = f.frame_id
-         WHERE f.project_id = ?
-           AND a.metadata LIKE '%"shared":true%'${whereExtra}
-         ORDER BY a.priority DESC, a.created_at DESC
-         LIMIT ?`
-    ).all(...params);
-    return rows.map((row) => ({
-      ...row,
-      metadata: JSON.parse(row.metadata || "{}")
-    }));
-  }
   async importData(data, format, options) {
     if (!this.db)
       throw new DatabaseError(

package/dist/src/core/extensions/provider-adapter.js

@@ -387,6 +387,11 @@ function createProvider(id, config) {
         apiKey: config.apiKey,
         baseUrl: config.baseUrl || "https://openrouter.ai/api"
       });
+    case "moonshot":
+      return new GPTAdapter({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl || "https://api.moonshot.ai/v1"
+      });
     default:
       throw new Error(`No adapter for provider: ${id}`);
   }