@stackmemoryai/stackmemory 1.10.5 → 1.14.0

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

@@ -3,6 +3,7 @@ import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { spawn, execSync } from "child_process";
+import { estimateTokens } from "../../core/cache/token-estimator.js";
 import {
   appendFileSync,
   existsSync,
@@ -19,6 +20,7 @@ import { createReadStream } from "fs";
 import { createInterface } from "readline";
 import { fileURLToPath } from "url";
 import { Transform } from "stream";
+import { createHash } from "crypto";
 import { logger } from "../../core/monitoring/logger.js";
 import { isProcessAlive } from "../../utils/process-cleanup.js";
 import {
@@ -34,6 +36,59 @@ import {
   TraceCollector,
   stringifyEventTruncated
 } from "./conductor-traces.js";
+const PROMPT_PHASES = [
+  "system",
+  "understand",
+  "implement",
+  "validate",
+  "deliver"
+];
+function buildPromptFromPhases(variables) {
+  const promptsDir = join(homedir(), ".stackmemory", "conductor", "prompts");
+  const systemPath = join(promptsDir, "system.md");
+  if (!existsSync(systemPath)) return null;
+  const versions = {};
+  const parts = [];
+  for (const phase of PROMPT_PHASES) {
+    const phasePath = join(promptsDir, `${phase}.md`);
+    if (!existsSync(phasePath)) continue;
+    let content = readFileSync(phasePath, "utf-8");
+    for (const [key, value] of Object.entries(variables)) {
+      content = content.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), value);
+    }
+    parts.push(content);
+    const hash = createHash("sha256").update(readFileSync(phasePath, "utf-8")).digest("hex").slice(0, 8);
+    versions[phase] = hash;
+  }
+  if (parts.length === 0) return null;
+  const dspyPath = join(
+    homedir(),
+    ".stackmemory",
+    "dspy",
+    "optimized_state.json"
+  );
+  if (existsSync(dspyPath)) {
+    try {
+      const state = JSON.parse(readFileSync(dspyPath, "utf-8"));
+      for (const phase of PROMPT_PHASES) {
+        const sig = state[phase];
+        if (sig?.fewShotExamples?.length) {
+          const examples = sig.fewShotExamples.slice(0, 3).map(
+            (ex) => `<example>
+Input: ${JSON.stringify(ex.input)}
+Output: ${JSON.stringify(ex.output)}
+</example>`
+          ).join("\n");
+          parts.push(`
+## Optimized Examples (${phase}):
+${examples}`);
+        }
+      }
+    } catch {
+    }
+  }
+  return { prompt: parts.join("\n\n"), versions };
+}
 function getOutcomesLogPath() {
   return join(homedir(), ".stackmemory", "conductor", "outcomes.jsonl");
 }
@@ -44,11 +99,6 @@ function logAgentOutcome(entry) {
 }
 function createPullRequest(opts) {
   try {
-    execSync(`git push -u origin "${opts.branch}"`, {
-      cwd: opts.workspacePath,
-      stdio: "pipe",
-      timeout: 6e4
-    });
     const prTitle = `feat(conductor): ${opts.issueId} \u2014 ${opts.title}`;
     const prBody = [
       "## Summary",
@@ -60,6 +110,33 @@ function createPullRequest(opts) {
       "",
       "_This PR was auto-created by StackMemory Conductor._"
     ].join("\n");
+    if (opts.useGitButler) {
+      execSync(`but push --branch "${opts.branch}"`, {
+        cwd: opts.workspacePath,
+        stdio: "pipe",
+        timeout: 6e4
+      });
+      const result2 = execSync(
+        `but pr create --branch "${opts.branch}" --title "${prTitle.replace(/"/g, '\\"')}" --body "${prBody.replace(/"/g, '\\"')}"`,
+        {
+          cwd: opts.workspacePath,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"],
+          timeout: 3e4
+        }
+      );
+      const prUrl2 = result2.trim();
+      logger.info("Created PR via GitButler", {
+        issueId: opts.issueId,
+        prUrl: prUrl2
+      });
+      return prUrl2;
+    }
+    execSync(`git push -u origin "${opts.branch}"`, {
+      cwd: opts.workspacePath,
+      stdio: "pipe",
+      timeout: 6e4
+    });
     const result = execSync(
       `gh pr create --base "${opts.baseBranch}" --head "${opts.branch}" --title "${prTitle.replace(/"/g, '\\"')}" --body "${prBody.replace(/"/g, '\\"')}"`,
       {
@@ -158,8 +235,74 @@ function getRetryStrategy(issue, outcomes) {
       );
     }
   }
+  const promptsDir = join(homedir(), ".stackmemory", "conductor", "prompts");
+  if (lastFailure?.phase && existsSync(join(promptsDir, "system.md"))) {
+    const phaseAssertions = getPhaseAssertions(
+      lastFailure.phase,
+      lastFailure.errorTail || ""
+    );
+    adjustments.push(...phaseAssertions);
+  }
   return { shouldRetry: true, adjustments };
 }
+function getPhaseAssertions(phase, error) {
+  const assertions = [];
+  switch (phase) {
+    case "reading":
+    case "planning":
+      assertions.push(
+        "ASSERTION: Re-read the issue description completely before planning.",
+        "ASSERTION: List ALL files you plan to modify before starting implementation."
+      );
+      break;
+    case "implementing":
+      if (/scope|unrelated|refactor/i.test(error)) {
+        assertions.push(
+          "ASSERTION: Only modify files directly required by the issue. Do NOT refactor surrounding code."
+        );
+      }
+      if (/import|module|ESM/i.test(error)) {
+        assertions.push(
+          "ASSERTION: Every relative import MUST end with .js extension. Check ALL new imports."
+        );
+      }
+      assertions.push(
+        "ASSERTION: After implementing, review your diff \u2014 if any change is not required by the issue, revert it."
+      );
+      break;
+    case "testing":
+    case "linting":
+    case "building":
+      if (/lint|eslint/i.test(error)) {
+        assertions.push(
+          "ASSERTION: Run `npm run lint` IMMEDIATELY. Fix every error. Do NOT proceed until lint passes.",
+          "ASSERTION: Common lint fixes \u2014 catch {} not catch (_err) {}, remove unused imports, add .js to relative imports."
+        );
+      }
+      if (/test|vitest|jest|FAIL/i.test(error)) {
+        assertions.push(
+          "ASSERTION: Read the FULL test error output. Identify which assertion fails and why.",
+          "ASSERTION: If vi.clearAllMocks() is in beforeEach, re-set any mockReturnValue calls after it."
+        );
+      }
+      if (/build|tsc|type/i.test(error)) {
+        assertions.push(
+          "ASSERTION: Run `npm run build` and fix ALL TypeScript errors before committing."
+        );
+      }
+      assertions.push(
+        "ASSERTION: Do NOT use --no-verify to bypass pre-commit hooks. Fix the underlying issue."
+      );
+      break;
+    case "committing":
+      assertions.push(
+        "ASSERTION: Commit message must follow format: type(scope): description",
+        "ASSERTION: If pre-commit hook fails, fix the issue and create a NEW commit \u2014 do NOT amend."
+      );
+      break;
+  }
+  return assertions;
+}
 function findPackageRoot() {
   const currentFile = fileURLToPath(import.meta.url);
   let dir = dirname(currentFile);
@@ -340,6 +483,8 @@ class Conductor {
   stateCache = /* @__PURE__ */ new Map();
   activeStatesLower;
   terminalStatesLower;
+  /** Whether to use GitButler virtual branches instead of git worktrees */
+  useGitButler = false;
   /** Global rate limit backoff state */
   rateLimit = {
     inBackoff: false,
@@ -397,21 +542,79 @@ class Conductor {
         );
       }
     }
-    if (!existsSync(this.config.workspaceRoot)) {
+    const wsMode = this.config.workspaceMode || "auto";
+    const laneMode = Boolean(this.config.laneBranch);
+    if (laneMode && wsMode === "gitbutler") {
+      throw new Error(
+        "--lane is only supported with git worktrees. Use --workspace-mode worktree or omit --workspace-mode."
+      );
+    }
+    if (!laneMode && (wsMode === "gitbutler" || wsMode === "auto")) {
+      try {
+        const butVersion = execSync("but --version", {
+          cwd: this.config.repoRoot,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"],
+          timeout: 5e3
+        }).trim();
+        const gbDir = join(this.config.repoRoot, ".git", "gitbutler");
+        if (wsMode === "gitbutler" || existsSync(gbDir)) {
+          this.useGitButler = true;
+          logger.info("Using GitButler virtual branches", {
+            version: butVersion
+          });
+          console.log(`[conductor] GitButler mode (${butVersion})`);
+        }
+      } catch {
+        if (wsMode === "gitbutler") {
+          throw new Error(
+            "GitButler CLI (but) not found. Install: brew install --cask gitbutler"
+          );
+        }
+      }
+    } else if (laneMode) {
+      logger.info("Lane mode enabled; using git worktrees", {
+        laneBranch: this.config.laneBranch
+      });
+    }
+    if (!this.useGitButler && !existsSync(this.config.workspaceRoot)) {
       mkdirSync(this.config.workspaceRoot, { recursive: true });
     }
     this.client = await this.createLinearClient();
-    if (!this.config.teamId && this.client) {
+    if (this.client) {
       try {
-        const team = await this.client.getTeam();
-        this.config.teamId = team.id;
-        logger.info("Auto-detected Linear team", {
-          id: team.id,
-          name: team.name,
-          key: team.key
-        });
+        if (this.config.teamId) {
+          const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-/i.test(this.config.teamId);
+          if (!isUuid) {
+            const teams = await this.client.getTeams();
+            const needle = this.config.teamId.toLowerCase();
+            const match = teams.find(
+              (t) => t.name.toLowerCase() === needle || t.key.toLowerCase() === needle
+            );
+            if (match) {
+              logger.info("Resolved team name to ID", {
+                name: this.config.teamId,
+                id: match.id,
+                key: match.key
+              });
+              this.config.teamId = match.id;
+            } else {
+              logger.warn("Team not found by name/key, will try as ID", {
+                team: this.config.teamId
+              });
+            }
+          }
+        } else {
+          const team = await this.client.getTeam();
+          this.config.teamId = team.id;
+          logger.info("Auto-detected Linear team", {
+            id: team.id,
+            name: team.name,
+            key: team.key
+          });
+        }
       } catch (err) {
-        logger.warn("Failed to auto-detect team", {
+        logger.warn("Failed to resolve team", {
           error: err.message
         });
       }
@@ -433,7 +636,9 @@ class Conductor {
     try {
       await this.poll();
     } catch (err) {
-      logger.error("Initial poll failed", { error: err.message });
+      const e = err;
+      logger.error("Initial poll failed", { error: e.message, stack: e.stack });
+      console.error(`[conductor] Initial poll failed: ${e.message}`);
     }
     await this.schedulePoll();
   }
@@ -691,6 +896,7 @@ class Conductor {
     const allCandidates = [];
     const issues = await this.client.getIssues({
       teamId: this.config.teamId,
+      stateType: "unstarted",
       limit: 50
     });
     for (const issue of issues) {
@@ -824,7 +1030,8 @@ class Conductor {
             title: issue.title,
             filesModified: run.filesModified,
             toolCalls: run.toolCalls,
-            workspacePath: run.workspacePath
+            workspacePath: run.workspacePath,
+            useGitButler: this.useGitButler
           });
           if (url) {
             prUrl = url;
@@ -843,6 +1050,7 @@ class Conductor {
           durationMs: Date.now() - run.startedAt,
           hasCommits: true,
           labels: issue.labels.map((l) => l.name),
+          promptVersions: this.lastPromptVersions,
           prUrl
         });
         await this.runHook(
@@ -878,6 +1086,7 @@ class Conductor {
           durationMs: Date.now() - run.startedAt,
           hasCommits: false,
           labels: issue.labels.map((l) => l.name),
+          promptVersions: this.lastPromptVersions,
           errorTail: run.error?.slice(-500)
         });
         if (this.handleRateLimitError(run.error, issue.identifier)) {
@@ -1102,6 +1311,45 @@ class Conductor {
   // ── Workspace Management ──
   async createWorkspace(issue) {
     const wsKey = this.sanitizeIdentifier(issue.identifier);
+    if (this.useGitButler) {
+      return this.createGitButlerBranch(issue, wsKey);
+    }
+    return this.createWorktree(issue, wsKey);
+  }
+  createGitButlerBranch(issue, wsKey) {
+    if (this.config.laneBranch) {
+      throw new Error(
+        "Lane mode requires git worktrees; GitButler virtual branches are not supported."
+      );
+    }
+    const branchName = `conductor/${wsKey}`;
+    try {
+      execSync("but pull", {
+        cwd: this.config.repoRoot,
+        stdio: "pipe",
+        timeout: 3e4
+      });
+    } catch {
+    }
+    try {
+      execSync(`but branch new "${branchName}"`, {
+        cwd: this.config.repoRoot,
+        stdio: "pipe",
+        timeout: 1e4
+      });
+      logger.info("Created GitButler virtual branch", {
+        identifier: issue.identifier,
+        branch: branchName
+      });
+    } catch {
+      logger.info("GitButler branch may already exist, reusing", {
+        identifier: issue.identifier,
+        branch: branchName
+      });
+    }
+    return this.config.repoRoot;
+  }
+  createWorktree(issue, wsKey) {
     const wsPath = join(this.config.workspaceRoot, wsKey);
     if (existsSync(wsPath)) {
       logger.info("Reusing existing workspace", {
@@ -1110,7 +1358,9 @@ class Conductor {
       });
       return wsPath;
     }
-    const branchName = `conductor/${wsKey}`;
+    const lane = this.config.laneBranch;
+    const branchName = lane ? `worktree-agent-${wsKey}` : `conductor/${wsKey}`;
+    const startPoint = lane ? lane : `origin/${this.config.baseBranch}`;
     try {
       execSync("git fetch origin", {
         cwd: this.config.repoRoot,
@@ -1118,7 +1368,7 @@ class Conductor {
         timeout: 3e4
       });
       execSync(
-        `git worktree add "${wsPath}" -b "${branchName}" "origin/${this.config.baseBranch}"`,
+        `git worktree add "${wsPath}" -b "${branchName}" "${startPoint}"`,
         {
           cwd: this.config.repoRoot,
           stdio: "pipe",
@@ -1128,7 +1378,8 @@ class Conductor {
       logger.info("Created workspace", {
         identifier: issue.identifier,
         path: wsPath,
-        branch: branchName
+        branch: branchName,
+        lane: lane || null
       });
     } catch (err) {
       try {
@@ -1147,6 +1398,25 @@ class Conductor {
   }
   async removeWorkspace(issue) {
     const wsKey = this.sanitizeIdentifier(issue.identifier);
+    const branchName = `conductor/${wsKey}`;
+    if (this.useGitButler) {
+      await this.runHook("before-remove", this.config.repoRoot, issue).catch(
+        () => {
+        }
+      );
+      try {
+        execSync(`but unapply "${branchName}"`, {
+          cwd: this.config.repoRoot,
+          stdio: "pipe",
+          timeout: 1e4
+        });
+      } catch {
+        logger.debug("GitButler branch already unapplied", {
+          identifier: issue.identifier
+        });
+      }
+      return;
+    }
     const wsPath = join(this.config.workspaceRoot, wsKey);
     if (!existsSync(wsPath)) return;
     await this.runHook("before-remove", wsPath, issue).catch(() => {
@@ -1333,7 +1603,7 @@ class Conductor {
                 }
                 if (block.type === "text" && block.text) {
                   const text = block.text;
-                  run.tokensUsed += Math.ceil(text.length / 4);
+                  run.tokensUsed += estimateTokens(text);
                   turnTextParts.push(text);
                 }
               }
@@ -1469,7 +1739,7 @@ class Conductor {
               }
             }
             if (msg.method === "item/text" && params?.text) {
-              run.tokensUsed += Math.ceil(params.text.length / 4);
+              run.tokensUsed += estimateTokens(params.text);
             }
             if (run.toolCalls % 5 === 0 || phase) {
               this.writeAgentStatus(issue.identifier, run);
@@ -1562,10 +1832,12 @@ class Conductor {
       }
     }
   }
+  /** Last prompt version hashes — set by buildPrompt, read by outcome logging */
+  lastPromptVersions = {};
   /**
-   * Build the agent prompt. If a custom template exists at
-   * ~/.stackmemory/conductor/prompt-template.md, use it with variable
-   * substitution. Otherwise fall back to the default template.
+   * Build the agent prompt. Tries decomposed phase files first
+   * (~/.stackmemory/conductor/prompts/*.md), then typed templates,
+   * then custom prompt-template.md, then default.
    *
    * Template variables: {{ISSUE_ID}}, {{TITLE}}, {{DESCRIPTION}},
    * {{LABELS}}, {{PRIORITY}}, {{ATTEMPT}}, {{PRIOR_CONTEXT}}
@@ -1593,6 +1865,21 @@ class Conductor {
       );
     }
     const priorContext = contextParts.join("\n");
+    const variables = {
+      ISSUE_ID: issue.identifier,
+      TITLE: issue.title,
+      DESCRIPTION: issue.description || "",
+      LABELS: labels,
+      PRIORITY: priority,
+      SCOPE: issue.identifier.toLowerCase().replace(/-\d+$/, ""),
+      ATTEMPT: String(attempt),
+      PRIOR_CONTEXT: priorContext
+    };
+    const phaseResult = buildPromptFromPhases(variables);
+    if (phaseResult) {
+      this.lastPromptVersions = phaseResult.versions;
+      return phaseResult.prompt;
+    }
     const templateDir = join(
       __dirname,
       "..",
@@ -1850,7 +2137,8 @@ class Conductor {
         title: run.issue.title,
         filesModified: run.filesModified,
         toolCalls: run.toolCalls,
-        workspacePath: wsPath
+        workspacePath: wsPath,
+        useGitButler: this.useGitButler
       });
       if (url) {
         prUrl = url;
@@ -1870,6 +2158,7 @@ class Conductor {
       durationMs,
       hasCommits,
       labels: run.issue.labels.map((l) => l.name),
+      promptVersions: this.lastPromptVersions,
       errorTail,
       prUrl
     });