@stackmemoryai/stackmemory 1.2.2 → 1.2.6

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

@@ -237,6 +237,10 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
         "FTS5 index populated from existing frames (migration v1\u2192v2)"
       );
     }
+    if (version < 3) {
+      this.db.prepare("INSERT OR REPLACE INTO schema_version (version) VALUES (?)").run(3);
+      logger.info("Schema migration v2\u2192v3: GC importance_score support");
+    }
   }
   /**
    * Initialize sqlite-vec for vector search
@@ -305,6 +309,7 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
     const retentionDays = options.retentionDays ?? 90;
     const batchSize = options.batchSize ?? 100;
     const dryRun = options.dryRun ?? false;
+    const protectedRunIds = options.protectedRunIds ?? [];
     const nowSec = Math.floor(Date.now() / 1e3);
     const defaultCutoff = nowSec - retentionDays * 86400;
     const ttl30dCutoff = nowSec - 30 * 86400;
@@ -317,8 +322,17 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
            OR (retention_policy = 'ttl_7d' AND created_at < ?)
          )
          AND retention_policy != 'keep_forever'
+         AND state = 'closed'
+         AND run_id NOT IN (SELECT value FROM json_each(?))
+         ORDER BY importance_score ASC, created_at ASC
          LIMIT ?`
-    ).all(defaultCutoff, ttl30dCutoff, ttl7dCutoff, batchSize);
+    ).all(
+      defaultCutoff,
+      ttl30dCutoff,
+      ttl7dCutoff,
+      JSON.stringify(protectedRunIds),
+      batchSize
+    );
     const frameIds = candidates.map((r) => r.frame_id);
     if (frameIds.length === 0) {
       return {
@@ -388,6 +402,69 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
       ftsEntriesDeleted: frameIds.length
     };
   }
+  /**
+   * Compute importance score for a single frame.
+   * Score range: [0.0, 1.0] — higher means more important, less likely to be GC'd.
+   */
+  computeImportanceScore(frameId) {
+    if (!this.db)
+      throw new DatabaseError(
+        "Database not connected",
+        ErrorCode.DB_CONNECTION_FAILED
+      );
+    const frame = this.db.prepare(
+      "SELECT frame_id, digest_text, created_at FROM frames WHERE frame_id = ?"
+    ).get(frameId);
+    if (!frame) return 0.3;
+    let score = 0.3;
+    const decisionCount = this.db.prepare(
+      "SELECT COUNT(*) as count FROM anchors WHERE frame_id = ? AND type = 'DECISION'"
+    ).get(frameId).count;
+    if (decisionCount > 0) score += 0.15;
+    const eventCount = this.db.prepare("SELECT COUNT(*) as count FROM events WHERE frame_id = ?").get(frameId).count;
+    if (eventCount > 3) score += 0.1;
+    if (frame.digest_text) score += 0.15;
+    const childCount = this.db.prepare(
+      "SELECT COUNT(*) as count FROM frames WHERE parent_frame_id = ?"
+    ).get(frameId).count;
+    if (childCount > 0) score += 0.1;
+    const nowSec = Math.floor(Date.now() / 1e3);
+    if (nowSec - frame.created_at < 86400) score += 0.1;
+    return Math.round(Math.min(score, 1) * 100) / 100;
+  }
+  /**
+   * Recompute importance scores for frames still at default score (0.5).
+   * Processes oldest frames first in batches.
+   * Returns count of frames updated.
+   */
+  recomputeImportanceScores(batchSize = 100) {
+    if (!this.db)
+      throw new DatabaseError(
+        "Database not connected",
+        ErrorCode.DB_CONNECTION_FAILED
+      );
+    const frames = this.db.prepare(
+      "SELECT frame_id FROM frames WHERE importance_score = 0.5 ORDER BY created_at ASC LIMIT ?"
+    ).all(batchSize);
+    const updateStmt = this.db.prepare(
+      "UPDATE frames SET importance_score = ? WHERE frame_id = ?"
+    );
+    let updated = 0;
+    for (const { frame_id } of frames) {
+      const score = this.computeImportanceScore(frame_id);
+      if (score !== 0.5) {
+        updateStmt.run(score, frame_id);
+        updated++;
+      }
+    }
+    if (updated > 0) {
+      logger.info("Recomputed importance scores", {
+        checked: frames.length,
+        updated
+      });
+    }
+    return updated;
+  }
   async migrateSchema(targetVersion) {
     if (!this.db)
       throw new DatabaseError(
@@ -1252,6 +1329,89 @@ 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/digest/frame-digest-integration.js

@@ -2,7 +2,7 @@ import { fileURLToPath as __fileURLToPath } from 'url';
 import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
-import { EnhancedHybridDigestGenerator } from "./enhanced-hybrid-digest.js";
+import { EnhancedHybridDigestGenerator } from "./hybrid-digest.js";
 import { logger } from "../monitoring/logger.js";
 class FrameDigestIntegration {
   frameManager;

package/dist/src/core/digest/index.js

@@ -4,5 +4,5 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 export * from "./types.js";
 export * from "./hybrid-digest-generator.js";
-export * from "./enhanced-hybrid-digest.js";
+export * from "./hybrid-digest.js";
 export * from "./frame-digest-integration.js";

package/dist/src/core/execution/parallel-executor.js

@@ -106,7 +106,11 @@ class ParallelExecutor extends EventEmitter {
           taskId,
           error: lastError.message
         });
-        this.emit("task-retry", { taskId, attempt: attempts, error: lastError });
+        this.emit("task-retry", {
+          taskId,
+          attempt: attempts,
+          error: lastError
+        });
         if (attempts < maxRetries) {
           await this.delay(Math.pow(2, attempts) * 1e3);
         }

package/dist/src/core/projects/project-isolation.js

@@ -25,9 +25,20 @@ class ProjectIsolationManager {
     try {
       const remoteUrl = this.getGitRemoteUrl(projectRoot);
       const gitInfo = this.parseGitRemote(remoteUrl);
-      const projectId = this.createStableProjectId(gitInfo.organization, gitInfo.repository);
-      const workspaceFilter = this.createWorkspaceFilter(gitInfo.organization, gitInfo.repository, projectRoot);
-      const linearConfig = this.getLinearConfiguration(gitInfo.organization, gitInfo.repository, projectRoot);
+      const projectId = this.createStableProjectId(
+        gitInfo.organization,
+        gitInfo.repository
+      );
+      const workspaceFilter = this.createWorkspaceFilter(
+        gitInfo.organization,
+        gitInfo.repository,
+        projectRoot
+      );
+      const linearConfig = this.getLinearConfiguration(
+        gitInfo.organization,
+        gitInfo.repository,
+        projectRoot
+      );
       const identification = {
         projectId,
         organization: gitInfo.organization,
@@ -45,7 +56,10 @@ class ProjectIsolationManager {
       });
       return identification;
     } catch (error) {
-      logger.warn("Could not determine git remote, using fallback identification", { error });
+      logger.warn(
+        "Could not determine git remote, using fallback identification",
+        { error }
+      );
       const fallback = this.createFallbackIdentification(projectRoot);
       this.projectCache.set(cacheKey, fallback);
       return fallback;

package/dist/src/core/security/index.js

@@ -15,6 +15,7 @@ import {
   validateInput,
   createAggregateSchema,
   validateShellArg,
+  validateShellCommand,
   safeJsonParse
 } from "./input-sanitizer.js";
 export {
@@ -30,5 +31,6 @@ export {
   sanitizeIdentifier,
   validateInput,
   validateShellArg,
+  validateShellCommand,
   validateTableName
 };

package/dist/src/core/security/input-sanitizer.js

@@ -280,6 +280,28 @@ function createAggregateSchema(allowedFields) {
     limit: z.number().int().min(1).max(1e3).optional()
   });
 }
+const DANGEROUS_SHELL_PATTERNS = [
+  /\brm\s+(-[a-zA-Z]*r[a-zA-Z]*f|--recursive)\b/i,
+  // rm -rf, rm -fr, rm --recursive
+  /\brm\s+-[a-zA-Z]*r\b/i,
+  // rm -r (any flag combo with r)
+  /\bmkfs\b/i,
+  /\bdd\s+if=/i,
+  /\b:\(\)\s*\{/i
+  // fork bomb
+];
+function validateShellCommand(command) {
+  for (const pattern of DANGEROUS_SHELL_PATTERNS) {
+    if (pattern.test(command)) {
+      throw new ValidationError(
+        `Blocked dangerous shell command: ${command.substring(0, 80)}`,
+        ErrorCode.VALIDATION_FAILED,
+        { reason: "dangerous_command" }
+      );
+    }
+  }
+  return command;
+}
 function validateShellArg(arg) {
   if (!arg) return "";
   const dangerousChars = /[;&|`$(){}[\]<>!#*?~\n\r]/;
@@ -316,5 +338,6 @@ export {
   sanitizeIdentifier,
   validateInput,
   validateShellArg,
+  validateShellCommand,
   validateTableName
 };

package/dist/src/core/utils/update-checker.js

@@ -63,12 +63,16 @@ class UpdateChecker {
   static async fetchLatestVersion() {
     try {
       const fetchVersion = async () => {
-        const output = execFileSync("npm", ["view", this.PACKAGE_NAME, "version"], {
-          encoding: "utf-8",
-          stdio: ["pipe", "pipe", "ignore"],
-          timeout: 5e3
-          // 5 second timeout
-        }).trim();
+        const output = execFileSync(
+          "npm",
+          ["view", this.PACKAGE_NAME, "version"],
+          {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "ignore"],
+            timeout: 5e3
+            // 5 second timeout
+          }
+        ).trim();
         return output;
       };
       return await gracefulDegrade(

package/dist/src/daemon/daemon-config.js

@@ -30,8 +30,9 @@ const DEFAULT_DAEMON_CONFIG = {
     ftsRebuildInterval: 24,
     // hours
     embeddingBatchSize: 50,
-    vacuumInterval: 168
+    vacuumInterval: 168,
     // weekly
+    gcIntervalSeconds: 60
   },
   memory: {
     enabled: true,

package/dist/src/daemon/services/auto-save-service.js

@@ -0,0 +1,121 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { existsSync } from "fs";
+import { join } from "path";
+import { execSync } from "child_process";
+import { homedir } from "os";
+class DaemonContextService {
+  config;
+  state;
+  intervalId;
+  isRunning = false;
+  onLog;
+  constructor(config, onLog) {
+    this.config = config;
+    this.onLog = onLog;
+    this.state = {
+      lastSaveTime: 0,
+      saveCount: 0,
+      errors: []
+    };
+  }
+  start() {
+    if (this.isRunning || !this.config.enabled) {
+      return;
+    }
+    this.isRunning = true;
+    const intervalMs = this.config.interval * 60 * 1e3;
+    this.onLog("INFO", "Context service started", {
+      interval: this.config.interval
+    });
+    this.saveContext();
+    this.intervalId = setInterval(() => {
+      this.saveContext();
+    }, intervalMs);
+  }
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = void 0;
+    }
+    this.isRunning = false;
+    this.onLog("INFO", "Context service stopped");
+  }
+  getState() {
+    return { ...this.state };
+  }
+  updateConfig(config) {
+    const wasRunning = this.isRunning;
+    if (wasRunning) {
+      this.stop();
+    }
+    this.config = { ...this.config, ...config };
+    if (wasRunning && this.config.enabled) {
+      this.start();
+    }
+  }
+  forceSave() {
+    this.saveContext();
+  }
+  saveContext() {
+    if (!this.isRunning) return;
+    try {
+      const stackmemoryBin = this.getStackMemoryBin();
+      if (!stackmemoryBin) {
+        this.onLog("WARN", "StackMemory binary not found");
+        return;
+      }
+      const message = this.config.checkpointMessage || `Auto-checkpoint #${this.state.saveCount + 1}`;
+      const fullMessage = `${message} at ${(/* @__PURE__ */ new Date()).toISOString()}`;
+      execSync(`"${stackmemoryBin}" context add observation "${fullMessage}"`, {
+        timeout: 3e4,
+        encoding: "utf8",
+        stdio: "pipe"
+      });
+      this.state.saveCount++;
+      this.state.lastSaveTime = Date.now();
+      this.onLog("INFO", "Context saved", {
+        saveCount: this.state.saveCount
+      });
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      if (!errorMsg.includes("EBUSY") && !errorMsg.includes("EAGAIN")) {
+        this.state.errors.push(errorMsg);
+        this.onLog("WARN", "Failed to save context", { error: errorMsg });
+        if (this.state.errors.length > 10) {
+          this.state.errors = this.state.errors.slice(-10);
+        }
+      }
+    }
+  }
+  getStackMemoryBin() {
+    const homeDir = homedir();
+    const locations = [
+      join(homeDir, ".stackmemory", "bin", "stackmemory"),
+      join(homeDir, ".local", "bin", "stackmemory"),
+      "/usr/local/bin/stackmemory",
+      "/opt/homebrew/bin/stackmemory"
+    ];
+    for (const loc of locations) {
+      if (existsSync(loc)) {
+        return loc;
+      }
+    }
+    try {
+      const result = execSync("which stackmemory", {
+        encoding: "utf8",
+        stdio: "pipe"
+      }).trim();
+      if (result && existsSync(result)) {
+        return result;
+      }
+    } catch {
+    }
+    return null;
+  }
+}
+export {
+  DaemonContextService
+};

package/dist/src/daemon/services/maintenance-service.js

@@ -10,6 +10,7 @@ class DaemonMaintenanceService {
   state;
   embeddingProvider = null;
   intervalId;
+  gcIntervalId;
   isRunning = false;
   onLog;
   constructor(config, onLog) {
@@ -48,12 +49,26 @@ class DaemonMaintenanceService {
         );
       });
     }, intervalMs);
+    if (this.config.gcEnabled !== false) {
+      const gcMs = (this.config.gcIntervalSeconds ?? 60) * 1e3;
+      this.gcIntervalId = setInterval(() => {
+        this.runGCCycle().catch((err) => {
+          this.addError(
+            `GC cycle: ${err instanceof Error ? err.message : String(err)}`
+          );
+        });
+      }, gcMs);
+    }
   }
   stop() {
     if (this.intervalId) {
       clearInterval(this.intervalId);
       this.intervalId = void 0;
     }
+    if (this.gcIntervalId) {
+      clearInterval(this.gcIntervalId);
+      this.gcIntervalId = void 0;
+    }
     this.isRunning = false;
     this.onLog("INFO", "Maintenance service stopped");
   }
@@ -93,6 +108,7 @@ class DaemonMaintenanceService {
       await this.backfillEmbeddings(db);
       await this.maybeVacuum(db);
       await this.generateMissingDigests(db);
+      await this.recomputeScores(db);
       await this.runGC(db);
       await db.disconnect();
       this.state.lastRunTime = Date.now();
@@ -280,14 +296,73 @@ class DaemonMaintenanceService {
       );
     }
   }
+  /**
+   * Dedicated lightweight GC cycle (runs more frequently than full maintenance).
+   * Queries active run_ids for protection and delegates to adapter.runGC().
+   */
+  async runGCCycle() {
+    try {
+      const db = await this.getDatabase();
+      if (!db) return;
+      const rawDb = db.getRawDatabase?.();
+      let protectedRunIds = [];
+      if (rawDb) {
+        const rows = rawDb.prepare(
+          "SELECT DISTINCT run_id FROM frames WHERE state = 'active' LIMIT 10"
+        ).all();
+        protectedRunIds = rows.map((r) => r.run_id);
+      }
+      const result = await db.runGC({
+        retentionDays: this.config.gcRetentionDays ?? 90,
+        batchSize: this.config.gcBatchSize ?? 100,
+        dryRun: false,
+        protectedRunIds
+      });
+      this.state.framesGarbageCollected += result.framesDeleted;
+      this.state.lastGcRun = Date.now();
+      if (result.framesDeleted > 0) {
+        this.onLog(
+          "INFO",
+          `GC cycle deleted ${result.framesDeleted} expired frames`
+        );
+      }
+      await db.disconnect();
+    } catch (err) {
+      this.addError(
+        `GC cycle: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  async recomputeScores(db) {
+    try {
+      if (typeof db.recomputeImportanceScores !== "function") return;
+      const updated = db.recomputeImportanceScores(100);
+      if (updated > 0) {
+        this.onLog("INFO", `Recomputed ${updated} importance scores`);
+      }
+    } catch (err) {
+      this.addError(
+        `Score recompute: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
   async runGC(db) {
     try {
       if (this.config.gcEnabled === false) return;
       if (typeof db.runGC !== "function") return;
+      const rawDb = db.getRawDatabase?.();
+      let protectedRunIds = [];
+      if (rawDb) {
+        const rows = rawDb.prepare(
+          "SELECT DISTINCT run_id FROM frames WHERE state = 'active' LIMIT 10"
+        ).all();
+        protectedRunIds = rows.map((r) => r.run_id);
+      }
       const result = await db.runGC({
         retentionDays: this.config.gcRetentionDays ?? 90,
         batchSize: this.config.gcBatchSize ?? 100,
-        dryRun: false
+        dryRun: false,
+        protectedRunIds
       });
       this.state.framesGarbageCollected += result.framesDeleted;
       this.state.lastGcRun = Date.now();

package/dist/src/features/sweep/prompt-builder.js

@@ -49,7 +49,7 @@ function trimContentAroundCursor(lines, cursorLine, cursorCol, maxTokens) {
   const windowSize = Math.floor(targetChars / avgLineLength);
   const halfWindow = Math.floor(windowSize / 2);
   let start = Math.max(0, cursorLine - halfWindow);
-  let end = Math.min(lines.length, start + windowSize);
+  const end = Math.min(lines.length, start + windowSize);
   if (end === lines.length) {
     start = Math.max(0, end - windowSize);
   }
@@ -60,7 +60,7 @@ function trimContentAroundCursor(lines, cursorLine, cursorCol, maxTokens) {
   };
 }
 function parseCompletion(completionText, originalLines, windowStart, windowEnd) {
-  let text = completionText.replace(/<\|file_sep\|>$/, "").replace(/<\/s>$/, "").trimEnd();
+  const text = completionText.replace(/<\|file_sep\|>$/, "").replace(/<\/s>$/, "").trimEnd();
   if (!text || text.trim().length === 0) {
     return null;
   }

package/dist/src/hooks/daemon.js

@@ -13,7 +13,6 @@ import {
 import { join, extname, relative } from "path";
 import { spawn } from "child_process";
 import { loadConfig } from "./config.js";
-import { GraphitiHooks } from "./graphiti-hooks.js";
 import {
   hookEmitter
 } from "./events.js";
@@ -143,13 +142,6 @@ function registerBuiltinHandlers() {
   hookEmitter.registerHandler("file_change", handleFileChange);
   hookEmitter.registerHandler("suggestion_ready", handleSuggestionReady);
   hookEmitter.registerHandler("error", handleError);
-  try {
-    if (process.env.GRAPHITI_ENDPOINT || process.env.GRAPHITI_ENABLED === "true") {
-      const graphiti = new GraphitiHooks();
-      graphiti.register(hookEmitter);
-    }
-  } catch {
-  }
   hookEmitter.on("*", () => {
     state.eventsProcessed++;
   });

package/dist/src/integrations/linear/config.js

@@ -62,7 +62,9 @@ class LinearConfigManager {
    * Get default configuration with project isolation
    */
   getDefaultConfig() {
-    const projectId = this.isolationManager.getProjectIdentification(this.projectRoot);
+    const projectId = this.isolationManager.getProjectIdentification(
+      this.projectRoot
+    );
     return {
       enabled: true,
       interval: 5,