@stackmemoryai/stackmemory 1.5.6 → 1.5.8

package/bin/gemini-sm

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * Gemini-SM CLI Launcher (ESM)
+ * Delegates to built CLI in dist without requiring tsx.
+ */
+import('../dist/src/cli/gemini-sm.js');

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

@@ -16,7 +16,9 @@ import { homedir, tmpdir } from "os";
 import Database from "better-sqlite3";
 import { logger } from "../../core/monitoring/logger.js";
 import { Conductor } from "./orchestrator.js";
-import { getAgentStatusDir } from "./orchestrator.js";
+import {
+  getAgentStatusDir
+} from "./orchestrator.js";
 function getGlobalStorePath() {
   const dir = join(homedir(), ".stackmemory", "conductor");
   if (!existsSync(dir)) {
@@ -73,6 +75,101 @@ function budgetBar(pct, width = 30) {
   const rst = "\x1B[0m";
   return `${color}${"\u2588".repeat(filled)}${dim}${"\u2591".repeat(empty)}${rst} ${String(pct).padStart(3)}%`;
 }
+const c = {
+  r: "\x1B[0m",
+  // reset
+  b: "\x1B[1m",
+  // bold
+  d: "\x1B[2m",
+  // dim
+  i: "\x1B[3m",
+  // italic
+  u: "\x1B[4m",
+  // underline
+  // Linear-inspired palette
+  purple: "\x1B[38;5;141m",
+  blue: "\x1B[38;5;75m",
+  cyan: "\x1B[38;5;80m",
+  green: "\x1B[38;5;114m",
+  yellow: "\x1B[38;5;221m",
+  orange: "\x1B[38;5;215m",
+  red: "\x1B[38;5;203m",
+  pink: "\x1B[38;5;176m",
+  gray: "\x1B[38;5;245m",
+  white: "\x1B[38;5;255m",
+  bg: {
+    purple: "\x1B[48;5;53m",
+    blue: "\x1B[48;5;24m",
+    green: "\x1B[48;5;22m",
+    red: "\x1B[48;5;52m",
+    yellow: "\x1B[48;5;58m",
+    gray: "\x1B[48;5;236m"
+  }
+};
+const phaseIcon = {
+  reading: "\u25D4",
+  planning: "\u25D1",
+  implementing: "\u25D5",
+  testing: "\u25CF",
+  committing: "\u2713"
+};
+const phaseColor = {
+  reading: c.cyan,
+  planning: c.blue,
+  implementing: c.yellow,
+  testing: c.pink,
+  committing: c.green
+};
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function phaseProgress(phase, toolCalls, stale, alive) {
+  const basePct = {
+    reading: 10,
+    planning: 25,
+    implementing: 50,
+    testing: 75,
+    committing: 90
+  };
+  let pct = basePct[phase] || 0;
+  if (phase === "implementing") {
+    pct += Math.min(Math.floor(toolCalls / 80 * 25), 25);
+  }
+  if (phase === "committing") {
+    pct = 90 + Math.min(Math.floor(toolCalls / 60 * 10), 9);
+  }
+  const labels = {
+    reading: "Reading",
+    planning: "Planning",
+    implementing: "Implementing",
+    testing: "Testing",
+    committing: "Committing"
+  };
+  let label = labels[phase] || phase;
+  let color = phaseColor[phase] || "";
+  let icon = phaseIcon[phase] || "\u25CB";
+  if (!alive) {
+    label = "Dead";
+    color = c.red;
+    icon = "\u2717";
+  } else if (stale) {
+    label = "Stalled";
+    color = c.orange;
+    icon = "\u23F8";
+  }
+  return { icon, color, pct, label };
+}
+function progressBar(pct, width) {
+  const filled = Math.min(Math.round(pct / 100 * width), width);
+  const empty = width - filled;
+  const col = pct >= 90 ? c.green : pct >= 50 ? c.yellow : c.cyan;
+  return `${col}${"\u2501".repeat(filled)}${c.d}${"\u254C".repeat(empty)}${c.r}`;
+}
 function fmtMinutes(m) {
   if (m < 0) return "N/A";
   if (m >= 60) return `${Math.floor(m / 60)}h ${m % 60}m`;
@@ -90,23 +187,23 @@ function printUsageSummary(u) {
   const mins20x = u.minutesRemaining20x ?? -1;
   const cacheHitRate = u.cacheHitRate || 0;
   const b = "\x1B[1m";
-  const d = "\x1B[2m";
+  const d2 = "\x1B[2m";
   const w = "\x1B[37m";
-  const r = "\x1B[0m";
-  console.log(`${b}Token Usage${r}`);
+  const r2 = "\x1B[0m";
+  console.log(`${b}Token Usage${r2}`);
   console.log(
-    `  Input  ${w}${fmtTokens(inputTokens)}${r}  ${d}|${r}  Output  ${w}${fmtTokens(outputTokens)}${r}  ${d}|${r}  Total  ${w}${fmtTokens(totalTokens)}${r}`
+    `  Input  ${w}${fmtTokens(inputTokens)}${r2}  ${d2}|${r2}  Output  ${w}${fmtTokens(outputTokens)}${r2}  ${d2}|${r2}  Total  ${w}${fmtTokens(totalTokens)}${r2}`
   );
   console.log(
-    `  Rate   ${w}${fmtTokens(tokensPerMin)}/min${r}  ${d}|${r}  Messages  ${w}${estMessages}${r}  ${d}|${r}  Cache hit  ${w}${cacheHitRate}%${r}`
+    `  Rate   ${w}${fmtTokens(tokensPerMin)}/min${r2}  ${d2}|${r2}  Messages  ${w}${estMessages}${r2}  ${d2}|${r2}  Cache hit  ${w}${cacheHitRate}%${r2}`
   );
   console.log("");
-  console.log(`${b}Budget (Max plan, 5h window)${r}`);
+  console.log(`${b}Budget (Max plan, 5h window)${r2}`);
   console.log(
-    `  5x  (225 msgs)  ${budgetBar(budgetPct5x)}  ${d}~${fmtMinutes(mins5x)} left${r}`
+    `  5x  (225 msgs)  ${budgetBar(budgetPct5x)}  ${d2}~${fmtMinutes(mins5x)} left${r2}`
   );
   console.log(
-    `  20x (900 msgs)  ${budgetBar(budgetPct20x)}  ${d}~${fmtMinutes(mins20x)} left${r}`
+    `  20x (900 msgs)  ${budgetBar(budgetPct20x)}  ${d2}~${fmtMinutes(mins20x)} left${r2}`
   );
 }
 function createConductorCommands() {
@@ -226,14 +323,14 @@ function createConductorCommands() {
         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}`);
+          for (const d2 of decisions.slice(0, 10)) {
+            lines.push(`- ${d2.text}`);
           }
         }
         if (risks.length > 0) {
           lines.push("", "### Risks");
-          for (const r of risks.slice(0, 5)) {
-            lines.push(`- ${r.text}`);
+          for (const r2 of risks.slice(0, 5)) {
+            lines.push(`- ${r2.text}`);
           }
         }
       } catch {
@@ -317,13 +414,13 @@ function createConductorCommands() {
     }
     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);
+    for (const r2 of results) {
+      const date = new Date(r2.captured_at * 1e3).toISOString().slice(0, 16);
       console.log(
-        `  ${r.issue_id} [${r.context_type}] attempt ${r.attempt} (${date})`
+        `  ${r2.issue_id} [${r2.context_type}] attempt ${r2.attempt} (${date})`
       );
-      if (r.summary) {
-        const snippet = r.summary.slice(0, 120).replace(/\n/g, " ");
+      if (r2.summary) {
+        const snippet = r2.summary.slice(0, 120).replace(/\n/g, " ");
         console.log(`    ${snippet}`);
       }
     }
@@ -354,13 +451,162 @@ function createConductorCommands() {
     statuses.sort(
       (a, b) => new Date(b.lastUpdate).getTime() - new Date(a.lastUpdate).getTime()
     );
-    const header = `${"Issue".padEnd(12)}${"Phase".padEnd(16)}${"Tools".padStart(7)}${"Files".padStart(7)}${"Tokens".padStart(9)}   Last Update`;
-    console.log(header);
+    const active = statuses.filter((s) => isProcessAlive(s.pid));
+    const stalled = statuses.filter(
+      (s) => isProcessAlive(s.pid) && Date.now() - new Date(s.lastUpdate).getTime() > 5 * 60 * 1e3
+    );
+    const dead = statuses.filter((s) => !isProcessAlive(s.pid));
+    const healthy = active.length - stalled.length;
+    const parts = [];
+    if (healthy > 0) parts.push(`${c.green}\u25CF ${healthy}${c.r}`);
+    if (stalled.length > 0)
+      parts.push(`${c.orange}\u23F8 ${stalled.length}${c.r}`);
+    if (dead.length > 0) parts.push(`${c.red}\u2717 ${dead.length}${c.r}`);
+    console.log(`
+  ${c.b}${c.white}Conductor${c.r}  ${parts.join(" ")}
+`);
+    const cols = (process.stdout.columns || 80) >= 90 ? 2 : 1;
+    const rows = [];
     for (const s of statuses) {
       const elapsed = Date.now() - new Date(s.lastUpdate).getTime();
-      const lastUpdate = formatElapsed(elapsed);
-      const line = `${s.issue.padEnd(12)}${s.phase.padEnd(16)}${String(s.toolCalls).padStart(7)}${String(s.filesModified).padStart(7)}${String(s.tokensUsed).padStart(9)}   ${lastUpdate}`;
-      console.log(line);
+      const staleFlag = elapsed > 5 * 60 * 1e3;
+      const alive = isProcessAlive(s.pid);
+      const { icon, color, pct, label } = phaseProgress(
+        s.phase,
+        s.toolCalls,
+        staleFlag,
+        alive
+      );
+      const bar = progressBar(pct, 8);
+      const timeColor = !alive ? c.red : staleFlag ? c.orange : c.gray;
+      const cell = [
+        `${color}${icon}${c.r} ${c.b}${s.issue}${c.r} ${color}${label}${c.r}`,
+        `  ${bar} ${c.d}${pct}%${c.r} ${c.gray}${s.toolCalls}t ${s.filesModified}f${c.r} ${timeColor}${formatElapsed(elapsed)}${c.r}`
+      ];
+      rows.push(cell);
+    }
+    if (cols === 2) {
+      for (let i = 0; i < rows.length; i += 2) {
+        const left = rows[i];
+        const right = rows[i + 1];
+        const pad = 42;
+        if (right) {
+          console.log(
+            `  ${left[0].padEnd(pad + 30)}${c.gray}\u2502${c.r} ${right[0]}`
+          );
+          console.log(
+            `  ${left[1].padEnd(pad + 30)}${c.gray}\u2502${c.r} ${right[1]}`
+          );
+        } else {
+          console.log(`  ${left[0]}`);
+          console.log(`  ${left[1]}`);
+        }
+        if (i + 2 < rows.length) {
+          console.log(`  ${c.gray}${"\u254C".repeat(38)}\u253C${"\u254C".repeat(38)}${c.r}`);
+        }
+      }
+    } else {
+      for (let i = 0; i < rows.length; i++) {
+        console.log(`  ${rows[i][0]}`);
+        console.log(`  ${rows[i][1]}`);
+        if (i < rows.length - 1) {
+          console.log(`  ${c.gray}${"\u254C".repeat(38)}${c.r}`);
+        }
+      }
+    }
+    console.log("");
+  });
+  cmd.command("finalize").description("Clean up completed/dead agents that conductor missed").option("--dry-run", "Show what would be done without doing it", false).action(async (options) => {
+    const agentsDir = join(homedir(), ".stackmemory", "conductor", "agents");
+    if (!existsSync(agentsDir)) {
+      console.log("No agent status files found");
+      return;
+    }
+    const entries = readdirSync(agentsDir, { withFileTypes: true });
+    const statuses = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const statusPath = join(agentsDir, entry.name, "status.json");
+      if (!existsSync(statusPath)) continue;
+      try {
+        const data = JSON.parse(readFileSync(statusPath, "utf-8"));
+        statuses.push({ ...data, dir: entry.name });
+      } catch {
+      }
+    }
+    const needsFinalize = statuses.filter((s) => {
+      const alive = isProcessAlive(s.pid);
+      const elapsed = Date.now() - new Date(s.lastUpdate).getTime();
+      return !alive || elapsed > 60 * 60 * 1e3;
+    });
+    if (needsFinalize.length === 0) {
+      console.log(
+        `${c.green}All agents are healthy \u2014 nothing to finalize.${c.r}`
+      );
+      return;
+    }
+    console.log(
+      `
+  ${c.b}Finalizing ${needsFinalize.length} agent(s)${c.r}
+`
+    );
+    for (const s of needsFinalize) {
+      const alive = isProcessAlive(s.pid);
+      const elapsed = Date.now() - new Date(s.lastUpdate).getTime();
+      const elapsedStr = formatElapsed(elapsed).replace(" ago", "");
+      let hasCommits = false;
+      if (s.workspacePath && existsSync(s.workspacePath)) {
+        try {
+          const log = execSync("git log origin/main..HEAD --oneline", {
+            cwd: s.workspacePath,
+            encoding: "utf-8",
+            timeout: 1e4
+          });
+          hasCommits = log.trim().length > 0;
+        } catch {
+        }
+      }
+      const statusIcon = !alive ? `${c.red}\u2717 dead${c.r}` : `${c.orange}\u23F8 stalled ${elapsedStr}${c.r}`;
+      const commitStatus = hasCommits ? `${c.green}has commits \u2192 In Review${c.r}` : `${c.gray}no commits \u2192 mark failed${c.r}`;
+      console.log(`  ${c.b}${s.issue}${c.r}  ${statusIcon}  ${commitStatus}`);
+      if (options.dryRun) continue;
+      if (alive) {
+        try {
+          process.kill(s.pid, "SIGTERM");
+          console.log(`     ${c.gray}Sent SIGTERM to pid ${s.pid}${c.r}`);
+        } catch {
+        }
+      }
+      const statusPath = join(agentsDir, s.dir, "status.json");
+      try {
+        const updated = { ...s };
+        delete updated["dir"];
+        writeFileSync(
+          statusPath,
+          JSON.stringify(
+            { ...updated, lastUpdate: (/* @__PURE__ */ new Date()).toISOString() },
+            null,
+            2
+          )
+        );
+      } catch {
+      }
+      if (hasCommits) {
+        console.log(
+          `     ${c.cyan}\u2192 Move ${s.issue} to "In Review" in Linear${c.r}`
+        );
+      }
+    }
+    if (options.dryRun) {
+      console.log(
+        `
+  ${c.d}Dry run \u2014 no changes made. Remove --dry-run to execute.${c.r}`
+      );
+    } else {
+      console.log(
+        `
+  ${c.green}Done.${c.r} Run ${c.cyan}conductor status${c.r} to verify.`
+      );
     }
   });
   cmd.command("logs").description("Tail agent output log").argument("<issue-id>", "Issue identifier (e.g., STA-499)").option("-f, --follow", "Follow the log (tail -f)", false).option("-n, --lines <n>", "Number of lines to show", "50").action(async (issueId, options) => {
@@ -474,13 +720,6 @@ function createConductorCommands() {
     let paused = false;
     let refreshInterval = interval;
     let phaseFilter = options.phase || null;
-    const b = "\x1B[1m";
-    const d = "\x1B[2m";
-    const cyan = "\x1B[36m";
-    const green = "\x1B[32m";
-    const yellow = "\x1B[33m";
-    const red = "\x1B[31m";
-    const r = "\x1B[0m";
     function readStatuses() {
       const agentsDir = join(
         homedir(),
@@ -501,7 +740,7 @@ function createConductorCommands() {
         }
       }
       statuses.sort(
-        (a, b2) => new Date(b2.lastUpdate).getTime() - new Date(a.lastUpdate).getTime()
+        (a, b) => new Date(b.lastUpdate).getTime() - new Date(a.lastUpdate).getTime()
       );
       if (phaseFilter) {
         return statuses.filter((s) => s.phase === phaseFilter);
@@ -514,12 +753,19 @@ function createConductorCommands() {
         console.log(`  No active agents${filterNote}`);
         return;
       }
-      const header = `${"Issue".padEnd(12)}${"Phase".padEnd(16)}${"Tools".padStart(7)}${"Files".padStart(7)}${"Tokens".padStart(9)}   Last Update`;
-      console.log(header);
       for (const s of statuses) {
         const elapsed = Date.now() - new Date(s.lastUpdate).getTime();
-        const line = `${s.issue.padEnd(12)}${s.phase.padEnd(16)}${String(s.toolCalls).padStart(7)}${String(s.filesModified).padStart(7)}${String(s.tokensUsed).padStart(9)}   ${formatElapsed(elapsed)}`;
-        console.log(line);
+        const stale = elapsed > 5 * 60 * 1e3;
+        const alive = isProcessAlive(s.pid);
+        const prog = phaseProgress(s.phase, s.toolCalls, stale, alive);
+        const bar = progressBar(prog.pct, 10);
+        const timeColor = !alive ? c.red : stale ? c.orange : c.gray;
+        console.log(
+          `  ${prog.color}${prog.icon}${c.r}  ${c.b}${s.issue}${c.r}  ${prog.color}${prog.label}${c.r}  ${timeColor}${formatElapsed(elapsed)}${c.r}`
+        );
+        console.log(
+          `     ${bar} ${c.d}${prog.pct}%${c.r}  ${c.gray}${s.toolCalls} tools  ${s.filesModified} files  ${fmtTokens(s.tokensUsed)} tok${c.r}`
+        );
       }
     }
     function getWorktreeFiles(workspacePath) {
@@ -543,23 +789,25 @@ function createConductorCommands() {
       }
       for (const s of statuses) {
         const elapsed = Date.now() - new Date(s.lastUpdate).getTime();
-        const phaseColor = s.phase === "committing" ? green : s.phase === "testing" ? yellow : s.phase === "implementing" ? cyan : "";
+        const stale = elapsed > 5 * 60 * 1e3;
+        const alive = isProcessAlive(s.pid);
+        const prog = phaseProgress(s.phase, s.toolCalls, stale, alive);
         console.log(
-          `${b}${s.issue}${r}  ${phaseColor}${s.phase}${r}  ${d}${formatElapsed(elapsed)}${r}`
+          `  ${prog.color}${prog.icon}${c.r}  ${c.b}${s.issue}${c.r}  ${prog.color}${prog.label}${c.r}  ${c.gray}${formatElapsed(elapsed)}${c.r}`
         );
         const files = getWorktreeFiles(s.workspacePath || "");
         if (files.length === 0) {
-          console.log(`  ${d}(no file changes detected)${r}`);
+          console.log(`     ${c.d}(no file changes)${c.r}`);
         } else {
           for (const f of files) {
             const status = f.substring(0, 2);
             const path = f.substring(3);
-            let color = "";
-            if (status.includes("M")) color = yellow;
+            let col = "";
+            if (status.includes("M")) col = c.yellow;
             else if (status.includes("A") || status.includes("?"))
-              color = green;
-            else if (status.includes("D")) color = red;
-            console.log(`  ${color}${status}${r} ${path}`);
+              col = c.green;
+            else if (status.includes("D")) col = c.red;
+            console.log(`     ${col}${status}${c.r} ${path}`);
           }
         }
         console.log("");
@@ -575,23 +823,20 @@ function createConductorCommands() {
       const pauseTag = paused ? " [PAUSED]" : "";
       const intervalSec = Math.round(refreshInterval / 1e3);
       console.log(
-        `${b}\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550${r}`
-      );
-      console.log(
-        `${b}  Conductor Monitor${r}  ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}${pauseTag}`
+        `${c.purple}${c.b}  \u2501\u2501\u2501 Conductor Monitor \u2501\u2501\u2501${c.r}  ${c.gray}${(/* @__PURE__ */ new Date()).toLocaleTimeString()}${pauseTag}${c.r}`
       );
       console.log(
-        `  Mode: ${cyan}${currentMode}${r}  |  Refresh: ${intervalSec}s`
+        `  ${c.gray}Mode:${c.r} ${c.cyan}${currentMode}${c.r}  ${c.gray}\u2502${c.r}  ${c.gray}Refresh:${c.r} ${intervalSec}s`
       );
-      const filterNote = phaseFilter ? `  Filter: ${cyan}${phaseFilter}${r}` : "";
+      const filterNote = phaseFilter ? `  ${c.gray}Filter:${c.r} ${c.cyan}${phaseFilter}${c.r}` : "";
       if (interactive) {
         console.log(
-          `  ${d}[s]tatus [u]sage [f]iles [d]ashboard [j]son [l]ogs [r]efresh [p]ause [1-5]phase [0]clear [+/-] [q]uit${r}`
+          `  ${c.d}[s]tatus [u]sage [f]iles [d]ashboard [j]son [l]ogs [r]efresh [p]ause [1-5]phase [0]clear [+/-] [q]uit${c.r}`
         );
       }
       if (filterNote) console.log(filterNote);
       console.log(
-        `${b}\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550${r}`
+        `${c.gray}  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${c.r}`
       );
       console.log("");
       const statuses = readStatuses();

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

@@ -6,6 +6,7 @@ import { spawn, execSync } from "child_process";
 import {
   existsSync,
   mkdirSync,
+  readFileSync,
   rmSync,
   writeFileSync,
   readdirSync,
@@ -452,6 +453,7 @@ class Conductor {
       logger.info("Rate limit backoff expired, resuming dispatch");
       console.log("[rate-limit] Backoff expired, resuming dispatch");
     }
+    await this.checkStaleAgents();
     await this.reconcile();
     const available = this.config.maxConcurrent - this.running.size;
     if (available <= 0) {
@@ -949,6 +951,26 @@ class Conductor {
     return "claude";
   }
   // ── Agent Execution ──
+  /**
+   * Build environment variables for an agent process.
+   * Injects PORTLESS_URL if portless is available, giving each worktree
+   * a stable named localhost URL for service discovery.
+   */
+  buildAgentEnv(issue, run) {
+    const env = { ...process.env };
+    delete env["CLAUDECODE"];
+    delete env["ANTHROPIC_API_KEY"];
+    const wsKey = this.sanitizeIdentifier(issue.identifier);
+    return {
+      ...env,
+      SYMPHONY_WORKSPACE_DIR: run.workspacePath,
+      SYMPHONY_ISSUE_ID: issue.id,
+      SYMPHONY_ISSUE_IDENTIFIER: issue.identifier,
+      SYMPHONY_ATTEMPT: String(run.attempt),
+      PORTLESS_URL: `http://${wsKey}.localhost:1355`,
+      PORTLESS_NAME: wsKey
+    };
+  }
   async runAgent(issue, run) {
     if (this.config.agentMode === "cli") {
       try {
@@ -995,18 +1017,7 @@ class Conductor {
         ],
         {
           cwd: run.workspacePath,
-          env: (() => {
-            const env = { ...process.env };
-            delete env.CLAUDECODE;
-            delete env.ANTHROPIC_API_KEY;
-            return {
-              ...env,
-              SYMPHONY_WORKSPACE_DIR: run.workspacePath,
-              SYMPHONY_ISSUE_ID: issue.id,
-              SYMPHONY_ISSUE_IDENTIFIER: issue.identifier,
-              SYMPHONY_ATTEMPT: String(run.attempt)
-            };
-          })(),
+          env: this.buildAgentEnv(issue, run),
           stdio: ["pipe", "pipe", "pipe"]
         }
       );
@@ -1114,18 +1125,9 @@ class Conductor {
   runAgentAdapter(issue, run) {
     return new Promise((resolve, reject) => {
       const prompt = this.buildPrompt(issue, run.attempt);
-      const env = { ...process.env };
-      delete env.CLAUDECODE;
-      delete env.ANTHROPIC_API_KEY;
       const proc = spawn("node", [this.config.appServerPath], {
         cwd: run.workspacePath,
-        env: {
-          ...env,
-          SYMPHONY_WORKSPACE_DIR: run.workspacePath,
-          SYMPHONY_ISSUE_ID: issue.id,
-          SYMPHONY_ISSUE_IDENTIFIER: issue.identifier,
-          SYMPHONY_ATTEMPT: String(run.attempt)
-        },
+        env: this.buildAgentEnv(issue, run),
         stdio: ["pipe", "pipe", "pipe"]
       });
       run.process = proc;
@@ -1405,6 +1407,117 @@ class Conductor {
     }
   }
   // ── Reconciliation ──
+  /**
+   * Check for stale agents — no status update in 1 hour.
+   * If the process is dead, clean up. If alive but stuck, kill and free the slot.
+   */
+  async checkStaleAgents() {
+    if (this.running.size === 0) return;
+    const staleThresholdMs = 60 * 60 * 1e3;
+    const now = Date.now();
+    for (const [issueId, run] of this.running) {
+      const agentDir = getAgentStatusDir(run.issue.identifier);
+      const statusPath = join(agentDir, "status.json");
+      let lastUpdate = run.startedAt;
+      try {
+        const data = JSON.parse(readFileSync(statusPath, "utf-8"));
+        lastUpdate = new Date(data.lastUpdate).getTime();
+      } catch {
+      }
+      const elapsed = now - lastUpdate;
+      if (elapsed < staleThresholdMs) continue;
+      const elapsedMin = Math.round(elapsed / 6e4);
+      const pid = run.process?.pid;
+      let alive = false;
+      if (pid) {
+        try {
+          process.kill(pid, 0);
+          alive = true;
+        } catch {
+        }
+      }
+      if (!alive) {
+        logger.warn("Stale agent process is dead, cleaning up", {
+          identifier: run.issue.identifier,
+          pid,
+          staleMins: elapsedMin
+        });
+        console.log(
+          `[${run.issue.identifier}] Agent dead after ${elapsedMin}m \u2014 finalizing`
+        );
+        await this.finalizeStaleAgent(run);
+        this.running.delete(issueId);
+      } else {
+        logger.warn("Stale agent still alive but stuck, killing", {
+          identifier: run.issue.identifier,
+          pid,
+          staleMins: elapsedMin
+        });
+        console.log(
+          `[${run.issue.identifier}] Agent stuck for ${elapsedMin}m \u2014 killing pid ${pid}`
+        );
+        run.process?.kill("SIGTERM");
+        await new Promise((resolve) => setTimeout(resolve, 1e4));
+        if (run.process && !run.process.killed) {
+          run.process.kill("SIGKILL");
+        }
+        await this.finalizeStaleAgent(run);
+        this.running.delete(issueId);
+      }
+    }
+  }
+  /**
+   * Finalize an agent that completed or died without proper cleanup.
+   * Checks for commits, transitions Linear issue, takes snapshot.
+   */
+  async finalizeStaleAgent(run) {
+    const wsPath = run.workspacePath;
+    if (!wsPath || !existsSync(wsPath)) {
+      this.completed.add(run.issue.id);
+      return;
+    }
+    let hasCommits = false;
+    try {
+      const log = execSync(
+        `git log origin/${this.config.baseBranch}..HEAD --oneline`,
+        { cwd: wsPath, encoding: "utf-8", timeout: 1e4 }
+      );
+      hasCommits = log.trim().length > 0;
+    } catch {
+    }
+    if (hasCommits) {
+      logger.info("Stale agent had commits, transitioning to In Review", {
+        identifier: run.issue.identifier
+      });
+      console.log(
+        `[${run.issue.identifier}] Found commits \u2014 moving to In Review`
+      );
+      this.takeSnapshot(wsPath, run.issue);
+      await this.transitionIssue(run.issue, this.config.inReviewState).catch(
+        (err) => {
+          logger.error("Failed to transition stale agent issue", {
+            identifier: run.issue.identifier,
+            error: err.message
+          });
+        }
+      );
+      this.completeCount++;
+    } else {
+      logger.info("Stale agent had no commits, marking as failed", {
+        identifier: run.issue.identifier
+      });
+      console.log(
+        `[${run.issue.identifier}] No commits found \u2014 marking failed`
+      );
+      this.failCount++;
+    }
+    this.writeAgentStatus(run.issue.identifier, {
+      ...run,
+      status: hasCommits ? "completed" : "failed",
+      phase: hasCommits ? "committing" : run.phase
+    });
+    this.completed.add(run.issue.id);
+  }
   async reconcile() {
     if (!this.client || this.running.size === 0) return;
     for (const [issueId, run] of this.running) {

package/dist/src/cli/gemini-sm.js

@@ -0,0 +1,481 @@
+#!/usr/bin/env node
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { config as loadDotenv } from "dotenv";
+loadDotenv({ override: true, debug: false });
+import { spawn, execSync, execFileSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { program } from "commander";
+import { v4 as uuidv4 } from "uuid";
+import chalk from "chalk";
+import { initializeTracing, trace } from "../core/trace/index.js";
+const DEFAULT_SM_CONFIG = {
+  defaultWorktree: false,
+  defaultTracing: true
+};
+function getConfigPath() {
+  return path.join(os.homedir(), ".stackmemory", "gemini-sm.json");
+}
+function loadSMConfig() {
+  try {
+    const configPath = getConfigPath();
+    if (fs.existsSync(configPath)) {
+      const content = fs.readFileSync(configPath, "utf8");
+      return { ...DEFAULT_SM_CONFIG, ...JSON.parse(content) };
+    }
+  } catch {
+  }
+  return { ...DEFAULT_SM_CONFIG };
+}
+function saveSMConfig(config) {
+  const configPath = getConfigPath();
+  const dir = path.dirname(configPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+class GeminiSM {
+  config;
+  stackmemoryPath;
+  smConfig;
+  constructor() {
+    this.smConfig = loadSMConfig();
+    this.config = {
+      instanceId: this.generateInstanceId(),
+      useWorktree: this.smConfig.defaultWorktree,
+      contextEnabled: true,
+      tracingEnabled: this.smConfig.defaultTracing,
+      verboseTracing: false,
+      sessionStartTime: Date.now()
+    };
+    this.stackmemoryPath = this.findStackMemory();
+  }
+  getRepoRoot() {
+    try {
+      const root = execSync("git rev-parse --show-toplevel", {
+        encoding: "utf8"
+      }).trim();
+      return root || null;
+    } catch {
+      return null;
+    }
+  }
+  ensureInitialized() {
+    try {
+      const root = this.getRepoRoot();
+      const dir = root || process.cwd();
+      const dbPath = path.join(dir, ".stackmemory", "context.db");
+      if (!fs.existsSync(dbPath)) {
+        console.log(chalk.blue("Initializing StackMemory for this project..."));
+        execSync(`${this.stackmemoryPath} init`, {
+          cwd: dir,
+          stdio: ["ignore", "ignore", "ignore"]
+        });
+      }
+    } catch {
+    }
+  }
+  generateInstanceId() {
+    return uuidv4().substring(0, 8);
+  }
+  findStackMemory() {
+    const possiblePaths = [
+      path.join(os.homedir(), ".stackmemory", "bin", "stackmemory"),
+      "/usr/local/bin/stackmemory",
+      "/opt/homebrew/bin/stackmemory",
+      "stackmemory"
+    ];
+    for (const smPath of possiblePaths) {
+      try {
+        execFileSync("which", [smPath], { stdio: "ignore" });
+        return smPath;
+      } catch {
+      }
+    }
+    return "stackmemory";
+  }
+  isGitRepo() {
+    try {
+      execSync("git rev-parse --git-dir", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getCurrentBranch() {
+    try {
+      return execSync("git rev-parse --abbrev-ref HEAD", {
+        encoding: "utf8"
+      }).trim();
+    } catch {
+      return "main";
+    }
+  }
+  hasUncommittedChanges() {
+    try {
+      const status = execSync("git status --porcelain", { encoding: "utf8" });
+      return status.length > 0;
+    } catch {
+      return false;
+    }
+  }
+  resolveGeminiBin() {
+    if (this.config.geminiBin && this.config.geminiBin.trim()) {
+      return this.config.geminiBin.trim();
+    }
+    const envBin = process.env["GEMINI_BIN"];
+    if (envBin && envBin.trim()) return envBin.trim();
+    const possiblePaths = [
+      path.join(
+        os.homedir(),
+        ".nvm",
+        "versions",
+        "node",
+        "v22.22.0",
+        "bin",
+        "gemini"
+      ),
+      "/usr/local/bin/gemini",
+      "/opt/homebrew/bin/gemini"
+    ];
+    for (const binPath of possiblePaths) {
+      if (fs.existsSync(binPath)) {
+        return binPath;
+      }
+    }
+    try {
+      execSync("which gemini", { stdio: "ignore" });
+      return "gemini";
+    } catch {
+    }
+    return null;
+  }
+  setupWorktree() {
+    if (!this.config.useWorktree || !this.isGitRepo()) {
+      return null;
+    }
+    console.log(chalk.blue("Setting up isolated worktree..."));
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").substring(0, 19);
+    const branch = this.config.branch || `gemini-${this.config.task || "work"}-${timestamp}-${this.config.instanceId}`;
+    const repoName = path.basename(process.cwd());
+    const worktreePath = path.join(
+      path.dirname(process.cwd()),
+      `${repoName}--${branch}`
+    );
+    try {
+      const cmd = `git worktree add -b "${branch}" "${worktreePath}"`;
+      execSync(cmd, { stdio: "inherit" });
+      console.log(chalk.green(`Worktree created: ${worktreePath}`));
+      console.log(chalk.gray(`Branch: ${branch}`));
+      const configPath = path.join(worktreePath, ".gemini-instance.json");
+      const configData = {
+        instanceId: this.config.instanceId,
+        worktreePath,
+        branch,
+        task: this.config.task,
+        created: (/* @__PURE__ */ new Date()).toISOString(),
+        parentRepo: process.cwd()
+      };
+      fs.writeFileSync(configPath, JSON.stringify(configData, null, 2));
+      const envFiles = [".env", ".env.local", ".mise.toml", ".tool-versions"];
+      for (const file of envFiles) {
+        const srcPath = path.join(process.cwd(), file);
+        if (fs.existsSync(srcPath)) {
+          fs.copyFileSync(srcPath, path.join(worktreePath, file));
+        }
+      }
+      return worktreePath;
+    } catch (err) {
+      console.error(chalk.red("Failed to create worktree:"), err);
+      return null;
+    }
+  }
+  saveContext(message, metadata = {}) {
+    if (!this.config.contextEnabled) return;
+    try {
+      const contextData = {
+        message,
+        metadata: {
+          ...metadata,
+          instanceId: this.config.instanceId,
+          worktree: this.config.worktreePath,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          tool: "gemini"
+        }
+      };
+      const cmd = `${this.stackmemoryPath} context save --json '${JSON.stringify(contextData)}'`;
+      execSync(cmd, { stdio: "ignore" });
+    } catch {
+    }
+  }
+  loadContext() {
+    if (!this.config.contextEnabled) return;
+    try {
+      console.log(chalk.blue("Loading previous context..."));
+      const cmd = `${this.stackmemoryPath} context show`;
+      const output = execSync(cmd, {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const lines = output.trim().split("\n").filter((l) => l.trim());
+      if (lines.length > 3) {
+        console.log(chalk.gray("Context stack loaded"));
+      }
+    } catch {
+    }
+  }
+  detectMultipleInstances() {
+    try {
+      const lockDir = path.join(process.cwd(), ".gemini-worktree-locks");
+      if (!fs.existsSync(lockDir)) return false;
+      const locks = fs.readdirSync(lockDir).filter((f) => f.endsWith(".lock"));
+      const activeLocks = locks.filter((lockFile) => {
+        const lockPath = path.join(lockDir, lockFile);
+        const lockData = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+        const lockAge = Date.now() - new Date(lockData.created).getTime();
+        return lockAge < 24 * 60 * 60 * 1e3;
+      });
+      return activeLocks.length > 0;
+    } catch {
+      return false;
+    }
+  }
+  suggestWorktreeMode() {
+    if (this.hasUncommittedChanges()) {
+      console.log(chalk.yellow("Uncommitted changes detected"));
+      console.log(chalk.gray("Consider using --worktree to work in isolation"));
+    }
+    if (this.detectMultipleInstances()) {
+      console.log(chalk.yellow("Other Gemini instances detected"));
+      console.log(
+        chalk.gray("Using --worktree is recommended to avoid conflicts")
+      );
+    }
+  }
+  async run(args) {
+    const geminiArgs = [];
+    let i = 0;
+    while (i < args.length) {
+      const arg = args[i];
+      switch (arg) {
+        case "--worktree":
+        case "-w":
+          this.config.useWorktree = true;
+          break;
+        case "--no-worktree":
+        case "-W":
+          this.config.useWorktree = false;
+          break;
+        case "--no-context":
+          this.config.contextEnabled = false;
+          break;
+        case "--no-trace":
+          this.config.tracingEnabled = false;
+          break;
+        case "--verbose-trace":
+          this.config.verboseTracing = true;
+          break;
+        case "--branch":
+        case "-b":
+          i++;
+          this.config.branch = args[i];
+          break;
+        case "--task":
+        case "-t":
+          i++;
+          this.config.task = args[i];
+          break;
+        case "--gemini-bin":
+          i++;
+          this.config.geminiBin = args[i];
+          process.env["GEMINI_BIN"] = this.config.geminiBin;
+          break;
+        case "--auto":
+        case "-a":
+          if (this.isGitRepo()) {
+            this.config.useWorktree = this.hasUncommittedChanges() || this.detectMultipleInstances();
+          }
+          break;
+        default:
+          geminiArgs.push(arg);
+      }
+      i++;
+    }
+    if (this.config.tracingEnabled) {
+      process.env["DEBUG_TRACE"] = "true";
+      process.env["STACKMEMORY_DEBUG"] = "true";
+      process.env["TRACE_OUTPUT"] = "file";
+      process.env["TRACE_MASK_SENSITIVE"] = "true";
+      if (this.config.verboseTracing) {
+        process.env["TRACE_VERBOSITY"] = "full";
+        process.env["TRACE_PARAMS"] = "true";
+        process.env["TRACE_RESULTS"] = "true";
+        process.env["TRACE_MEMORY"] = "true";
+      } else {
+        process.env["TRACE_VERBOSITY"] = "summary";
+        process.env["TRACE_PARAMS"] = "true";
+        process.env["TRACE_RESULTS"] = "false";
+      }
+      initializeTracing();
+      trace.command(
+        "gemini-sm",
+        {
+          instanceId: this.config.instanceId,
+          worktree: this.config.useWorktree,
+          task: this.config.task
+        },
+        async () => {
+        }
+      );
+    }
+    console.log(chalk.cyan("Gemini + StackMemory"));
+    console.log();
+    this.ensureInitialized();
+    if (this.isGitRepo()) {
+      const branch = this.getCurrentBranch();
+      console.log(chalk.gray(`Branch: ${branch}`));
+      if (!this.config.useWorktree) {
+        this.suggestWorktreeMode();
+      }
+    }
+    if (this.config.useWorktree) {
+      const worktreePath = this.setupWorktree();
+      if (worktreePath) {
+        this.config.worktreePath = worktreePath;
+        process.chdir(worktreePath);
+        this.saveContext("Created worktree for Gemini instance", {
+          action: "worktree_created",
+          path: worktreePath,
+          branch: this.config.branch
+        });
+      }
+    }
+    this.loadContext();
+    process.env["GEMINI_INSTANCE_ID"] = this.config.instanceId;
+    if (this.config.worktreePath) {
+      process.env["GEMINI_WORKTREE_PATH"] = this.config.worktreePath;
+    }
+    console.log(chalk.gray(`Instance: ${this.config.instanceId}`));
+    console.log(chalk.gray(`Working in: ${process.cwd()}`));
+    if (this.config.tracingEnabled) {
+      console.log(
+        chalk.gray(`Tracing enabled (logs to ~/.stackmemory/traces/)`)
+      );
+    }
+    console.log();
+    console.log(chalk.gray("Starting Gemini CLI..."));
+    console.log(chalk.gray("-".repeat(40)));
+    const geminiBin = this.resolveGeminiBin();
+    if (!geminiBin) {
+      console.error(chalk.red("Gemini CLI not found."));
+      console.log(
+        chalk.gray(
+          "Install Gemini CLI or set an override:\n  npm install -g @anthropic-ai/gemini-cli\n  export GEMINI_BIN=/path/to/gemini\n  gemini-sm --help"
+        )
+      );
+      process.exit(1);
+      return;
+    }
+    const gemini = spawn(geminiBin, geminiArgs, {
+      stdio: "inherit",
+      env: process.env
+    });
+    gemini.on("error", (err) => {
+      console.error(chalk.red("Failed to launch Gemini CLI."));
+      if (err.code === "ENOENT") {
+        console.error(
+          chalk.gray("Not found. Set GEMINI_BIN or install gemini.")
+        );
+      } else {
+        console.error(chalk.gray(`${err.message}`));
+      }
+      process.exit(1);
+    });
+    gemini.on("exit", async (code) => {
+      this.saveContext("Gemini session ended", {
+        action: "session_end",
+        exitCode: code
+      });
+      if (this.config.tracingEnabled) {
+        const summary = trace.getExecutionSummary();
+        console.log();
+        console.log(chalk.gray("-".repeat(40)));
+        console.log(chalk.cyan("Trace Summary:"));
+        console.log(chalk.gray(summary));
+      }
+      if (this.config.worktreePath) {
+        console.log();
+        console.log(chalk.gray("-".repeat(40)));
+        console.log(chalk.cyan("Session ended in worktree:"));
+        console.log(chalk.gray(`  ${this.config.worktreePath}`));
+      }
+      process.exit(code || 0);
+    });
+    process.on("SIGINT", () => {
+      this.saveContext("Gemini session interrupted", {
+        action: "session_interrupt"
+      });
+      gemini.kill("SIGINT");
+    });
+    process.on("SIGTERM", () => {
+      this.saveContext("Gemini session terminated", {
+        action: "session_terminate"
+      });
+      gemini.kill("SIGTERM");
+    });
+  }
+}
+program.name("gemini-sm").description("Gemini CLI with StackMemory context and worktree isolation").version("1.0.0");
+const configCmd = program.command("config").description("Manage gemini-sm defaults");
+configCmd.command("show").description("Show current default settings").action(() => {
+  const config = loadSMConfig();
+  console.log(chalk.cyan("gemini-sm defaults:"));
+  console.log(
+    `  defaultWorktree: ${config.defaultWorktree ? chalk.green("true") : chalk.gray("false")}`
+  );
+  console.log(
+    `  defaultTracing:  ${config.defaultTracing ? chalk.green("true") : chalk.gray("false")}`
+  );
+  console.log(chalk.gray(`
+Config: ${getConfigPath()}`));
+});
+configCmd.command("set <key> <value>").description("Set a default (e.g., set worktree true)").action((key, value) => {
+  const config = loadSMConfig();
+  const boolValue = value === "true" || value === "1" || value === "on";
+  const keyMap = {
+    worktree: "defaultWorktree",
+    tracing: "defaultTracing"
+  };
+  const configKey = keyMap[key];
+  if (!configKey) {
+    console.log(chalk.red(`Unknown key: ${key}`));
+    console.log(chalk.gray("Valid keys: worktree, tracing"));
+    process.exit(1);
+  }
+  config[configKey] = boolValue;
+  saveSMConfig(config);
+  console.log(chalk.green(`Set ${key} = ${boolValue}`));
+});
+configCmd.command("worktree-on").description("Enable worktree mode by default").action(() => {
+  const config = loadSMConfig();
+  config.defaultWorktree = true;
+  saveSMConfig(config);
+  console.log(chalk.green("Worktree mode enabled by default"));
+});
+configCmd.command("worktree-off").description("Disable worktree mode by default").action(() => {
+  const config = loadSMConfig();
+  config.defaultWorktree = false;
+  saveSMConfig(config);
+  console.log(chalk.green("Worktree mode disabled by default"));
+});
+program.option("-w, --worktree", "Create isolated worktree for this instance").option("-W, --no-worktree", "Disable worktree (override default)").option("-a, --auto", "Automatically detect and apply best settings").option("-b, --branch <name>", "Specify branch name for worktree").option("-t, --task <desc>", "Task description for context").option("--gemini-bin <path>", "Path to gemini CLI (or use GEMINI_BIN)").option("--no-context", "Disable StackMemory context integration").option("--no-trace", "Disable debug tracing (enabled by default)").option("--verbose-trace", "Enable verbose debug tracing with full details").helpOption("-h, --help", "Display help").allowUnknownOption(true).action(async (_options) => {
+  const geminiSM = new GeminiSM();
+  const args = process.argv.slice(2);
+  await geminiSM.run(args);
+});
+program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackmemoryai/stackmemory",
-  "version": "1.5.6",
+  "version": "1.5.8",
   "description": "Lossless, project-scoped memory for AI coding tools. Durable context across sessions with 56 MCP tools, FTS5 search, conductor orchestrator, loop/watch monitoring, snapshot capture, pre-flight overlap checks, Claude/Codex/OpenCode wrappers, Linear sync, and automatic hooks.",
   "engines": {
     "node": ">=20.0.0",
@@ -14,7 +14,8 @@
     "codex-smd": "bin/codex-smd",
     "claude-sm": "bin/claude-sm",
     "claude-smd": "bin/claude-smd",
-    "opencode-sm": "bin/opencode-sm"
+    "opencode-sm": "bin/opencode-sm",
+    "gemini-sm": "bin/gemini-sm"
   },
   "files": [
     "bin",