claude-teammate 0.1.270 → 0.1.271

package/package.json

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

package/src/dashboard/app/composables/useStatus.ts

@@ -143,6 +143,26 @@ export interface StatusResponse {
   state: WorkerState;
 }
 
+export interface SkillFixEvent {
+  ts: string;
+  skill: string;
+  location?: "repo" | "global";
+  errorType?: string;
+  status:
+    | "generating"
+    | "pr-created"
+    | "patched"
+    | "patched-fallback"
+    | "pr-exists"
+    | "no-fix"
+    | "error"
+    | "lock-skipped"
+    | "not-found";
+  prUrl?: string;
+  files?: number;
+  error?: string;
+}
+
 // Singleton state — shared across all useStatus() calls
 const _status = ref<StatusResponse | null>(null);
 const _loading = ref(false);
@@ -179,3 +199,20 @@ export function useStatus() {
 
   return { status: _status, loading: _loading, error: _error, loadStatus, startPolling, stopPolling };
 }
+
+const _skillFixes = ref<SkillFixEvent[]>([]);
+
+export function useSkillFixes() {
+  const { apiFetch } = useApi();
+
+  async function loadSkillFixes() {
+    try {
+      const data = await apiFetch<{ events: SkillFixEvent[] }>("/api/skill-fixes");
+      _skillFixes.value = data.events ?? [];
+    } catch {
+      // ignore — endpoint may not exist yet
+    }
+  }
+
+  return { skillFixes: _skillFixes, loadSkillFixes };
+}

package/src/dashboard/app/pages/index.vue

@@ -276,6 +276,56 @@
       </div>
     </template>
 
+    <!-- SKILL SELF-REPAIR -->
+    <div class="card" v-if="skillFixes.length > 0">
+      <div class="card-header">
+        <span class="card-title">⚙ Skill Self-Repair</span>
+        <span style="font-family:var(--f-mono);font-size:.7rem;color:var(--ink-3)">{{ activeSkillFixes.length > 0 ? `${activeSkillFixes.length} active` : '' }} {{ skillFixes.length }} events</span>
+      </div>
+      <!-- Active fixes banner -->
+      <div v-if="activeSkillFixes.length > 0" style="padding:8px 12px;background:rgba(234,179,8,.08);border-bottom:1px solid rgba(234,179,8,.2);font-size:.8rem;color:var(--ink-2)">
+        <span style="color:#ca8a04;font-weight:600">Fixing:</span>
+        <span v-for="f in activeSkillFixes" :key="f.skill + f.ts" style="margin-left:8px">
+          <span style="font-family:var(--f-mono);color:var(--ink-1)">{{ f.skill }}</span>
+          <span style="color:var(--ink-3);margin-left:4px">({{ f.location || '?' }})</span>
+        </span>
+      </div>
+      <div class="table-wrap">
+        <table>
+          <thead>
+            <tr>
+              <th>Time</th>
+              <th>Skill</th>
+              <th>Location</th>
+              <th>Trigger</th>
+              <th>Status</th>
+              <th>Details</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr v-for="ev in skillFixes.slice(0, 20)" :key="ev.skill + ev.ts">
+              <td style="font-family:var(--f-mono);font-size:.75rem;color:var(--ink-3);white-space:nowrap">{{ formatRelative(ev.ts) }}</td>
+              <td style="font-family:var(--f-mono);font-weight:600">{{ ev.skill }}</td>
+              <td>
+                <span v-if="ev.location" :class="['tag', ev.location === 'repo' ? 'sky' : 'violet']">{{ ev.location }}</span>
+                <span v-else style="color:var(--ink-3)">—</span>
+              </td>
+              <td style="font-size:.75rem;color:var(--ink-2)">{{ skillFixTriggerLabel(ev.errorType) }}</td>
+              <td>
+                <span :class="['tag', skillFixStatusClass(ev.status)]">{{ ev.status }}</span>
+              </td>
+              <td style="font-size:.75rem">
+                <a v-if="ev.prUrl" :href="ev.prUrl" target="_blank" style="color:var(--sky);text-decoration:none">PR →</a>
+                <span v-else-if="ev.error" style="color:var(--red);font-family:var(--f-mono)" :title="ev.error">{{ ev.error.slice(0, 40) }}…</span>
+                <span v-else-if="ev.files" style="color:var(--ink-3)">{{ ev.files }} file{{ ev.files !== 1 ? 's' : '' }}</span>
+                <span v-else style="color:var(--ink-3)">—</span>
+              </td>
+            </tr>
+          </tbody>
+        </table>
+      </div>
+    </div>
+
     <!-- ISSUE DRAWER (always mounted) -->
     <IssueDrawer
       :issue="drawerIssue"
@@ -288,9 +338,10 @@
 </template>
 
 <script setup lang="ts">
-import type { DraftPr, ReviewPr, StuckTask, WorkflowIssue } from "~/composables/useStatus";
+import type { DraftPr, ReviewPr, SkillFixEvent, StuckTask, WorkflowIssue } from "~/composables/useStatus";
 
 const { status, loadStatus } = useStatus();
+const { skillFixes, loadSkillFixes } = useSkillFixes();
 const { apiFetch } = useApi();
 // biome-ignore lint/correctness/noUnusedVariables: used in template
 const { formatTime, formatRelative, formatDuration, stateLabel, shortenUrl } = useHelpers();
@@ -461,11 +512,33 @@ function _closeDrawer() {
   drawerOpen.value = false;
 }
 
+// biome-ignore lint/correctness/noUnusedVariables: used in template
+const activeSkillFixes = computed(() => (skillFixes.value as SkillFixEvent[]).filter((e) => e.status === "generating"));
+
+// biome-ignore lint/correctness/noUnusedVariables: used in template
+function skillFixStatusClass(status: SkillFixEvent["status"]): string {
+  if (status === "pr-created" || status === "patched" || status === "patched-fallback") return "green";
+  if (status === "generating") return "yellow";
+  if (status === "error" || status === "no-fix") return "red";
+  return "";
+}
+
+// biome-ignore lint/correctness/noUnusedVariables: used in template
+function skillFixTriggerLabel(errorType?: string): string {
+  if (!errorType) return "—";
+  if (errorType === "user-feedback") return "user feedback";
+  if (errorType === "bash-error-in-skill") return "bash error";
+  if (errorType === "tool-error-in-skill") return "mcp error";
+  if (errorType === "skill-load-failed") return "load failed";
+  return errorType;
+}
+
 async function _refresh() {
-  await loadStatus();
+  await Promise.all([loadStatus(), loadSkillFixes()]);
 }
 
 onMounted(async () => {
+  loadSkillFixes();
   try {
     const config = await apiFetch<{ config: Record<string, string> }>("/api/config");
     const url = config?.config?.JIRA_BASE_URL || "";

package/src/dashboard/app/pages/logs.vue

@@ -42,6 +42,7 @@ const TABS = [
   { id: "draft-pr", label: "Draft PR", tag: "draft-pr" },
   { id: "review-pr", label: "PR Review", tag: "review-pr" },
   { id: "review-discussion", label: "Discussions", tag: "review-discussion" },
+  { id: "skill-fix", label: "Skill Fix", tag: "skill-fix" },
   { id: "system", label: "System", tag: "" }
 ] as const;
 
@@ -66,6 +67,7 @@ function getTag(line: string): string | null {
   if (/^(?:Draft PR\s|Draft pull request\s|Pull request\s)/i.test(body)) return "draft-pr";
   if (/^PR\s+review\s/i.test(body)) return "review-pr";
   if (/^PR\s+discussion\s/i.test(body)) return "review-discussion";
+  if (/skill-fix:/i.test(body)) return "skill-fix";
 
   return null;
 }

package/src/dashboard/server.js

@@ -139,6 +139,10 @@ async function handleRequest(req, res, projectRoot, runtimePaths) {
     return handleGetUsage(res, runtimePaths);
   }
 
+  if (pathname === "/api/skill-fixes" && req.method === "GET") {
+    return handleGetSkillFixes(res, projectRoot);
+  }
+
   const resetMatch = pathname.match(/^\/api\/issues\/([^/]+)\/reset$/u);
   if (resetMatch && req.method === "POST") {
     return handleResetIssue(res, projectRoot, resetMatch[1]);
@@ -838,6 +842,21 @@ async function parseJsonlFile(filePath, sessionIdToMeta, tokensBySession) {
   }
 }
 
+async function handleGetSkillFixes(res, projectRoot) {
+  const file = path.join(projectRoot, "memory", "skill-fixes.json");
+  try {
+    const content = await readFile(file, "utf8");
+    const events = JSON.parse(content);
+    sendJson(res, 200, { events: Array.isArray(events) ? events : [] });
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      sendJson(res, 200, { events: [] });
+      return;
+    }
+    throw err;
+  }
+}
+
 function sanitizePath(rawPath) {
   const decoded = decodeURIComponent(rawPath);
 

package/src/skills/index.js

@@ -1,7 +1,11 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
 import { extractSkillFailures } from "./detector.js";
 import { applySkillFix, generateSkillFix, readSkillFiles } from "./fixer.js";
 import { findSkillLocation } from "./locator.js";
 
+const SKILL_FIX_EVENTS_MAX = 50;
+
 // Module-level lock: prevents concurrent fix attempts for the same skill
 // (multiple tasks can detect the same failing skill simultaneously)
 const activeFixLocks = new Set();
@@ -32,19 +36,20 @@ async function fixSkillsAsync(failures, projectRoot, logger, invokeClaudeTask) {
   // Deduplicate by skillName — one fix per skill per invocation
   const seen = new Set();
 
-  for (const { skillName, errorContent } of failures) {
+  for (const { skillName, errorContent, errorType } of failures) {
     if (!skillName || skillName === "unknown" || seen.has(skillName)) continue;
     seen.add(skillName);
 
     // Skip if another concurrent task is already fixing this skill
     if (activeFixLocks.has(skillName)) {
       logger?.info("skill-fix: fix already in progress, skipping", { skill: skillName });
+      await appendSkillFixEvent(projectRoot, { skill: skillName, errorType, status: "lock-skipped" });
       continue;
     }
 
     activeFixLocks.add(skillName);
     try {
-      await fixSingleSkill({ skillName, errorContent, projectRoot, logger, invokeClaudeTask });
+      await fixSingleSkill({ skillName, errorContent, errorType, projectRoot, logger, invokeClaudeTask });
     } finally {
       activeFixLocks.delete(skillName);
     }
@@ -74,6 +79,7 @@ export function scheduleSkillFixWithFeedback({
   fixSingleSkill({
     skillName,
     errorContent: `User correction: ${correctionSummary}`,
+    errorType: "user-feedback",
     projectRoot,
     logger,
     invokeClaudeTask,
@@ -83,10 +89,19 @@ export function scheduleSkillFixWithFeedback({
     .finally(() => activeFixLocks.delete(skillName));
 }
 
-async function fixSingleSkill({ skillName, errorContent, projectRoot, logger, invokeClaudeTask, epicContext }) {
+async function fixSingleSkill({
+  skillName,
+  errorContent,
+  errorType,
+  projectRoot,
+  logger,
+  invokeClaudeTask,
+  epicContext
+}) {
   const location = findSkillLocation(skillName, projectRoot);
   if (!location) {
     logger?.info("skill-fix: skill file not found, skipping", { skill: skillName });
+    await appendSkillFixEvent(projectRoot, { skill: skillName, errorType, status: "not-found" });
     return;
   }
 
@@ -94,10 +109,18 @@ async function fixSingleSkill({ skillName, errorContent, projectRoot, logger, in
   if (skillFiles.length === 0) return;
 
   logger?.info("skill-fix: generating fix", { skill: skillName, location: location.type, files: skillFiles.length });
+  await appendSkillFixEvent(projectRoot, {
+    skill: skillName,
+    location: location.type,
+    errorType,
+    status: "generating",
+    files: skillFiles.length
+  });
 
   const fix = await generateSkillFix(skillName, skillFiles, errorContent, projectRoot, invokeClaudeTask, epicContext);
   if (!Array.isArray(fix?.files) || fix.files.length === 0) {
     logger?.info("skill-fix: no fix generated", { skill: skillName });
+    await appendSkillFixEvent(projectRoot, { skill: skillName, location: location.type, errorType, status: "no-fix" });
     return;
   }
 
@@ -111,4 +134,30 @@ async function fixSingleSkill({ skillName, errorContent, projectRoot, logger, in
   });
 
   logger?.info(`skill-fix: ${result.status}`, { skill: skillName, ...result });
+  await appendSkillFixEvent(projectRoot, {
+    skill: skillName,
+    location: location.type,
+    errorType,
+    status: result.status,
+    prUrl: result.prUrl,
+    error: result.error,
+    files: fix.files.length
+  });
+}
+
+async function appendSkillFixEvent(projectRoot, fields) {
+  try {
+    const file = path.join(projectRoot, "memory", "skill-fixes.json");
+    await mkdir(path.dirname(file), { recursive: true });
+    let events = [];
+    try {
+      events = JSON.parse(await readFile(file, "utf8"));
+    } catch {}
+    if (!Array.isArray(events)) events = [];
+    events.unshift({ ts: new Date().toISOString(), ...fields });
+    events = events.slice(0, SKILL_FIX_EVENTS_MAX);
+    await writeFile(file, JSON.stringify(events, null, 2), "utf8");
+  } catch {
+    // never throw — event logging is best-effort
+  }
 }