@stackmemoryai/stackmemory 1.3.2 → 1.5.0

package/README.md

@@ -22,6 +22,9 @@ StackMemory is a **production-ready memory runtime** for AI coding tools that pr
 - **Multi-wrapper support** — `claude-sm`, `codex-sm`, `opencode-sm` with auto context loading
 - **Skills system** with `/spec` and `/linear-run` for Claude Code
 - **Automatic hooks** for task tracking, Linear sync, and spec progress
+- **Snapshot capture** — post-run context snapshots for session handoff (`snapshot save`)
+- **Pre-flight overlap check** — predict file conflicts before parallel task dispatch (`preflight`)
+- **Conductor orchestrator** — polls Linear, creates worktrees, spawns agents with bounded concurrency
 - **Memory monitor daemon** with automatic capture/clear on RAM pressure
 - **Auto-save service** for periodic context persistence
 - **Comprehensive test coverage** across all core modules
@@ -63,6 +66,8 @@ Tools forget decisions and constraints between sessions. StackMemory makes conte
 - **Hooks**: automatic context save, task tracking, Linear sync, PROMPT_PLAN updates, cord tracing
 - **Prompt Forge**: watches CLAUDE.md and AGENTS.md for prompt optimization (GEPA)
 - **Safe branches**: worktree isolation with `--worktree` or `-w`
+- **Snapshot**: post-run context capture — records what changed, commits, and decisions (`stackmemory snapshot`)
+- **Pre-flight check**: file overlap prediction before parallel task dispatch (`stackmemory preflight`)
 - **Persistent context**: frames, anchors, decisions, retrieval
 - **Integrations**: Linear (API key + OAuth), DiffMem, Browser MCP, log-mcp (log analysis)
 
@@ -351,6 +356,39 @@ npm run mcp:dev
 
 See [docs/cli.md](https://github.com/stackmemoryai/stackmemory/blob/main/docs/cli.md) for the full command reference.
 
+### Snapshot (`snapshot` / `snap`)
+
+Capture a point-in-time snapshot of what changed on your branch — files modified, commits, and key decisions. Useful for session handoff and post-task review.
+
+```bash
+# Save a snapshot of current branch state
+stackmemory snapshot save --task "add auth middleware"
+
+# Save with explicit decisions
+stackmemory snap save -d "chose JWT over session cookies" -d "switched to argon2"
+
+# List recent snapshots
+stackmemory snap list
+
+# Show latest snapshot (or by branch)
+stackmemory snap show feature/auth
+```
+
+### Pre-flight Check (`preflight` / `pf`)
+
+Predict file overlaps before running parallel tasks. Uses git history, import graphs, and keyword matching to flag conflicts.
+
+```bash
+# Check if two tasks can safely run in parallel
+stackmemory preflight "add user auth" "refactor database layer"
+
+# With explicit file hints
+stackmemory pf "auth work" "db migration" -f "task1:src/auth.ts;task2:src/db.ts"
+
+# JSON output for programmatic use
+stackmemory pf "task A" "task B" "task C" --json
+```
+
 ---
 
 ## Documentation

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

@@ -0,0 +1,123 @@
+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 { execSync } from "child_process";
+import chalk from "chalk";
+function parseSeconds(value) {
+  const match = value.match(/^(\d+)(s|m|h)?$/);
+  if (!match) return parseInt(value, 10) || 10;
+  const num = parseInt(match[1], 10);
+  switch (match[2]) {
+    case "h":
+      return num * 3600;
+    case "m":
+      return num * 60;
+    default:
+      return num;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function checkCondition(output, exitCode, opts) {
+  if (opts.untilExit) return exitCode === 0;
+  if (opts.untilEmpty) return output.trim().length === 0;
+  if (opts.untilNonEmpty) return output.trim().length > 0;
+  if (opts.until) return output.includes(opts.until);
+  if (opts.untilNot) return !output.includes(opts.untilNot);
+  return exitCode === 0;
+}
+function createLoopCommand() {
+  return new Command("loop").alias("watch").description(
+    "Run a command repeatedly until a condition is met (monitor CI, deploys, logs)"
+  ).argument("<command>", "Shell command to run on each iteration").option("--until <pattern>", "Stop when output contains this string").option(
+    "--until-not <pattern>",
+    "Stop when output no longer contains this string"
+  ).option("--until-empty", "Stop when output is empty", false).option("--until-non-empty", "Stop when output is non-empty", false).option(
+    "--until-exit",
+    "Stop when command exits with code 0 (ignore output)",
+    false
+  ).option("-i, --interval <duration>", "Check interval (e.g. 10s, 1m)", "10s").option("-t, --timeout <duration>", "Max wait time (e.g. 30m, 1h)", "30m").option("-q, --quiet", "Only show final result", false).option("--json", "Output result as JSON", false).option("-l, --label <name>", "Label for this loop (shown in output)").option("--shell <path>", "Shell to use", "/bin/sh").action(async (command, opts) => {
+    const intervalSec = parseSeconds(opts.interval);
+    const timeoutSec = parseSeconds(opts.timeout);
+    const label = opts.label || command.slice(0, 40);
+    const startTime = Date.now();
+    const deadline = startTime + timeoutSec * 1e3;
+    let iterations = 0;
+    let lastOutput = "";
+    if (!opts.quiet && !opts.json) {
+      console.log(
+        chalk.cyan(`[loop] ${label}`) + chalk.gray(` (every ${intervalSec}s, timeout ${timeoutSec}s)`)
+      );
+    }
+    while (Date.now() < deadline) {
+      iterations++;
+      let output = "";
+      let exitCode = 0;
+      try {
+        output = execSync(command, {
+          encoding: "utf8",
+          timeout: Math.min(intervalSec * 1e3, 6e4),
+          shell: opts.shell,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      } catch (error) {
+        const e = error;
+        exitCode = e.status ?? 1;
+        output = (e.stdout || "") + (e.stderr || "");
+      }
+      lastOutput = output;
+      if (!opts.quiet && !opts.json) {
+        const elapsed = Math.round((Date.now() - startTime) / 1e3);
+        const preview = output.trim().split("\n").slice(-3).join("\n");
+        console.log(
+          chalk.gray(`[${elapsed}s #${iterations}]`) + (preview ? `
+${preview}` : chalk.gray(" (no output)"))
+        );
+      }
+      if (checkCondition(output, exitCode, opts)) {
+        const result2 = {
+          ok: true,
+          reason: "matched",
+          iterations,
+          elapsed: Date.now() - startTime,
+          lastOutput: lastOutput.trim()
+        };
+        if (opts.json) {
+          console.log(JSON.stringify(result2));
+        } else if (!opts.quiet) {
+          console.log(
+            chalk.green(`[loop] Condition met after ${iterations} iterations`)
+          );
+        }
+        return;
+      }
+      const remaining = deadline - Date.now();
+      if (remaining > 0) {
+        await sleep(Math.min(intervalSec * 1e3, remaining));
+      }
+    }
+    const result = {
+      ok: false,
+      reason: "timeout",
+      iterations,
+      elapsed: Date.now() - startTime,
+      lastOutput: lastOutput.trim()
+    };
+    if (opts.json) {
+      console.log(JSON.stringify(result));
+    } else {
+      console.log(
+        chalk.yellow(
+          `[loop] Timed out after ${timeoutSec}s (${iterations} iterations)`
+        )
+      );
+    }
+    process.exit(1);
+  });
+}
+export {
+  createLoopCommand
+};

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
 };