claude-teammate 0.1.312 → 0.1.314

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-teammate",
-  "version": "0.1.312",
+  "version": "0.1.314",
   "description": "CLI bootstrapper for Claude Teammate.",
   "license": "MIT",
   "type": "module",

package/src/claude/prompts.js

@@ -422,6 +422,8 @@ export function buildGitHubPRPlanBreakdownSystemPrompt() {
     "Each step must be self-contained: a single developer can implement it in isolation by reading only that step description.",
     "Steps must be ordered by dependency — steps that others depend on come first.",
     "Each step description must be specific enough to act on without reading the full PR body: name the exact files, classes, functions, or fields to change and what the change is.",
+    "Each step must describe a product code, configuration, schema, or test-code change in the target repository.",
+    "Do not create process-only steps such as opening a terminal, changing directories, locating files, reading files, running grep/ls/find, or using an editor.",
     "Aim for 3-8 steps. Do not produce trivial steps or steps that only say 'test' or 'verify'.",
     LANGUAGE_PRESERVATION_RULES,
     "Return only structured output matching the provided schema.",
@@ -444,9 +446,10 @@ ${JSON.stringify(input.memory?.epic || {}, null, 2)}
 Instructions:
 - Produce an ordered list of atomic implementation steps.
 - Each step must be specific enough to implement without reading this full description again: name the exact files, classes, methods, or enum values involved.
+- Each step must describe a code/config/schema/test-code change, not an execution tactic or repository exploration action.
 - Steps must be ordered by dependency (earlier steps must not depend on later ones).
 - Aim for 3-8 steps covering the full scope of the plan.
-- Do not include steps for committing, pushing, or testing unless the test is part of the plan.`;
+- Do not include steps for committing, pushing, opening a terminal, changing directories, locating files, reading files, running grep/ls/find, using an editor, or testing unless the test is part of the plan.`;
 }
 
 export function buildGitHubPRStepBreakdownSystemPrompt() {
@@ -455,6 +458,8 @@ export function buildGitHubPRStepBreakdownSystemPrompt() {
     "Each sub-step must be self-contained and implementable by reading only that sub-step description.",
     "Sub-steps must be ordered by dependency.",
     "Each sub-step must be specific: name the exact files, classes, functions, or fields to change.",
+    "Each sub-step must describe a code/config/schema/test-code change, not an execution tactic or repository exploration action.",
+    "Do not create process-only sub-steps such as opening a terminal, changing directories, locating files, reading files, running grep/ls/find, or using an editor.",
     "Do not produce trivial sub-steps.",
     LANGUAGE_PRESERVATION_RULES,
     "Return only structured output matching the provided schema."
@@ -473,8 +478,9 @@ ${input.step}
 Instructions:
 - Produce 2-4 ordered atomic sub-steps that together complete this step.
 - Each sub-step must be specific: name the exact files, classes, methods, or values to change.
+- Each sub-step must describe a code/config/schema/test-code change, not an execution tactic or repository exploration action.
 - Sub-steps must be ordered by dependency.
-- Do not include steps for committing, pushing, or testing.`;
+- Do not include steps for committing, pushing, opening a terminal, changing directories, locating files, reading files, running grep/ls/find, using an editor, or testing.`;
 }
 
 export function buildGitHubPRImplementationStepSystemPrompt() {

package/src/repo.js

@@ -770,6 +770,31 @@ export async function branchHasChangesAgainstMain(repoPath, baseRef) {
   return Number.isFinite(count) && count > 0;
 }
 
+/**
+ * True when HEAD's own work has already landed on the base branch (e.g. the
+ * branch was merged via another MR / a human merged it directly). In that case
+ * HEAD is an ancestor of the base tip while still being a distinct commit, so a
+ * branch-vs-base diff is empty and re-running Claude can never produce changes.
+ * Callers use this to terminate instead of looping on "no changes to commit".
+ * A brand-new branch that merely points at the base tip (HEAD === base) returns
+ * false — that is an unstarted PR, not a merged one. Best-effort; never throws.
+ */
+export async function branchMergedIntoBase(repoPath, baseRef) {
+  const branch = baseRef || (await resolveRemoteDefaultBranch(repoPath));
+  try {
+    const headSha = (await execGitOutput(repoPath, ["rev-parse", "HEAD"])).trim();
+    const baseSha = (await execGitOutput(repoPath, ["rev-parse", `origin/${branch}`])).trim();
+    if (!headSha || !baseSha || headSha === baseSha) {
+      return false;
+    }
+    // exit 0 → HEAD is an ancestor of the base tip → already merged.
+    await execGit(repoPath, ["merge-base", "--is-ancestor", "HEAD", `origin/${branch}`]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 async function resolveRemoteDefaultBranch(repoPath) {
   try {
     const output = await execGitOutput(repoPath, ["symbolic-ref", "refs/remotes/origin/HEAD"]);

package/src/worker/pr-session-store.js

@@ -2,11 +2,12 @@ import { mkdir, readFile } from "node:fs/promises";
 import path from "node:path";
 import { atomicWriteFile } from "../fs-atomic.js";
 
-// Durable map of Claude session ids keyed by repo + PR branch, so a PR comment
+// Durable map of Claude session ids keyed by repo + PR branch + PR scope, so a PR comment
 // or reopen can resume the prior conversation instead of rebuilding context
 // from memory (which previously dropped diffs / decisions and caused the model
-// to "forget" earlier work). Stored under the same memory dir as issue memory
-// so it survives worker restarts.
+// to "forget" earlier work). The PR scope prevents separate PRs that reuse a
+// generic branch name from inheriting each other's Claude conversation.
+// Stored under the same memory dir as issue memory so it survives worker restarts.
 const SESSIONS_FILE = "pr-sessions.json";
 const MAX_ENTRIES = 1000;
 
@@ -14,8 +15,13 @@ function sessionStorePath(projectRoot) {
   return path.join(projectRoot, "memory", SESSIONS_FILE);
 }
 
-function sessionKey(repoUrl, branchName) {
-  return `${String(repoUrl || "").trim()}#${String(branchName || "").trim()}`;
+function sessionKey(repoUrl, branchName, scope = "") {
+  const parts = [String(repoUrl || "").trim(), String(branchName || "").trim()];
+  const normalizedScope = String(scope || "").trim();
+  if (normalizedScope) {
+    parts.push(normalizedScope);
+  }
+  return parts.join("#");
 }
 
 async function readStore(projectRoot) {
@@ -29,12 +35,12 @@ async function readStore(projectRoot) {
   }
 }
 
-export async function loadPrSessionId(projectRoot, repoUrl, branchName) {
+export async function loadPrSessionId(projectRoot, repoUrl, branchName, scope = "") {
   if (!projectRoot || !branchName) {
     return "";
   }
   const store = await readStore(projectRoot);
-  const entry = store[sessionKey(repoUrl, branchName)];
+  const entry = store[sessionKey(repoUrl, branchName, scope)];
   return entry && typeof entry.session_id === "string" ? entry.session_id : "";
 }
 
@@ -42,14 +48,17 @@ export async function loadPrSessionId(projectRoot, repoUrl, branchName) {
 // never lose each other's entries.
 let writeChain = Promise.resolve();
 
-export async function savePrSessionId(projectRoot, repoUrl, branchName, sessionId) {
+export async function savePrSessionId(projectRoot, repoUrl, branchName, scopeOrSessionId, maybeSessionId) {
+  const hasScope = maybeSessionId !== undefined;
+  const scope = hasScope ? scopeOrSessionId : "";
+  const sessionId = hasScope ? maybeSessionId : scopeOrSessionId;
   if (!projectRoot || !branchName || !sessionId) {
     return;
   }
   writeChain = writeChain
     .then(async () => {
       const store = await readStore(projectRoot);
-      store[sessionKey(repoUrl, branchName)] = {
+      store[sessionKey(repoUrl, branchName, scope)] = {
         session_id: String(sessionId).trim(),
         updated_at: new Date().toISOString()
       };

package/src/worker/pull-request-workflow-support.js

@@ -2,11 +2,11 @@ import {
   isClaudeCliError,
   runClaudeImplementation,
   runClaudeImplementationPlanBreakdown,
-  runClaudeImplementationStep,
-  runClaudeStepBreakdown
+  runClaudeImplementationStep
 } from "../claude.js";
 import {
   branchHasChangesAgainstMain,
+  branchMergedIntoBase,
   commitAndPushRepoChanges,
   ensureWorktreeForBranch,
   getBranchDiffAgainstBase,
@@ -30,13 +30,23 @@ import {
   formatPullRequestOutcomeComment,
   getNextPlanStep,
   hasImplementationPlan,
-  replaceStepWithSubSteps,
   setImplementationPlan,
   setPullRequestStatus,
+  stripImplementationPlan,
   tickPlanStep
 } from "./pull-request.js";
 import { extractJiraKey, parseOptionalInt, summarizeForLog, toErrorMessage } from "./utils.js";
 
+const STEP_BRANCH_DIFF_MAX_CHARS = 3000;
+
+function truncateForPrompt(value, maxChars, label) {
+  const text = String(value || "");
+  if (text.length <= maxChars) {
+    return text;
+  }
+  return `${text.slice(0, maxChars)}\n\n[${label}: ${text.length - maxChars} chars omitted]`;
+}
+
 async function commitPartialPullRequestChanges(repo, detail, logger) {
   try {
     const commitResult = await commitAndPushRepoChanges(
@@ -81,7 +91,6 @@ export function createPullRequestImplementationServices(overrides = {}) {
     runClaudeImplementation,
     runClaudeImplementationPlanBreakdown,
     runClaudeImplementationStep,
-    runClaudeStepBreakdown,
     commitAndPushRepoChanges,
     prepareRepoForBranch,
     persistEpicImplementationKnowledge,
@@ -186,9 +195,13 @@ export async function processPullRequestImplementation({
     // it from memory (which dropped diffs/decisions and caused re-work). The
     // branchDiff + latestComment below remain as the fallback when no session
     // id is stored or the stored id is stale.
-    const resumeSessionId = await loadPrSessionId(projectRoot, repo.url, detail.headRef);
+    const prSessionScope =
+      [githubIssueMemory?.jira_key, detail.number, detail.url].filter(Boolean).map(String).join("#") ||
+      detail.headRef ||
+      issueKey;
+    const resumeSessionId = await loadPrSessionId(projectRoot, repo.url, detail.headRef, prSessionScope);
     const onSessionId = (sessionId) => {
-      void savePrSessionId(projectRoot, repo.url, detail.headRef, sessionId);
+      void savePrSessionId(projectRoot, repo.url, detail.headRef, prSessionScope, sessionId);
     };
 
     // Re-ground the run on any work earlier runs already committed to this
@@ -198,12 +211,17 @@ export async function processPullRequestImplementation({
       typeof services.getBranchDiffAgainstBase === "function"
         ? await services.getBranchDiffAgainstBase(repoPath, detail.baseRef)
         : "";
+    const stepBranchDiff = truncateForPrompt(
+      branchDiff,
+      STEP_BRANCH_DIFF_MAX_CHARS,
+      "branch diff truncated for step prompt"
+    );
 
     // Proactively break down large PRs before attempting full implementation
     if (!inStepMode && nextBody.length > 5000) {
       try {
         const proactiveBreakdown = await services.runClaudeImplementationPlanBreakdown({
-          pullRequest: { ...detail, body: nextBody.slice(0, 8000) },
+          pullRequest: { ...detail, body: stripImplementationPlan(nextBody).slice(0, 8000) },
           memory: { epic: epicSnapshot },
           issueKey,
           logger
@@ -269,7 +287,7 @@ export async function processPullRequestImplementation({
         step: stepText,
         memory: { epic: epicSnapshot },
         epicContext: epicMemory,
-        branchDiff,
+        branchDiff: stepBranchDiff,
         repoPath,
         repoPaths: repoAccess.repoPaths,
         branchName: detail.headRef,
@@ -314,6 +332,16 @@ export async function processPullRequestImplementation({
         pr: detail.number
       });
       result = { result: "implemented", summary: "Implementation already committed on previous run." };
+    } else if (!latestComment && (await branchMergedIntoBase(repoPath, detail.baseRef).catch(() => false))) {
+      // The branch's work already landed on the base (merged via another MR or
+      // by a human). There is nothing left to implement, so skip Claude
+      // entirely — running it would only report "no changes" and loop. A human
+      // comment overrides this so feedback can still be addressed.
+      await logger.info("Head branch already merged into base; skipping Claude (nothing to implement)", {
+        repo: repo.url,
+        pr: detail.number
+      });
+      result = { result: "implemented", summary: "Changes already merged into the base branch." };
     } else {
       result = await services.runClaudeImplementation({
         pullRequest: { ...detail, body: nextBody },
@@ -423,7 +451,53 @@ export async function processPullRequestImplementation({
       );
 
       if (!commitResult.committed && !commitResult.branchHasImplementation) {
-        throw new Error("Claude reported success but no repository changes were available to commit.");
+        // No diff to commit. If the branch's work already landed on the base
+        // (merged via another MR / by a human), re-running Claude can never
+        // produce changes — treat it as terminally implemented instead of
+        // looping. Otherwise stop without preserving STUCK_AT so the bot waits
+        // for human guidance rather than machine-gun retrying an unchangeable
+        // no-op every retry window.
+        const mergedIntoBase = await branchMergedIntoBase(repoPath, detail.baseRef).catch(() => false);
+        if (mergedIntoBase) {
+          const mergedBody = setPullRequestStatus(nextBody, "IMPLEMENTED");
+          await github.updatePullRequest(repo.url, detail.number, { title: detail.title, body: mergedBody });
+          await services.clearForgePullRequestBlocked(github, { ...detail, repoUrl: repo.url });
+          if (markReadyOnSuccess) {
+            await github.markPullRequestReady(repo.url, detail.number);
+            await services.transitionLinkedJiraIssueToReview(detail.title, jira, logger, detail.number);
+          }
+          const mergedComment =
+            successCommentBody ||
+            formatPullRequestOutcomeComment(
+              result.summary,
+              "The requested changes are already merged into the base branch; nothing left to implement."
+            );
+          await postPullRequestComment(github, repo.url, detail.number, mergedComment);
+          await postLinkedJiraComment(extractJiraKey(detail.title), mergedComment, jira, logger);
+          await logger.info("Branch already merged into base; PR marked IMPLEMENTED", {
+            repo: repo.url,
+            pr: detail.number
+          });
+          return buildDraftPrState(
+            { ...detail, body: mergedBody, draft: markReadyOnSuccess ? false : detail.draft },
+            "IMPLEMENTED",
+            "implemented"
+          );
+        }
+        const noChangeBody = clearStuckAt(setPullRequestStatus(nextBody, "STUCK"));
+        await github.updatePullRequest(repo.url, detail.number, { title: detail.title, body: noChangeBody });
+        await services.setForgePullRequestBlocked(github, { ...detail, repoUrl: repo.url });
+        const noChangeComment = formatPullRequestOutcomeComment(
+          result.summary,
+          "Claude reported success but produced no repository changes, so there was nothing to commit. Halting automatic retries until there is new guidance."
+        );
+        await postPullRequestComment(github, repo.url, detail.number, noChangeComment);
+        await postLinkedJiraComment(extractJiraKey(detail.title), noChangeComment, jira, logger);
+        await logger.error("Pull request produced no repository changes; halting auto-retry", {
+          repo: repo.url,
+          pr: detail.number
+        });
+        return buildDraftPrState({ ...detail, body: noChangeBody }, "STUCK", "stuck");
       }
 
       const implementedBody = setPullRequestStatus(nextBody, "IMPLEMENTED");
@@ -504,7 +578,7 @@ export async function processPullRequestImplementation({
             const issueKey = githubIssueMemory?.jira_key || `PR-${detail.number}`;
             const epicSnapshot = buildEpicMemoryPromptSnapshot(epicMemory);
             const breakdown = await services.runClaudeImplementationPlanBreakdown({
-              pullRequest: { ...detail, body: nextBody.slice(0, 8000) },
+              pullRequest: { ...detail, body: stripImplementationPlan(nextBody).slice(0, 8000) },
               memory: { epic: epicSnapshot },
               issueKey,
               logger
@@ -527,38 +601,15 @@ export async function processPullRequestImplementation({
             });
           }
         }
-        // Try to split the failing step into sub-steps before giving up permanently.
         if (inStepMode && stepText) {
-          try {
-            const issueKey = githubIssueMemory?.jira_key || `PR-${detail.number}`;
-            const subBreakdown = await services.runClaudeStepBreakdown({
-              pullRequest: { ...detail },
-              step: stepText,
-              issueKey,
-              logger
-            });
-            if (subBreakdown?.steps?.length > 1) {
-              const splitBody = setPullRequestStatus(
-                replaceStepWithSubSteps(nextBody, stepText, subBreakdown.steps),
-                "IMPLEMENTING"
-              );
-              await github.updatePullRequest(repo.url, detail.number, { title: detail.title, body: splitBody });
-              await logger.info("Split too-large step into sub-steps", {
-                repo: repo.url,
-                pr: detail.number,
-                subSteps: subBreakdown.steps.length
-              });
-              return buildDraftPrState({ ...detail, body: splitBody }, "IMPLEMENTING", "implementing");
-            }
-          } catch (stepBreakdownError) {
-            await logger.error("Failed to split stuck step into sub-steps", {
-              repo: repo.url,
-              pr: detail.number,
-              error: stepBreakdownError
-            });
-          }
+          await logger.error("Pull request implementation step is too large; stopping without recursive breakdown", {
+            repo: repo.url,
+            pr: detail.number,
+            step: summarizeForLog(stepText)
+          });
         }
-        // Step could not be subdivided further → permanent stuck.
+        // A planned step that still exceeds the prompt budget should stop here
+        // instead of recursively expanding the PR body with more generated steps.
         // Otherwise (no plan yet, breakdown failed) → allow auto-retry by preserving STUCK_AT.
         const promptTooLongComment = inStepMode
           ? "Even a single implementation step is too large for Claude to process. Please split this PR into smaller, more focused changes."

package/src/worker/pull-request.js

@@ -132,15 +132,30 @@ const PLAN_START = "<!-- tm8:steps -->";
 const PLAN_END = "<!-- /tm8:steps -->";
 const UNCHECKED_STEP_RE = /^- \[ \] (.+)$/mu;
 const CHECKED_STEP_RE = /^- \[x\] /mu;
+const MAX_IMPLEMENTATION_PLAN_STEPS = 20;
+const MAX_STEP_BREAKDOWN_STEPS = 4;
+const MAX_IMPLEMENTATION_STEP_CHARS = 1000;
 
 export function hasImplementationPlan(body) {
   const s = String(body || "");
   return s.includes(PLAN_START) && s.includes(PLAN_END);
 }
 
+export function stripImplementationPlan(body) {
+  const normalized = String(body || "");
+  if (!hasImplementationPlan(normalized)) {
+    return normalized;
+  }
+  return normalized
+    .replace(new RegExp(`\\n*${escapeRegExpStr(PLAN_START)}[\\s\\S]*?${escapeRegExpStr(PLAN_END)}`, "u"), "")
+    .trimEnd();
+}
+
 export function setImplementationPlan(body, steps) {
   const normalized = String(body || "");
-  const planLines = steps.map((step) => `- [ ] ${step}`).join("\n");
+  const planLines = normalizeImplementationSteps(steps, MAX_IMPLEMENTATION_PLAN_STEPS)
+    .map((step) => `- [ ] ${step}`)
+    .join("\n");
   const planBlock = `${PLAN_START}\n${planLines}\n${PLAN_END}`;
   if (hasImplementationPlan(normalized)) {
     return normalized.replace(
@@ -173,7 +188,9 @@ export function replaceStepWithSubSteps(body, stepText, subSteps) {
     return body;
   }
   const escaped = stepText.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-  const subLines = subSteps.map((s) => `- [ ] ${s}`).join("\n");
+  const subLines = normalizeImplementationSteps(subSteps, MAX_STEP_BREAKDOWN_STEPS)
+    .map((s) => `- [ ] ${s}`)
+    .join("\n");
   return String(body || "").replace(new RegExp(`^- \\[ \\] ${escaped}$`, "mu"), subLines);
 }
 
@@ -192,6 +209,25 @@ function escapeRegExpStr(value) {
   return String(value).replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
 
+function normalizeImplementationSteps(steps, maxSteps) {
+  if (!Array.isArray(steps)) {
+    return [];
+  }
+  return steps
+    .map((step) =>
+      String(step || "")
+        .replace(/\s+/gu, " ")
+        .trim()
+    )
+    .filter(Boolean)
+    .slice(0, maxSteps)
+    .map((step) =>
+      step.length > MAX_IMPLEMENTATION_STEP_CHARS
+        ? `${step.slice(0, MAX_IMPLEMENTATION_STEP_CHARS - 3).trimEnd()}...`
+        : step
+    );
+}
+
 export function formatPullRequestOutcomeComment(summary, fallback) {
   const normalized = String(summary || "").trim();
   return normalized || fallback;