@stackmemoryai/stackmemory 1.2.9 → 1.3.1

package/dist/src/cli/commands/symphony.js

@@ -0,0 +1,267 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { Command } from "commander";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import Database from "better-sqlite3";
+import { logger } from "../../core/monitoring/logger.js";
+function getGlobalStorePath() {
+  const dir = join(homedir(), ".stackmemory", "symphony");
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function getGlobalDb() {
+  const dbPath = join(getGlobalStorePath(), "context.db");
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS symphony_contexts (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      issue_id TEXT NOT NULL,
+      attempt INTEGER NOT NULL DEFAULT 1,
+      workspace TEXT,
+      captured_at INTEGER NOT NULL,
+      context_type TEXT NOT NULL DEFAULT 'run',
+      summary TEXT,
+      frames_json TEXT,
+      anchors_json TEXT,
+      events_json TEXT,
+      metadata_json TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_symphony_issue
+      ON symphony_contexts(issue_id);
+    CREATE INDEX IF NOT EXISTS idx_symphony_captured
+      ON symphony_contexts(captured_at);
+  `);
+  return db;
+}
+function createSymphonyCommands() {
+  const cmd = new Command("symphony");
+  cmd.description("Symphony orchestrator integration commands");
+  cmd.command("capture").description("Capture workspace context after an agent run").requiredOption("--issue <id>", "Issue identifier (e.g., STA-476)").option("--workspace <path>", "Workspace directory", process.cwd()).option("--attempt <n>", "Attempt number", "1").action(async (options) => {
+    const workspace = options.workspace;
+    const issueId = options.issue;
+    const attempt = parseInt(options.attempt, 10);
+    const dbPath = join(workspace, ".stackmemory", "context.db");
+    let summary = "";
+    let framesJson = "[]";
+    let anchorsJson = "[]";
+    let eventsJson = "[]";
+    if (existsSync(dbPath)) {
+      try {
+        const db = new Database(dbPath, { readonly: true });
+        const frames = db.prepare(
+          "SELECT frame_id, name, type, digest_text, created_at FROM frames ORDER BY created_at DESC LIMIT 20"
+        ).all();
+        framesJson = JSON.stringify(frames);
+        const anchors = db.prepare(
+          "SELECT anchor_id, type, text, priority FROM anchors WHERE type IN ('DECISION', 'FACT', 'CONSTRAINT', 'RISK') ORDER BY priority DESC LIMIT 30"
+        ).all();
+        anchorsJson = JSON.stringify(anchors);
+        const events = db.prepare(
+          "SELECT event_type, payload, ts FROM events ORDER BY ts DESC LIMIT 50"
+        ).all();
+        eventsJson = JSON.stringify(events);
+        const digests = frames.filter((f) => f.digest_text).map((f) => f.digest_text).slice(0, 5);
+        summary = digests.join("\n");
+        db.close();
+      } catch (err) {
+        logger.warn("Failed to read workspace database", {
+          error: err.message
+        });
+      }
+    }
+    let metadata = { workspace, attempt };
+    try {
+      const { execSync } = await import("child_process");
+      const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+        cwd: workspace,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 5e3
+      }).trim();
+      const lastCommit = execSync("git log -1 --oneline", {
+        cwd: workspace,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 5e3
+      }).trim();
+      metadata = { ...metadata, branch, lastCommit };
+    } catch {
+    }
+    const globalDb = getGlobalDb();
+    globalDb.prepare(
+      `INSERT INTO symphony_contexts
+           (issue_id, attempt, workspace, captured_at, context_type, summary, frames_json, anchors_json, events_json, metadata_json)
+           VALUES (?, ?, ?, ?, 'run', ?, ?, ?, ?, ?)`
+    ).run(
+      issueId,
+      attempt,
+      workspace,
+      Math.floor(Date.now() / 1e3),
+      summary,
+      framesJson,
+      anchorsJson,
+      eventsJson,
+      JSON.stringify(metadata)
+    );
+    globalDb.close();
+    const frameCount = JSON.parse(framesJson).length;
+    const anchorCount = JSON.parse(anchorsJson).length;
+    console.log(
+      `Captured ${frameCount} frames, ${anchorCount} anchors for ${issueId} (attempt ${attempt})`
+    );
+  });
+  cmd.command("restore").description("Restore context from prior runs into workspace").requiredOption("--issue <id>", "Issue identifier (e.g., STA-476)").option("--workspace <path>", "Workspace directory", process.cwd()).option("--related", "Also include context from related issues", false).action(async (options) => {
+    const workspace = options.workspace;
+    const issueId = options.issue;
+    const globalDbPath = join(getGlobalStorePath(), "context.db");
+    if (!existsSync(globalDbPath)) {
+      console.log("No prior Symphony context found");
+      return;
+    }
+    const globalDb = getGlobalDb();
+    const contexts = globalDb.prepare(
+      `SELECT issue_id, attempt, summary, anchors_json, metadata_json, captured_at
+           FROM symphony_contexts
+           WHERE issue_id = ?
+           ORDER BY captured_at DESC
+           LIMIT 10`
+    ).all(issueId);
+    if (contexts.length === 0 && !options.related) {
+      console.log(`No prior context for ${issueId}`);
+      globalDb.close();
+      return;
+    }
+    const lines = [
+      `# Prior Context for ${issueId}`,
+      "",
+      `Found ${contexts.length} prior run(s).`,
+      ""
+    ];
+    for (const ctx of contexts) {
+      const date = new Date(ctx.captured_at * 1e3).toISOString();
+      lines.push(`## Attempt ${ctx.attempt} (${date})`);
+      if (ctx.summary) {
+        lines.push("", ctx.summary);
+      }
+      try {
+        const anchors = JSON.parse(ctx.anchors_json || "[]");
+        const decisions = anchors.filter((a) => a.type === "DECISION");
+        const risks = anchors.filter((a) => a.type === "RISK");
+        if (decisions.length > 0) {
+          lines.push("", "### Decisions");
+          for (const d of decisions.slice(0, 10)) {
+            lines.push(`- ${d.text}`);
+          }
+        }
+        if (risks.length > 0) {
+          lines.push("", "### Risks");
+          for (const r of risks.slice(0, 5)) {
+            lines.push(`- ${r.text}`);
+          }
+        }
+      } catch {
+      }
+      try {
+        const meta = JSON.parse(ctx.metadata_json || "{}");
+        if (meta.branch || meta.lastCommit) {
+          lines.push("", "### Git State");
+          if (meta.branch) lines.push(`- Branch: ${meta.branch}`);
+          if (meta.lastCommit)
+            lines.push(`- Last commit: ${meta.lastCommit}`);
+        }
+      } catch {
+      }
+      lines.push("");
+    }
+    const restoreDir = join(workspace, ".stackmemory");
+    if (!existsSync(restoreDir)) {
+      mkdirSync(restoreDir, { recursive: true });
+    }
+    const restorePath = join(restoreDir, "symphony-context.md");
+    writeFileSync(restorePath, lines.join("\n"));
+    globalDb.close();
+    console.log(
+      `Restored ${contexts.length} prior run(s) for ${issueId} \u2192 ${restorePath}`
+    );
+  });
+  cmd.command("archive").description("Archive workspace context before removal").requiredOption("--issue <id>", "Issue identifier (e.g., STA-476)").option("--workspace <path>", "Workspace directory", process.cwd()).action(async (options) => {
+    const workspace = options.workspace;
+    const issueId = options.issue;
+    const dbPath = join(workspace, ".stackmemory", "context.db");
+    if (!existsSync(dbPath)) {
+      console.log(`No context to archive for ${issueId}`);
+      return;
+    }
+    const db = new Database(dbPath, { readonly: true });
+    const frames = db.prepare("SELECT * FROM frames ORDER BY created_at DESC").all();
+    const anchors = db.prepare("SELECT * FROM anchors").all();
+    const events = db.prepare("SELECT * FROM events ORDER BY ts DESC LIMIT 100").all();
+    const digests = frames.filter((f) => f.digest_text).map((f) => f.digest_text).slice(0, 10);
+    db.close();
+    const globalDb = getGlobalDb();
+    globalDb.prepare(
+      `INSERT INTO symphony_contexts
+           (issue_id, attempt, workspace, captured_at, context_type, summary, frames_json, anchors_json, events_json, metadata_json)
+           VALUES (?, 0, ?, ?, 'archive', ?, ?, ?, ?, ?)`
+    ).run(
+      issueId,
+      workspace,
+      Math.floor(Date.now() / 1e3),
+      digests.join("\n"),
+      JSON.stringify(frames),
+      JSON.stringify(anchors),
+      JSON.stringify(events),
+      JSON.stringify({ archived: true, workspace })
+    );
+    globalDb.close();
+    console.log(
+      `Archived ${frames.length} frames, ${anchors.length} anchors for ${issueId}`
+    );
+  });
+  cmd.command("search").description("Search across all Symphony issue contexts").argument("<query>", "Search query").option("--limit <n>", "Max results", "10").action(async (query, options) => {
+    const globalDbPath = join(getGlobalStorePath(), "context.db");
+    if (!existsSync(globalDbPath)) {
+      console.log("No Symphony context database found");
+      return;
+    }
+    const limit = parseInt(options.limit, 10);
+    const globalDb = getGlobalDb();
+    const results = globalDb.prepare(
+      `SELECT issue_id, attempt, context_type, summary, anchors_json, captured_at
+           FROM symphony_contexts
+           WHERE summary LIKE ? OR anchors_json LIKE ?
+           ORDER BY captured_at DESC
+           LIMIT ?`
+    ).all(`%${query}%`, `%${query}%`, limit);
+    if (results.length === 0) {
+      console.log(`No results for "${query}"`);
+      globalDb.close();
+      return;
+    }
+    console.log(`Found ${results.length} result(s) for "${query}":
+`);
+    for (const r of results) {
+      const date = new Date(r.captured_at * 1e3).toISOString().slice(0, 16);
+      console.log(
+        `  ${r.issue_id} [${r.context_type}] attempt ${r.attempt} (${date})`
+      );
+      if (r.summary) {
+        const snippet = r.summary.slice(0, 120).replace(/\n/g, " ");
+        console.log(`    ${snippet}`);
+      }
+    }
+    globalDb.close();
+  });
+  return cmd;
+}
+export {
+  createSymphonyCommands
+};

package/dist/src/cli/index.js

@@ -57,6 +57,7 @@ import { createBenchCommand } from "./commands/bench.js";
 import { createDigestCommands } from "./commands/digest.js";
 import { createTeamCommands } from "./commands/team.js";
 import { createDesiresCommands } from "./commands/desires.js";
+import { createSymphonyCommands } from "./commands/symphony.js";
 import chalk from "chalk";
 import * as fs from "fs";
 import * as path from "path";
@@ -507,6 +508,7 @@ program.addCommand(createBenchCommand());
 program.addCommand(createDigestCommands());
 program.addCommand(createTeamCommands());
 program.addCommand(createDesiresCommands());
+program.addCommand(createSymphonyCommands());
 registerSetupCommands(program);
 program.command("mm-spike").description(
   "Run multi-agent planning/implementation spike (planner/implementer/critic)"

package/dist/src/core/context/frame-handoff-manager.js

@@ -12,6 +12,7 @@ import {
 class FrameHandoffManager {
   dualStackManager;
   activeHandoffs = /* @__PURE__ */ new Map();
+  handoffMetadata = /* @__PURE__ */ new Map();
   pendingApprovals = /* @__PURE__ */ new Map();
   notifications = /* @__PURE__ */ new Map();
   constructor(dualStackManager) {
@@ -53,6 +54,7 @@ class FrameHandoffManager {
         errors: []
       };
       this.activeHandoffs.set(requestId, progress);
+      this.handoffMetadata.set(requestId, metadata);
       await this.createHandoffNotifications(requestId, metadata, targetUserId);
       await this.scheduleHandoffReminders(requestId, metadata);
       logger.info(`Initiated enhanced handoff: ${requestId}`, {
@@ -372,12 +374,13 @@ class FrameHandoffManager {
   async notifyChangesRequested(requestId, approval) {
     const progress = this.activeHandoffs.get(requestId);
     if (!progress) return;
+    const metadata = this.handoffMetadata.get(requestId);
+    const requesterId = metadata?.initiatorId || "unknown";
     const changeRequestNotification = {
       id: `${requestId}-changes-${Date.now()}`,
       type: "request",
       requestId,
-      recipientId: "requester",
-      // TODO: Get actual requester from handoff metadata
+      recipientId: requesterId,
       title: "Changes Requested for Handoff",
       message: `${approval.reviewerId} has requested changes: ${approval.feedback || "See detailed suggestions"}`,
       actionRequired: true,
@@ -385,9 +388,9 @@ class FrameHandoffManager {
       // 48 hours
       createdAt: /* @__PURE__ */ new Date()
     };
-    const notifications = this.notifications.get("requester") || [];
+    const notifications = this.notifications.get(requesterId) || [];
     notifications.push(changeRequestNotification);
-    this.notifications.set("requester", notifications);
+    this.notifications.set(requesterId, notifications);
     logger.info(`Changes requested for handoff: ${requestId}`, {
       reviewer: approval.reviewerId,
       feedback: approval.feedback,

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

@@ -9,6 +9,13 @@ class DatabaseAdapter {
     this.projectId = projectId;
     this.config = config || {};
   }
+  // Paginated table reads (for migration)
+  async getTablePage(table, offset, limit) {
+    void table;
+    void offset;
+    void limit;
+    return [];
+  }
   /** Returns the configured embedding provider, if any */
   getEmbeddingProvider() {
     return void 0;

package/dist/src/core/database/migration-manager.js

@@ -307,25 +307,12 @@ class MigrationManager extends EventEmitter {
     }
     const safeLimit = Math.max(1, Math.min(limit, 1e4));
     const safeOffset = Math.max(0, offset);
-    void safeLimit;
-    void safeOffset;
-    switch (table) {
-      case "frames":
-        return [];
-      // Placeholder
-      case "events":
-        return [];
-      // Placeholder
-      case "anchors":
-        return [];
-      // Placeholder
-      default:
-        throw new DatabaseError(
-          `Unsupported table: ${table}`,
-          ErrorCode.DB_QUERY_FAILED,
-          { table }
-        );
-    }
+    const validTable = table;
+    return this.config.sourceAdapter.getTablePage(
+      validTable,
+      safeOffset,
+      safeLimit
+    );
   }
   async migrateBatch(table, batch) {
     const allowedTables = ["frames", "events", "anchors"];

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

@@ -292,11 +292,16 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
     logger.info("FTS5 index rebuilt");
   }
   /**
-   * Incremental garbage collection: delete expired frames and cascade to related tables.
-   * Respects retention_policy per frame:
+   * Incremental garbage collection with generational compression.
+   *
+   * Phase 1 — Compress: Apply generational strategies to mature/old frames.
+   *   - 'digest_only': Strip inputs/outputs/events, keep digest + anchors
+   *   - 'anchors_only': Strip inputs/outputs/events/digest_json, keep digest_text + anchors
+   *   - 'keep_all': No compression
+   *
+   * Phase 2 — Delete: Remove frames past retention cutoffs.
    *   - 'keep_forever': never deleted
-   *   - 'default': deleted after retentionDays (default 90)
-   *   - 'archive': same as default
+   *   - 'default'/'archive': deleted after retentionDays (default 90)
    *   - 'ttl_30d': deleted after 30 days
    *   - 'ttl_7d': deleted after 7 days
    */
@@ -314,6 +319,62 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
     const defaultCutoff = nowSec - retentionDays * 86400;
     const ttl30dCutoff = nowSec - 30 * 86400;
     const ttl7dCutoff = nowSec - 7 * 86400;
+    let framesCompressed = 0;
+    const gc = options.generationalGc;
+    if (gc && !dryRun) {
+      const youngDays = gc.youngCutoffDays ?? 1;
+      const matureDays = gc.matureCutoffDays ?? 7;
+      const oldDays = gc.oldCutoffDays ?? 30;
+      const youngCutoff = nowSec - youngDays * 86400;
+      const matureCutoff = nowSec - matureDays * 86400;
+      const matureStrategy = gc.mature_strategy ?? "digest_only";
+      if (matureStrategy !== "keep_all") {
+        const matureFrames = this.db.prepare(
+          `SELECT frame_id FROM frames
+             WHERE created_at < ? AND created_at >= ?
+             AND state = 'closed'
+             AND retention_policy != 'keep_forever'
+             AND inputs != '{}'
+             AND run_id NOT IN (SELECT value FROM json_each(?))
+             LIMIT ?`
+        ).all(
+          youngCutoff,
+          matureCutoff,
+          JSON.stringify(protectedRunIds),
+          batchSize
+        );
+        if (matureFrames.length > 0) {
+          framesCompressed += this.compressFrames(
+            matureFrames.map((f) => f.frame_id),
+            matureStrategy
+          );
+        }
+      }
+      const oldStrategy = gc.old_strategy ?? "anchors_only";
+      if (oldStrategy !== "keep_all") {
+        const oldCutoff = nowSec - oldDays * 86400;
+        const oldFrames = this.db.prepare(
+          `SELECT frame_id FROM frames
+             WHERE created_at < ? AND created_at >= ?
+             AND state = 'closed'
+             AND retention_policy != 'keep_forever'
+             AND inputs != '{}'
+             AND run_id NOT IN (SELECT value FROM json_each(?))
+             LIMIT ?`
+        ).all(
+          matureCutoff,
+          oldCutoff,
+          JSON.stringify(protectedRunIds),
+          batchSize
+        );
+        if (oldFrames.length > 0) {
+          framesCompressed += this.compressFrames(
+            oldFrames.map((f) => f.frame_id),
+            oldStrategy
+          );
+        }
+      }
+    }
     const candidates = this.db.prepare(
       `SELECT frame_id FROM frames
          WHERE (
@@ -340,7 +401,8 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
         eventsDeleted: 0,
         anchorsDeleted: 0,
         embeddingsDeleted: 0,
-        ftsEntriesDeleted: 0
+        ftsEntriesDeleted: 0,
+        framesCompressed
       };
     }
     if (dryRun) {
@@ -362,8 +424,9 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
         eventsDeleted: eventsCount,
         anchorsDeleted: anchorsCount,
         embeddingsDeleted: embeddingsCount,
-        ftsEntriesDeleted: frameIds.length
+        ftsEntriesDeleted: frameIds.length,
         // FTS has one entry per frame
+        framesCompressed
       };
     }
     const placeholders = frameIds.map(() => "?").join(",");
@@ -392,14 +455,16 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
       framesDeleted: frameIds.length,
       eventsDeleted,
       anchorsDeleted,
-      embeddingsDeleted
+      embeddingsDeleted,
+      framesCompressed
     });
     return {
       framesDeleted: frameIds.length,
       eventsDeleted,
       anchorsDeleted,
       embeddingsDeleted,
-      ftsEntriesDeleted: frameIds.length
+      ftsEntriesDeleted: frameIds.length,
+      framesCompressed
     };
   }
   /**
@@ -432,6 +497,85 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
     if (nowSec - frame.created_at < 86400) score += 0.1;
     return Math.round(Math.min(score, 1) * 100) / 100;
   }
+  /**
+   * Compress a frame by stripping data according to strategy.
+   *
+   * - 'digest_only': Remove inputs, outputs, events. Keep digest_text, digest_json, anchors.
+   * - 'anchors_only': Remove inputs, outputs, events, digest_json. Keep digest_text, anchors.
+   *
+   * Returns true if the frame was compressed, false if not found.
+   */
+  compressFrame(frameId, strategy) {
+    if (!this.db)
+      throw new DatabaseError(
+        "Database not connected",
+        ErrorCode.DB_CONNECTION_FAILED
+      );
+    const frame = this.db.prepare("SELECT frame_id FROM frames WHERE frame_id = ?").get(frameId);
+    if (!frame) return false;
+    this.db.prepare("BEGIN").run();
+    try {
+      if (strategy === "digest_only") {
+        this.db.prepare(
+          "UPDATE frames SET inputs = '{}', outputs = '{}' WHERE frame_id = ?"
+        ).run(frameId);
+      } else {
+        this.db.prepare(
+          "UPDATE frames SET inputs = '{}', outputs = '{}', digest_json = '{}' WHERE frame_id = ?"
+        ).run(frameId);
+      }
+      this.db.prepare("DELETE FROM events WHERE frame_id = ?").run(frameId);
+      if (this.vecEnabled) {
+        this.db.prepare("DELETE FROM frame_embeddings WHERE frame_id = ?").run(frameId);
+      }
+      this.db.prepare("COMMIT").run();
+      return true;
+    } catch (error) {
+      this.db.prepare("ROLLBACK").run();
+      throw error;
+    }
+  }
+  /**
+   * Compress multiple frames in a single transaction.
+   * Returns count of frames compressed.
+   */
+  compressFrames(frameIds, strategy) {
+    if (!this.db || frameIds.length === 0) return 0;
+    const placeholders = frameIds.map(() => "?").join(",");
+    this.db.prepare("BEGIN").run();
+    try {
+      if (strategy === "digest_only") {
+        this.db.prepare(
+          `UPDATE frames SET inputs = '{}', outputs = '{}' WHERE frame_id IN (${placeholders})`
+        ).run(...frameIds);
+      } else {
+        this.db.prepare(
+          `UPDATE frames SET inputs = '{}', outputs = '{}', digest_json = '{}' WHERE frame_id IN (${placeholders})`
+        ).run(...frameIds);
+      }
+      this.db.prepare(`DELETE FROM events WHERE frame_id IN (${placeholders})`).run(...frameIds);
+      if (this.vecEnabled) {
+        this.db.prepare(
+          `DELETE FROM frame_embeddings WHERE frame_id IN (${placeholders})`
+        ).run(...frameIds);
+      }
+      this.db.prepare("COMMIT").run();
+      return frameIds.length;
+    } catch (error) {
+      this.db.prepare("ROLLBACK").run();
+      throw error;
+    }
+  }
+  /**
+   * Get database file size in bytes.
+   */
+  getDatabaseSize() {
+    if (!this.db) return 0;
+    const result = this.db.prepare(
+      "SELECT page_count * page_size as size FROM pragma_page_count(), pragma_page_size()"
+    ).get();
+    return result?.size ?? 0;
+  }
   /**
    * Recompute importance scores for frames still at default score (0.5).
    * Processes oldest frames first in batches.
@@ -1222,6 +1366,24 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
       }
     });
   }
+  async getTablePage(table, offset, limit) {
+    if (!this.db)
+      throw new DatabaseError(
+        "Database not connected",
+        ErrorCode.DB_CONNECTION_FAILED
+      );
+    const safeLimit = Math.max(1, Math.min(limit, 1e4));
+    const safeOffset = Math.max(0, offset);
+    const allowedTables = ["frames", "events", "anchors"];
+    if (!allowedTables.includes(table)) {
+      throw new DatabaseError(
+        `Invalid table name: ${table}`,
+        ErrorCode.DB_QUERY_FAILED,
+        { table }
+      );
+    }
+    return this.db.prepare(`SELECT * FROM ${table} ORDER BY rowid LIMIT ? OFFSET ?`).all(safeLimit, safeOffset);
+  }
   async vacuum() {
     if (!this.db)
       throw new DatabaseError(

package/dist/src/integrations/claude-code/subagent-client.js

@@ -4,8 +4,7 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { logger } from "../../core/monitoring/logger.js";
 import { STRUCTURED_RESPONSE_SUFFIX } from "../../orchestrators/multimodal/constants.js";
-import { exec } from "child_process";
-import { promisify } from "util";
+import { spawn } from "child_process";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
@@ -18,12 +17,11 @@ import {
   createProvider
 } from "../../core/extensions/provider-adapter.js";
 import { AnthropicBatchClient } from "../anthropic/batch-client.js";
-const execAsync = promisify(exec);
 class ClaudeCodeSubagentClient {
   tempDir;
   activeSubagents = /* @__PURE__ */ new Map();
   mockMode;
-  constructor(mockMode = true) {
+  constructor(mockMode = false) {
     this.mockMode = mockMode;
     this.tempDir = path.join(os.tmpdir(), "stackmemory-rlm");
     if (!fs.existsSync(this.tempDir)) {
@@ -148,7 +146,8 @@ class ClaudeCodeSubagentClient {
     }
   }
   /**
-   * Original CLI-based subagent execution (unchanged behavior)
+   * Execute subagent via Claude Code CLI (`claude -p --output-format stream-json`).
+   * Spawns a real Claude Code process with full tool use.
    */
   async executeSubagentViaCLI(request, startTime, subagentId) {
     try {
@@ -158,31 +157,24 @@ class ClaudeCodeSubagentClient {
         contextFile,
         JSON.stringify(request.context, null, 2)
       );
-      const resultFile = path.join(this.tempDir, `${subagentId}-result.json`);
-      const taskCommand = this.buildTaskCommand(
-        request,
-        prompt,
-        contextFile,
-        resultFile
-      );
-      const result = await this.executeTaskTool(taskCommand, request.timeout);
-      let subagentResult = {};
-      if (fs.existsSync(resultFile)) {
-        const resultContent = await fs.promises.readFile(resultFile, "utf-8");
-        try {
-          subagentResult = JSON.parse(resultContent);
-        } catch {
-          subagentResult = { rawOutput: resultContent };
-        }
-      }
+      const fullPrompt = `${prompt}
+
+Context (JSON): ${JSON.stringify(request.context)}`;
+      const result = await this.spawnClaude(fullPrompt, request.timeout);
       this.cleanup(subagentId);
+      let parsed;
+      try {
+        parsed = JSON.parse(result.text);
+      } catch {
+        parsed = { rawOutput: result.text };
+      }
       return {
         success: true,
-        result: subagentResult,
-        output: result.stdout,
+        result: parsed,
+        output: result.text,
         duration: Date.now() - startTime,
         subagentType: request.type,
-        tokens: this.estimateTokens(prompt + JSON.stringify(subagentResult))
+        tokens: this.estimateTokens(fullPrompt + result.text)
       };
     } catch (error) {
       logger.error(`Subagent CLI execution failed: ${request.type}`, {
@@ -347,66 +339,94 @@ class ClaudeCodeSubagentClient {
     return (request.systemPrompt || prompts[request.type] || prompts.planning) + STRUCTURED_RESPONSE_SUFFIX;
   }
   /**
-   * Build Task tool command
-   * This creates a command that Claude Code's Task tool can execute
+   * Spawn `claude -p --output-format stream-json` and collect the result.
+   * Parses stream-json events to extract the final assistant text.
    */
-  buildTaskCommand(request, prompt, contextFile, resultFile) {
-    const scriptContent = `
-#!/bin/bash
-# Subagent execution script for ${request.type}
-
-# Read context
-CONTEXT=$(cat "${contextFile}")
-
-# Execute task based on type
-case "${request.type}" in
-  "testing")
-    # For testing subagent, actually run tests
-    echo "Generating and running tests..."
-    # The subagent will generate test files and run them
-    ;;
-  "linting")
-    # For linting subagent, run actual linters
-    echo "Running linters..."
-    npm run lint || true
-    ;;
-  "code")
-    # For code generation, create implementation files
-    echo "Generating implementation..."
-    ;;
-  *)
-    # Default behavior
-    echo "Executing ${request.type} task..."
-    ;;
-esac
-
-# Write result
-echo '{"status": "completed", "type": "${request.type}"}' > "${resultFile}"
-`;
-    const scriptFile = path.join(this.tempDir, `${request.type}-script.sh`);
-    fs.writeFileSync(scriptFile, scriptContent);
-    fs.chmodSync(scriptFile, "755");
-    return scriptFile;
-  }
-  /**
-   * Execute via Task tool (simulated for now)
-   * In production, this would use Claude Code's actual Task tool API
-   */
-  async executeTaskTool(command, timeout) {
-    try {
-      const result = await execAsync(command, {
-        timeout: timeout || 3e5,
-        // 5 minutes default
-        maxBuffer: 10 * 1024 * 1024
-        // 10MB buffer
+  spawnClaude(prompt, timeout) {
+    return new Promise((resolve, reject) => {
+      const args = [
+        "-p",
+        "--output-format",
+        "stream-json",
+        "--dangerously-skip-permissions",
+        prompt
+      ];
+      const claude = spawn("claude", args, {
+        cwd: process.cwd(),
+        env: { ...process.env },
+        stdio: ["pipe", "pipe", "pipe"]
       });
-      return result;
-    } catch (error) {
-      if (error.killed || error.signal === "SIGTERM") {
-        throw new Error(`Subagent timeout after ${timeout}ms`);
-      }
-      throw error;
-    }
+      const timeoutMs = timeout || 3e5;
+      const timer = setTimeout(() => {
+        claude.kill("SIGTERM");
+        reject(new Error(`Subagent timeout after ${timeoutMs}ms`));
+      }, timeoutMs);
+      let lastAssistantText = "";
+      let toolUseCount = 0;
+      let lineBuffer = "";
+      let stderr = "";
+      claude.stdout.on("data", (chunk) => {
+        lineBuffer += chunk.toString();
+        const lines = lineBuffer.split("\n");
+        lineBuffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const event = JSON.parse(line);
+            if (event.type === "assistant" && event.message) {
+              const textBlocks = (event.message.content || []).filter((b) => b.type === "text").map((b) => b.text);
+              if (textBlocks.length > 0) {
+                lastAssistantText = textBlocks.join("\n");
+              }
+              const toolBlocks = (event.message.content || []).filter(
+                (b) => b.type === "tool_use"
+              );
+              toolUseCount += toolBlocks.length;
+            }
+            if (event.type === "result" && event.result) {
+              lastAssistantText = event.result;
+            }
+          } catch {
+          }
+        }
+      });
+      claude.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      claude.on("close", (code) => {
+        clearTimeout(timer);
+        if (lineBuffer.trim()) {
+          try {
+            const event = JSON.parse(lineBuffer);
+            if (event.type === "result" && event.result) {
+              lastAssistantText = event.result;
+            }
+          } catch {
+          }
+        }
+        logger.info("Claude subagent completed", {
+          code,
+          toolUseCount,
+          outputLength: lastAssistantText.length
+        });
+        if (code === 0 && lastAssistantText) {
+          resolve({ text: lastAssistantText, toolUseCount });
+        } else if (code === 0) {
+          resolve({
+            text: "(Claude completed but produced no text output)",
+            toolUseCount
+          });
+        } else {
+          reject(
+            new Error(`Claude exited code ${code}: ${stderr.slice(0, 500)}`)
+          );
+        }
+      });
+      claude.on("error", (err) => {
+        clearTimeout(timer);
+        reject(new Error(`Failed to spawn claude: ${err.message}`));
+      });
+    });
   }
   /**
    * Get mock response for testing

package/dist/src/integrations/claude-code/task-coordinator.js

@@ -3,6 +3,7 @@ import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { v4 as uuidv4 } from "uuid";
+import { spawn } from "child_process";
 import { logger } from "../../core/monitoring/logger.js";
 class ClaudeCodeTaskCoordinator {
   activeTasks = /* @__PURE__ */ new Map();
@@ -205,26 +206,68 @@ class ClaudeCodeTaskCoordinator {
       agentType: agentConfig.type,
       promptTokens: this.estimateTokenUsage(prompt, "")
     });
-    return this.simulateClaudeCodeExecution(agentName, prompt, agentConfig);
+    return this.spawnClaudeCode(agentName, prompt, agentConfig);
   }
   /**
-   * Simulate Claude Code execution (temporary until real integration)
+   * Spawn Claude Code CLI as a subprocess.
+   * Uses `claude --print` for non-interactive execution with stdout capture.
+   * Workspace cwd is inherited from the coordinator's process.
    */
-  simulateClaudeCodeExecution(agentName, prompt, agentConfig) {
-    return new Promise((resolve) => {
-      const executionTime = agentConfig.type === "oracle" ? 2e3 + Math.random() * 3e3 : 1e3 + Math.random() * 2e3;
-      setTimeout(() => {
-        const result = `Claude Code agent '${agentName}' completed task successfully.
-        
-Agent Capabilities Used: ${agentConfig.capabilities.slice(0, 3).join(", ")}
-Task Type: ${agentConfig.type}
-Specializations: ${agentConfig.specializations.join(", ")}
-
-Simulated output based on prompt context: ${prompt.substring(0, 100)}...
-
-This simulation will be replaced with actual Claude Code Task tool integration.`;
-        resolve(result);
-      }, executionTime);
+  spawnClaudeCode(agentName, prompt, agentConfig) {
+    return new Promise((resolve, reject) => {
+      const args = ["--print"];
+      if (agentConfig.type === "oracle") {
+        args.push("--model", "opus");
+      }
+      if (agentConfig.capabilities.includes("code_implementation")) {
+        args.push("--allowedTools", "Edit,Write,Bash,Read,Glob,Grep");
+      } else {
+        args.push("--allowedTools", "Read,Glob,Grep,Bash");
+      }
+      args.push(prompt);
+      logger.info("Spawning claude CLI", {
+        agentName,
+        agentType: agentConfig.type,
+        cwd: process.cwd(),
+        promptLength: prompt.length
+      });
+      const proc = spawn("claude", args, {
+        cwd: process.cwd(),
+        env: { ...process.env },
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("error", (err) => {
+        logger.error("Failed to spawn claude CLI", {
+          agentName,
+          error: err.message
+        });
+        reject(new Error(`Failed to spawn claude: ${err.message}`));
+      });
+      proc.on("close", (code) => {
+        if (code === 0) {
+          logger.debug("Claude CLI completed", {
+            agentName,
+            outputLength: stdout.length
+          });
+          resolve(stdout.trim());
+        } else {
+          const errMsg = stderr.slice(0, 500) || `exit code ${code}`;
+          logger.warn("Claude CLI failed", {
+            agentName,
+            exitCode: code,
+            stderr: errMsg
+          });
+          reject(new Error(`Claude CLI exited with code ${code}: ${errMsg}`));
+        }
+      });
     });
   }
   /**

package/dist/src/integrations/mcp/handlers/linear-handlers.js

@@ -2,11 +2,19 @@ import { fileURLToPath as __fileURLToPath } from 'url';
 import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
+import { LinearClient } from "../../linear/client.js";
 import { logger } from "../../../core/monitoring/logger.js";
 class LinearHandlers {
   constructor(deps) {
     this.deps = deps;
   }
+  /**
+   * Create an authenticated LinearClient from the auth manager token
+   */
+  async getClient() {
+    const token = await this.deps.linearAuthManager.getValidToken();
+    return new LinearClient({ apiKey: token, useBearer: true });
+  }
   /**
    * Sync tasks with Linear
    */
@@ -67,7 +75,7 @@ class LinearHandlers {
     }
   }
   /**
-   * Update Linear task status
+   * Update Linear issue directly via GraphQL API
    */
   async handleLinearUpdateTask(args) {
     try {
@@ -75,27 +83,30 @@ class LinearHandlers {
       if (!linear_id) {
         throw new Error("Linear ID is required");
       }
-      try {
-        await this.deps.linearAuthManager.getValidToken();
-      } catch {
-        throw new Error("Linear authentication required");
-      }
+      const client = await this.getClient();
       const updateData = {};
-      if (status) {
-        updateData.status = status;
-      }
-      if (assignee_id) {
-        updateData.assigneeId = assignee_id;
-      }
-      if (priority) {
-        updateData.priority = priority;
-      }
+      if (status) updateData.stateId = status;
+      if (assignee_id) updateData.assigneeId = assignee_id;
+      if (priority !== void 0) updateData.priority = priority;
       if (labels) {
-        updateData.labels = Array.isArray(labels) ? labels : [labels];
+        updateData.labelIds = Array.isArray(labels) ? labels : [labels];
       }
-      throw new Error(
-        "Linear issue updates via MCP are not yet implemented. Use `stackmemory linear sync` instead."
-      );
+      const issue = await client.updateIssue(linear_id, updateData);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Updated ${issue.identifier}: ${issue.title}
+Status: ${issue.state.name} | Priority: ${issue.priority}`
+          }
+        ],
+        metadata: {
+          id: issue.id,
+          identifier: issue.identifier,
+          state: issue.state.name,
+          url: issue.url
+        }
+      };
     } catch (error) {
       logger.error(
         "Error updating Linear task",
@@ -105,40 +116,43 @@ class LinearHandlers {
     }
   }
   /**
-   * Get tasks from Linear
+   * Get issues from Linear via GraphQL API
    */
   async handleLinearGetTasks(args) {
     try {
-      const {
-        team_id,
-        assignee_id,
-        state = "active",
-        limit = 20,
-        search
-      } = args;
-      try {
-        await this.deps.linearAuthManager.getValidToken();
-      } catch {
-        throw new Error("Linear authentication required");
-      }
-      const filters = {
-        limit
+      const { team_id, assignee_id, state = "active", limit = 20 } = args;
+      const client = await this.getClient();
+      const stateTypeMap = {
+        active: "started",
+        closed: "completed",
+        all: void 0
       };
-      if (team_id) {
-        filters.teamId = team_id;
-      }
-      if (assignee_id) {
-        filters.assigneeId = assignee_id;
-      }
-      if (state) {
-        filters.state = state;
-      }
-      if (search) {
-        filters.search = search;
-      }
-      throw new Error(
-        "Linear issue listing via MCP is not yet implemented. Use `stackmemory linear sync` instead."
+      const issues = await client.getIssues({
+        teamId: team_id,
+        assigneeId: assignee_id,
+        stateType: stateTypeMap[state],
+        limit
+      });
+      const issueLines = issues.map(
+        (i) => `${i.identifier} [${i.state.name}] ${i.title}${i.assignee ? ` (@${i.assignee.name})` : ""}`
       );
+      const text = issues.length > 0 ? `Found ${issues.length} issues:
+${issueLines.join("\n")}` : "No issues found matching filters.";
+      return {
+        content: [{ type: "text", text }],
+        metadata: {
+          count: issues.length,
+          issues: issues.map((i) => ({
+            id: i.id,
+            identifier: i.identifier,
+            title: i.title,
+            state: i.state.name,
+            priority: i.priority,
+            assignee: i.assignee?.name,
+            url: i.url
+          }))
+        }
+      };
     } catch (error) {
       logger.error(
         "Error getting Linear tasks",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackmemoryai/stackmemory",
-  "version": "1.2.9",
+  "version": "1.3.1",
   "description": "Project-scoped memory for AI coding tools. Durable context across sessions with 56 MCP tools, FTS5 search, Claude/Codex/OpenCode wrappers, Linear sync, automatic hooks, and log analysis.",
   "engines": {
     "node": ">=20.0.0",