@stackmemoryai/stackmemory 1.5.9 → 1.6.1

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";
@@ -37,6 +38,86 @@ function logAgentOutcome(entry) {
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
   appendFileSync(getOutcomesLogPath(), JSON.stringify(entry) + "\n");
 }
+function getRetryStrategy(issue, outcomes) {
+  if (!outcomes) {
+    const logPath = getOutcomesLogPath();
+    if (!existsSync(logPath)) {
+      return { shouldRetry: true, adjustments: [] };
+    }
+    try {
+      const lines = readFileSync(logPath, "utf-8").trim().split("\n").filter(Boolean);
+      outcomes = lines.map((l) => JSON.parse(l));
+    } catch {
+      return { shouldRetry: true, adjustments: [] };
+    }
+  }
+  const issueOutcomes = outcomes.filter((o) => o.issue === issue);
+  const relevant = issueOutcomes.length > 0 ? issueOutcomes : outcomes;
+  const failures = relevant.filter(
+    (o) => o.outcome === "failure" || o.outcome === "partial"
+  );
+  if (failures.length === 0) {
+    return { shouldRetry: true, adjustments: [] };
+  }
+  const lastFailure = failures[failures.length - 1];
+  if (lastFailure.errorTail && /429|rate.?limit|too many requests|usage.?limit|overloaded/i.test(
+    lastFailure.errorTail
+  )) {
+    return {
+      shouldRetry: false,
+      reason: "Last failure was a rate limit (429) \u2014 retrying immediately will not help",
+      adjustments: []
+    };
+  }
+  if (issueOutcomes.length > 0) {
+    const issueFailures = issueOutcomes.filter(
+      (o) => o.outcome === "failure" || o.outcome === "partial"
+    );
+    const phaseFailCounts = /* @__PURE__ */ new Map();
+    for (const f of issueFailures) {
+      phaseFailCounts.set(f.phase, (phaseFailCounts.get(f.phase) || 0) + 1);
+    }
+    for (const [phase, count] of phaseFailCounts) {
+      if (count >= 2) {
+        return {
+          shouldRetry: false,
+          reason: `Issue has failed ${count} times in '${phase}' phase \u2014 likely a structural problem`,
+          adjustments: []
+        };
+      }
+    }
+  }
+  const adjustments = [];
+  if (lastFailure.errorTail) {
+    const tail = lastFailure.errorTail;
+    if (/timeout|timed?.?out|ETIMEDOUT|ESOCKETTIMEDOUT/i.test(tail)) {
+      adjustments.push(
+        "Previous attempt timed out. Work in smaller increments and commit partial progress early."
+      );
+    }
+    if (/lint|eslint|prettier|formatting|style.?error/i.test(tail)) {
+      adjustments.push(
+        "Previous attempt failed on linting. Run `npm run lint:fix` after each file change and fix all lint errors before committing."
+      );
+    }
+    if (/test.?fail|assertion|expect|vitest|jest|FAIL/i.test(tail)) {
+      adjustments.push(
+        "Previous attempt failed tests. Run tests incrementally after each change. Check existing test expectations before modifying code."
+      );
+    }
+    if (/build.?fail|tsc|type.?error|TS\d{4}|compile/i.test(tail)) {
+      adjustments.push(
+        "Previous attempt had build/type errors. Run `npm run build` after changes and fix type errors before committing."
+      );
+    }
+    if (/cannot find module|ERR_MODULE_NOT_FOUND|import/i.test(tail)) {
+      adjustments.push(
+        "Previous attempt had module resolution errors. Ensure all imports use .js extensions for relative paths (ESM)."
+      );
+    }
+  }
+  return { shouldRetry: true, adjustments };
+}
 function findPackageRoot() {
   const currentFile = fileURLToPath(import.meta.url);
   let dir = dirname(currentFile);
@@ -135,6 +216,52 @@ function inferPhase(msg) {
   }
   return null;
 }
+const SIMPLE_LABELS = ["bug", "fix", "typo", "chore", "docs", "hotfix"];
+const COMPLEX_LABELS = [
+  "feature",
+  "refactor",
+  "architecture",
+  "migration",
+  "security",
+  "performance"
+];
+function estimateIssueComplexity(issue, attempt) {
+  let score = 0;
+  const descLen = (issue.description || "").length;
+  if (descLen > 800) score += 2;
+  else if (descLen > 400) score += 1;
+  else if (descLen < 200) score -= 1;
+  const labelNames = (issue.labels || []).map((l) => l.name.toLowerCase());
+  for (const label of labelNames) {
+    if (SIMPLE_LABELS.some((s) => label.includes(s))) score -= 1;
+    if (COMPLEX_LABELS.some((c) => label.includes(c))) score += 2;
+  }
+  const titleLower = issue.title.toLowerCase();
+  if (SIMPLE_LABELS.some((s) => titleLower.includes(s))) score -= 1;
+  if (COMPLEX_LABELS.some((c) => titleLower.includes(c))) score += 1;
+  if (issue.priority === 1) score += 2;
+  else if (issue.priority === 2) score += 1;
+  if (issue.estimate) {
+    if (issue.estimate >= 5) score += 2;
+    else if (issue.estimate >= 3) score += 1;
+    else if (issue.estimate <= 1) score -= 1;
+  }
+  if (attempt && attempt > 1) score += 2;
+  if (score >= 3) return "complex";
+  if (score >= 1) return "moderate";
+  return "simple";
+}
+function selectModelForIssue(complexity, config) {
+  const modelSetting = config.model || "auto";
+  if (modelSetting !== "auto") return modelSetting;
+  switch (complexity) {
+    case "simple":
+    case "moderate":
+      return "claude-sonnet-4-20250514";
+    case "complex":
+      return "claude-opus-4-20250514";
+  }
+}
 const DEFAULT_CONFIG = {
   activeStates: ["Todo"],
   terminalStates: ["Done", "Cancelled", "Canceled", "Closed"],
@@ -654,7 +781,8 @@ class Conductor {
           filesModified: run.filesModified,
           tokensUsed: run.tokensUsed,
           durationMs: Date.now() - run.startedAt,
-          hasCommits: true
+          hasCommits: true,
+          labels: issue.labels.map((l) => l.name)
         });
         await this.runHook(
           "after-run",
@@ -677,6 +805,20 @@ class Conductor {
           error: run.error,
           attempt: run.attempt
         });
+        logAgentOutcome({
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          issue: issue.identifier,
+          attempt: run.attempt,
+          outcome: "failure",
+          phase: run.phase,
+          toolCalls: run.toolCalls,
+          filesModified: run.filesModified,
+          tokensUsed: run.tokensUsed,
+          durationMs: Date.now() - run.startedAt,
+          hasCommits: false,
+          labels: issue.labels.map((l) => l.name),
+          errorTail: run.error?.slice(-500)
+        });
         if (this.handleRateLimitError(run.error, issue.identifier)) {
           throw err;
         }
@@ -690,6 +832,23 @@ class Conductor {
           });
         }
         if (run.attempt < maxAttempts && !this.stopping) {
+          const strategy = getRetryStrategy(issue.identifier);
+          if (!strategy.shouldRetry) {
+            console.log(
+              `[${issue.identifier}] Skipping retry: ${strategy.reason}`
+            );
+            logger.info("Retry skipped by intelligence", {
+              identifier: issue.identifier,
+              reason: strategy.reason
+            });
+            throw err;
+          }
+          if (strategy.adjustments.length > 0) {
+            run.retryAdjustments = strategy.adjustments;
+            console.log(
+              `[${issue.identifier}] Retry with adjustments: ${strategy.adjustments.length} hint(s)`
+            );
+          }
           console.log(
             `[${issue.identifier}] Failed (attempt ${run.attempt}), retrying...`
           );
@@ -1023,25 +1182,33 @@ class Conductor {
    */
   runAgentCLI(issue, run) {
     return new Promise((resolve, reject) => {
-      const prompt = this.buildPrompt(issue, run.attempt);
+      const prompt = this.buildPrompt(issue, run.attempt, run.retryAdjustments);
+      const complexity = estimateIssueComplexity(issue, run.attempt);
+      const selectedModel = selectModelForIssue(complexity, this.config);
+      logger.info("Agent model selected", {
+        identifier: issue.identifier,
+        complexity,
+        model: selectedModel || "(default)",
+        reason: this.config.model && this.config.model !== "auto" ? "config override" : `auto: ${complexity} issue`
+      });
       const claudeBin = this.findClaudeBinary();
-      const proc = spawn(
-        claudeBin,
-        [
-          "-p",
-          "--output-format",
-          "stream-json",
-          "--dangerously-skip-permissions",
-          "--settings",
-          '{"hooks":{}}',
-          prompt
-        ],
-        {
-          cwd: run.workspacePath,
-          env: this.buildAgentEnv(issue, run),
-          stdio: ["pipe", "pipe", "pipe"]
-        }
-      );
+      const args = [
+        "-p",
+        "--output-format",
+        "stream-json",
+        "--dangerously-skip-permissions",
+        "--settings",
+        '{"hooks":{}}'
+      ];
+      if (selectedModel) {
+        args.push("--model", selectedModel);
+      }
+      args.push(prompt);
+      const proc = spawn(claudeBin, args, {
+        cwd: run.workspacePath,
+        env: this.buildAgentEnv(issue, run),
+        stdio: ["pipe", "pipe", "pipe"]
+      });
       run.process = proc;
       proc.stdin.end();
       const logStream = this.openAgentLogStream(issue.identifier);
@@ -1145,7 +1312,7 @@ class Conductor {
    */
   runAgentAdapter(issue, run) {
     return new Promise((resolve, reject) => {
-      const prompt = this.buildPrompt(issue, run.attempt);
+      const prompt = this.buildPrompt(issue, run.attempt, run.retryAdjustments);
       const proc = spawn("node", [this.config.appServerPath], {
         cwd: run.workspacePath,
         env: this.buildAgentEnv(issue, run),
@@ -1300,7 +1467,7 @@ class Conductor {
    * Template variables: {{ISSUE_ID}}, {{TITLE}}, {{DESCRIPTION}},
    * {{LABELS}}, {{PRIORITY}}, {{ATTEMPT}}, {{PRIOR_CONTEXT}}
    */
-  buildPrompt(issue, attempt) {
+  buildPrompt(issue, attempt, retryAdjustments) {
     const templatePath = join(
       homedir(),
       ".stackmemory",
@@ -1309,7 +1476,20 @@ class Conductor {
     );
     const priority = ["None", "Urgent", "High", "Medium", "Low"][issue.priority] || "None";
     const labels = issue.labels.length > 0 ? issue.labels.map((l) => l.name).join(", ") : "";
-    const priorContext = attempt > 1 ? `This is attempt ${attempt}. Check .stackmemory/conductor-context.md for context from prior attempts.` : "";
+    const contextParts = [];
+    if (attempt > 1) {
+      contextParts.push(
+        `This is attempt ${attempt}. Check .stackmemory/conductor-context.md for context from prior attempts.`
+      );
+    }
+    if (retryAdjustments && retryAdjustments.length > 0) {
+      contextParts.push(
+        "## Retry Adjustments (from prior failure analysis)",
+        "",
+        ...retryAdjustments.map((a) => `- ${a}`)
+      );
+    }
+    const priorContext = contextParts.join("\n");
     if (existsSync(templatePath)) {
       try {
         let template = readFileSync(templatePath, "utf-8");
@@ -1469,14 +1649,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,
@@ -1553,6 +1726,7 @@ class Conductor {
       tokensUsed: run.tokensUsed,
       durationMs,
       hasCommits,
+      labels: run.issue.labels.map((l) => l.name),
       errorTail
     });
     if (hasCommits) {
@@ -1637,6 +1811,9 @@ class Conductor {
 }
 export {
   Conductor,
+  estimateIssueComplexity,
   getAgentStatusDir,
-  getOutcomesLogPath
+  getOutcomesLogPath,
+  getRetryStrategy,
+  selectModelForIssue
 };

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.1",
   "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",
@@ -20,7 +20,6 @@
   "files": [
     "bin",
     "dist/src",
-    "scripts/gepa",
     "scripts/git-hooks",
     "scripts/hooks",
     "scripts/setup",

package/scripts/gepa/.before-optimize.md

@@ -1,112 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Project Overview
-
-Sol is the monorepo for **Rize**, an automatic time tracking application. The stack consists of:
-- **api/** - Rails 7.1 GraphQL backend (Ruby 3.3.5)
-- **web/** - Next.js 14 React web app (Node 22)
-- **electron/** - Electron desktop app (Node 22)
-- **services/** - Bun-based TypeScript event consumers/workers
-- **vanity/** - Webflow marketing site scripts (deprecated)
-- **voyager/** - Marketing website for home and landing pageas (Next.js)
-- **puppet/** - Puppeteer server for images/PDFs
-- **chrome/** - Chrome browser extension
-- **docs/** - Docusaurus documentation site
-- **zapier/** - Zapier integration
-
-## Development Commands
-
-### Starting Development Environment
-```bash
-# Start all services (requires iTerm2 on macOS)
-./scripts/run-dev.sh
-
-# Or start individually:
-cd api && hivemind Procfile.dev     # Rails + AnyCable + Sidekiq + Clockwork
-cd web && npm run dev               # Next.js dev server
-cd electron && npm run dev          # Electron with hot reload
-cd services && hivemind Procfile.dev # Bun services
-```
-
-### Docker Dependencies (api/docker-compose.yml)
-```bash
-cd api && docker-compose up -d
-# TimescaleDB: localhost:15432
-# Redis: localhost:16379
-# Kafka: localhost:9092
-# MySQL: localhost:13306
-```
-
-### Testing
-```bash
-# API (RSpec)
-cd api && bundle exec rspec
-cd api && bundle exec rspec spec/path/to/file_spec.rb      # Single file
-cd api && bundle exec rspec spec/path/to/file_spec.rb:42   # Single test at line
-
-# Electron (Jest)
-cd electron && npm test
-cd electron && npm run test:watch
-cd electron && npm run test:coverage
-
-# Web - no active tests (exits 0)
-```
-
-### Building
-```bash
-cd api && bundle install && rake db:migrate
-cd web && npm run build       # Runs gql-gen, tailwind, next build
-cd electron && npm run build  # Electron Forge make
-cd services && bun install
-```
-
-### GraphQL Code Generation
-```bash
-cd web && npm run build       # Includes gql codegen
-cd electron && npm run dev    # Runs gql codegen as part of dev
-```
-
-## Architecture
-
-### GraphQL API Structure
-The API exposes two GraphQL endpoints:
-- **api/v1** - Public API (OAuth consumers, Zapier)
-- **private/v1** - Private API (web, electron apps)
-
-Located at `api/app/graphql/{api,private}/v1/`
-
-### Real-time Communication
-- **AnyCable** WebSocket server for subscriptions
-- ActionCable channels in `api/app/channels/`
-- WebSocket config: `api/config/cable.yml` and `api/config/anycable.yml`
-
-### Background Jobs
-- **Sidekiq** for async job processing (`api/config/sidekiq.yml`)
-- **Clockwork** for scheduled jobs (`api/config/clock.rb`)
-
-### Event Streaming
-- **Kafka** for event publishing/consumption
-- Services consume events via `services/consumers/`
-- Kafka config: `api/config/initializers/kafka.rb`
-
-### Databases
-- **Primary PostgreSQL** - Main application data
-- **TimescaleDB** - Time-series data (separate connection in `database.yml`)
-- **MySQL** - Legacy/external integrations
-- **Redis** - Caching, ActionCable, Sidekiq
-
-## Style Guidelines
-
-### JavaScript/TypeScript
-- Use `test()` instead of `it()` in tests
-- Use `toBeCalled()` instead of `toHaveBeenCalledWith()` in jest assertions
-
-## Key Configuration Files
-
-- `api/config/database.yml` - Database connections (primary + timescale)
-- `api/config/cable.yml` - AnyCable WebSocket config
-- `api/Procfile.dev` - Development processes (rails, anycable, sidekiq, clockwork)
-- `sol.code-workspace` - VS Code multi-folder workspace
-- Each project requires its own `.env` file (not in repo)