@stackmemoryai/stackmemory 1.5.9 → 1.6.0

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

@@ -9,12 +9,14 @@ 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,
@@ -123,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,
@@ -231,6 +225,205 @@ function printUsageSummary(u) {
     `  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");
   cmd.description("Conductor \u2014 autonomous agent orchestration via Linear");
@@ -538,12 +731,25 @@ function createConductorCommands() {
       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 {
         }
@@ -600,20 +806,26 @@ 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).action(async (options) => {
+  ).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(
@@ -792,6 +1004,20 @@ function createConductorCommands() {
       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) => {
@@ -859,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()),
@@ -1017,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;
     }
@@ -1137,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;

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

@@ -20,6 +20,7 @@ import { createInterface } from "readline";
 import { fileURLToPath } from "url";
 import { Transform } from "stream";
 import { logger } from "../../core/monitoring/logger.js";
+import { isProcessAlive } from "../../utils/process-cleanup.js";
 import {
   LinearClient
 } from "../../integrations/linear/client.js";
@@ -1469,14 +1470,7 @@ class Conductor {
       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 {
-        }
-      }
+      const alive = pid ? isProcessAlive(pid) : false;
       if (!alive) {
         logger.warn("Stale agent process is dead, cleaning up", {
           identifier: run.issue.identifier,

package/dist/src/daemon/daemon-config.js

@@ -5,6 +5,7 @@ const __dirname = __pathDirname(__filename);
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
+import { isProcessAlive } from "../utils/process-cleanup.js";
 const DEFAULT_DAEMON_CONFIG = {
   version: "1.0.0",
   context: {
@@ -139,9 +140,7 @@ function readDaemonStatus() {
   try {
     const pidContent = readFileSync(pidFile, "utf8").trim();
     const pid = parseInt(pidContent, 10);
-    try {
-      process.kill(pid, 0);
-    } catch {
+    if (!isProcessAlive(pid)) {
       return defaultStatus;
     }
     if (!existsSync(statusFile)) {

package/dist/src/daemon/session-daemon.js

@@ -6,6 +6,7 @@ const __dirname = __pathDirname(__filename);
 import * as fs from "fs";
 import * as path from "path";
 import { execSync } from "child_process";
+import { isProcessAlive } from "../utils/process-cleanup.js";
 class SessionDaemon {
   config;
   state;
@@ -69,16 +70,14 @@ class SessionDaemon {
       try {
         const existingPid = fs.readFileSync(this.pidFile, "utf8").trim();
         const pid = parseInt(existingPid, 10);
-        try {
-          process.kill(pid, 0);
+        if (isProcessAlive(pid)) {
           this.log("WARN", "Daemon already running for this session", {
             existingPid: pid
           });
           return false;
-        } catch {
-          this.log("INFO", "Cleaning up stale PID file", { stalePid: pid });
-          fs.unlinkSync(this.pidFile);
         }
+        this.log("INFO", "Cleaning up stale PID file", { stalePid: pid });
+        fs.unlinkSync(this.pidFile);
       } catch {
         try {
           fs.unlinkSync(this.pidFile);

package/dist/src/daemon/unified-daemon.js

@@ -10,6 +10,7 @@ import {
   appendFileSync,
   readFileSync
 } from "fs";
+import { isProcessAlive } from "../utils/process-cleanup.js";
 import {
   loadDaemonConfig,
   getDaemonPaths,
@@ -75,14 +76,12 @@ class UnifiedDaemon {
       try {
         const existingPid = readFileSync(this.paths.pidFile, "utf8").trim();
         const pid = parseInt(existingPid, 10);
-        try {
-          process.kill(pid, 0);
+        if (isProcessAlive(pid)) {
           this.log("WARN", "daemon", "Daemon already running", { pid });
           return false;
-        } catch {
-          this.log("INFO", "daemon", "Cleaning stale PID file", { pid });
-          unlinkSync(this.paths.pidFile);
         }
+        this.log("INFO", "daemon", "Cleaning stale PID file", { pid });
+        unlinkSync(this.paths.pidFile);
       } catch {
         try {
           unlinkSync(this.paths.pidFile);

package/dist/src/features/sweep/sweep-server-manager.js

@@ -10,6 +10,7 @@ import {
 } from "./types.js";
 import { createPredictionClient } from "./prediction-client.js";
 import { logger } from "../../core/monitoring/logger.js";
+import { isProcessAlive } from "../../utils/process-cleanup.js";
 const HOME = process.env["HOME"] || "/tmp";
 const PID_FILE = join(HOME, ".stackmemory", "sweep", "server.pid");
 const LOG_FILE = join(HOME, ".stackmemory", "sweep", "server.log");
@@ -149,9 +150,7 @@ Download with: huggingface-cli download sweepai/sweep-next-edit-1.5B sweep-next-
       process.kill(status.pid, "SIGTERM");
       await new Promise((resolve) => {
         const checkInterval = setInterval(() => {
-          try {
-            process.kill(status.pid, 0);
-          } catch {
+          if (!isProcessAlive(status.pid)) {
             clearInterval(checkInterval);
             resolve();
           }
@@ -186,9 +185,7 @@ Download with: huggingface-cli download sweepai/sweep-next-edit-1.5B sweep-next-
     try {
       const data = JSON.parse(readFileSync(PID_FILE, "utf-8"));
       const { pid, port, host, modelPath, startedAt } = data;
-      try {
-        process.kill(pid, 0);
-      } catch {
+      if (!isProcessAlive(pid)) {
         return { running: false };
       }
       const client = createPredictionClient({ port, host });

package/dist/src/hooks/daemon.js

@@ -13,6 +13,7 @@ import {
 import { join, extname, relative } from "path";
 import { spawn } from "child_process";
 import { loadConfig } from "./config.js";
+import { isProcessAlive } from "../utils/process-cleanup.js";
 import {
   hookEmitter
 } from "./events.js";
@@ -51,13 +52,11 @@ async function startDaemon(options = {}) {
   const pidFile = config.daemon.pid_file;
   if (existsSync(pidFile)) {
     const pid = parseInt(readFileSync(pidFile, "utf-8").trim(), 10);
-    try {
-      process.kill(pid, 0);
+    if (isProcessAlive(pid)) {
       log("warn", "Daemon already running", { pid });
       return;
-    } catch {
-      unlinkSync(pidFile);
     }
+    unlinkSync(pidFile);
   }
   if (!options.foreground) {
     const child = spawn(
@@ -117,17 +116,15 @@ function getDaemonStatus() {
     return { running: false };
   }
   const pid = parseInt(readFileSync(pidFile, "utf-8").trim(), 10);
-  try {
-    process.kill(pid, 0);
+  if (isProcessAlive(pid)) {
     return {
       running: true,
       pid,
       uptime: state.running ? Date.now() - state.startTime : void 0,
       eventsProcessed: state.eventsProcessed
     };
-  } catch {
-    return { running: false };
   }
+  return { running: false };
 }
 function setupLogStream() {
   const logFile = config.daemon.log_file;

package/dist/src/utils/process-cleanup.js

@@ -7,6 +7,14 @@ import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
 import { logger } from "../core/monitoring/logger.js";
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
 const STACKMEMORY_PROCESS_PATTERNS = [
   "stackmemory",
   "ralph orchestrate",
@@ -131,5 +139,6 @@ export {
   cleanupStaleProcesses,
   findStaleProcesses,
   getStackmemoryProcesses,
+  isProcessAlive,
   killStaleProcesses
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackmemoryai/stackmemory",
-  "version": "1.5.9",
+  "version": "1.6.0",
   "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",