claude-teammate 0.1.306 → 0.1.308

package/package.json

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

package/src/claude/prompts.js

@@ -179,6 +179,7 @@ export function buildJiraClarificationUserPrompt(input) {
     referenceRepos: input.referenceRepos,
     repoPaths: input.repoPaths
   });
+  const attachmentsSection = formatIssueAttachments(input.issue.attachments);
 
   return `Clarify this Jira issue.
 
@@ -189,6 +190,7 @@ Status: ${input.issue.status}
 Description:
 ${input.issue.descriptionText || "(none)"}
 
+${attachmentsSection}
 Memory snapshot:
 ${JSON.stringify(input.memory, null, 2)}
 
@@ -202,6 +204,20 @@ ${reopenContext}
 Decide whether the requirements are clear enough to plan implementation and whether the task needs code changes. Read code only if it helps.`;
 }
 
+// List attachments already present on the Jira issue so the agent reads
+// material the user attached instead of asking for it. These are downloadable
+// with jira_download_attachments by filename.
+function formatIssueAttachments(attachments) {
+  const list = (Array.isArray(attachments) ? attachments : []).filter((item) => item && item.filename);
+  if (list.length === 0) {
+    return "";
+  }
+  const lines = list.map((item) => `- ${item.filename}${item.mimeType ? ` (${item.mimeType})` : ""}`).join("\n");
+  return `Issue attachments (download with jira_download_attachments before planning; read every one relevant to the task):
+${lines}
+`;
+}
+
 function formatClarificationRepoScope({ targetRepo, referenceRepos, repoPaths }) {
   const repoPathLines = (Array.isArray(repoPaths) ? repoPaths : []).filter(Boolean);
 

package/src/forge/repo-host.js

@@ -66,6 +66,25 @@ export function getProviderLabel(provider) {
   return provider === "gitlab" ? "GitLab" : "GitHub";
 }
 
+// Turn a host into an env-var suffix, e.g. gitlab.ignify.co -> GITLAB_IGNIFY_CO,
+// so a self-hosted instance can carry its own token / CA bundle independent of
+// the global one (fixes "token is not configured for <host>" and TLS failures
+// against self-hosted GitLab).
+function hostEnvSlug(host) {
+  return String(host || "")
+    .trim()
+    .toUpperCase()
+    .replace(/[^A-Z0-9]+/gu, "_")
+    .replace(/^_+|_+$/gu, "");
+}
+
+// Resolve a config value preferring a per-host override over the global key.
+function resolveHostScoped(config, baseKey, hostSlug) {
+  const scoped = hostSlug ? config[`${baseKey}_${hostSlug}`] || process.env[`${baseKey}_${hostSlug}`] : "";
+  const global = config[baseKey] || process.env[baseKey] || "";
+  return String(scoped || global || "").trim();
+}
+
 export function buildGitEnvForRepoUrl(targetUrl = "https://github.com/", config = process.env) {
   const env = {
     ...process.env,
@@ -84,24 +103,35 @@ export function buildGitEnvForRepoUrl(targetUrl = "https://github.com/", config
     return env;
   }
 
-  const token = String(
-    repo.provider === "gitlab"
-      ? config.GITLAB_TOKEN || process.env.GITLAB_TOKEN || ""
-      : config.GITHUB_PAT || process.env.GITHUB_PAT || ""
-  ).trim();
+  const hostSlug = hostEnvSlug(repo.host);
+  const tokenBaseKey = repo.provider === "gitlab" ? "GITLAB_TOKEN" : "GITHUB_PAT";
+  const token = resolveHostScoped(config, tokenBaseKey, hostSlug);
+
+  // CA bundle for self-hosted hosts behind a private/internal CA. Per-host
+  // override (GIT_SSL_CAINFO_<HOST>) wins over the global GIT_SSL_CAINFO.
+  const caBundle = resolveHostScoped(config, "GIT_SSL_CAINFO", hostSlug);
 
-  if (!token) {
+  const configEntries = [];
+  if (token) {
+    const username = repo.provider === "gitlab" ? "oauth2" : "x-access-token";
+    const basicAuth = Buffer.from(`${username}:${token}`, "utf8").toString("base64");
+    configEntries.push([`http.${repo.origin}/.extraheader`, `AUTHORIZATION: Basic ${basicAuth}`]);
+  }
+  if (caBundle) {
+    configEntries.push([`http.${repo.origin}/.sslCAInfo`, caBundle]);
+    env.GIT_SSL_CAINFO = caBundle;
+  }
+
+  if (configEntries.length === 0) {
     return env;
   }
 
-  const username = repo.provider === "gitlab" ? "oauth2" : "x-access-token";
-  const basicAuth = Buffer.from(`${username}:${token}`, "utf8").toString("base64");
-  return {
-    ...env,
-    GIT_CONFIG_COUNT: "1",
-    GIT_CONFIG_KEY_0: `http.${repo.origin}/.extraheader`,
-    GIT_CONFIG_VALUE_0: `AUTHORIZATION: Basic ${basicAuth}`
-  };
+  const next = { ...env, GIT_CONFIG_COUNT: String(configEntries.length) };
+  configEntries.forEach(([key, value], i) => {
+    next[`GIT_CONFIG_KEY_${i}`] = key;
+    next[`GIT_CONFIG_VALUE_${i}`] = value;
+  });
+  return next;
 }
 
 export function extractRepoUrls(text) {

package/src/jira.js

@@ -306,10 +306,28 @@ function mapIssueDetail(issue, baseUrl) {
     ? issue.fields.comment.comments.map(mapComment).sort(compareCommentsByCreated)
     : [];
 
+  // The detail fetch uses fields=*all, so existing attachments are already in
+  // the payload — surface them so the intake/planning step can download and
+  // read documents that users attach to the issue (a frequent "tài liệu đã
+  // đính kèm" complaint where the bot ignored material already on the task).
+  const attachments = Array.isArray(issue.fields?.attachment) ? issue.fields.attachment.map(mapAttachment) : [];
+
   return {
     ...mapIssue(issue, baseUrl),
     descriptionText: adfToText(issue.fields?.description).trim(),
-    comments
+    comments,
+    attachments
+  };
+}
+
+function mapAttachment(attachment) {
+  return {
+    id: attachment?.id ?? null,
+    filename: attachment?.filename ?? "",
+    mimeType: attachment?.mimeType ?? "",
+    size: attachment?.size ?? null,
+    url: attachment?.content ?? null,
+    created: attachment?.created ?? null
   };
 }
 

package/src/memory.js

@@ -263,6 +263,7 @@ function normalizeIssueMemoryData(data) {
   normalized.last_jira_memory_comment_id = String(normalized.last_jira_memory_comment_id ?? "").trim();
   normalized.code_change_verdict = String(normalized.code_change_verdict ?? "").trim();
   normalized.code_change_input_id = String(normalized.code_change_input_id ?? "").trim();
+  normalized.no_code_locked = Boolean(normalized.no_code_locked);
   delete normalized.github_issue_url;
   delete normalized.github_issue_number;
   delete normalized.latest_processed_comment_id;

package/src/worker/forge-sync.js

@@ -60,6 +60,33 @@ export function getLatestGitHubComment(comments) {
   return Array.isArray(comments) && comments.length > 0 ? comments[comments.length - 1] : null;
 }
 
+// Post a one-shot "automatic retries paused" notice on a GitHub/GitLab issue
+// when its circuit-breaker trips. Idempotent per CLAUDE.md: if the latest
+// comment is already from the bot we skip, so the bot never stacks two
+// consecutive comments across worker restarts / repeated trips.
+export async function postGitHubBackoffNotice({ provider, botUser, repoUrl, issueNumber, count, logger }) {
+  try {
+    const detail = await provider.fetchIssue(repoUrl, issueNumber);
+    const latest = getLatestGitHubComment(detail.comments || []);
+    if (latest && isForgeBotAuthor(latest.author, botUser)) {
+      return false;
+    }
+    await provider.postIssueComment(
+      repoUrl,
+      issueNumber,
+      `This task has failed ${count} times in a row, so I have paused automatic retries to avoid spamming. Please check the issue details and repository setup, then add a comment when it is ready for me to try again.`
+    );
+    return true;
+  } catch (error) {
+    await logger?.error?.("Failed to post GitHub backoff notice (non-fatal)", {
+      repo: repoUrl,
+      issue: issueNumber,
+      error
+    });
+    return false;
+  }
+}
+
 export async function markGitHubThreadRead({ github, logger, repoUrl, issueNumber, commentId = "" }) {
   try {
     if (!commentId) {

package/src/worker/jira-helpers.js

@@ -185,11 +185,51 @@ export function shouldDisplayIssueInState(issue) {
   });
 }
 
+// Matches an explicit "no code" declaration in any of: "no code", "no_code",
+// "no-code", "nocode" (case-insensitive). Users add this to tell the bot a task
+// is documentation/estimate only and must NOT create a repo issue or push code.
+const NO_CODE_MARKER = /\bno[\s_-]?code\b/iu;
+
+// Deterministic no-code detection from explicit user signals, so the verdict no
+// longer depends on the LLM guessing (which flipped to "code" and made users
+// repeat "task no code" on every comment). Checks an explicit Jira label, the
+// description, and the latest human comment.
+export function detectNoCodeMarker(detail, botUser, jira) {
+  if (!detail) {
+    return false;
+  }
+
+  const labels = Array.isArray(detail.labels) ? detail.labels : [];
+  if (labels.some((label) => /^no[\s_-]?code$/iu.test(String(label || "").trim()))) {
+    return true;
+  }
+
+  if (NO_CODE_MARKER.test(String(detail.descriptionText || ""))) {
+    return true;
+  }
+
+  const latestHumanComment = [...(Array.isArray(detail.comments) ? detail.comments : [])]
+    .filter((comment) => !String(comment?.bodyText || "").startsWith(PROGRESS_COMMENT_PREFIX))
+    .sort(compareCommentsNewestFirst)
+    .find((comment) => (botUser ? !jira.isBotAuthor(comment.author, botUser) : true));
+
+  return Boolean(latestHumanComment && NO_CODE_MARKER.test(String(latestHumanComment.bodyText || "")));
+}
+
 export function shouldReuseNoCodeDecision({ issueMemory, latestInputId }) {
+  const noGithubIssues = !Array.isArray(issueMemory?.github_issues) || issueMemory.github_issues.length === 0;
+
+  // Once an explicit no-code marker has locked the issue, keep the no-code
+  // verdict sticky across subsequent comments (new input ids) so a follow-up
+  // that does not repeat "no code" is not re-evaluated back into a code task.
+  if (issueMemory?.no_code_locked && noGithubIssues) {
+    return true;
+  }
+
   return (
     issueMemory?.code_change_verdict === "no_code" &&
     issueMemory?.code_change_input_id === latestInputId &&
-    (!Array.isArray(issueMemory?.github_issues) || issueMemory.github_issues.length === 0)
+    noGithubIssues
   );
 }
 

package/src/worker/jira-issue-workflow.js

@@ -22,6 +22,7 @@ import {
   cleanupJiraProgressComments,
   deriveRawTaskRepos,
   deriveTaskRepos,
+  detectNoCodeMarker,
   ensureJiraComment,
   getLatestBlockedTaskRestartComment,
   getLatestClarificationInput,
@@ -632,7 +633,18 @@ export async function processJiraIssue({
       issueMemory,
       latestInputId: latestInput.id
     });
-    if (shouldReusePreservedNoCodeDecision) {
+    if (detectNoCodeMarker(detail, botUser, jira)) {
+      // Explicit user signal ("task no code" / no-code label) overrides the
+      // LLM verdict and locks the issue so later comments stay no-code. This
+      // stops the bot from re-deciding "code" and creating a repo issue, which
+      // forced users to repeat "task no code" on every comment.
+      decisionResult = { verdict: "no_code" };
+      issueMemory.no_code_locked = true;
+      await logger.info("Explicit no-code marker detected; forcing no_code verdict", {
+        issue: detail.key,
+        input: latestInput.id
+      });
+    } else if (shouldReusePreservedNoCodeDecision) {
       decisionResult = { verdict: "no_code" };
       await logger.info("Reusing preserved no-code decision", {
         issue: detail.key,

package/src/worker/pollers/draft-pull-requests.js

@@ -63,7 +63,7 @@ export function createDraftPullRequestPoller({
         return true;
       }
       if (stuckAt) {
-        await logger.info("Draft PR is stuck but retry window has not elapsed, not queueing for work", {
+        await logger.debug("Draft PR is stuck but retry window has not elapsed, not queueing for work", {
           pr: pullRequest.number,
           repo: pullRequest.repoUrl
         });
@@ -83,7 +83,7 @@ export function createDraftPullRequestPoller({
     }
 
     if (hasEyesReaction(latestComment) || hasPlusOneReaction(latestComment)) {
-      await logger.info("Draft PR latest comment already acknowledged, not queueing for work", {
+      await logger.debug("Draft PR latest comment already acknowledged, not queueing for work", {
         pr: pullRequest.number,
         repo: pullRequest.repoUrl
       });
@@ -92,7 +92,7 @@ export function createDraftPullRequestPoller({
 
     const isMember = await checkCommentAuthorIsMember(provider, repo, latestComment, logger, pullRequest.number, true);
     if (!isMember) {
-      await logger.info("Draft PR latest comment author is not a repo member, not queueing for work", {
+      await logger.debug("Draft PR latest comment author is not a repo member, not queueing for work", {
         pr: pullRequest.number,
         repo: pullRequest.repoUrl
       });
@@ -100,7 +100,7 @@ export function createDraftPullRequestPoller({
     }
 
     if (isPullRequestReviewRequestComment(latestComment.body, botUser)) {
-      await logger.info("Draft PR latest comment is only a review request, not queueing for work", {
+      await logger.debug("Draft PR latest comment is only a review request, not queueing for work", {
         pr: pullRequest.number,
         repo: pullRequest.repoUrl
       });
@@ -114,7 +114,7 @@ export function createDraftPullRequestPoller({
     const taskId = buildPullRequestQueueId(pullRequest.repoUrl, pullRequest.number);
 
     if (inFlight.has(taskId)) {
-      await logger.info("Draft PR already queued or in-flight, skipping", {
+      await logger.debug("Draft PR already queued or in-flight, skipping", {
         pr: pullRequest.number,
         repo: pullRequest.repoUrl
       });

package/src/worker/pollers/jira.js

@@ -45,7 +45,7 @@ export function createJiraPoller({
 
   async function shouldDispatchIssue(issue) {
     if (hasPendingJiraWorkLabel(issue)) {
-      await logger.info("Jira issue waiting on external input, not queueing for work", { issue: issue.key });
+      await logger.debug("Jira issue waiting on external input, not queueing for work", { issue: issue.key });
       return { dispatch: false, detail: null };
     }
 
@@ -70,7 +70,9 @@ export function createJiraPoller({
     }
     const shouldResume = hasNewHumanReplyWhileWaiting(detail, jiraBotUser, jira);
     if (!shouldResume) {
-      await logger.info("Jira issue is in review with no new human reply, not queueing for work", { issue: issue.key });
+      await logger.debug("Jira issue is in review with no new human reply, not queueing for work", {
+        issue: issue.key
+      });
     }
     return { dispatch: shouldResume, detail: shouldResume ? detail : null };
   }
@@ -89,7 +91,7 @@ export function createJiraPoller({
       state.pollerCurrent.jira = String(issue?.key || "");
 
       if (inFlight.has(issue.key)) {
-        await logger.info("Jira issue already queued or in-flight, skipping", { issue: issue.key });
+        await logger.debug("Jira issue already queued or in-flight, skipping", { issue: issue.key });
         continue;
       }
 
@@ -105,7 +107,7 @@ export function createJiraPoller({
           await persistState();
         }
       } else if (isIssueInBackoff(state, issue.key)) {
-        await logger.info("Jira issue in failure backoff, skipping until retry window elapses", {
+        await logger.debug("Jira issue in failure backoff, skipping until retry window elapses", {
           issue: issue.key
         });
         continue;

package/src/worker/pollers/review-pull-request-discussions.js

@@ -68,7 +68,7 @@ export function createReviewPullRequestDiscussionPoller({
     for (const pr of prsWithThreads) {
       const taskId = buildTaskId(pr.repoUrl, pr.number);
       if (inFlight.has(taskId)) {
-        await logger.info("Suggestion revision already in-flight, skipping", {
+        await logger.debug("Suggestion revision already in-flight, skipping", {
           pr: pr.number,
           repo: pr.repoUrl
         });

package/src/worker/pollers/review-pull-requests.js

@@ -66,7 +66,7 @@ export function createReviewPullRequestPoller({
       const taskId = buildPullRequestQueueId(pr.repoUrl, pr.number);
 
       if (inFlight.has(taskId)) {
-        await logger.info("PR review already queued or in-flight, skipping", {
+        await logger.debug("PR review already queued or in-flight, skipping", {
           pr: pr.number,
           repo: pr.repoUrl
         });

package/src/worker/pollers/tracked-issues.js

@@ -1,5 +1,10 @@
 import { listIssueMemoryRecords } from "../../memory.js";
-import { getForgeBotUserForRepo, getLatestGitHubComment, isForgeBotAuthor } from "../forge-sync.js";
+import {
+  getForgeBotUserForRepo,
+  getLatestGitHubComment,
+  isForgeBotAuthor,
+  postGitHubBackoffNotice
+} from "../forge-sync.js";
 import { clearIssueBackoff, isIssueInBackoff, recordIssueFailure } from "../issue-backoff.js";
 import { checkCommentAuthorIsMember, hasEyesReaction, hasPlusOneReaction, isApprovalComment } from "../pull-request.js";
 import { normalizeRepoIdentity } from "../repo-utils.js";
@@ -60,7 +65,7 @@ export function createTrackedIssuePoller({
       `${normalizeRepoIdentity(repo.url || "")}#${String(issue.number || "").trim()}`
     );
     if (!issueMemoryRecord) {
-      await logger.info("GitHub issue has no linked Jira memory, not queueing for work", {
+      await logger.debug("GitHub issue has no linked Jira memory, not queueing for work", {
         issue: issue.number,
         repo: issue.repoUrl
       });
@@ -78,7 +83,7 @@ export function createTrackedIssuePoller({
     }
 
     if (hasEyesReaction(latestComment) || hasPlusOneReaction(latestComment)) {
-      await logger.info("GitHub issue latest comment already acknowledged, not queueing for work", {
+      await logger.debug("GitHub issue latest comment already acknowledged, not queueing for work", {
         issue: issue.number,
         repo: issue.repoUrl
       });
@@ -94,7 +99,7 @@ export function createTrackedIssuePoller({
       linkedGitHubIssue &&
       String(linkedGitHubIssue.last_issue_memory_comment_id || "") === String(latestComment.id)
     ) {
-      await logger.info("GitHub issue latest comment already processed (memory stamp), not queueing for work", {
+      await logger.debug("GitHub issue latest comment already processed (memory stamp), not queueing for work", {
         issue: issue.number,
         repo: issue.repoUrl
       });
@@ -103,7 +108,7 @@ export function createTrackedIssuePoller({
 
     const isMember = await checkCommentAuthorIsMember(provider, repo, latestComment, logger, issue.number, false);
     if (!isMember) {
-      await logger.info("GitHub issue latest comment author is not a repo member, not queueing for work", {
+      await logger.debug("GitHub issue latest comment author is not a repo member, not queueing for work", {
         issue: issue.number,
         repo: issue.repoUrl
       });
@@ -147,7 +152,7 @@ export function createTrackedIssuePoller({
     const taskId = buildIssueQueueId(issue.repoUrl, issue.number);
 
     if (inFlight.has(taskId)) {
-      await logger.info("GitHub issue already queued or in-flight, skipping", {
+      await logger.debug("GitHub issue already queued or in-flight, skipping", {
         issue: issue.number,
         repo: issue.repoUrl
       });
@@ -163,7 +168,7 @@ export function createTrackedIssuePoller({
     // human signal); otherwise skip while the issue is in its retry-backoff
     // window so a persistently failing issue is not re-dispatched every poll.
     if (isIssueInBackoff(state, taskId, { trigger: decision.commentId })) {
-      await logger.info("GitHub issue in failure backoff, skipping until retry window elapses", {
+      await logger.debug("GitHub issue in failure backoff, skipping until retry window elapses", {
         issue: issue.number,
         repo: issue.repoUrl
       });
@@ -195,13 +200,23 @@ export function createTrackedIssuePoller({
         await processIssue({ issue, repo: repoWithPath, provider, botUser, taskId });
         clearIssueBackoff(state, taskId);
       } catch (error) {
-        const { count } = recordIssueFailure(state, taskId, { trigger: decision.commentId });
+        const { count, shouldNotify } = recordIssueFailure(state, taskId, { trigger: decision.commentId });
         await logger.error("GitHub issue task failed", {
           issue: issue.number,
           repo: issue.repoUrl,
           error,
           failureCount: count
         });
+        if (shouldNotify) {
+          await postGitHubBackoffNotice({
+            provider,
+            botUser,
+            repoUrl: issue.repoUrl,
+            issueNumber: issue.number,
+            count,
+            logger
+          });
+        }
       } finally {
         inFlight.delete(taskId);
         removeWorkQueueItem(state, workQueueItem.id);

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

@@ -0,0 +1,70 @@
+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
+// 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.
+const SESSIONS_FILE = "pr-sessions.json";
+const MAX_ENTRIES = 1000;
+
+function sessionStorePath(projectRoot) {
+  return path.join(projectRoot, "memory", SESSIONS_FILE);
+}
+
+function sessionKey(repoUrl, branchName) {
+  return `${String(repoUrl || "").trim()}#${String(branchName || "").trim()}`;
+}
+
+async function readStore(projectRoot) {
+  try {
+    const raw = await readFile(sessionStorePath(projectRoot), "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    // Missing file / corrupt JSON → start from empty; resume is best-effort.
+    return {};
+  }
+}
+
+export async function loadPrSessionId(projectRoot, repoUrl, branchName) {
+  if (!projectRoot || !branchName) {
+    return "";
+  }
+  const store = await readStore(projectRoot);
+  const entry = store[sessionKey(repoUrl, branchName)];
+  return entry && typeof entry.session_id === "string" ? entry.session_id : "";
+}
+
+// Serialize read-modify-write so concurrent PR tasks writing the shared file
+// never lose each other's entries.
+let writeChain = Promise.resolve();
+
+export async function savePrSessionId(projectRoot, repoUrl, branchName, sessionId) {
+  if (!projectRoot || !branchName || !sessionId) {
+    return;
+  }
+  writeChain = writeChain
+    .then(async () => {
+      const store = await readStore(projectRoot);
+      store[sessionKey(repoUrl, branchName)] = {
+        session_id: String(sessionId).trim(),
+        updated_at: new Date().toISOString()
+      };
+      // Bound file growth: drop oldest entries beyond the cap.
+      const keys = Object.keys(store);
+      if (keys.length > MAX_ENTRIES) {
+        keys
+          .sort((a, b) => String(store[a].updated_at || "").localeCompare(String(store[b].updated_at || "")))
+          .slice(0, keys.length - MAX_ENTRIES)
+          .forEach((k) => delete store[k]);
+      }
+      const file = sessionStorePath(projectRoot);
+      await mkdir(path.dirname(file), { recursive: true });
+      await atomicWriteFile(file, JSON.stringify(store, null, 2));
+    })
+    .catch(() => {});
+  return writeChain;
+}

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

@@ -20,6 +20,7 @@ import {
   setForgePullRequestBlocked,
   transitionLinkedJiraIssueToReview
 } from "./forge-sync.js";
+import { loadPrSessionId, savePrSessionId } from "./pr-session-store.js";
 import {
   allPlanStepsDone,
   buildDraftPrState,
@@ -180,6 +181,16 @@ export async function processPullRequestImplementation({
     const issueKey = githubIssueMemory?.jira_key || `PR-${detail.number}`;
     const epicSnapshot = buildEpicMemoryPromptSnapshot(epicMemory);
 
+    // Resume the prior Claude conversation for this PR branch so a follow-up
+    // comment / reopen keeps the model's earlier context instead of rebuilding
+    // 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 onSessionId = (sessionId) => {
+      void savePrSessionId(projectRoot, repo.url, detail.headRef, sessionId);
+    };
+
     // Re-ground the run on any work earlier runs already committed to this
     // branch. Without this, a re-invocation triggered by a PR comment loses the
     // context of what was done and re-implements or reverts prior changes.
@@ -266,6 +277,8 @@ export async function processPullRequestImplementation({
         timeoutMs: parseOptionalInt(config.CLAUDE_TIMEOUT_MS),
         issueKey,
         logger,
+        resumeSessionId,
+        onSessionId,
         onSpawn: (child) => {
           void updatePrSubtaskState("prImplementation", {
             phase: "implementation",
@@ -315,6 +328,8 @@ export async function processPullRequestImplementation({
         timeoutMs: parseOptionalInt(config.CLAUDE_TIMEOUT_MS),
         issueKey,
         logger,
+        resumeSessionId,
+        onSessionId,
         onSpawn: (child) => {
           void updatePrSubtaskState("prImplementation", {
             phase: "implementation",