claude-teammate 0.1.281 → 0.1.282

package/package.json

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

package/src/claude/stream.js

@@ -72,6 +72,16 @@ export function parseClaudeOutput(output) {
       return direct;
     }
 
+    // Skill-fix schema: { analysis, files, reason }
+    if ("analysis" in direct && Array.isArray(direct.files)) {
+      return direct;
+    }
+
+    // Skill-correction schema: { isCorrection, skillName, correctionSummary }
+    if ("isCorrection" in direct) {
+      return direct;
+    }
+
     if ("result" in direct && typeof direct.result === "string") {
       return JSON.parse(direct.result);
     }

package/src/claude.js

@@ -538,6 +538,8 @@ export async function runClaudeSkillCorrectionCheck({
       SKILL_CORRECTION_SYSTEM,
       `Previous bot response:\n<previous>\n${String(previousBotResponse || "").slice(0, 2500)}\n</previous>\n\nUser message:\n<user>\n${humanMessage}\n</user>\n\nIs the user correcting specific output behavior from a skill?`,
       {
+        model: "haiku",
+        effort: "low",
         runOpts: {
           cwd,
           timeout: timeoutMs || 30_000,
@@ -564,6 +566,7 @@ export function triggerSkillFeedbackFix({
   skillName,
   correctionSummary,
   projectRoot,
+  projectRoots,
   eventsRoot,
   logger,
   epicContext,
@@ -573,6 +576,7 @@ export function triggerSkillFeedbackFix({
     skillName,
     correctionSummary,
     projectRoot,
+    projectRoots,
     eventsRoot: eventsRoot || CLAUDE_TEAMMATE_ROOT,
     logger,
     invokeClaudeTask,

package/src/skills/detector.js

@@ -18,6 +18,9 @@ import { findSkillLocation } from "./locator.js";
 // load, close the attribution window. Prevents errors from unrelated work done
 // long after the skill completed being wrongly attributed to it.
 const MAX_ATTRIBUTION_DEPTH = 20;
+// Cap the trail in inferSilentRecovery to prevent unbounded memory growth
+// in long tasks that call many tools under one active skill.
+const MAX_TRAIL_SIZE = 100;
 
 export function extractSkillFailures(streamLines) {
   const failures = [];
@@ -194,6 +197,8 @@ export function inferSilentRecovery(streamLines) {
     if (!isAttributable) continue;
     const isError = event.is_error === true || (toolName === "Bash" && looksLikeBashError(contentText));
     trail.push({ name: toolName, isError, contentText });
+    // Evict oldest entries once trail grows past the cap so memory stays bounded.
+    if (trail.length > MAX_TRAIL_SIZE) trail.splice(0, trail.length - MAX_TRAIL_SIZE);
 
     // Retry pattern: same tool seen earlier with isError=true, now called again.
     if (trail.length >= 2) {

package/src/skills/fixer.js

@@ -5,7 +5,7 @@ import { tmpdir } from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { promisify } from "node:util";
-import { parseRepoUrl } from "../forge/repo-host.js";
+import { buildGitEnvForRepoUrl, parseRepoUrl } from "../forge/repo-host.js";
 
 const execFileAsync = promisify(execFile);
 
@@ -237,10 +237,11 @@ async function detectProvider(projectRoot) {
       encoding: "utf8",
       timeout: 5000
     });
-    const repo = parseRepoUrl(stdout.trim());
-    return { provider: repo.provider, repo };
+    const remoteUrl = stdout.trim();
+    const repo = parseRepoUrl(remoteUrl);
+    return { provider: repo.provider, repo, remoteUrl };
   } catch {
-    return { provider: "github", repo: null };
+    return { provider: "github", repo: null, remoteUrl: null };
   }
 }
 
@@ -287,7 +288,7 @@ async function getDefaultBranch(projectRoot) {
 
 async function createSkillFixPR({ skillName, files, reason, location, projectRoot, logger }) {
   const branch = `fix/skill-${sanitizeBranchSegment(skillName)}`;
-  const { provider, repo } = await detectProvider(projectRoot);
+  const { provider, repo, remoteUrl } = await detectProvider(projectRoot);
 
   // Fail fast for GitLab if token missing — without an MR API call we cannot
   // ship the fix upstream, and writing into the active working tree would
@@ -298,6 +299,19 @@ async function createSkillFixPR({ skillName, files, reason, location, projectRoo
     return { status: "error", error: msg };
   }
 
+  // Warn for GitHub if PAT is missing — git push will fall back to system
+  // credential helpers which may not be configured in containers / CI.
+  if (provider === "github" && !process.env.GITHUB_PAT) {
+    logger?.warn?.(
+      "skill-fix: GITHUB_PAT not set — git push will rely on system credential helper (may fail in CI/container)",
+      { skill: skillName }
+    );
+  }
+
+  // Build auth env so git fetch + push work in environments without a system
+  // credential helper (containers, CI). Mirrors how repo.js authenticates.
+  const gitAuthEnv = remoteUrl ? buildGitEnvForRepoUrl(remoteUrl) : undefined;
+
   // Idempotency: skip if PR/MR already open.
   // null = API unreachable; log and proceed rather than silently skipping (risk of
   // duplicate is low; failing to fix would be worse than a duplicate PR).
@@ -327,8 +341,17 @@ async function createSkillFixPR({ skillName, files, reason, location, projectRoo
   try {
     // Pull latest default branch so the fix is based on current HEAD, not stale local state.
     try {
-      await execFileAsync("git", ["fetch", "origin", defaultBranch], { cwd: projectRoot, timeout: 60000 });
-    } catch {}
+      await execFileAsync("git", ["fetch", "origin", defaultBranch], {
+        cwd: projectRoot,
+        timeout: 60000,
+        ...(gitAuthEnv && { env: gitAuthEnv })
+      });
+    } catch (fetchErr) {
+      logger?.warn?.("skill-fix: fetch failed, proceeding with stale base — fix PR may conflict on merge", {
+        skill: skillName,
+        error: fetchErr?.message
+      });
+    }
 
     // Prune stale worktree registrations left by prior SIGKILL — otherwise
     // `git worktree add -B branch` fails if the branch is still "checked out"
@@ -384,7 +407,8 @@ async function createSkillFixPR({ skillName, files, reason, location, projectRoo
     // --force-with-lease: safe retry after partial failure — only overwrites if remote matches expected
     await execFileAsync("git", ["push", "--force-with-lease", "-u", "origin", branch], {
       cwd: worktreePath,
-      timeout: 60000
+      timeout: 60000,
+      ...(gitAuthEnv && { env: gitAuthEnv })
     });
 
     const prUrl = await openPR({ branch, prTitle, safeReason, defaultBranch, provider, repo, projectRoot });

package/src/skills/index.js

@@ -1,10 +1,11 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
+import process from "node:process";
 import { extractSkillFailures, inferBypassedSkills, inferSilentRecovery } from "./detector.js";
 import { applySkillFix, generateSkillFix, readSkillFiles } from "./fixer.js";
-import { findSkillLocation } from "./locator.js";
+import { findSkillLocationInRoots } from "./locator.js";
 
-const SKILL_FIX_EVENTS_MAX = 50;
+const SKILL_FIX_EVENTS_MAX = parseInt(process.env.SKILL_FIX_EVENTS_MAX || "200", 10);
 
 // Module-level lock: prevents concurrent fix attempts for the same skill
 // (multiple tasks can detect the same failing skill simultaneously)
@@ -113,7 +114,8 @@ async function fixSkillsAsync(failures, projectRoot, eventsRoot, logger, invokeC
     if (!existing) {
       grouped.set(f.skillName, { ...f });
     } else {
-      existing.errorContent = `${existing.errorContent}\n---\n[${f.errorType}]\n${f.errorContent || ""}`.slice(0, 1800);
+      const combined = `${existing.errorContent}\n---\n[${f.errorType}]\n${f.errorContent || ""}`;
+      existing.errorContent = combined.length > 1800 ? `${combined.slice(0, 1797)}…` : combined;
       // Keep the first errorType as the primary classification for telemetry,
       // but tag composite when more than one mode contributed.
       if (existing.errorType !== f.errorType && !existing.errorType.endsWith("+")) {
@@ -156,13 +158,17 @@ async function fixSkillsAsync(failures, projectRoot, eventsRoot, logger, invokeC
  * Haiku already classified it — this applies the fix using user correction as context.
  * Fire-and-forget safe: never throws.
  *
- * projectRoot: cloned repo path (skill lookup + git PR).
+ * projectRoot: primary cloned repo path (skill lookup + git PR).
+ * projectRoots: optional array of all cloned repo paths to search for the skill.
+ *               Handles multi-repo projects where a skill may live in any repo.
+ *               Falls back to [projectRoot] when omitted.
  * eventsRoot: claude-teammate root (event log destination).
  */
 export function scheduleSkillFixWithFeedback({
   skillName,
   correctionSummary,
   projectRoot,
+  projectRoots,
   eventsRoot,
   logger,
   invokeClaudeTask,
@@ -188,6 +194,7 @@ export function scheduleSkillFixWithFeedback({
     errorContent: `User correction: ${correctionSummary}`,
     errorType: "user-feedback",
     projectRoot,
+    projectRoots,
     eventsRoot: eventsRoot || projectRoot,
     logger,
     invokeClaudeTask,
@@ -203,20 +210,29 @@ async function fixSingleSkill({
   errorContent,
   errorType,
   projectRoot,
+  projectRoots,
   eventsRoot,
   logger,
   invokeClaudeTask,
   epicContext,
   issueKey
 }) {
-  const location = findSkillLocation(skillName, projectRoot);
+  // Search all provided repo roots so multi-repo projects can find skills in any repo.
+  const roots = Array.isArray(projectRoots) && projectRoots.length > 0 ? projectRoots : [projectRoot];
+  const location = findSkillLocationInRoots(skillName, roots);
   if (!location) {
-    logger?.info("skill-fix: skill file not found, skipping", { skill: skillName, projectRoot });
+    logger?.info("skill-fix: skill file not found in any project root, skipping", {
+      skill: skillName,
+      roots
+    });
     await appendSkillFixEvent(eventsRoot, { skill: skillName, errorType, status: "not-found" });
     return;
   }
   if (location.type === "plugin-cache") {
-    logger?.info("skill-fix: plugin-cache skill is out of scope for auto-fix", { skill: skillName });
+    logger?.info(
+      "skill-fix: plugin-cache skill is out of scope for auto-fix (owned by plugin author; update the plugin to fix)",
+      { skill: skillName }
+    );
     await appendSkillFixEvent(eventsRoot, { skill: skillName, errorType, status: "scope-excluded" });
     return;
   }

package/src/skills/locator.js

@@ -3,29 +3,33 @@ import { homedir } from "node:os";
 import path from "node:path";
 
 /**
- * Find where a skill's SKILL.md lives.
- * Returns { path, type: 'repo' | 'global' } or null.
+ * Find where a skill's SKILL.md lives, searching multiple project roots.
+ * Returns { path, type: 'repo' | 'global', dir } or null.
  *
  * Skill structure on disk: {root}/skills/{skillName}/SKILL.md
  *
  * Repo skills  → fix via PR.
  * Global skills → fix in-place, notify user.
+ * Plugin-cache → out of scope for auto-fix (owned by plugin authors).
+ *
+ * Checks all repo-level skill dirs first (in order), then global.
+ * This handles multi-repo projects where a skill may live in any cloned repo.
  */
-export function findSkillLocation(skillName, projectRoot) {
-  // Normalize: strip leading slash, plugin prefix ("plugin:skill" → "skill")
+export function findSkillLocationInRoots(skillName, projectRoots) {
   const raw = String(skillName || "")
     .replace(/^\//, "")
     .trim();
   const isPluginPrefixed = raw.includes(":");
   const base = isPluginPrefixed ? raw.split(":").pop() : raw;
-  // Reject empty, dotfiles, or path traversal attempts
   if (!base || base.startsWith(".") || base.includes("/") || base.includes("\\")) return null;
 
   const home = homedir();
+  const roots = Array.isArray(projectRoots) ? projectRoots.filter(Boolean) : [];
+
   // Only repo-level and user-level skill dirs are managed; plugin cache skills
   // are owned by their plugin authors and intentionally out of scope.
   const candidates = [
-    { root: path.join(projectRoot, ".claude", "skills"), type: "repo" },
+    ...roots.map((root) => ({ root: path.join(root, ".claude", "skills"), type: "repo" })),
     { root: path.join(home, ".claude", "skills"), type: "global" }
   ].map((c) => ({ ...c, path: path.join(c.root, base, "SKILL.md") }));
 
@@ -40,6 +44,10 @@ export function findSkillLocation(skillName, projectRoot) {
     // log "scope-excluded" instead of the misleading "not-found".
     return isPluginPrefixed ? { type: "plugin-cache", path: null, dir: null } : null;
   }
-  // dir: skill directory containing SKILL.md and any companion scripts
   return { ...found, dir: path.dirname(found.path) };
 }
+
+/** Single-root convenience wrapper — backward-compatible. */
+export function findSkillLocation(skillName, projectRoot) {
+  return findSkillLocationInRoots(skillName, projectRoot ? [projectRoot] : []);
+}

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

@@ -255,7 +255,9 @@ export async function processJiraIssue({
       botUser,
       jira,
       projectRoot,
-      eventsRoot: projectRoot,
+      // eventsRoot intentionally omitted — triggerSkillFeedbackFix defaults to
+      // CLAUDE_TEAMMATE_ROOT (the stable teammate process root), which is correct.
+      // Passing projectRoot here would write events into the cloned repo dir instead.
       liveRepos,
       issueMemory,
       issueMemoryRecord,
@@ -769,7 +771,9 @@ export async function maybeCheckSkillCorrection({
     .sort(compareCommentsNewestFirst)
     .find((c) => jira.isBotAuthor(c.author, botUser) && getCommentTimestamp(c) < humanTs);
 
-  const repoCwd = liveRepos?.find((r) => r?.local_path)?.local_path || projectRoot;
+  // Collect all repo local paths so the skill fixer can search every cloned repo.
+  const allRepoPaths = (liveRepos || []).map((r) => r?.local_path).filter(Boolean);
+  const repoCwd = allRepoPaths[0] || projectRoot;
 
   // Fire-and-forget by design: run-1 already produced the broken output, run-2
   // (next poll cycle) will pick up the fixed skill. We do not block the main
@@ -791,6 +795,7 @@ export async function maybeCheckSkillCorrection({
         skillName: result.skillName,
         correctionSummary: result.correctionSummary,
         projectRoot: repoCwd,
+        projectRoots: allRepoPaths.length > 0 ? allRepoPaths : undefined,
         eventsRoot,
         logger,
         epicContext,