claude-teammate 0.1.199 → 0.1.201

package/package.json

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

package/src/claude/prompts.js

@@ -585,11 +585,18 @@ export function buildEpicMemoryCleanupSystemPrompt() {
     "Remove obvious, redundant, contradicted, or one-off ticket details.",
     LANGUAGE_PRESERVATION_RULES,
     "Do not invent knowledge that is not grounded in the provided memory snapshot.",
+    "Also extract repo_branches: for each repository URL in the known repos list (or mentioned in the candidate updates), if the candidate updates specify the TARGET/BASE branch — the branch the PR or MR should merge INTO (e.g. 'tạo MR vào nhánh main', 'merge into develop', 'PR target is staging', 'nhánh chính là develop') — emit {url, branch} for it. Do NOT capture implementation/feature branch names (the short-lived branch being created for this task). Only include repos where a base/target branch is explicitly mentioned.",
+    "Also extract pr_repo_url: if the candidate updates indicate which specific repository should receive the pull request or merge request (e.g. 'tạo PR vào org/backend', 'create PR in org/frontend', 'MR goes to repo X'), set this to that repository's full URL from the known repos list. Set to empty string if not mentioned or ambiguous.",
     "Return only structured output matching the schema."
   ].join(" ");
 }
 
 export function buildEpicMemoryCleanupUserPrompt(input) {
+  const knownRepos = (input.epicMemory?.repos || []).map((r) => r.url).filter(Boolean);
+  const reposLine = knownRepos.length > 0
+    ? `\nKnown repos:\n${knownRepos.map((u) => `- ${u}`).join("\n")}`
+    : "";
+
   return `Update this epic memory facts and guardrails and clean it up.
 
 Reason:
@@ -597,7 +604,7 @@ ${input.reason || "(none)"}
 
 Current epic memory:
 ${JSON.stringify(input.epicMemory || {}, null, 2)}
-
+${reposLine}
 Latest candidate updates:
 ${JSON.stringify(input.candidateUpdates || {}, null, 2)}
 

package/src/claude/validators.js

@@ -121,7 +121,13 @@ export function validateEpicMemoryCleanupResult(result) {
       : [],
     guardrails: Array.isArray(result.guardrails)
       ? result.guardrails.map((item) => String(item).trim()).filter(Boolean)
-      : []
+      : [],
+    repo_branches: Array.isArray(result.repo_branches)
+      ? result.repo_branches
+          .filter((rb) => rb && typeof rb.url === "string" && rb.url.trim())
+          .map((rb) => ({ url: String(rb.url).trim(), branch: String(rb.branch || "").trim() }))
+      : [],
+    pr_repo_url: typeof result.pr_repo_url === "string" ? result.pr_repo_url.trim() : ""
   };
 }
 

package/src/claude.js

@@ -247,16 +247,25 @@ const EPIC_MEMORY_CLEANUP_SCHEMA = {
   properties: {
     facts: {
       type: "array",
-      items: {
-        type: "string"
-      }
+      items: { type: "string" }
     },
     guardrails: {
+      type: "array",
+      items: { type: "string" }
+    },
+    repo_branches: {
       type: "array",
       items: {
-        type: "string"
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          url: { type: "string" },
+          branch: { type: "string" }
+        },
+        required: ["url", "branch"]
       }
-    }
+    },
+    pr_repo_url: { type: "string" }
   },
   required: ["facts", "guardrails"]
 };

package/src/memory.js

@@ -190,10 +190,12 @@ function normalizeEpicMemoryData(data) {
 
   normalized.repos = uniqueRepos(normalized.repos).map((repo) => ({
     url: repo.url,
-    local_path: repo.local_path || ""
+    local_path: repo.local_path || "",
+    working_branch: repo.working_branch || ""
   }));
   normalized.facts = [...new Set(normalized.facts.map((fact) => String(fact).trim()).filter(Boolean))];
   normalized.guardrails = [...new Set(normalized.guardrails.map((guardrail) => String(guardrail).trim()).filter(Boolean))];
+  normalized.pr_repo_url = String(normalized.pr_repo_url || "").trim();
 
   delete normalized.repo_url;
   delete normalized.local_repo_path;
@@ -386,13 +388,15 @@ function uniqueRepos(repos) {
 
     const existing = seen.get(repo.url) ?? {
       url: repo.url,
-      local_path: ""
+      local_path: "",
+      working_branch: ""
     };
 
     seen.set(repo.url, {
       ...existing,
       ...repo,
-      local_path: repo.local_path || existing.local_path || ""
+      local_path: repo.local_path || existing.local_path || "",
+      working_branch: repo.working_branch || existing.working_branch || ""
     });
   }
 

package/src/worker/epic-memory.js

@@ -121,10 +121,16 @@ export async function saveMaintainedEpicMemory({
         issueKey: issue.key,
         logger
       });
+      const updatedRepos = applyRepoBranchUpdates(
+        startingEpicMemory.repos || [],
+        cleaned.repo_branches || []
+      );
       nextEpicMemory = normalizeEpicMemoryContent({
         ...startingEpicMemory,
         facts: cleaned.facts || [],
-        guardrails: cleaned.guardrails || []
+        guardrails: cleaned.guardrails || [],
+        repos: updatedRepos,
+        pr_repo_url: cleaned.pr_repo_url || startingEpicMemory.pr_repo_url || ""
       });
       if (logger) {
         await logger.info("Updated epic memory", {
@@ -230,10 +236,30 @@ function hasEpicMemoryContentChanges(current, next) {
     JSON.stringify(dedupeTextValues(current?.facts || [])) !==
       JSON.stringify(dedupeTextValues(next?.facts || [])) ||
     JSON.stringify(dedupeTextValues(current?.guardrails || [])) !==
-      JSON.stringify(dedupeTextValues(next?.guardrails || []))
+      JSON.stringify(dedupeTextValues(next?.guardrails || [])) ||
+    (current?.pr_repo_url || "") !== (next?.pr_repo_url || "") ||
+    JSON.stringify(current?.repos || []) !== JSON.stringify(next?.repos || [])
   );
 }
 
+function applyRepoBranchUpdates(existingRepos, repoBranches) {
+  if (!Array.isArray(repoBranches) || repoBranches.length === 0) {
+    return existingRepos;
+  }
+
+  let repos = [...existingRepos];
+  for (const rb of repoBranches) {
+    if (!rb.url) continue;
+    const idx = repos.findIndex((r) => r.url === rb.url);
+    if (idx === -1) {
+      repos.push({ url: rb.url, local_path: "", working_branch: rb.branch });
+    } else if (rb.branch) {
+      repos[idx] = { ...repos[idx], working_branch: rb.branch };
+    }
+  }
+  return repos;
+}
+
 export function buildReopenContext({ reopenedFromInReview, issueMemoryPath, epicMemoryPath, workerLogPath }) {
   if (!reopenedFromInReview) {
     return null;

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

@@ -256,7 +256,10 @@ export async function processGitHubIssue({
         return buildGitHubIssueState(detail, githubIssueMemory, "blocked");
       }
 
-      const defaultBranch = await github.getDefaultBranch(githubIssueMemory.repo_url);
+      const repoEpicEntry = (approvalEpicMemory?.repos || []).find(
+        (r) => r.url === githubIssueMemory.repo_url
+      );
+      const baseBranch = repoEpicEntry?.working_branch || await github.getDefaultBranch(githubIssueMemory.repo_url);
       await services.pullLatest(githubIssueMemory.local_path);
 
       // Use a short-lived worktree to create the branch so the primary clone
@@ -270,9 +273,9 @@ export async function processGitHubIssue({
             githubIssueMemory.local_path,
             nextBranchName
           );
-          await services.ensureBranchFromDefault(branchWorktree, nextBranchName, defaultBranch);
+          await services.ensureBranchFromDefault(branchWorktree, nextBranchName, baseBranch);
         } else {
-          await services.ensureBranchFromDefault(githubIssueMemory.local_path, nextBranchName, defaultBranch);
+          await services.ensureBranchFromDefault(githubIssueMemory.local_path, nextBranchName, baseBranch);
         }
       } finally {
         if (branchWorktree) {
@@ -283,7 +286,7 @@ export async function processGitHubIssue({
         title: detail.title,
         body: buildInitialPullRequestBody(detail.number, detail.body),
         head: nextBranchName,
-        base: defaultBranch,
+        base: baseBranch,
         draft: true
       });
       githubIssueMemory.pr_url = pullRequest.url;

package/src/worker/jira-helpers.js

@@ -206,14 +206,15 @@ export function resetIssueMemoryForCommentRestart(issueMemory, commentId) {
 
 export function deriveTaskRepos(detail, epicMemory, forgeRegistry) {
   const rememberedRepos = Array.isArray(epicMemory?.repos) ? epicMemory.repos : [];
-  const repoUrls = [
-    ...rememberedRepos.map((repo) => repo?.url).filter(Boolean),
-    ...extractRepoUrls(detail?.descriptionText || ""),
-    ...findRepoUrlsInComments(Array.isArray(detail?.comments) ? detail.comments : [])
-  ];
+  const knownRepoUrls = rememberedRepos.map((r) => r.url).filter(Boolean);
+  const descriptionPairs = extractRepoBranchPairs(detail?.descriptionText || "");
+  const commentPairs = findRepoBranchPairsInComments(
+    Array.isArray(detail?.comments) ? detail.comments : [],
+    knownRepoUrls
+  );
 
   return filterReposForActiveForge(
-    mergeRepoUrls(rememberedRepos, repoUrls),
+    mergeRepoUrls(rememberedRepos, [...descriptionPairs, ...commentPairs]),
     forgeRegistry
   );
 }
@@ -233,7 +234,7 @@ export function filterReposForActiveForge(repos, forgeRegistry) {
   });
 }
 
-export function selectIssueCreationRepo({ detail, issueMemory, repos }) {
+export function selectIssueCreationRepo({ detail, issueMemory, repos, epicMemory }) {
   if (!Array.isArray(repos) || repos.length === 0) {
     return null;
   }
@@ -243,6 +244,14 @@ export function selectIssueCreationRepo({ detail, issueMemory, repos }) {
   }
 
   const repoByUrl = new Map(repos.map((repo) => [String(repo.url || "").trim(), repo]));
+
+  if (epicMemory?.pr_repo_url) {
+    const prRepo = repoByUrl.get(String(epicMemory.pr_repo_url).trim());
+    if (prRepo) {
+      return prRepo;
+    }
+  }
+
   const latestExplicitRepo = getLatestExplicitIssueCreationRepo(detail, repoByUrl);
   if (latestExplicitRepo) {
     return latestExplicitRepo;
@@ -414,19 +423,53 @@ function ensureImplementationInstruction(body) {
   return `${normalizedBody}\n\n---\n\n${IMPLEMENTATION_INSTRUCTION}`.trim();
 }
 
-function findRepoUrlsInComments(comments) {
-  const repoUrls = [];
+const BRANCH_KEYWORD_RE = /\b(?:branch|nhánh)\s*[:=]\s*([a-zA-Z0-9][a-zA-Z0-9_\-./]*)/iu;
+
+function extractRepoBranchPairs(text) {
+  const str = String(text || "");
+  const urls = extractRepoUrls(str);
+  if (urls.length === 0) {
+    return [];
+  }
+
+  if (urls.length === 1) {
+    const branchMatch = str.match(BRANCH_KEYWORD_RE);
+    return [{ url: urls[0], working_branch: branchMatch ? branchMatch[1] : "" }];
+  }
+
+  return urls.map((url) => {
+    const lineWithUrl = str.split("\n").find((line) => line.includes(url)) || "";
+    const lineBranchMatch = lineWithUrl.match(BRANCH_KEYWORD_RE);
+    return { url, working_branch: lineBranchMatch ? lineBranchMatch[1] : "" };
+  });
+}
+
+function findRepoBranchPairsInComments(comments, knownRepoUrls = []) {
+  const seen = new Map();
 
   for (const comment of [...comments].reverse()) {
-    const urls = extractRepoUrls(comment.bodyText);
-    for (const url of urls) {
-      if (!repoUrls.includes(url)) {
-        repoUrls.push(url);
+    const pairs = extractRepoBranchPairs(comment.bodyText || "");
+
+    for (const pair of pairs) {
+      if (!seen.has(pair.url)) {
+        seen.set(pair.url, pair.working_branch);
+      } else if (pair.working_branch && !seen.get(pair.url)) {
+        seen.set(pair.url, pair.working_branch);
+      }
+    }
+
+    // Branch-only comment (no URL): when there's exactly one known repo, apply the branch to it.
+    // Newest-first iteration ensures the latest explicit branch wins.
+    if (knownRepoUrls.length === 1 && pairs.length === 0) {
+      const url = knownRepoUrls[0];
+      const branchMatch = String(comment.bodyText || "").match(BRANCH_KEYWORD_RE);
+      if (branchMatch && (!seen.has(url) || !seen.get(url))) {
+        seen.set(url, branchMatch[1]);
       }
     }
   }
 
-  return repoUrls;
+  return [...seen.entries()].map(([url, working_branch]) => ({ url, working_branch }));
 }
 
 function getLatestComment(comments) {
@@ -489,15 +532,17 @@ function isBlockedOrFailedIssueState(detail, issueMemory, blockedLabel) {
   );
 }
 
-function mergeRepoUrls(existingRepos, repoUrls) {
+function mergeRepoUrls(existingRepos, repoPairs) {
   const merged = Array.isArray(existingRepos) ? [...existingRepos] : [];
 
-  for (const url of repoUrls) {
-    if (!merged.some((repo) => normalizeRepoIdentity(repo.url) === normalizeRepoIdentity(url))) {
-      merged.push({
-        url,
-        local_path: ""
-      });
+  for (const pair of repoPairs) {
+    const url = pair.url;
+    const workingBranch = pair.working_branch || "";
+    const existingIdx = merged.findIndex((repo) => normalizeRepoIdentity(repo.url) === normalizeRepoIdentity(url));
+    if (existingIdx === -1) {
+      merged.push({ url, local_path: "", working_branch: workingBranch });
+    } else if (workingBranch) {
+      merged[existingIdx] = { ...merged[existingIdx], working_branch: workingBranch };
     }
   }
 

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

@@ -159,6 +159,7 @@ export async function continueGitHubIssueCreation({
   issueMemoryRecord,
   issueMemory,
   repos,
+  epicMemory = null,
   logger,
   claudeResult = null,
   services
@@ -168,7 +169,7 @@ export async function continueGitHubIssueCreation({
   }
 
   const latestRepoSelectionReply = getLatestHumanRepoSelectionReply(detail, botUser, jira);
-  let selectedRepo = selectIssueCreationRepo({ detail, issueMemory, repos });
+  let selectedRepo = selectIssueCreationRepo({ detail, issueMemory, repos, epicMemory });
   const latestRepoPrompt = getLatestRepoSelectionPromptComment(detail, botUser, jira);
   if (!selectedRepo && latestRepoSelectionReply) {
     const fallback = await services.runClaudeRepoSelection({

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

@@ -170,6 +170,10 @@ export async function processJiraIssue({
       services
     }));
 
+    // Re-derive after LLM may have updated epicMemory (repo branches, pr_repo_url).
+    // Regex derivation uses epicMemory.repos as base so LLM-set branches are preserved.
+    liveRepos = deriveTaskRepos(detail, epicMemory, forgeRegistry);
+
     let reopenedFromInReview = false;
     if (isInReviewStatus(detail.status) && hasNewHumanReplyWhileWaiting(detail, botUser, jira)) {
       const transition = await jira.transitionIssueToStatus(detail.key, "In Progress");
@@ -197,9 +201,14 @@ export async function processJiraIssue({
       await pickUpToDoJiraIssue({ detail, jira, logger, saveProgress });
     }
 
-    const previousRepoUrls = Array.isArray(epicMemory?.repos) ? epicMemory.repos.map((repo) => repo.url) : [];
+    const previousRepos = Array.isArray(epicMemory?.repos) ? epicMemory.repos : [];
+    const previousRepoUrls = previousRepos.map((repo) => repo.url);
     const nextRepoUrls = liveRepos.map((repo) => repo.url);
-    if (JSON.stringify(previousRepoUrls) !== JSON.stringify(nextRepoUrls)) {
+    const branchChanged = liveRepos.some((repo) => {
+      const prev = previousRepos.find((r) => r.url === repo.url);
+      return (repo.working_branch || "") !== (prev?.working_branch || "");
+    });
+    if (JSON.stringify(previousRepoUrls) !== JSON.stringify(nextRepoUrls) || branchChanged) {
       epicMemory.repos = liveRepos;
       epicMemory = await services.saveEpicMemory(epicMemoryRecord.filePath, detail, epicMemory);
       await logger.info("Updated epic repo knowledge", {
@@ -455,6 +464,7 @@ export async function processJiraIssue({
       issueMemoryRecord,
       issueMemory,
       repos: liveRepos,
+      epicMemory,
       logger,
       claudeResult,
       services