@stackmemoryai/stackmemory 1.6.0 → 1.6.1

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

@@ -275,6 +275,94 @@ function ensureDefaultPromptTemplate() {
   }
   return templatePath;
 }
+function predictDifficulty(labels, description, priority, outcomes) {
+  let difficulty = "medium";
+  let confidence = 0.5;
+  const reasons = [];
+  const lowerLabels = labels.map((l) => l.toLowerCase());
+  if (outcomes.length > 0 && labels.length > 0) {
+    const matching = outcomes.filter(
+      (o) => o.labels && o.labels.some((ol) => lowerLabels.includes(ol.toLowerCase()))
+    );
+    if (matching.length >= 3) {
+      const failRate = matching.filter((o) => o.outcome === "failure").length / matching.length;
+      if (failRate > 0.6) {
+        difficulty = "hard";
+        confidence = Math.min(confidence + 0.1, 0.9);
+        reasons.push(
+          `Historical failure rate ${Math.round(failRate * 100)}% for similar labels`
+        );
+      } else if (failRate < 0.2) {
+        difficulty = "easy";
+        confidence = Math.min(confidence + 0.1, 0.9);
+        reasons.push(
+          `Historical failure rate ${Math.round(failRate * 100)}% for similar labels`
+        );
+      }
+    }
+  }
+  const hasBugOrFix = lowerLabels.some(
+    (l) => l === "bug" || l === "fix" || l.includes("bugfix")
+  );
+  if (description.length < 100 && hasBugOrFix) {
+    if (difficulty !== "easy") difficulty = "easy";
+    confidence = Math.min(confidence + 0.1, 0.9);
+    reasons.push("Short description with bug/fix label suggests simple fix");
+  }
+  const hasComplexLabel = lowerLabels.some(
+    (l) => l === "feature" || l === "refactor" || l === "refactoring" || l === "architecture"
+  );
+  if (description.length > 500 || hasComplexLabel) {
+    if (difficulty !== "hard") {
+      difficulty = description.length > 500 && hasComplexLabel ? "hard" : difficulty === "easy" ? "medium" : "hard";
+    }
+    confidence = Math.min(confidence + 0.1, 0.9);
+    if (description.length > 500) {
+      reasons.push(
+        `Long description (${description.length} chars) suggests complexity`
+      );
+    }
+    if (hasComplexLabel) {
+      reasons.push("Feature/refactor label suggests higher complexity");
+    }
+  }
+  if (priority === 1 || priority === 2) {
+    if (difficulty === "easy") difficulty = "medium";
+    else if (difficulty === "medium") difficulty = "hard";
+    confidence = Math.min(confidence + 0.1, 0.9);
+    reasons.push(
+      `Priority ${priority} (${priority === 1 ? "urgent" : "high"}) \u2014 higher difficulty expected`
+    );
+  }
+  if (outcomes.length > 0 && labels.length > 0) {
+    const matching = outcomes.filter(
+      (o) => o.labels && o.labels.some((ol) => lowerLabels.includes(ol.toLowerCase()))
+    );
+    if (matching.length >= 3) {
+      const avgToolCalls = matching.reduce((s, o) => s + o.toolCalls, 0) / matching.length;
+      if (avgToolCalls > 80) {
+        difficulty = "hard";
+        confidence = Math.min(confidence + 0.1, 0.9);
+        reasons.push(
+          `Historical avg tool calls ${Math.round(avgToolCalls)} for similar labels (>80)`
+        );
+      }
+    }
+  }
+  if (reasons.length === 0) {
+    reasons.push("No strong signals \u2014 defaulting to medium");
+  }
+  return { difficulty, confidence, reasons };
+}
+function loadOutcomes() {
+  const logPath = getOutcomesLogPath();
+  if (!existsSync(logPath)) return [];
+  try {
+    return readFileSync(logPath, "utf-8").trim().split("\n").filter(Boolean).map((l) => JSON.parse(l));
+  } catch {
+    return [];
+  }
+}
 function spawnClaudePrint(prompt, timeoutMs = 12e4) {
   return new Promise((resolve, reject) => {
     const child = cpSpawn("claude", ["--print"], {
@@ -825,6 +913,10 @@ function createConductorCommands() {
     "--evolve",
     "Auto-mutate prompt template using GEPA-style evolution from failure data",
     false
+  ).option(
+    "--predict",
+    "Show difficulty predictions alongside actual outcomes",
+    false
   ).action(async (options) => {
     const logPath = getOutcomesLogPath();
     if (!existsSync(logPath)) {
@@ -1018,8 +1110,157 @@ function createConductorCommands() {
         outcomes
       });
     }
+    if (options.predict) {
+      console.log(
+        `
+  ${c.b}${c.purple}Difficulty Predictions vs Actual${c.r}
+`
+      );
+      const byIssue = /* @__PURE__ */ new Map();
+      for (const o of outcomes) {
+        byIssue.set(o.issue, o);
+      }
+      const difficultyColor = {
+        easy: c.green,
+        medium: c.yellow,
+        hard: c.red
+      };
+      for (const [issue, outcome] of byIssue) {
+        const issueLabels = outcome.labels || [];
+        const otherOutcomes = outcomes.filter((o) => o.issue !== issue);
+        const pred = predictDifficulty(
+          issueLabels,
+          "",
+          // no description in outcome data
+          0,
+          // no priority in outcome data
+          otherOutcomes
+        );
+        const actualDifficulty = outcome.outcome === "success" && outcome.toolCalls < 40 ? "easy" : outcome.outcome === "failure" || outcome.toolCalls > 80 ? "hard" : "medium";
+        const match = pred.difficulty === actualDifficulty;
+        const matchIcon = match ? `${c.green}\u2713${c.r}` : `${c.red}\u2717${c.r}`;
+        console.log(
+          `    ${matchIcon} ${c.white}${issue.padEnd(12)}${c.r}  predicted: ${difficultyColor[pred.difficulty]}${pred.difficulty.padEnd(6)}${c.r}  actual: ${difficultyColor[actualDifficulty]}${actualDifficulty.padEnd(6)}${c.r}  ${c.gray}(${Math.round(pred.confidence * 100)}% conf)${c.r}`
+        );
+      }
+      const issueList = [...byIssue.values()];
+      const correct = issueList.filter((o) => {
+        const otherOutcomes = outcomes.filter((oo) => oo.issue !== o.issue);
+        const pred = predictDifficulty(o.labels || [], "", 0, otherOutcomes);
+        const actual = o.outcome === "success" && o.toolCalls < 40 ? "easy" : o.outcome === "failure" || o.toolCalls > 80 ? "hard" : "medium";
+        return pred.difficulty === actual;
+      }).length;
+      const accuracy = Math.round(correct / issueList.length * 100);
+      console.log(
+        `
+    ${c.b}Accuracy${c.r}: ${accuracy}% (${correct}/${issueList.length})`
+      );
+    }
     console.log("");
   });
+  cmd.command("predict [issue-id]").description("Predict difficulty for an issue based on historical outcomes").option("--title <title>", "Issue title (for testing without Linear)").option(
+    "--labels <labels>",
+    "Comma-separated labels (for testing without Linear)"
+  ).option("--priority <n>", "Priority 0-4 (for testing without Linear)", "0").option("--json", "Output as JSON", false).action(async (issueId, options) => {
+    let title = options.title || "";
+    let labels = options.labels ? options.labels.split(",").map((l) => l.trim()) : [];
+    let description = "";
+    let priority = parseInt(options.priority, 10) || 0;
+    if (issueId && !options.title && !options.labels) {
+      try {
+        const { LinearClient } = await import("../../integrations/linear/client.js");
+        const { LinearAuthManager } = await import("../../integrations/linear/auth.js");
+        let client;
+        try {
+          const authManager = new LinearAuthManager(process.cwd());
+          const token = await authManager.getValidToken();
+          client = new LinearClient({ apiKey: token, useBearer: true });
+        } catch {
+          const apiKey = process.env.LINEAR_API_KEY;
+          if (!apiKey) {
+            console.log(
+              `${c.red}No Linear auth found.${c.r} Use --title/--labels/--priority for testing.`
+            );
+            return;
+          }
+          client = new LinearClient({ apiKey });
+        }
+        const issue = await client.getIssue(issueId);
+        if (!issue) {
+          console.log(`${c.red}Issue ${issueId} not found.${c.r}`);
+          return;
+        }
+        title = issue.title;
+        description = issue.description || "";
+        labels = issue.labels.map((l) => l.name);
+        priority = issue.priority;
+      } catch (err) {
+        console.log(
+          `${c.red}Failed to fetch issue:${c.r} ${err.message}`
+        );
+        return;
+      }
+    }
+    if (!issueId && !options.title) {
+      console.log(
+        `${c.yellow}Provide an issue ID or --title/--labels for testing.${c.r}`
+      );
+      return;
+    }
+    const outcomes = loadOutcomes();
+    const pred = predictDifficulty(labels, description, priority, outcomes);
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            issueId: issueId || "inline",
+            title,
+            labels,
+            priority,
+            ...pred
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    const difficultyColor = {
+      easy: c.green,
+      medium: c.yellow,
+      hard: c.red
+    };
+    console.log(`
+  ${c.b}${c.purple}Difficulty Prediction${c.r}
+`);
+    if (title) {
+      console.log(`  ${c.b}Issue${c.r}       ${issueId || "inline"}`);
+      console.log(`  ${c.b}Title${c.r}       ${title}`);
+    }
+    if (labels.length > 0) {
+      console.log(`  ${c.b}Labels${c.r}      ${labels.join(", ")}`);
+    }
+    if (priority > 0) {
+      console.log(`  ${c.b}Priority${c.r}    ${priority}`);
+    }
+    console.log(
+      `
+  ${c.b}Difficulty${c.r}  ${difficultyColor[pred.difficulty]}${pred.difficulty.toUpperCase()}${c.r}`
+    );
+    console.log(
+      `  ${c.b}Confidence${c.r}  ${Math.round(pred.confidence * 100)}%`
+    );
+    console.log(`
+  ${c.b}Signals${c.r}`);
+    for (const reason of pred.reasons) {
+      console.log(`    ${c.cyan}\u2192${c.r} ${reason}`);
+    }
+    console.log(
+      `
+  ${c.d}Based on ${outcomes.length} historical outcomes${c.r}
+`
+    );
+  });
   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(),
@@ -1084,6 +1325,10 @@ function createConductorCommands() {
     "--mode <mode>",
     'Agent mode: "cli" (claude -p, session auth) or "adapter" (JSON-RPC, API key)',
     "cli"
+  ).option(
+    "--model <model>",
+    'Model routing: "auto" (complexity-based) or a specific model ID',
+    "auto"
   ).action(async (options) => {
     ensureDefaultPromptTemplate();
     const conductor = new Conductor({
@@ -1098,7 +1343,8 @@ function createConductorCommands() {
       baseBranch: options.branch,
       maxRetries: parseInt(options.retries, 10),
       turnTimeoutMs: parseInt(options.turnTimeout, 10),
-      agentMode: options.mode === "adapter" ? "adapter" : "cli"
+      agentMode: options.mode === "adapter" ? "adapter" : "cli",
+      model: options.model
     });
     await conductor.start();
   });
@@ -1379,5 +1625,6 @@ function createConductorCommands() {
 }
 export {
   createConductorCommands,
-  formatElapsed
+  formatElapsed,
+  predictDifficulty
 };

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

@@ -38,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);
@@ -136,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"],
@@ -655,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",
@@ -678,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;
         }
@@ -691,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...`
           );
@@ -1024,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);
@@ -1146,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),
@@ -1301,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",
@@ -1310,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");
@@ -1547,6 +1726,7 @@ class Conductor {
       tokensUsed: run.tokensUsed,
       durationMs,
       hasCommits,
+      labels: run.issue.labels.map((l) => l.name),
       errorTail
     });
     if (hasCommits) {
@@ -1631,6 +1811,9 @@ class Conductor {
 }
 export {
   Conductor,
+  estimateIssueComplexity,
   getAgentStatusDir,
-  getOutcomesLogPath
+  getOutcomesLogPath,
+  getRetryStrategy,
+  selectModelForIssue
 };

package/package.json

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