@stackmemoryai/stackmemory 1.3.2 → 1.4.0

package/dist/src/cli/commands/{symphony.js → orchestrate.js}

@@ -3,14 +3,15 @@ import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { Command } from "commander";
+import { execSync } from "child_process";
 import { existsSync, mkdirSync, writeFileSync } from "fs";
 import { join } from "path";
 import { homedir, tmpdir } from "os";
 import Database from "better-sqlite3";
 import { logger } from "../../core/monitoring/logger.js";
-import { SymphonyOrchestrator } from "./symphony-orchestrator.js";
+import { Conductor } from "./orchestrator.js";
 function getGlobalStorePath() {
-  const dir = join(homedir(), ".stackmemory", "symphony");
+  const dir = join(homedir(), ".stackmemory", "conductor");
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true });
   }
@@ -42,9 +43,9 @@ function getGlobalDb() {
   `);
   return db;
 }
-function createSymphonyCommands() {
-  const cmd = new Command("symphony");
-  cmd.description("Symphony orchestrator integration commands");
+function createConductorCommands() {
+  const cmd = new Command("conductor");
+  cmd.description("Conductor \u2014 autonomous agent orchestration via Linear");
   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;
@@ -54,16 +55,20 @@ function createSymphonyCommands() {
     let framesJson = "[]";
     let anchorsJson = "[]";
     let eventsJson = "[]";
+    let frameCount = 0;
+    let anchorCount = 0;
     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();
+        frameCount = frames.length;
         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();
+        anchorCount = anchors.length;
         anchorsJson = JSON.stringify(anchors);
         const events = db.prepare(
           "SELECT event_type, payload, ts FROM events ORDER BY ts DESC LIMIT 50"
@@ -80,7 +85,6 @@ function createSymphonyCommands() {
     }
     let metadata = { workspace, attempt };
     try {
-      const { execSync } = await import("child_process");
       const branch = execSync("git rev-parse --abbrev-ref HEAD", {
         cwd: workspace,
         encoding: "utf8",
@@ -113,8 +117,6 @@ function createSymphonyCommands() {
       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})`
     );
@@ -124,7 +126,7 @@ function createSymphonyCommands() {
     const issueId = options.issue;
     const globalDbPath = join(getGlobalStorePath(), "context.db");
     if (!existsSync(globalDbPath)) {
-      console.log("No prior Symphony context found");
+      console.log("No prior orchestrator context found");
       return;
     }
     const globalDb = getGlobalDb();
@@ -186,7 +188,7 @@ function createSymphonyCommands() {
     if (!existsSync(restoreDir)) {
       mkdirSync(restoreDir, { recursive: true });
     }
-    const restorePath = join(restoreDir, "symphony-context.md");
+    const restorePath = join(restoreDir, "conductor-context.md");
     writeFileSync(restorePath, lines.join("\n"));
     globalDb.close();
     console.log(
@@ -227,10 +229,10 @@ function createSymphonyCommands() {
       `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) => {
+  cmd.command("search").description("Search across all orchestrator 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");
+      console.log("No orchestrator context database found");
       return;
     }
     const limit = parseInt(options.limit, 10);
@@ -261,7 +263,7 @@ function createSymphonyCommands() {
     }
     globalDb.close();
   });
-  cmd.command("start").description("Start the Symphony orchestrator daemon").option("--team <id>", "Linear team ID").option(
+  cmd.command("start").description("Start the orchestrator daemon").option("--team <id>", "Linear team ID").option(
     "--states <states>",
     "Comma-separated issue states to pick up",
     "Todo"
@@ -274,23 +276,23 @@ function createSymphonyCommands() {
     "State name for completed review",
     "In Review"
   ).option("--poll <ms>", "Polling interval in milliseconds", "30000").option("--concurrency <n>", "Max concurrent agents", "3").option("--workspace-root <path>", "Workspace root directory").option("--repo <path>", "Git repo root for worktrees", process.cwd()).option("--branch <name>", "Base branch for worktrees", "main").option("--retries <n>", "Max retries per issue", "1").option("--turn-timeout <ms>", "Agent turn timeout in ms", "3600000").action(async (options) => {
-    const orchestrator = new SymphonyOrchestrator({
+    const conductor = new Conductor({
       teamId: options.team,
       activeStates: options.states.split(",").map((s) => s.trim()),
       inProgressState: options.inProgress,
       inReviewState: options.inReview,
       pollIntervalMs: parseInt(options.poll, 10),
       maxConcurrent: parseInt(options.concurrency, 10),
-      workspaceRoot: options.workspaceRoot || join(tmpdir(), "symphony_workspaces"),
+      workspaceRoot: options.workspaceRoot || join(tmpdir(), "conductor_workspaces"),
       repoRoot: options.repo,
       baseBranch: options.branch,
       maxRetries: parseInt(options.retries, 10),
       turnTimeoutMs: parseInt(options.turnTimeout, 10)
     });
-    await orchestrator.start();
+    await conductor.start();
   });
   return cmd;
 }
 export {
-  createSymphonyCommands
+  createConductorCommands
 };

package/dist/src/cli/commands/{symphony-orchestrator.js → orchestrator.js}

@@ -11,6 +11,11 @@ import {
   LinearClient
 } from "../../integrations/linear/client.js";
 import { LinearAuthManager } from "../../integrations/linear/auth.js";
+import {
+  PreflightChecker
+} from "../../core/worktree/preflight.js";
+import { ContextCapture } from "../../core/worktree/capture.js";
+import { extractKeywords } from "../../core/utils/text.js";
 const DEFAULT_CONFIG = {
   activeStates: ["Todo"],
   terminalStates: ["Done", "Cancelled", "Canceled", "Closed"],
@@ -18,7 +23,7 @@ const DEFAULT_CONFIG = {
   inReviewState: "In Review",
   pollIntervalMs: 3e4,
   maxConcurrent: 3,
-  workspaceRoot: join(tmpdir(), "symphony_workspaces"),
+  workspaceRoot: join(tmpdir(), "conductor_workspaces"),
   repoRoot: process.cwd(),
   baseBranch: "main",
   appServerPath: join(
@@ -27,14 +32,14 @@ const DEFAULT_CONFIG = {
     "..",
     "..",
     "scripts",
-    "symphony",
+    "conductor",
     "claude-app-server.cjs"
   ),
   turnTimeoutMs: 36e5,
   maxRetries: 1,
   hookTimeoutMs: 6e4
 };
-class SymphonyOrchestrator {
+class Conductor {
   config;
   client = null;
   running = /* @__PURE__ */ new Map();
@@ -47,8 +52,16 @@ class SymphonyOrchestrator {
   completeCount = 0;
   stopping = false;
   stateCache = /* @__PURE__ */ new Map();
+  activeStatesLower;
+  terminalStatesLower;
   constructor(config = {}) {
     this.config = { ...DEFAULT_CONFIG, ...config };
+    this.activeStatesLower = this.config.activeStates.map(
+      (s) => s.trim().toLowerCase()
+    );
+    this.terminalStatesLower = this.config.terminalStates.map(
+      (s) => s.trim().toLowerCase()
+    );
   }
   /**
    * Start the orchestrator loop.
@@ -77,14 +90,14 @@ class SymphonyOrchestrator {
     }
     this.client = await this.createLinearClient();
     await this.cacheWorkflowStates();
-    logger.info("Symphony orchestrator started", {
+    logger.info("Orchestrator started", {
       activeStates: this.config.activeStates,
       maxConcurrent: this.config.maxConcurrent,
       pollIntervalMs: this.config.pollIntervalMs,
       workspaceRoot: this.config.workspaceRoot
     });
     console.log(
-      `Symphony started \u2014 polling every ${this.config.pollIntervalMs / 1e3}s, max ${this.config.maxConcurrent} concurrent`
+      `Orchestrator started \u2014 polling every ${this.config.pollIntervalMs / 1e3}s, max ${this.config.maxConcurrent} concurrent`
     );
     const shutdown = () => this.stop();
     process.on("SIGINT", shutdown);
@@ -103,8 +116,8 @@ class SymphonyOrchestrator {
   async stop() {
     if (this.stopping) return;
     this.stopping = true;
-    console.log("\nSymphony stopping...");
-    logger.info("Symphony orchestrator stopping", {
+    console.log("\nOrchestrator stopping...");
+    logger.info("Orchestrator stopping", {
       runningCount: this.running.size
     });
     if (this.pollTimer) {
@@ -132,7 +145,7 @@ class SymphonyOrchestrator {
     this.running.clear();
     this.claimed.clear();
     console.log(
-      `Symphony stopped. Completed: ${this.completeCount}, Failed: ${this.failCount}`
+      `Orchestrator stopped. Completed: ${this.completeCount}, Failed: ${this.failCount}`
     );
   }
   /**
@@ -185,10 +198,12 @@ class SymphonyOrchestrator {
       (issue) => !this.claimed.has(issue.id) && !this.completed.has(issue.id)
     );
     if (eligible.length === 0) return;
-    const toDispatch = eligible.sort((a, b) => (a.priority || 4) - (b.priority || 4)).slice(0, available);
+    const sorted = eligible.sort((a, b) => (a.priority || 4) - (b.priority || 4)).slice(0, available);
+    const toDispatch = this.preflightFilter(sorted);
     logger.info("Dispatching issues", {
       count: toDispatch.length,
-      identifiers: toDispatch.map((i) => i.identifier)
+      identifiers: toDispatch.map((i) => i.identifier),
+      skipped: sorted.length - toDispatch.length
     });
     for (const issue of toDispatch) {
       this.dispatch(issue).catch((err) => {
@@ -206,17 +221,81 @@ class SymphonyOrchestrator {
       teamId: this.config.teamId,
       limit: 50
     });
-    const activeStatesLower = this.config.activeStates.map(
-      (s) => s.trim().toLowerCase()
-    );
     for (const issue of issues) {
       const stateName = issue.state.name.trim().toLowerCase();
-      if (activeStatesLower.includes(stateName)) {
+      if (this.activeStatesLower.includes(stateName)) {
         allCandidates.push(issue);
       }
     }
     return allCandidates;
   }
+  // ── Pre-flight ──
+  /**
+   * Filter candidates against running issues using file overlap prediction.
+   * Returns only issues that are parallel-safe with currently running work.
+   */
+  preflightFilter(candidates) {
+    if (candidates.length === 0 || this.running.size === 0) {
+      return candidates;
+    }
+    try {
+      const checker = new PreflightChecker(this.config.repoRoot);
+      const runningFileSets = [];
+      const runningNames = [];
+      for (const run of this.running.values()) {
+        const task = {
+          name: run.issue.identifier,
+          description: run.issue.title,
+          keywords: this.extractIssueKeywords(run.issue)
+        };
+        runningFileSets.push(checker.predictFiles(task));
+        runningNames.push(run.issue.identifier);
+      }
+      const safe = [];
+      for (const candidate of candidates) {
+        const candidateTask = {
+          name: candidate.identifier,
+          description: candidate.title,
+          keywords: this.extractIssueKeywords(candidate)
+        };
+        const candidateFiles = checker.predictFiles(candidateTask);
+        const conflictFiles = [];
+        const conflictTasks = [];
+        for (let i = 0; i < runningFileSets.length; i++) {
+          const shared = [...candidateFiles].filter(
+            (f) => runningFileSets[i].has(f)
+          );
+          if (shared.length > 0) {
+            conflictFiles.push(...shared);
+            conflictTasks.push(runningNames[i]);
+          }
+        }
+        if (conflictFiles.length > 0) {
+          const uniqueFiles = [...new Set(conflictFiles)].slice(0, 3);
+          logger.info("Preflight: skipping conflicting issue", {
+            identifier: candidate.identifier,
+            conflictsWith: conflictTasks,
+            files: uniqueFiles
+          });
+          console.log(
+            `[${candidate.identifier}] Deferred \u2014 file overlap with running work (${uniqueFiles.join(", ")})`
+          );
+        } else {
+          safe.push(candidate);
+        }
+      }
+      return safe;
+    } catch (err) {
+      logger.warn("Preflight check failed, dispatching all", {
+        error: err.message
+      });
+      return candidates;
+    }
+  }
+  extractIssueKeywords(issue) {
+    const labelText = issue.labels.map((l) => l.name).join(" ");
+    return extractKeywords(`${issue.title} ${labelText}`, { maxCount: 8 });
+  }
   // ── Dispatch ──
   async dispatch(issue) {
     const issueId = issue.id;
@@ -242,6 +321,7 @@ class SymphonyOrchestrator {
       run.status = "completed";
       this.completeCount++;
       await this.runHook("after-run", workspacePath, issue, run.attempt);
+      this.takeSnapshot(workspacePath, issue);
       await this.transitionIssue(issue, this.config.inReviewState);
       console.log(`[${issue.identifier}] Completed successfully`);
     } catch (err) {
@@ -314,7 +394,7 @@ class SymphonyOrchestrator {
       });
       return wsPath;
     }
-    const branchName = `symphony/${wsKey}`;
+    const branchName = `conductor/${wsKey}`;
     try {
       execSync("git fetch origin", {
         cwd: this.config.repoRoot,
@@ -398,8 +478,7 @@ class SymphonyOrchestrator {
       run.process = proc;
       let stderr = "";
       let turnCompleted = false;
-      let timer;
-      timer = setTimeout(() => {
+      const timer = setTimeout(() => {
         if (!turnCompleted) {
           logger.warn("Agent turn timeout", {
             identifier: issue.identifier,
@@ -485,14 +564,16 @@ class SymphonyOrchestrator {
     });
   }
   handleAgentMessage(msg, issue, _run) {
+    const params = msg.params;
     if (msg.method === "item/commandExecution/started") {
       logger.debug("Agent tool use", {
         identifier: issue.identifier,
-        tool: msg.params?.tool
+        tool: params?.tool
       });
     }
     if (msg.method === "turn/completed") {
-      const output = msg.params?.result?.output;
+      const result = params?.result;
+      const output = result?.output;
       if (Array.isArray(output)) {
         const text = output.filter((b) => b.type === "text").map((b) => b.text).join("\n");
         if (text) {
@@ -521,7 +602,7 @@ class SymphonyOrchestrator {
     if (attempt > 1) {
       lines.push(
         "",
-        `This is attempt ${attempt}. Check .stackmemory/symphony-context.md for context from prior attempts.`
+        `This is attempt ${attempt}. Check .stackmemory/conductor-context.md for context from prior attempts.`
       );
     }
     lines.push(
@@ -538,12 +619,32 @@ class SymphonyOrchestrator {
     );
     return lines.join("\n");
   }
+  // ── Snapshot ──
+  takeSnapshot(workspacePath, issue) {
+    try {
+      const capture = new ContextCapture(workspacePath);
+      const result = capture.capture({
+        task: `${issue.identifier}: ${issue.title}`
+      });
+      logger.info("Snapshot captured", {
+        identifier: issue.identifier,
+        filesChanged: result.filesChanged.length,
+        filesCreated: result.filesCreated.length,
+        commits: result.commits.length
+      });
+    } catch (err) {
+      logger.warn("Snapshot capture failed", {
+        identifier: issue.identifier,
+        error: err.message
+      });
+    }
+  }
   // ── Hooks ──
   async runHook(hookName, workspacePath, issue, attempt) {
     const hookPath = join(
       this.config.repoRoot,
       "scripts",
-      "symphony",
+      "conductor",
       `${hookName}.sh`
     );
     if (!existsSync(hookPath)) {
@@ -622,16 +723,12 @@ class SymphonyOrchestrator {
   // ── Reconciliation ──
   async reconcile() {
     if (!this.client || this.running.size === 0) return;
-    const terminalLower = this.config.terminalStates.map(
-      (s) => s.trim().toLowerCase()
-    );
     for (const [issueId, run] of this.running) {
       try {
-        const issues = await this.client.getIssues({ limit: 1 });
-        const fresh = issues.find((i) => i.id === issueId);
+        const fresh = await this.client.getIssue(issueId);
         if (!fresh) continue;
         const currentState = fresh.state.name.trim().toLowerCase();
-        if (terminalLower.includes(currentState)) {
+        if (this.terminalStatesLower.includes(currentState)) {
           logger.info(
             "Issue moved to terminal state externally, stopping agent",
             {
@@ -672,5 +769,5 @@ class SymphonyOrchestrator {
   }
 }
 export {
-  SymphonyOrchestrator
+  Conductor
 };

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

@@ -0,0 +1,87 @@
+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 chalk from "chalk";
+import {
+  PreflightChecker
+} from "../../core/worktree/preflight.js";
+function createPreflightCommand() {
+  const cmd = new Command("preflight").alias("pf").description("Check file overlap before running parallel tasks").argument("<tasks...>", "Task descriptions (quoted strings)").option(
+    "-k, --keywords <keywords>",
+    "Comma-separated keywords per task (task1:kw1,kw2;task2:kw3)"
+  ).option(
+    "-f, --files <files>",
+    "Comma-separated files per task (task1:file1,file2;task2:file3)"
+  ).option("--json", "Output as JSON").action((taskArgs, options) => {
+    const checker = new PreflightChecker();
+    const tasks = taskArgs.map((desc, i) => {
+      const task = {
+        name: `task-${i + 1}`,
+        description: desc
+      };
+      if (options.keywords) {
+        const kwParts = options.keywords.split(";");
+        if (kwParts[i]) {
+          const [, kws] = kwParts[i].split(":");
+          if (kws) task.keywords = kws.split(",");
+        }
+      }
+      if (options.files) {
+        const fileParts = options.files.split(";");
+        if (fileParts[i]) {
+          const [, fs] = fileParts[i].split(":");
+          if (fs) task.files = fs.split(",");
+        }
+      }
+      if (desc.length <= 40) {
+        task.name = desc;
+      }
+      return task;
+    });
+    const result = checker.check(tasks);
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(chalk.cyan("\nPre-flight Check\n"));
+    console.log(chalk.gray(`Tasks: ${tasks.length}`));
+    console.log(chalk.gray(`Overlaps: ${result.allOverlaps.length}
+`));
+    if (result.parallelSafe.length === 1 && result.allOverlaps.length === 0) {
+      console.log(chalk.green("All tasks are parallel-safe.\n"));
+      for (const task of result.parallelSafe[0]) {
+        console.log(chalk.green(`  + ${task.name}`));
+      }
+    } else {
+      for (let i = 0; i < result.parallelSafe.length; i++) {
+        const group = result.parallelSafe[i];
+        console.log(chalk.cyan(`Group ${i + 1} (parallel-safe):`));
+        for (const task of group) {
+          console.log(chalk.green(`  + ${task.name}`));
+        }
+      }
+    }
+    if (result.sequential.length > 0) {
+      console.log(chalk.yellow("\nSequential (file overlaps detected):"));
+      for (const entry of result.sequential) {
+        console.log(
+          chalk.yellow(`  "${entry.task.name}" -> after "${entry.after}"`)
+        );
+        for (const overlap of entry.overlaps.slice(0, 5)) {
+          const conf = Math.round(overlap.confidence * 100);
+          console.log(
+            chalk.gray(`    ${overlap.file} (${overlap.source}, ${conf}%)`)
+          );
+        }
+      }
+    }
+    console.log(chalk.gray(`
+${result.summary}`));
+  });
+  return cmd;
+}
+export {
+  createPreflightCommand
+};

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

@@ -0,0 +1,89 @@
+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 chalk from "chalk";
+import { ContextCapture } from "../../core/worktree/capture.js";
+function createSnapshotCommand() {
+  const cmd = new Command("snapshot").alias("snap").description("Point-in-time snapshot of work (what changed and why)");
+  cmd.command("save").alias("s").description("Save a snapshot of current branch state").option("-t, --task <name>", "Task name or description").option(
+    "-b, --base <branch>",
+    "Base branch to diff against (default: auto-detect)"
+  ).option(
+    "-d, --decision <decisions...>",
+    "Key decisions made during this task"
+  ).option("--json", "Output as JSON").action((options) => {
+    const capture = new ContextCapture();
+    const result = capture.capture({
+      task: options.task,
+      baseBranch: options.base,
+      decisions: options.decision
+    });
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(chalk.green("\nSnapshot saved.\n"));
+    console.log(chalk.gray(`  Branch: ${result.branch}`));
+    console.log(chalk.gray(`  Base: ${result.baseBranch}`));
+    console.log(chalk.gray(`  Changed: ${result.filesChanged.length} files`));
+    console.log(chalk.gray(`  Created: ${result.filesCreated.length} files`));
+    console.log(chalk.gray(`  Deleted: ${result.filesDeleted.length} files`));
+    console.log(chalk.gray(`  Commits: ${result.commits.length}`));
+    if (result.decisions.length > 0) {
+      console.log(chalk.cyan("\n  Decisions:"));
+      result.decisions.forEach((d) => console.log(chalk.gray(`    - ${d}`)));
+    }
+    if (result.duration) {
+      console.log(chalk.gray(`  Duration: ${result.duration}`));
+    }
+    console.log(chalk.gray(`
+  Saved: ${result.id}`));
+  });
+  cmd.command("list").alias("ls").description("List recent snapshots").option("-n, --limit <n>", "Number of captures to show", "10").option("--json", "Output as JSON").action((options) => {
+    const capture = new ContextCapture();
+    const captures = capture.list(parseInt(options.limit));
+    if (captures.length === 0) {
+      console.log(chalk.yellow("No snapshots found."));
+      return;
+    }
+    if (options.json) {
+      console.log(JSON.stringify(captures, null, 2));
+      return;
+    }
+    console.log(chalk.cyan(`
+Recent Snapshots (${captures.length}):
+`));
+    for (const cap of captures) {
+      const date = new Date(cap.timestamp).toLocaleDateString();
+      const files = cap.filesChanged.length + cap.filesCreated.length;
+      console.log(
+        chalk.gray(
+          `  ${date}  ${cap.branch.padEnd(30)}  ${files} files  ${cap.commits.length} commits`
+        )
+      );
+    }
+  });
+  cmd.command("show [branch]").description("Show snapshot details (latest or by branch)").option("--json", "Output as JSON").action((branch, options) => {
+    const capturer = new ContextCapture();
+    const result = capturer.getLatest(branch);
+    if (!result) {
+      console.log(
+        chalk.yellow(
+          branch ? `No snapshot found for branch: ${branch}` : "No snapshots found."
+        )
+      );
+      return;
+    }
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(capturer.format(result));
+  });
+  return cmd;
+}
+export {
+  createSnapshotCommand
+};

package/dist/src/cli/index.js

@@ -57,7 +57,9 @@ 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 { createConductorCommands } from "./commands/orchestrate.js";
+import { createPreflightCommand } from "./commands/preflight.js";
+import { createSnapshotCommand } from "./commands/snapshot.js";
 import chalk from "chalk";
 import * as fs from "fs";
 import * as path from "path";
@@ -508,7 +510,9 @@ program.addCommand(createBenchCommand());
 program.addCommand(createDigestCommands());
 program.addCommand(createTeamCommands());
 program.addCommand(createDesiresCommands());
-program.addCommand(createSymphonyCommands());
+program.addCommand(createConductorCommands());
+program.addCommand(createPreflightCommand());
+program.addCommand(createSnapshotCommand());
 registerSetupCommands(program);
 program.command("mm-spike").description(
   "Run multi-agent planning/implementation spike (planner/implementer/critic)"

package/dist/src/core/retrieval/summary-generator.js

@@ -6,6 +6,7 @@ import {
   DEFAULT_RETRIEVAL_CONFIG
 } from "./types.js";
 import { logger } from "../monitoring/logger.js";
+import { extractKeywords as extractKeywordsShared } from "../utils/text.js";
 class CompressedSummaryGenerator {
   db;
   frameManager;
@@ -570,20 +571,7 @@ class CompressedSummaryGenerator {
     }
   }
   extractKeywords(text) {
-    const stopWords = /* @__PURE__ */ new Set([
-      "the",
-      "a",
-      "an",
-      "and",
-      "or",
-      "but",
-      "in",
-      "on",
-      "at",
-      "to",
-      "for"
-    ]);
-    return text.toLowerCase().split(/\W+/).filter((word) => word.length > 2 && !stopWords.has(word));
+    return extractKeywordsShared(text, { maxCount: 20 });
   }
   /**
    * Clear the cache

package/dist/src/core/utils/fs.js

@@ -0,0 +1,18 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { readdirSync, unlinkSync } from "fs";
+import { join } from "path";
+function pruneOldFiles(dir, ext, maxKeep) {
+  try {
+    const files = readdirSync(dir).filter((f) => f.endsWith(ext)).sort().reverse();
+    for (const old of files.slice(maxKeep)) {
+      unlinkSync(join(dir, old));
+    }
+  } catch {
+  }
+}
+export {
+  pruneOldFiles
+};