@stackmemoryai/stackmemory 1.5.8 → 1.6.0

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

@@ -9,15 +9,18 @@ import {
   mkdirSync,
   writeFileSync,
   readFileSync,
-  readdirSync
+  readdirSync,
+  copyFileSync
 } from "fs";
 import { join } from "path";
 import { homedir, tmpdir } from "os";
 import Database from "better-sqlite3";
 import { logger } from "../../core/monitoring/logger.js";
+import { isProcessAlive } from "../../utils/process-cleanup.js";
 import { Conductor } from "./orchestrator.js";
 import {
-  getAgentStatusDir
+  getAgentStatusDir,
+  getOutcomesLogPath
 } from "./orchestrator.js";
 function getGlobalStorePath() {
   const dir = join(homedir(), ".stackmemory", "conductor");
@@ -75,6 +78,8 @@ function budgetBar(pct, width = 30) {
   const rst = "\x1B[0m";
   return `${color}${"\u2588".repeat(filled)}${dim}${"\u2591".repeat(empty)}${rst} ${String(pct).padStart(3)}%`;
 }
+const STALE_UI_THRESHOLD_MS = 5 * 60 * 1e3;
+const STALE_FINALIZE_THRESHOLD_MS = 60 * 60 * 1e3;
 const c = {
   r: "\x1B[0m",
   // reset
@@ -120,14 +125,6 @@ const phaseColor = {
   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,
@@ -170,6 +167,32 @@ function progressBar(pct, width) {
   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 scanAgentStatuses() {
+  const agentsDir2 = join(homedir(), ".stackmemory", "conductor", "agents");
+  if (!existsSync(agentsDir2)) return [];
+  const entries = readdirSync(agentsDir2, { withFileTypes: true });
+  const statuses = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const statusPath = join(agentsDir2, entry.name, "status.json");
+    if (!existsSync(statusPath)) continue;
+    try {
+      const data = JSON.parse(readFileSync(statusPath, "utf-8"));
+      statuses.push({ ...data, dir: entry.name });
+    } catch {
+    }
+  }
+  statuses.sort(
+    (a, b) => new Date(b.lastUpdate).getTime() - new Date(a.lastUpdate).getTime()
+  );
+  return statuses;
+}
+function enrichStatus(s) {
+  const elapsed = Date.now() - new Date(s.lastUpdate).getTime();
+  const alive = isProcessAlive(s.pid);
+  const stale = alive && elapsed > STALE_UI_THRESHOLD_MS;
+  return { elapsed, alive, stale };
+}
 function fmtMinutes(m) {
   if (m < 0) return "N/A";
   if (m >= 60) return `${Math.floor(m / 60)}h ${m % 60}m`;
@@ -186,25 +209,220 @@ function printUsageSummary(u) {
   const mins5x = u.minutesRemaining5x ?? -1;
   const mins20x = u.minutesRemaining20x ?? -1;
   const cacheHitRate = u.cacheHitRate || 0;
-  const b = "\x1B[1m";
-  const d2 = "\x1B[2m";
-  const w = "\x1B[37m";
-  const r2 = "\x1B[0m";
-  console.log(`${b}Token Usage${r2}`);
+  console.log(`${c.b}Token Usage${c.r}`);
   console.log(
-    `  Input  ${w}${fmtTokens(inputTokens)}${r2}  ${d2}|${r2}  Output  ${w}${fmtTokens(outputTokens)}${r2}  ${d2}|${r2}  Total  ${w}${fmtTokens(totalTokens)}${r2}`
+    `  Input  ${c.white}${fmtTokens(inputTokens)}${c.r}  ${c.d}|${c.r}  Output  ${c.white}${fmtTokens(outputTokens)}${c.r}  ${c.d}|${c.r}  Total  ${c.white}${fmtTokens(totalTokens)}${c.r}`
   );
   console.log(
-    `  Rate   ${w}${fmtTokens(tokensPerMin)}/min${r2}  ${d2}|${r2}  Messages  ${w}${estMessages}${r2}  ${d2}|${r2}  Cache hit  ${w}${cacheHitRate}%${r2}`
+    `  Rate   ${c.white}${fmtTokens(tokensPerMin)}/min${c.r}  ${c.d}|${c.r}  Messages  ${c.white}${estMessages}${c.r}  ${c.d}|${c.r}  Cache hit  ${c.white}${cacheHitRate}%${c.r}`
   );
   console.log("");
-  console.log(`${b}Budget (Max plan, 5h window)${r2}`);
+  console.log(`${c.b}Budget (Max plan, 5h window)${c.r}`);
   console.log(
-    `  5x  (225 msgs)  ${budgetBar(budgetPct5x)}  ${d2}~${fmtMinutes(mins5x)} left${r2}`
+    `  5x  (225 msgs)  ${budgetBar(budgetPct5x)}  ${c.d}~${fmtMinutes(mins5x)} left${c.r}`
   );
   console.log(
-    `  20x (900 msgs)  ${budgetBar(budgetPct20x)}  ${d2}~${fmtMinutes(mins20x)} left${r2}`
+    `  20x (900 msgs)  ${budgetBar(budgetPct20x)}  ${c.d}~${fmtMinutes(mins20x)} left${c.r}`
+  );
+}
+const DEFAULT_PROMPT_TEMPLATE = `# Agent Prompt \u2014 {{ISSUE_ID}}
+
+You are working on Linear issue **{{ISSUE_ID}}**: {{TITLE}}
+
+## Description
+
+{{DESCRIPTION}}
+
+## Context
+
+- Priority: {{PRIORITY}}
+- Labels: {{LABELS}}
+{{PRIOR_CONTEXT}}
+
+## Instructions
+
+1. Read the issue description and related code carefully
+2. Plan your approach before writing code
+3. Implement the requested changes
+4. Run \`npm run lint\` and fix any errors
+5. Run \`npm run test:run\` and fix any failures
+6. Commit your changes with format: \`type(scope): message\`
+
+## Rules
+
+- Follow existing code conventions (ESM imports with .js extension, TypeScript strict)
+- Keep changes focused \u2014 only modify what the issue requires
+- Write or update tests for any new functionality
+- Do not skip pre-commit hooks
+- If stuck, leave a comment in the code explaining the blocker
+
+Work in the current directory. All changes will be on a dedicated branch.
+`;
+function ensureDefaultPromptTemplate() {
+  const templatePath = join(
+    homedir(),
+    ".stackmemory",
+    "conductor",
+    "prompt-template.md"
   );
+  if (!existsSync(templatePath)) {
+    const dir = join(homedir(), ".stackmemory", "conductor");
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(templatePath, DEFAULT_PROMPT_TEMPLATE);
+    console.log(
+      `  ${c.d}Created default prompt template: ${templatePath}${c.r}`
+    );
+  }
+  return templatePath;
+}
+function spawnClaudePrint(prompt, timeoutMs = 12e4) {
+  return new Promise((resolve, reject) => {
+    const child = cpSpawn("claude", ["--print"], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env }
+    });
+    let stdout = "";
+    let stderr = "";
+    let killed = false;
+    const timer = setTimeout(() => {
+      killed = true;
+      child.kill("SIGTERM");
+    }, timeoutMs);
+    child.stdout.on("data", (d) => stdout += d.toString());
+    child.stderr.on("data", (d) => stderr += d.toString());
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (killed)
+        return reject(new Error(`claude timed out after ${timeoutMs}ms`));
+      if (code !== 0 && !stdout)
+        return reject(new Error(stderr || `claude exited ${code}`));
+      resolve(stdout);
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    child.stdin.write(prompt);
+    child.stdin.end();
+  });
+}
+async function evolvePromptTemplate(input) {
+  const {
+    templatePath,
+    successRate,
+    failures,
+    failPhases,
+    errorPatterns,
+    recs,
+    outcomes
+  } = input;
+  let currentTemplate;
+  if (existsSync(templatePath)) {
+    currentTemplate = readFileSync(templatePath, "utf-8");
+  } else {
+    currentTemplate = DEFAULT_PROMPT_TEMPLATE;
+    const dir = join(homedir(), ".stackmemory", "conductor");
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(templatePath, currentTemplate);
+  }
+  const failPhaseSummary = Object.entries(failPhases).sort((a, b) => b[1] - a[1]).map(([phase, count]) => `  - ${phase}: ${count} failures`).join("\n");
+  const errorSummary = Object.entries(errorPatterns).sort((a, b) => b[1] - a[1]).map(([pattern, count]) => `  - ${pattern}: ${count} occurrences`).join("\n");
+  const failedOutcomes = outcomes.filter((o) => o.outcome === "failure" && o.errorTail).slice(-5);
+  const errorTails = failedOutcomes.map(
+    (o) => `  [${o.issue} attempt ${o.attempt}, phase: ${o.phase}]
+  ${o.errorTail}`
+  ).join("\n\n");
+  const mutationPrompt = `You are optimizing a prompt template for autonomous AI coding agents managed by a conductor system.
+
+CURRENT PROMPT TEMPLATE:
+\`\`\`markdown
+${currentTemplate}
+\`\`\`
+
+PERFORMANCE DATA:
+- Success rate: ${successRate}%
+- Total failures: ${failures}
+
+FAILURE PHASE BREAKDOWN:
+${failPhaseSummary || "  (none)"}
+
+ERROR PATTERNS:
+${errorSummary || "  (none)"}
+
+SAMPLE ERROR TAILS FROM RECENT FAILURES:
+${errorTails || "  (none)"}
+
+RECOMMENDATIONS FROM ANALYSIS:
+${recs.map((r) => `- ${r}`).join("\n")}
+
+YOUR TASK:
+Improve the prompt template to reduce failures. Focus on:
+1. Adding specific instructions that address the most common failure modes
+2. Making implicit requirements explicit (lint rules, test commands, commit format)
+3. Adding guardrails for the error patterns seen (e.g., if lint failures are common, add lint-specific instructions)
+4. Keeping the template concise \u2014 agents work better with clear, structured prompts
+5. Preserving all {{VARIABLE}} placeholders exactly as-is
+
+REQUIREMENTS:
+- Output ONLY the improved markdown template
+- Keep all {{VARIABLE}} placeholders: {{ISSUE_ID}}, {{TITLE}}, {{DESCRIPTION}}, {{LABELS}}, {{PRIORITY}}, {{ATTEMPT}}, {{PRIOR_CONTEXT}}
+- Do not add commentary, explanations, or markdown fences around the output
+- Target similar length to the current template (no bloat)
+
+OUTPUT THE IMPROVED TEMPLATE:`;
+  try {
+    console.log(
+      `    ${c.d}Calling Claude to generate improved template...${c.r}`
+    );
+    const evolved = await spawnClaudePrint(mutationPrompt);
+    if (!evolved.trim()) {
+      console.log(`    ${c.red}Empty response from Claude \u2014 skipping.${c.r}`);
+      return;
+    }
+    const requiredVars = ["{{ISSUE_ID}}", "{{TITLE}}", "{{DESCRIPTION}}"];
+    const missing = requiredVars.filter((v) => !evolved.includes(v));
+    if (missing.length > 0) {
+      console.log(
+        `    ${c.red}Evolved template missing variables: ${missing.join(", ")} \u2014 skipping.${c.r}`
+      );
+      return;
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const backupPath = templatePath.replace(".md", `.backup-${timestamp}.md`);
+    copyFileSync(templatePath, backupPath);
+    console.log(`    ${c.d}Backed up to ${backupPath}${c.r}`);
+    writeFileSync(templatePath, evolved.trim() + "\n");
+    console.log(
+      `    ${c.green}Evolved template written to ${templatePath}${c.r}`
+    );
+    const evolutionLog = join(
+      homedir(),
+      ".stackmemory",
+      "conductor",
+      "evolution-log.jsonl"
+    );
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      successRate,
+      failures,
+      failPhases,
+      errorPatterns,
+      backupPath
+    };
+    const dir = join(homedir(), ".stackmemory", "conductor");
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      evolutionLog,
+      (existsSync(evolutionLog) ? readFileSync(evolutionLog, "utf-8") : "") + JSON.stringify(entry) + "\n"
+    );
+    console.log(`    ${c.d}Evolution logged to ${evolutionLog}${c.r}`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.log(`    ${c.red}Evolution failed: ${msg}${c.r}`);
+    console.log(
+      `    ${c.d}Tip: Ensure 'claude' CLI is available and authenticated.${c.r}`
+    );
+  }
 }
 function createConductorCommands() {
   const cmd = new Command("conductor");
@@ -323,14 +541,14 @@ function createConductorCommands() {
         const risks = anchors.filter((a) => a.type === "RISK");
         if (decisions.length > 0) {
           lines.push("", "### Decisions");
-          for (const d2 of decisions.slice(0, 10)) {
-            lines.push(`- ${d2.text}`);
+          for (const d of decisions.slice(0, 10)) {
+            lines.push(`- ${d.text}`);
           }
         }
         if (risks.length > 0) {
           lines.push("", "### Risks");
-          for (const r2 of risks.slice(0, 5)) {
-            lines.push(`- ${r2.text}`);
+          for (const r of risks.slice(0, 5)) {
+            lines.push(`- ${r.text}`);
           }
         }
       } catch {
@@ -414,48 +632,28 @@ function createConductorCommands() {
     }
     console.log(`Found ${results.length} result(s) for "${query}":
 `);
-    for (const r2 of results) {
-      const date = new Date(r2.captured_at * 1e3).toISOString().slice(0, 16);
+    for (const r of results) {
+      const date = new Date(r.captured_at * 1e3).toISOString().slice(0, 16);
       console.log(
-        `  ${r2.issue_id} [${r2.context_type}] attempt ${r2.attempt} (${date})`
+        `  ${r.issue_id} [${r.context_type}] attempt ${r.attempt} (${date})`
       );
-      if (r2.summary) {
-        const snippet = r2.summary.slice(0, 120).replace(/\n/g, " ");
+      if (r.summary) {
+        const snippet = r.summary.slice(0, 120).replace(/\n/g, " ");
         console.log(`    ${snippet}`);
       }
     }
     globalDb.close();
   });
   cmd.command("status").description("Show running agent status table").action(async () => {
-    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);
-      } catch {
-      }
-    }
+    const statuses = scanAgentStatuses();
     if (statuses.length === 0) {
       console.log("No agent status files found");
       return;
     }
-    statuses.sort(
-      (a, b) => new Date(b.lastUpdate).getTime() - new Date(a.lastUpdate).getTime()
-    );
-    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 enriched = statuses.map((s) => ({ ...s, ...enrichStatus(s) }));
+    const active = enriched.filter((s) => s.alive);
+    const stalled = enriched.filter((s) => s.stale);
+    const dead = enriched.filter((s) => !s.alive);
     const healthy = active.length - stalled.length;
     const parts = [];
     if (healthy > 0) parts.push(`${c.green}\u25CF ${healthy}${c.r}`);
@@ -467,21 +665,18 @@ function createConductorCommands() {
 `);
     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 staleFlag = elapsed > 5 * 60 * 1e3;
-      const alive = isProcessAlive(s.pid);
+    for (const s of enriched) {
       const { icon, color, pct, label } = phaseProgress(
         s.phase,
         s.toolCalls,
-        staleFlag,
-        alive
+        s.stale,
+        s.alive
       );
       const bar = progressBar(pct, 8);
-      const timeColor = !alive ? c.red : staleFlag ? c.orange : c.gray;
+      const timeColor = !s.alive ? c.red : s.stale ? 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}`
+        `  ${bar} ${c.d}${pct}%${c.r} ${c.gray}${s.toolCalls}t ${s.filesModified}f${c.r} ${timeColor}${formatElapsed(s.elapsed)}${c.r}`
       ];
       rows.push(cell);
     }
@@ -517,27 +712,9 @@ function createConductorCommands() {
     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;
+    const statuses = scanAgentStatuses();
+    const needsFinalize = statuses.map((s) => ({ ...s, ...enrichStatus(s) })).filter((s) => {
+      return !s.alive || s.elapsed > STALE_FINALIZE_THRESHOLD_MS;
     });
     if (needsFinalize.length === 0) {
       console.log(
@@ -551,26 +728,37 @@ function createConductorCommands() {
 `
     );
     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", "");
+      const elapsedStr = formatElapsed(s.elapsed).replace(" ago", "");
       let hasCommits = false;
       if (s.workspacePath && existsSync(s.workspacePath)) {
+        let baseBranch = "main";
         try {
-          const log = execSync("git log origin/main..HEAD --oneline", {
+          const ref = execSync("git symbolic-ref refs/remotes/origin/HEAD", {
             cwd: s.workspacePath,
             encoding: "utf-8",
-            timeout: 1e4
-          });
+            timeout: 5e3
+          }).trim();
+          baseBranch = ref.replace("refs/remotes/origin/", "");
+        } catch {
+        }
+        try {
+          const log = execSync(
+            `git log origin/${baseBranch}..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 statusIcon = !s.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) {
+      if (s.alive) {
         try {
           process.kill(s.pid, "SIGTERM");
           console.log(`     ${c.gray}Sent SIGTERM to pid ${s.pid}${c.r}`);
@@ -618,17 +806,220 @@ function createConductorCommands() {
     const lines = parseInt(options.lines, 10);
     const args = options.follow ? ["-f", "-n", String(lines), logPath] : ["-n", String(lines), logPath];
     const tail = cpSpawn("tail", args, { stdio: "inherit" });
+    const forward = () => {
+      tail.kill("SIGTERM");
+    };
+    process.on("SIGINT", forward);
+    process.on("SIGTERM", forward);
     await new Promise((resolve) => {
       tail.on("close", () => {
+        process.removeListener("SIGINT", forward);
+        process.removeListener("SIGTERM", forward);
         resolve();
       });
-      const forward = () => {
-        tail.kill("SIGTERM");
-      };
-      process.on("SIGINT", forward);
-      process.on("SIGTERM", forward);
     });
   });
+  cmd.command("learn").description(
+    "Analyze agent outcomes and generate improved prompt templates"
+  ).option("--last <n>", "Analyze last N outcomes (default: all)", "0").option("--failures-only", "Only analyze failures", false).option("--export", "Export analysis as JSON", false).option(
+    "--evolve",
+    "Auto-mutate prompt template using GEPA-style evolution from failure data",
+    false
+  ).action(async (options) => {
+    const logPath = getOutcomesLogPath();
+    if (!existsSync(logPath)) {
+      console.log(
+        `${c.yellow}No outcomes log found.${c.r} Run conductor to generate data.`
+      );
+      return;
+    }
+    const raw = readFileSync(logPath, "utf-8").trim().split("\n").filter((l) => l.length > 0);
+    let outcomes = raw.map(
+      (line) => JSON.parse(line)
+    );
+    if (options.failuresOnly) {
+      outcomes = outcomes.filter((o) => o.outcome === "failure");
+    }
+    const lastN = parseInt(options.last, 10);
+    if (lastN > 0) {
+      outcomes = outcomes.slice(-lastN);
+    }
+    if (outcomes.length === 0) {
+      console.log(`${c.gray}No matching outcomes to analyze.${c.r}`);
+      return;
+    }
+    const total = outcomes.length;
+    const successes = outcomes.filter((o) => o.outcome === "success").length;
+    const failures = outcomes.filter((o) => o.outcome === "failure").length;
+    const successRate = Math.round(successes / total * 100);
+    const avgTokens = Math.round(
+      outcomes.reduce((s, o) => s + o.tokensUsed, 0) / total
+    );
+    const avgDuration = Math.round(
+      outcomes.reduce((s, o) => s + o.durationMs, 0) / total / 6e4
+    );
+    const avgTools = Math.round(
+      outcomes.reduce((s, o) => s + o.toolCalls, 0) / total
+    );
+    const failPhases = {};
+    for (const o of outcomes.filter((o2) => o2.outcome === "failure")) {
+      failPhases[o.phase] = (failPhases[o.phase] || 0) + 1;
+    }
+    const retries = outcomes.filter((o) => o.attempt > 1);
+    const retrySuccessRate = retries.length > 0 ? Math.round(
+      retries.filter((o) => o.outcome === "success").length / retries.length * 100
+    ) : 0;
+    const errorPatterns = {};
+    for (const o of outcomes.filter(
+      (o2) => o2.outcome === "failure" && o2.errorTail
+    )) {
+      const tail = o.errorTail;
+      if (tail.includes("lint"))
+        errorPatterns["lint_failure"] = (errorPatterns["lint_failure"] || 0) + 1;
+      else if (tail.includes("test"))
+        errorPatterns["test_failure"] = (errorPatterns["test_failure"] || 0) + 1;
+      else if (tail.includes("timeout") || tail.includes("timed out"))
+        errorPatterns["timeout"] = (errorPatterns["timeout"] || 0) + 1;
+      else if (tail.includes("conflict"))
+        errorPatterns["git_conflict"] = (errorPatterns["git_conflict"] || 0) + 1;
+      else if (tail.includes("429") || tail.includes("rate"))
+        errorPatterns["rate_limit"] = (errorPatterns["rate_limit"] || 0) + 1;
+      else errorPatterns["unknown"] = (errorPatterns["unknown"] || 0) + 1;
+    }
+    if (options.export) {
+      const analysis = {
+        total,
+        successes,
+        failures,
+        successRate,
+        avgTokens,
+        avgDurationMin: avgDuration,
+        avgToolCalls: avgTools,
+        failPhases,
+        retrySuccessRate,
+        errorPatterns,
+        outcomes
+      };
+      console.log(JSON.stringify(analysis, null, 2));
+      return;
+    }
+    console.log(`
+  ${c.b}${c.purple}Conductor Learning Report${c.r}
+`);
+    const rateColor = successRate >= 80 ? c.green : successRate >= 50 ? c.yellow : c.red;
+    console.log(
+      `  ${c.b}Outcomes${c.r}  ${c.white}${total}${c.r} total  ${c.green}${successes}${c.r} success  ${c.red}${failures}${c.r} failed  ${rateColor}${successRate}%${c.r} success rate`
+    );
+    console.log(
+      `  ${c.b}Averages${c.r}  ${c.white}${avgDuration}m${c.r} duration  ${c.white}${fmtTokens(avgTokens)}${c.r} tokens  ${c.white}${avgTools}${c.r} tool calls`
+    );
+    if (retries.length > 0) {
+      console.log(
+        `  ${c.b}Retries${c.r}   ${c.white}${retries.length}${c.r} attempts  ${c.white}${retrySuccessRate}%${c.r} retry success rate`
+      );
+    }
+    if (failures > 0) {
+      console.log(`
+  ${c.b}Failure Phases${c.r}`);
+      const sorted = Object.entries(failPhases).sort((a, b) => b[1] - a[1]);
+      for (const [phase, count] of sorted) {
+        const pct = Math.round(count / failures * 100);
+        const bar = progressBar(pct, 10);
+        console.log(
+          `    ${phaseIcon[phase] || "\u25CB"} ${phase.padEnd(14)} ${bar} ${c.white}${count}${c.r} ${c.gray}(${pct}%)${c.r}`
+        );
+      }
+    }
+    if (Object.keys(errorPatterns).length > 0) {
+      console.log(`
+  ${c.b}Error Patterns${c.r}`);
+      const sorted = Object.entries(errorPatterns).sort(
+        (a, b) => b[1] - a[1]
+      );
+      for (const [pattern, count] of sorted) {
+        console.log(
+          `    ${c.red}\u25CF${c.r} ${pattern.padEnd(16)} ${c.white}${count}${c.r}`
+        );
+      }
+    }
+    console.log(`
+  ${c.b}Recommendations${c.r}`);
+    const recs = [];
+    if (errorPatterns["lint_failure"] > 0) {
+      recs.push(
+        "Add explicit lint rules to prompt template (ESLint conventions, import style)"
+      );
+    }
+    if (errorPatterns["test_failure"] > 0) {
+      recs.push(
+        'Add "run tests before committing" emphasis, include test command in prompt'
+      );
+    }
+    if (errorPatterns["timeout"] > 0) {
+      recs.push(
+        "Reduce scope per issue or increase turnTimeoutMs in conductor config"
+      );
+    }
+    if (failPhases["implementing"] > failures * 0.5) {
+      recs.push(
+        "Agents stall during implementation \u2014 add examples or break issues smaller"
+      );
+    }
+    if (failPhases["reading"] > 0) {
+      recs.push(
+        "Agents fail during reading \u2014 improve issue descriptions or add context pointers"
+      );
+    }
+    if (retrySuccessRate < 30 && retries.length > 2) {
+      recs.push(
+        "Low retry success \u2014 consider better prior-attempt context injection"
+      );
+    }
+    if (successRate >= 80) {
+      recs.push(
+        "High success rate \u2014 current prompt template is working well"
+      );
+    }
+    if (recs.length === 0) {
+      recs.push("Collect more data for actionable recommendations");
+    }
+    for (const rec of recs) {
+      console.log(`    ${c.cyan}\u2192${c.r} ${rec}`);
+    }
+    const templatePath = join(
+      homedir(),
+      ".stackmemory",
+      "conductor",
+      "prompt-template.md"
+    );
+    if (!existsSync(templatePath)) {
+      console.log(
+        `
+  ${c.d}Tip: Create ${templatePath} to customize agent prompts.${c.r}`
+      );
+      console.log(
+        `  ${c.d}Variables: {{ISSUE_ID}} {{TITLE}} {{DESCRIPTION}} {{LABELS}} {{PRIORITY}} {{ATTEMPT}} {{PRIOR_CONTEXT}}${c.r}`
+      );
+    } else {
+      console.log(`
+  ${c.d}Using custom template: ${templatePath}${c.r}`);
+    }
+    if (options.evolve) {
+      console.log(`
+  ${c.b}${c.cyan}Evolving prompt template...${c.r}
+`);
+      await evolvePromptTemplate({
+        templatePath,
+        successRate,
+        failures,
+        failPhases,
+        errorPatterns,
+        recs,
+        outcomes
+      });
+    }
+    console.log("");
+  });
   cmd.command("usage").description("Show token usage, budget, and time-to-exhaustion").option("--json", "Output as JSON", false).option("--scan", "Scan Claude Code JSONL logs for historical data", false).action(async (options) => {
     const statusPath = join(
       process.cwd(),
@@ -694,6 +1085,7 @@ function createConductorCommands() {
     'Agent mode: "cli" (claude -p, session auth) or "adapter" (JSON-RPC, API key)',
     "cli"
   ).action(async (options) => {
+    ensureDefaultPromptTemplate();
     const conductor = new Conductor({
       teamId: options.team,
       activeStates: options.states.split(",").map((s) => s.trim()),
@@ -721,27 +1113,7 @@ function createConductorCommands() {
     let refreshInterval = interval;
     let phaseFilter = options.phase || null;
     function readStatuses() {
-      const agentsDir = join(
-        homedir(),
-        ".stackmemory",
-        "conductor",
-        "agents"
-      );
-      if (!existsSync(agentsDir)) 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 {
-          statuses.push(JSON.parse(readFileSync(statusPath, "utf-8")));
-        } catch {
-        }
-      }
-      statuses.sort(
-        (a, b) => new Date(b.lastUpdate).getTime() - new Date(a.lastUpdate).getTime()
-      );
+      const statuses = scanAgentStatuses();
       if (phaseFilter) {
         return statuses.filter((s) => s.phase === phaseFilter);
       }
@@ -754,9 +1126,7 @@ function createConductorCommands() {
         return;
       }
       for (const s of statuses) {
-        const elapsed = Date.now() - new Date(s.lastUpdate).getTime();
-        const stale = elapsed > 5 * 60 * 1e3;
-        const alive = isProcessAlive(s.pid);
+        const { elapsed, alive, stale } = enrichStatus(s);
         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;
@@ -788,9 +1158,7 @@ function createConductorCommands() {
         return;
       }
       for (const s of statuses) {
-        const elapsed = Date.now() - new Date(s.lastUpdate).getTime();
-        const stale = elapsed > 5 * 60 * 1e3;
-        const alive = isProcessAlive(s.pid);
+        const { elapsed, alive, stale } = enrichStatus(s);
         const prog = phaseProgress(s.phase, s.toolCalls, stale, alive);
         console.log(
           `  ${prog.color}${prog.icon}${c.r}  ${c.b}${s.issue}${c.r}  ${prog.color}${prog.label}${c.r}  ${c.gray}${formatElapsed(elapsed)}${c.r}`
@@ -813,10 +1181,10 @@ function createConductorCommands() {
         console.log("");
       }
     }
+    const cachedConductor = new Conductor({ repoRoot: process.cwd() });
     async function getUsage() {
-      const conductor = new Conductor({ repoRoot: process.cwd() });
-      await conductor.scanUsageLogs();
-      return conductor.getUsageSummary();
+      await cachedConductor.scanUsageLogs();
+      return cachedConductor.getUsageSummary();
     }
     async function render() {
       process.stdout.write("\x1B[2J\x1B[H");
@@ -867,7 +1235,7 @@ function createConductorCommands() {
       }
       console.log("");
       console.log(
-        `${d}\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\u2500${r}`
+        `${c.d}\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\u2500${c.r}`
       );
     }
     await render();
@@ -876,14 +1244,14 @@ function createConductorCommands() {
         if (!paused) await render();
       }, refreshInterval);
       await new Promise((resolve) => {
-        process.on("SIGINT", () => {
-          clearInterval(timer);
-          resolve();
-        });
-        process.on("SIGTERM", () => {
+        const cleanup = () => {
           clearInterval(timer);
+          process.removeListener("SIGINT", cleanup);
+          process.removeListener("SIGTERM", cleanup);
           resolve();
-        });
+        };
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
       });
       return;
     }
@@ -996,16 +1364,15 @@ function createConductorCommands() {
       }
     });
     await new Promise((resolve) => {
-      process.on("SIGINT", () => {
+      const cleanup = () => {
         if (refreshTimer) clearTimeout(refreshTimer);
         if (process.stdin.isTTY) process.stdin.setRawMode(false);
+        process.removeListener("SIGINT", cleanup);
+        process.removeListener("SIGTERM", cleanup);
         resolve();
-      });
-      process.on("SIGTERM", () => {
-        if (refreshTimer) clearTimeout(refreshTimer);
-        if (process.stdin.isTTY) process.stdin.setRawMode(false);
-        resolve();
-      });
+      };
+      process.on("SIGINT", cleanup);
+      process.on("SIGTERM", cleanup);
     });
   });
   return cmd;