forgehive 0.8.1 → 1.0.0

package/dist/cli.js

@@ -2749,12 +2749,401 @@ var init_harness = __esm({
   }
 });
 
+// src/outcomes.ts
+var outcomes_exports = {};
+__export(outcomes_exports, {
+  aggregateByAgent: () => aggregateByAgent,
+  aggregateByTaskType: () => aggregateByTaskType,
+  appendOutcome: () => appendOutcome,
+  readOutcomes: () => readOutcomes,
+  updateRating: () => updateRating
+});
+import fs13 from "node:fs";
+import path13 from "node:path";
+function readOutcomes(forgehiveDir2) {
+  const filePath = path13.join(forgehiveDir2, OUTCOMES_FILE);
+  if (!fs13.existsSync(filePath)) return [];
+  return fs13.readFileSync(filePath, "utf8").trim().split("\n").filter(Boolean).map((line) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return null;
+    }
+  }).filter((e) => e !== null);
+}
+function writeOutcomes(forgehiveDir2, entries) {
+  const filePath = path13.join(forgehiveDir2, OUTCOMES_FILE);
+  fs13.writeFileSync(filePath, entries.map((e) => JSON.stringify(e)).join("\n") + "\n", "utf8");
+}
+function appendOutcome(forgehiveDir2, entry) {
+  const filePath = path13.join(forgehiveDir2, OUTCOMES_FILE);
+  fs13.appendFileSync(filePath, JSON.stringify(entry) + "\n", "utf8");
+  const entries = readOutcomes(forgehiveDir2);
+  if (entries.length >= MAX_ENTRIES) {
+    const kept = entries.slice(-KEEP_AFTER_ROTATION);
+    writeOutcomes(forgehiveDir2, kept);
+  }
+}
+function updateRating(forgehiveDir2, runId, rating) {
+  const entries = readOutcomes(forgehiveDir2);
+  const updated = entries.map((e) => e.runId === runId ? { ...e, rating } : e);
+  writeOutcomes(forgehiveDir2, updated);
+}
+function aggregateByAgent(forgehiveDir2) {
+  const entries = readOutcomes(forgehiveDir2);
+  const result = {};
+  for (const entry of entries) {
+    for (const agent of entry.agents) {
+      if (!result[agent]) {
+        result[agent] = { avgDurationMs: 0, taskTypes: {}, avgRating: null };
+      }
+      const stats = result[agent];
+      if (!stats.taskTypes[entry.taskType]) {
+        stats.taskTypes[entry.taskType] = { count: 0, avgDurationMs: 0 };
+      }
+      const ttStats = stats.taskTypes[entry.taskType];
+      const prevCount = ttStats.count;
+      ttStats.avgDurationMs = (ttStats.avgDurationMs * prevCount + entry.durationMs) / (prevCount + 1);
+      ttStats.count++;
+    }
+  }
+  for (const agent of Object.keys(result)) {
+    const agentEntries = entries.filter((e) => e.agents.includes(agent));
+    result[agent].avgDurationMs = agentEntries.reduce((sum, e) => sum + e.durationMs, 0) / agentEntries.length;
+    const rated = agentEntries.filter((e) => e.rating !== null);
+    result[agent].avgRating = rated.length > 0 ? rated.reduce((sum, e) => sum + e.rating, 0) / rated.length : null;
+  }
+  return result;
+}
+function aggregateByTaskType(forgehiveDir2) {
+  const entries = readOutcomes(forgehiveDir2);
+  const result = {};
+  for (const entry of entries) {
+    if (!result[entry.taskType]) {
+      result[entry.taskType] = { count: 0, avgDurationMs: 0 };
+    }
+    const agg = result[entry.taskType];
+    agg.avgDurationMs = (agg.avgDurationMs * agg.count + entry.durationMs) / (agg.count + 1);
+    agg.count++;
+  }
+  return result;
+}
+var OUTCOMES_FILE, MAX_ENTRIES, KEEP_AFTER_ROTATION;
+var init_outcomes = __esm({
+  "src/outcomes.ts"() {
+    "use strict";
+    OUTCOMES_FILE = "outcomes.jsonl";
+    MAX_ENTRIES = 500;
+    KEEP_AFTER_ROTATION = 400;
+  }
+});
+
+// src/next.ts
+var next_exports = {};
+__export(next_exports, {
+  PHASE_LABELS: () => PHASE_LABELS,
+  buildRecommendation: () => buildRecommendation,
+  detectPhase: () => detectPhase,
+  detectTaskTypeFromTitle: () => detectTaskTypeFromTitle,
+  formatNextCompact: () => formatNextCompact,
+  formatNextFull: () => formatNextFull,
+  loadNextState: () => loadNextState
+});
+import fs16 from "node:fs";
+import path16 from "node:path";
+function detectPhase(state) {
+  if (state.securityScanAgeMs > SEVEN_DAYS_MS) return "health-check";
+  if (state.storiesInSprint.length > 0 && state.activeRunIds.length > 0) return "implementing";
+  if (state.storiesInSprint.length > 0 && state.openPRNumbers.length > 0 && state.lastOutcomeType !== "party") return "review";
+  if (state.storiesInSprint.length > 0) return "implementing";
+  if (state.storiesDone.length > 0 && state.lastVelocityAgeMs > FOURTEEN_DAYS_MS) {
+    return "closing-sprint";
+  }
+  if (state.epicsWithoutStories.length > 0) return "solutioning";
+  if (state.storiesBacklog.length > 0) return "planning";
+  return "kickoff";
+}
+function detectTaskTypeFromTitle(title) {
+  const lower = title.toLowerCase();
+  for (const [keywords, taskType] of TASK_KEYWORDS) {
+    if (keywords.some((kw) => lower.includes(kw))) return taskType;
+  }
+  return "feature";
+}
+function getAgentRefinement(forgehiveDir2, taskType) {
+  const outcomesPath = path16.join(forgehiveDir2, "outcomes.jsonl");
+  if (!fs16.existsSync(outcomesPath)) return null;
+  const entries = fs16.readFileSync(outcomesPath, "utf8").trim().split("\n").filter(Boolean).map((l) => {
+    try {
+      return JSON.parse(l);
+    } catch {
+      return null;
+    }
+  }).filter((e) => e !== null);
+  const agentData = {};
+  for (const entry of entries) {
+    if (entry.taskType !== taskType) continue;
+    for (const agent of entry.agents) {
+      if (!agentData[agent]) agentData[agent] = [];
+      agentData[agent].push(entry.durationMs);
+    }
+  }
+  const eligible = Object.entries(agentData).filter(([, durations]) => durations.length >= 3);
+  if (eligible.length < 2) return null;
+  const avgByAgent = eligible.map(([agent, durations]) => ({
+    agent,
+    avg: durations.reduce((a, b) => a + b, 0) / durations.length
+  }));
+  avgByAgent.sort((a, b) => a.avg - b.avg);
+  const best = avgByAgent[0];
+  const second = avgByAgent[1];
+  const pct = Math.round((1 - best.avg / second.avg) * 100);
+  const bestMinutes = (best.avg / 6e4).toFixed(0);
+  return `${best.agent} empfohlen \u2014 ${pct}% schneller bei ${taskType} (\xD8 ${bestMinutes} Min)`;
+}
+function getSecondaryRecommendation(state, phase) {
+  if (phase !== "health-check" && state.securityScanAgeMs > SECONDARY_SCAN_AGE_MS) {
+    const days = Math.floor(state.securityScanAgeMs / (24 * 60 * 60 * 1e3));
+    return { command: "fh security scan", reason: `letzter Scan vor ${days} Tagen` };
+  }
+  if (phase !== "closing-sprint" && state.storiesDone.length > 0 && state.lastVelocityAgeMs > SECONDARY_VELOCITY_AGE_MS) {
+    return { command: "fh velocity record", reason: "Velocity nicht erfasst seit > 14 Tagen" };
+  }
+  return null;
+}
+function buildRecommendation(phase, state, forgehiveDir2) {
+  const secondary = getSecondaryRecommendation(state, phase);
+  const baseRec = {
+    phase,
+    secondary: secondary?.command ?? null,
+    secondaryReason: secondary?.reason ?? null
+  };
+  switch (phase) {
+    case "health-check":
+      return { ...baseRec, primary: "fh security scan", primaryHint: null };
+    case "implementing": {
+      const story = state.storiesInSprint[0] ?? "US-?";
+      const hint = getAgentRefinement(forgehiveDir2, "feature");
+      return { ...baseRec, primary: `fh auto ${story}`, primaryHint: hint };
+    }
+    case "review":
+      return { ...baseRec, primary: "/review-party", primaryHint: null };
+    case "closing-sprint": {
+      const sprint = state.storiesDone.length;
+      return { ...baseRec, primary: `fh velocity record sprint-${sprint}`, primaryHint: null };
+    }
+    case "planning":
+      return { ...baseRec, primary: "/fh-sprint", primaryHint: null };
+    case "kickoff":
+      return { ...baseRec, primary: 'fh story create "<first story>"', primaryHint: null };
+    case "solutioning": {
+      const epic = state.epicsWithoutStories[0] ?? "EPC-?";
+      return { ...baseRec, primary: `fh story create --epic ${epic}`, primaryHint: null };
+    }
+  }
+}
+function loadNextState(forgehiveDir2, projectRoot2) {
+  const storiesDir = path16.join(forgehiveDir2, "memory", "stories");
+  const epicsDir = path16.join(forgehiveDir2, "memory", "epics");
+  function readIds(dir, statusFilter) {
+    if (!fs16.existsSync(dir)) return [];
+    const results = [];
+    for (const filename of fs16.readdirSync(dir)) {
+      if (!filename.endsWith(".md")) continue;
+      try {
+        const content = fs16.readFileSync(path16.join(dir, filename), "utf8");
+        const match = content.match(/^---\n([\s\S]*?)\n---/);
+        if (!match) continue;
+        const data = jsYaml.load(match[1]);
+        if (!data?.id) continue;
+        if (statusFilter && data.status !== statusFilter) continue;
+        results.push(data.id);
+      } catch {
+      }
+    }
+    return results;
+  }
+  function getEpicsWithoutStories() {
+    if (!fs16.existsSync(epicsDir)) return [];
+    const allStoryEpicIds = /* @__PURE__ */ new Set();
+    if (fs16.existsSync(storiesDir)) {
+      for (const f of fs16.readdirSync(storiesDir)) {
+        if (!f.endsWith(".md")) continue;
+        try {
+          const content = fs16.readFileSync(path16.join(storiesDir, f), "utf8");
+          const match = content.match(/^---\n([\s\S]*?)\n---/);
+          if (!match) continue;
+          const data = jsYaml.load(match[1]);
+          if (data?.epicId) allStoryEpicIds.add(data.epicId);
+        } catch {
+        }
+      }
+    }
+    const result = [];
+    for (const f of fs16.readdirSync(epicsDir)) {
+      if (!f.endsWith(".md")) continue;
+      try {
+        const content = fs16.readFileSync(path16.join(epicsDir, f), "utf8");
+        const match = content.match(/^---\n([\s\S]*?)\n---/);
+        if (!match) continue;
+        const data = jsYaml.load(match[1]);
+        if (data?.id && !allStoryEpicIds.has(data.id)) result.push(data.id);
+      } catch {
+      }
+    }
+    return result;
+  }
+  let securityScanAgeMs = 0;
+  const secPath = path16.join(forgehiveDir2, "security-last-scan.txt");
+  if (fs16.existsSync(secPath)) {
+    try {
+      const ts = fs16.readFileSync(secPath, "utf8").trim();
+      securityScanAgeMs = Date.now() - new Date(ts).getTime();
+    } catch {
+      securityScanAgeMs = Infinity;
+    }
+  } else {
+    securityScanAgeMs = Infinity;
+  }
+  let lastVelocityAgeMs = Infinity;
+  const velocityPath = path16.join(forgehiveDir2, "memory", "velocity.md");
+  if (fs16.existsSync(velocityPath)) {
+    try {
+      const content = fs16.readFileSync(velocityPath, "utf8");
+      const dateMatches = content.match(/\|\s*(\d{4}-\d{2}-\d{2})\s*\|/g);
+      if (dateMatches && dateMatches.length > 0) {
+        const lastDate = dateMatches[dateMatches.length - 1].replace(/[\|\s]/g, "");
+        lastVelocityAgeMs = Date.now() - new Date(lastDate).getTime();
+      }
+    } catch {
+    }
+  }
+  const runsDir = path16.join(forgehiveDir2, "runs");
+  const activeRunIds = [];
+  if (fs16.existsSync(runsDir)) {
+    for (const runDir of fs16.readdirSync(runsDir)) {
+      const statePath = path16.join(runsDir, runDir, "state.yaml");
+      if (!fs16.existsSync(statePath)) continue;
+      try {
+        const state = jsYaml.load(fs16.readFileSync(statePath, "utf8"));
+        if (state?.status && !["done", "gate-stuck"].includes(state.status) && state.runId) {
+          activeRunIds.push(state.runId);
+        }
+      } catch {
+      }
+    }
+  }
+  let openPRNumbers = [];
+  const prCachePath = path16.join(forgehiveDir2, "github-pr-cache.json");
+  if (fs16.existsSync(prCachePath)) {
+    try {
+      const cache = JSON.parse(fs16.readFileSync(prCachePath, "utf8"));
+      openPRNumbers = cache.open ?? [];
+    } catch {
+    }
+  }
+  let lastOutcomeType = null;
+  const outcomesPath = path16.join(forgehiveDir2, "outcomes.jsonl");
+  if (fs16.existsSync(outcomesPath)) {
+    try {
+      const lines = fs16.readFileSync(outcomesPath, "utf8").trim().split("\n").filter(Boolean);
+      if (lines.length > 0) {
+        const last = JSON.parse(lines[lines.length - 1]);
+        if (last.type === "auto" || last.type === "party") {
+          lastOutcomeType = last.type;
+        }
+      }
+    } catch {
+    }
+  }
+  return {
+    storiesInSprint: readIds(storiesDir, "in-sprint"),
+    storiesBacklog: readIds(storiesDir, "backlog"),
+    storiesDone: readIds(storiesDir, "done"),
+    epicsWithoutStories: getEpicsWithoutStories(),
+    openPRNumbers,
+    activeRunIds,
+    securityScanAgeMs,
+    lastVelocityAgeMs,
+    lastOutcomeType
+  };
+}
+function formatNextFull(projectRoot2, forgehiveDir2) {
+  const state = loadNextState(forgehiveDir2, projectRoot2);
+  const phase = detectPhase(state);
+  const rec = buildRecommendation(phase, state, forgehiveDir2);
+  const phaseLabel = PHASE_LABELS[phase];
+  const lines = [
+    "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    "fh next",
+    "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    `Phase: ${phaseLabel}`,
+    ""
+  ];
+  if (state.storiesInSprint.length > 0) {
+    lines.push(`  ${state.storiesInSprint.length} Stories in Sprint:`);
+    for (const id of state.storiesInSprint) {
+      lines.push(`    ${id}`);
+    }
+    lines.push("");
+  }
+  lines.push("Empfehlung:");
+  lines.push(`  \u2192 ${rec.primary}`);
+  if (rec.primaryHint) {
+    lines.push(`    ${rec.primaryHint}`);
+  }
+  if (rec.secondary) {
+    lines.push("");
+    lines.push("Auch f\xE4llig:");
+    lines.push(`  \u2192 ${rec.secondary}  (${rec.secondaryReason})`);
+  }
+  lines.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  return lines.join("\n");
+}
+function formatNextCompact(projectRoot2, forgehiveDir2) {
+  const state = loadNextState(forgehiveDir2, projectRoot2);
+  const phase = detectPhase(state);
+  const rec = buildRecommendation(phase, state, forgehiveDir2);
+  const phaseLabel = PHASE_LABELS[phase];
+  const hint = rec.primaryHint ? `  (${rec.primaryHint})` : "";
+  return `## Next
+Phase: ${phaseLabel}
+\u2192 ${rec.primary}${hint}`;
+}
+var SEVEN_DAYS_MS, FOURTEEN_DAYS_MS, TASK_KEYWORDS, SECONDARY_SCAN_AGE_MS, SECONDARY_VELOCITY_AGE_MS, PHASE_LABELS;
+var init_next = __esm({
+  "src/next.ts"() {
+    "use strict";
+    init_js_yaml();
+    SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1e3;
+    FOURTEEN_DAYS_MS = 14 * 24 * 60 * 60 * 1e3;
+    TASK_KEYWORDS = [
+      [["fix", "bug", "crash", "error", "broken"], "bug-fix"],
+      [["test", "coverage", "spec", "assertion"], "test-gap"],
+      [["security", "vulnerability", "auth", "cve"], "security"],
+      [["design", "ui", "ux", "layout"], "design"],
+      [["docs", "readme", "onboarding"], "documentation"]
+    ];
+    SECONDARY_SCAN_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+    SECONDARY_VELOCITY_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
+    PHASE_LABELS = {
+      "health-check": "Health Check",
+      "implementing": "Implementation",
+      "review": "Review",
+      "closing-sprint": "Sprint Abschluss",
+      "planning": "Planung",
+      "kickoff": "Kickoff",
+      "solutioning": "Solutioning"
+    };
+  }
+});
+
 // src/cli.ts
 init_js_yaml();
-import fs35 from "node:fs";
-import path36 from "node:path";
-import { spawnSync as spawnSync12 } from "node:child_process";
-import { createInterface } from "node:readline";
+import fs39 from "node:fs";
+import path40 from "node:path";
+import { spawnSync as spawnSync15 } from "node:child_process";
+import { createInterface as createInterface2 } from "node:readline";
 
 // src/scanner.ts
 import fs from "node:fs";
@@ -3837,19 +4226,24 @@ function pullRemoteSkills(forgehiveDir2, gitUrl) {
 
 // src/party.ts
 init_js_yaml();
-import fs13 from "node:fs";
-import path13 from "node:path";
+import fs14 from "node:fs";
+import path14 from "node:path";
 import { spawnSync as spawnSync3 } from "node:child_process";
+
+// src/party-subagent.ts
+init_outcomes();
+
+// src/party.ts
 function loadConfig(forgehiveDir2) {
-  const configPath = path13.join(forgehiveDir2, "party", "config.yaml");
-  if (!fs13.existsSync(configPath)) {
+  const configPath = path14.join(forgehiveDir2, "party", "config.yaml");
+  if (!fs14.existsSync(configPath)) {
     throw new Error("party/config.yaml nicht gefunden \u2014 f\xFChre `fh init` aus");
   }
-  return jsYaml.load(fs13.readFileSync(configPath, "utf8"));
+  return jsYaml.load(fs14.readFileSync(configPath, "utf8"));
 }
 function saveConfig(forgehiveDir2, config) {
-  fs13.writeFileSync(
-    path13.join(forgehiveDir2, "party", "config.yaml"),
+  fs14.writeFileSync(
+    path14.join(forgehiveDir2, "party", "config.yaml"),
     jsYaml.dump(config),
     "utf8"
   );
@@ -3899,12 +4293,12 @@ function runParty(forgehiveDir2, projectRoot2, setName) {
     );
   }
   const sessionId = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace(/[:-]/g, "");
-  const wtBaseDir = path13.join(forgehiveDir2, "worktrees");
-  fs13.mkdirSync(wtBaseDir, { recursive: true });
+  const wtBaseDir = path14.join(forgehiveDir2, "worktrees");
+  fs14.mkdirSync(wtBaseDir, { recursive: true });
   const state = { setName, sessionId, worktrees: [] };
   for (const agent of config.sets[setName].agents) {
     const branch = `forgehive/party/${sessionId}/${agent}`;
-    const wtPath = path13.join(wtBaseDir, `${sessionId}-${agent}`);
+    const wtPath = path14.join(wtBaseDir, `${sessionId}-${agent}`);
     const result = spawnSync3("git", ["worktree", "add", "-b", branch, wtPath], {
       cwd: projectRoot2,
       encoding: "utf8"
@@ -3916,8 +4310,8 @@ function runParty(forgehiveDir2, projectRoot2, setName) {
       spawnSync3("git", ["worktree", "prune"], { cwd: projectRoot2, encoding: "utf8" });
       throw result.error ?? new Error(`Worktree f\xFCr ${agent} fehlgeschlagen: ${result.stderr?.trim()}`);
     }
-    fs13.writeFileSync(
-      path13.join(wtPath, ".forgehive-agent-dispatch.md"),
+    fs14.writeFileSync(
+      path14.join(wtPath, ".forgehive-agent-dispatch.md"),
       [
         `# ${agent} \u2014 Party Session ${sessionId}`,
         "",
@@ -3935,18 +4329,18 @@ function runParty(forgehiveDir2, projectRoot2, setName) {
     );
     state.worktrees.push({ agent, branch, path: wtPath, status: "pending" });
   }
-  fs13.writeFileSync(
-    path13.join(forgehiveDir2, "party", "party-session.yaml"),
+  fs14.writeFileSync(
+    path14.join(forgehiveDir2, "party", "party-session.yaml"),
     jsYaml.dump(state),
     "utf8"
   );
   return state;
 }
 function getPartyStatus(forgehiveDir2) {
-  const statePath = path13.join(forgehiveDir2, "party", "party-session.yaml");
-  if (!fs13.existsSync(statePath)) return null;
+  const statePath = path14.join(forgehiveDir2, "party", "party-session.yaml");
+  if (!fs14.existsSync(statePath)) return null;
   try {
-    return jsYaml.load(fs13.readFileSync(statePath, "utf8"));
+    return jsYaml.load(fs14.readFileSync(statePath, "utf8"));
   } catch {
     return null;
   }
@@ -3956,7 +4350,7 @@ function cleanupPartyWorktrees(forgehiveDir2, projectRoot2) {
   if (!state) throw new Error("Keine aktive Party-Session gefunden");
   const removed = [];
   for (const wt of state.worktrees) {
-    if (fs13.existsSync(wt.path)) {
+    if (fs14.existsSync(wt.path)) {
       const result = spawnSync3("git", ["worktree", "remove", "--force", wt.path], {
         cwd: projectRoot2,
         encoding: "utf8"
@@ -3965,8 +4359,8 @@ function cleanupPartyWorktrees(forgehiveDir2, projectRoot2) {
     }
   }
   spawnSync3("git", ["worktree", "prune"], { cwd: projectRoot2, encoding: "utf8" });
-  const statePath = path13.join(forgehiveDir2, "party", "party-session.yaml");
-  if (fs13.existsSync(statePath)) fs13.unlinkSync(statePath);
+  const statePath = path14.join(forgehiveDir2, "party", "party-session.yaml");
+  if (fs14.existsSync(statePath)) fs14.unlinkSync(statePath);
   return removed;
 }
 function getPartyDefaultSet(forgehiveDir2) {
@@ -3989,8 +4383,8 @@ function setAgentModel(forgehiveDir2, setName, agentName, modelId) {
 }
 
 // src/wire.ts
-import fs14 from "node:fs";
-import path14 from "node:path";
+import fs15 from "node:fs";
+import path15 from "node:path";
 var SERVICES = {
   linear: {
     mcp: {
@@ -4827,19 +5221,19 @@ function wireService(projectRoot2, forgehiveDir2, service) {
       `Unbekannter Service: "${service}". Verf\xFCgbar: ${Object.keys(SERVICES).join(", ")}`
     );
   }
-  const mcpJsonPath = path14.join(projectRoot2, ".mcp.json");
+  const mcpJsonPath = path15.join(projectRoot2, ".mcp.json");
   let mcpConfig = { mcpServers: {} };
-  if (fs14.existsSync(mcpJsonPath)) {
-    mcpConfig = JSON.parse(fs14.readFileSync(mcpJsonPath, "utf8"));
+  if (fs15.existsSync(mcpJsonPath)) {
+    mcpConfig = JSON.parse(fs15.readFileSync(mcpJsonPath, "utf8"));
     if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
   }
   if (!mcpConfig.mcpServers[service]) {
     mcpConfig.mcpServers[service] = def.mcp;
-    fs14.writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 2) + "\n", "utf8");
+    fs15.writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 2) + "\n", "utf8");
   }
-  const skillPath = path14.join(forgehiveDir2, "skills", "workflows", `${service}.md`);
-  fs14.mkdirSync(path14.dirname(skillPath), { recursive: true });
-  fs14.writeFileSync(skillPath, def.skillContent, "utf8");
+  const skillPath = path15.join(forgehiveDir2, "skills", "workflows", `${service}.md`);
+  fs15.mkdirSync(path15.dirname(skillPath), { recursive: true });
+  fs15.writeFileSync(skillPath, def.skillContent, "utf8");
 }
 function validateWireService(service) {
   if (!SERVICES[service]) {
@@ -4853,21 +5247,146 @@ function validateWireService(service) {
 
 // src/status.ts
 init_js_yaml();
-import fs15 from "node:fs";
-import path15 from "node:path";
+init_next();
+import fs17 from "node:fs";
+import path17 from "node:path";
 import { spawnSync as spawnSync4 } from "node:child_process";
 function countMdFiles(dir) {
-  if (!fs15.existsSync(dir)) return 0;
-  return fs15.readdirSync(dir).filter((f) => f.endsWith(".md")).length;
+  if (!fs17.existsSync(dir)) return 0;
+  return fs17.readdirSync(dir).filter((f) => f.endsWith(".md")).length;
+}
+function readYamlFrontmatterFiles(dir) {
+  if (!fs17.existsSync(dir)) return [];
+  const results = [];
+  for (const filename of fs17.readdirSync(dir)) {
+    if (!filename.endsWith(".md")) continue;
+    try {
+      const content = fs17.readFileSync(path17.join(dir, filename), "utf8");
+      const match = content.match(/^---\n([\s\S]*?)\n---/);
+      if (!match) continue;
+      const parsed = jsYaml.load(match[1]);
+      if (parsed && typeof parsed === "object") results.push(parsed);
+    } catch {
+    }
+  }
+  return results;
+}
+function formatSprintSection(forgehiveDir2) {
+  const storiesDir = path17.join(forgehiveDir2, "memory", "stories");
+  if (!fs17.existsSync(storiesDir)) return "";
+  const stories = readYamlFrontmatterFiles(storiesDir);
+  const open = stories.filter((s) => s.status !== "done");
+  const inSprint = stories.filter((s) => s.status === "in-sprint");
+  const next = inSprint[0] ?? open[0] ?? null;
+  const epicsDir = path17.join(forgehiveDir2, "memory", "epics");
+  const activeEpics = readYamlFrontmatterFiles(epicsDir).filter((e) => e.status === "active" || e.status === "in-progress");
+  const lines = ["SPRINT"];
+  lines.push(`  \u25CF ${open.length} offen  \u25CF ${inSprint.length} in-sprint`);
+  if (activeEpics.length > 0) {
+    lines.push(`  Epic: ${activeEpics[0].id} ${activeEpics[0].title}`);
+  }
+  if (next) {
+    const pts = next.points ? `  [${next.points} pts]` : "";
+    lines.push(`  \u2192 n\xE4chstes: ${next.id} "${next.title}"${pts}`);
+  }
+  return lines.join("\n");
+}
+function formatCodeHealthSection(projectRoot2, forgehiveDir2) {
+  const lines = ["CODE HEALTH"];
+  const gitResult = spawnSync4("git", ["status", "--porcelain"], {
+    cwd: projectRoot2,
+    encoding: "utf8"
+  });
+  if (gitResult.status === 0) {
+    const changed = gitResult.stdout.trim().split("\n").filter(Boolean).length;
+    lines.push(
+      changed === 0 ? "  \u2713 Arbeitsbaum sauber" : `  \u26A0 ${changed} ge\xE4nderte Datei(en) \u2014 nicht committed`
+    );
+  }
+  const secPath = path17.join(forgehiveDir2, "security-last-scan.txt");
+  if (fs17.existsSync(secPath)) {
+    try {
+      const ts = fs17.readFileSync(secPath, "utf8").trim();
+      const days = Math.floor((Date.now() - new Date(ts).getTime()) / 864e5);
+      lines.push(
+        days > 7 ? `  \u26A0 Security-Scan: ${days} Tage alt \u2014 fh security scan` : `  \u2713 Security-Scan: ${days} Tage alt`
+      );
+    } catch {
+    }
+  }
+  const prCachePath = path17.join(forgehiveDir2, "github-pr-cache.json");
+  if (fs17.existsSync(prCachePath)) {
+    try {
+      const cache = JSON.parse(fs17.readFileSync(prCachePath, "utf8"));
+      if (cache.open.length > 0) {
+        lines.push(`  \u25CF ${cache.open.length} offene PR(s): #${cache.open.join(", #")}`);
+      }
+    } catch {
+    }
+  }
+  const outcomesPath = path17.join(forgehiveDir2, "outcomes.jsonl");
+  if (fs17.existsSync(outcomesPath)) {
+    try {
+      const rawLines = fs17.readFileSync(outcomesPath, "utf8").trim().split("\n").filter(Boolean);
+      const lastParty = rawLines.map((l) => {
+        try {
+          return JSON.parse(l);
+        } catch {
+          return null;
+        }
+      }).filter((e) => e !== null && e.type === "party").pop();
+      if (lastParty) {
+        const days = Math.floor((Date.now() - new Date(lastParty.ts).getTime()) / 864e5);
+        const set2 = lastParty.partySet ?? "party";
+        const findings = lastParty.signals?.findingsCount ?? 0;
+        lines.push(`  \u25CF Letzter Review (${set2}): vor ${days} Tag(en) \u2014 ${findings} Findings`);
+      }
+    } catch {
+    }
+  }
+  return lines.join("\n");
+}
+function formatWatchSection(forgehiveDir2) {
+  const logPath = path17.join(forgehiveDir2, "watch-events.jsonl");
+  if (!fs17.existsSync(logPath)) return "";
+  const events = fs17.readFileSync(logPath, "utf8").trim().split("\n").filter(Boolean).map((line) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return null;
+    }
+  }).filter((e) => e !== null).slice(-5).reverse();
+  if (events.length === 0) return "";
+  const lines = ["WATCH  (letzte Ereignisse)"];
+  for (const e of events) {
+    const time = new Date(e.ts).toLocaleTimeString("de", { hour: "2-digit", minute: "2-digit" });
+    if (e.type === "stack-update") {
+      lines.push(`  [${time}] \u2713 Stack-Update (${e.file ?? "?"}) \u2014 capabilities.yaml aktualisiert`);
+    } else {
+      const verdict = e.accepted === true ? "\u2192 gestartet" : e.accepted === false ? "\u2192 abgelehnt" : "\u2192 vorgeschlagen";
+      lines.push(`  [${time}] \u26A0 ${e.file ?? e.type}  ${verdict}: ${e.agent ?? "?"}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatDashboard(projectRoot2, forgehiveDir2) {
+  const sections = [
+    formatSprintSection(forgehiveDir2),
+    formatCodeHealthSection(projectRoot2, forgehiveDir2),
+    formatWatchSection(forgehiveDir2),
+    formatNextCompact(projectRoot2, forgehiveDir2)
+  ].filter(Boolean);
+  if (sections.length === 0) return "";
+  return "\n" + sections.join("\n\n");
 }
 function checkDrift(projectRoot2, forgehiveDir2) {
-  const scanPath = path15.join(forgehiveDir2, "scan-result.yaml");
-  if (!fs15.existsSync(scanPath)) {
+  const scanPath = path17.join(forgehiveDir2, "scan-result.yaml");
+  if (!fs17.existsSync(scanPath)) {
     return { daysSinceScan: null, recentCommits: 0, isDrifted: false };
   }
   let scannedAt = null;
   try {
-    const raw = jsYaml.load(fs15.readFileSync(scanPath, "utf8"));
+    const raw = jsYaml.load(fs17.readFileSync(scanPath, "utf8"));
     scannedAt = raw?.scanned_at ?? null;
   } catch {
   }
@@ -4890,14 +5409,14 @@ function checkDrift(projectRoot2, forgehiveDir2) {
 }
 function projectStatus(projectRoot2, forgehiveDir2) {
   const lines = ["ForgeHive Status", ""];
-  if (!fs15.existsSync(forgehiveDir2)) {
+  if (!fs17.existsSync(forgehiveDir2)) {
     lines.push("\u2717 Not initialized \u2014 run: fh init");
     return lines.join("\n");
   }
-  const capsPath = path15.join(forgehiveDir2, "capabilities.yaml");
-  if (fs15.existsSync(capsPath)) {
+  const capsPath = path17.join(forgehiveDir2, "capabilities.yaml");
+  if (fs17.existsSync(capsPath)) {
     try {
-      const raw = jsYaml.load(fs15.readFileSync(capsPath, "utf8"));
+      const raw = jsYaml.load(fs17.readFileSync(capsPath, "utf8"));
       const caps = raw && typeof raw === "object" ? raw : {};
       const confirmed = caps.capabilities?.confirmed?.length ?? 0;
       const inferred = caps.capabilities?.inferred?.length ?? 0;
@@ -4908,10 +5427,10 @@ function projectStatus(projectRoot2, forgehiveDir2) {
       lines.push("\u26A0 Capabilities: capabilities.yaml unlesbar");
     }
   }
-  const claudeMdPath = path15.join(projectRoot2, "CLAUDE.md");
-  if (fs15.existsSync(claudeMdPath)) {
+  const claudeMdPath = path17.join(projectRoot2, "CLAUDE.md");
+  if (fs17.existsSync(claudeMdPath)) {
     try {
-      const content = fs15.readFileSync(claudeMdPath, "utf8");
+      const content = fs17.readFileSync(claudeMdPath, "utf8");
       const hasBlock = content.includes("<!-- forgehive:start -->");
       lines.push(hasBlock ? "\u2713 CLAUDE.md block present" : "\u26A0 CLAUDE.md block missing \u2014 run: fh init");
     } catch {
@@ -4920,15 +5439,15 @@ function projectStatus(projectRoot2, forgehiveDir2) {
   } else {
     lines.push("\u26A0 CLAUDE.md not found");
   }
-  const skillsDir = path15.join(forgehiveDir2, "skills");
-  const generated = countMdFiles(path15.join(skillsDir, "generated"));
-  const expert = countMdFiles(path15.join(skillsDir, "expert"));
-  const workflows = countMdFiles(path15.join(skillsDir, "workflows"));
+  const skillsDir = path17.join(forgehiveDir2, "skills");
+  const generated = countMdFiles(path17.join(skillsDir, "generated"));
+  const expert = countMdFiles(path17.join(skillsDir, "expert"));
+  const workflows = countMdFiles(path17.join(skillsDir, "workflows"));
   lines.push(`\u2713 Skills: ${generated} generated, ${expert} expert, ${workflows} workflows`);
-  const mcpPath = path15.join(projectRoot2, ".mcp.json");
-  if (fs15.existsSync(mcpPath)) {
+  const mcpPath = path17.join(projectRoot2, ".mcp.json");
+  if (fs17.existsSync(mcpPath)) {
     try {
-      const mcp = JSON.parse(fs15.readFileSync(mcpPath, "utf8"));
+      const mcp = JSON.parse(fs17.readFileSync(mcpPath, "utf8"));
       const services = Object.keys(mcp.mcpServers ?? {});
       lines.push(
         services.length > 0 ? `\u2713 MCP: ${services.join(", ")}` : "  MCP: none configured"
@@ -4939,17 +5458,17 @@ function projectStatus(projectRoot2, forgehiveDir2) {
   } else {
     lines.push("  MCP: none configured (fh wire <service>)");
   }
-  const memoryDir = path15.join(forgehiveDir2, "memory");
-  if (fs15.existsSync(memoryDir)) {
-    const files = fs15.readdirSync(memoryDir).filter((f) => f.endsWith(".md"));
+  const memoryDir = path17.join(forgehiveDir2, "memory");
+  if (fs17.existsSync(memoryDir)) {
+    const files = fs17.readdirSync(memoryDir).filter((f) => f.endsWith(".md"));
     lines.push(`\u2713 Memory: ${files.length} file(s)`);
   } else {
     lines.push("  Memory: not initialized");
   }
-  const scanPath = path15.join(forgehiveDir2, "scan-result.yaml");
-  if (fs15.existsSync(scanPath)) {
+  const scanPath = path17.join(forgehiveDir2, "scan-result.yaml");
+  if (fs17.existsSync(scanPath)) {
     try {
-      const raw = jsYaml.load(fs15.readFileSync(scanPath, "utf8"));
+      const raw = jsYaml.load(fs17.readFileSync(scanPath, "utf8"));
       const scan2 = raw && typeof raw === "object" ? raw : {};
       lines.push(`\u2713 Last scan: ${scan2.scanned_at ?? "unknown"}`);
     } catch {
@@ -4963,23 +5482,24 @@ function projectStatus(projectRoot2, forgehiveDir2) {
   } else if (drift.daysSinceScan !== null) {
     lines.push(`\u2713 Kontext aktuell (${drift.daysSinceScan} Tage, ${drift.recentCommits} Commits seit Scan)`);
   }
-  const agentMemDir = path15.join(forgehiveDir2, "agents", "memory");
-  if (fs15.existsSync(agentMemDir)) {
-    const agents = fs15.readdirSync(agentMemDir).filter((f) => f.endsWith(".md"));
+  const agentMemDir = path17.join(forgehiveDir2, "agents", "memory");
+  if (fs17.existsSync(agentMemDir)) {
+    const agents = fs17.readdirSync(agentMemDir).filter((f) => f.endsWith(".md"));
     lines.push(`\u2713 Agent memory: ${agents.length} agent(s)`);
   }
   return lines.join("\n");
 }
 
 // src/watch.ts
-import fs16 from "node:fs";
-import path16 from "node:path";
+import fs18 from "node:fs";
+import path18 from "node:path";
+import { spawnSync as spawnSync5 } from "node:child_process";
 function checkProjectHash(projectRoot2, forgehiveDir2, claudeMdBlock) {
-  const hashPath = path16.join(forgehiveDir2, ".scan-hash");
-  const savedHash = fs16.existsSync(hashPath) ? fs16.readFileSync(hashPath, "utf8").trim() : null;
+  const hashPath = path18.join(forgehiveDir2, ".scan-hash");
+  const savedHash = fs18.existsSync(hashPath) ? fs18.readFileSync(hashPath, "utf8").trim() : null;
   const currentHash = computeHash(projectRoot2);
   if (currentHash === savedHash) return false;
-  fs16.writeFileSync(hashPath, currentHash, "utf8");
+  fs18.writeFileSync(hashPath, currentHash, "utf8");
   const scanResult = scan(projectRoot2);
   const capMap = mapSignalsToCapabilities(scanResult);
   writeForgehiveDir(projectRoot2, scanResult, capMap, claudeMdBlock);
@@ -4996,7 +5516,7 @@ function watchProject(projectRoot2, forgehiveDir2, claudeMdBlock, onUpdate = def
     "go.mod",
     "pyproject.toml",
     "composer.json"
-  ].map((f) => path16.join(projectRoot2, f)).filter((f) => fs16.existsSync(f));
+  ].map((f) => path18.join(projectRoot2, f)).filter((f) => fs18.existsSync(f));
   let debounce = null;
   const watchers = [];
   function schedule() {
@@ -5008,12 +5528,12 @@ function watchProject(projectRoot2, forgehiveDir2, claudeMdBlock, onUpdate = def
   }
   for (const f of candidates) {
     try {
-      watchers.push(fs16.watch(f, schedule));
+      watchers.push(fs18.watch(f, schedule));
     } catch {
     }
   }
   try {
-    watchers.push(fs16.watch(projectRoot2, schedule));
+    watchers.push(fs18.watch(projectRoot2, schedule));
   } catch {
   }
   return () => {
@@ -5031,10 +5551,95 @@ function defaultOnUpdate(changed) {
     console.log("[forgehive] \u2713 Codebase changed \u2014 capabilities.yaml aktualisiert");
   }
 }
+function appendWatchEvent(forgehiveDir2, event) {
+  const logPath = path18.join(forgehiveDir2, "watch-events.jsonl");
+  fs18.appendFileSync(logPath, JSON.stringify(event) + "\n", "utf8");
+  try {
+    const stat = fs18.statSync(logPath);
+    if (stat.size > 25e3) {
+      const lines = fs18.readFileSync(logPath, "utf8").trim().split("\n").filter(Boolean);
+      if (lines.length >= 500) {
+        fs18.writeFileSync(logPath, lines.slice(-500).join("\n") + "\n", "utf8");
+      }
+    }
+  } catch {
+  }
+}
+function detectErrorType(output) {
+  const lower = output.toLowerCase();
+  if (lower.includes("failing") || lower.includes("assertionerror") || lower.includes("not ok")) {
+    return { agent: "sam", reason: "Test-Fehler erkannt" };
+  }
+  if (lower.includes("error ts") || lower.includes("type error")) {
+    return { agent: "kai", reason: "TypeScript-Fehler erkannt" };
+  }
+  if (lower.includes("secret") || lower.includes("vulnerability") || lower.includes("cve")) {
+    return { agent: "vera", reason: "Sicherheitsproblem erkannt" };
+  }
+  if (lower.includes("error") || lower.includes("failed to compile")) {
+    return { agent: "kai", reason: "Build-Fehler erkannt" };
+  }
+  return null;
+}
+function smartWatch(projectRoot2, forgehiveDir2, testCmd, onSuggest) {
+  const srcDir = path18.join(projectRoot2, "src");
+  const testDir = path18.join(projectRoot2, "test");
+  const watchDirs = [srcDir, testDir].filter((d) => fs18.existsSync(d));
+  let debounce = null;
+  const watchers = [];
+  function runAndAnalyze(changedFile) {
+    const result = spawnSync5(testCmd, {
+      cwd: projectRoot2,
+      encoding: "utf8",
+      shell: true
+    });
+    if (result.status === 0) return;
+    const output = (result.stdout ?? "") + (result.stderr ?? "");
+    const detection = detectErrorType(output);
+    if (!detection) return;
+    const relFile = path18.relative(projectRoot2, changedFile);
+    console.log(`
+\u26A0 ${relFile} \u2014 ${detection.reason}`);
+    console.log(`  \u2192 ${detection.agent} ist der richtige Agent.`);
+    void onSuggest(detection.agent, detection.reason, relFile).then((accepted) => {
+      appendWatchEvent(forgehiveDir2, {
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "test-failure",
+        file: relFile,
+        agent: detection.agent,
+        accepted
+      });
+    });
+  }
+  function schedule(changedFile) {
+    if (debounce) clearTimeout(debounce);
+    debounce = setTimeout(() => runAndAnalyze(changedFile), 1500);
+  }
+  for (const dir of watchDirs) {
+    try {
+      const watcher = fs18.watch(dir, { recursive: true }, (_evt, filename) => {
+        if (filename && (filename.endsWith(".ts") || filename.endsWith(".js"))) {
+          schedule(path18.join(dir, filename));
+        }
+      });
+      watchers.push(watcher);
+    } catch {
+    }
+  }
+  return () => {
+    if (debounce) clearTimeout(debounce);
+    for (const w of watchers) {
+      try {
+        w.close();
+      } catch {
+      }
+    }
+  };
+}
 
 // src/cost.ts
-import fs17 from "node:fs";
-import path17 from "node:path";
+import fs19 from "node:fs";
+import path19 from "node:path";
 import os2 from "node:os";
 var PRICING = {
   input: 3,
@@ -5045,31 +5650,31 @@ var PRICING = {
 function calcCost(inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens) {
   return inputTokens / 1e6 * PRICING.input + outputTokens / 1e6 * PRICING.output + cacheCreationTokens / 1e6 * PRICING.cacheCreation + cacheReadTokens / 1e6 * PRICING.cacheRead;
 }
-function parseCostSessions(_projectRoot, claudeHome = path17.join(os2.homedir(), ".claude")) {
-  const projectsDir = path17.join(claudeHome, "projects");
-  if (!fs17.existsSync(projectsDir)) return [];
-  const matchDirs = fs17.readdirSync(projectsDir);
+function parseCostSessions(_projectRoot, claudeHome = path19.join(os2.homedir(), ".claude")) {
+  const projectsDir = path19.join(claudeHome, "projects");
+  if (!fs19.existsSync(projectsDir)) return [];
+  const matchDirs = fs19.readdirSync(projectsDir);
   const sessions = [];
   for (const dir of matchDirs) {
-    const dirPath = path17.join(projectsDir, dir);
+    const dirPath = path19.join(projectsDir, dir);
     let stat;
     try {
-      stat = fs17.statSync(dirPath);
+      stat = fs19.statSync(dirPath);
     } catch {
       continue;
     }
     if (!stat.isDirectory()) continue;
     let files;
     try {
-      files = fs17.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl"));
+      files = fs19.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl"));
     } catch {
       continue;
     }
     for (const jsonlFile of files) {
-      const filePath = path17.join(dirPath, jsonlFile);
+      const filePath = path19.join(dirPath, jsonlFile);
       let inputTokens = 0, outputTokens = 0, cacheCreationTokens = 0, cacheReadTokens = 0;
       try {
-        const lines = fs17.readFileSync(filePath, "utf8").split("\n").filter(Boolean);
+        const lines = fs19.readFileSync(filePath, "utf8").split("\n").filter(Boolean);
         for (const line of lines) {
           try {
             const entry = JSON.parse(line);
@@ -5082,7 +5687,7 @@ function parseCostSessions(_projectRoot, claudeHome = path17.join(os2.homedir(),
           } catch {
           }
         }
-        const mtime = fs17.statSync(filePath).mtime;
+        const mtime = fs19.statSync(filePath).mtime;
         sessions.push({
           sessionFile: jsonlFile,
           date: mtime.toISOString().slice(0, 10),
@@ -5130,28 +5735,28 @@ function formatCostReport(sessions, range) {
 }
 
 // src/mcp-auth.ts
-import fs18 from "node:fs";
-import path18 from "node:path";
+import fs20 from "node:fs";
+import path20 from "node:path";
 import os3 from "node:os";
 function getCredsPath() {
-  const dir = path18.join(os3.homedir(), ".forgehive");
-  fs18.mkdirSync(dir, { recursive: true });
-  return path18.join(dir, "credentials.json");
+  const dir = path20.join(os3.homedir(), ".forgehive");
+  fs20.mkdirSync(dir, { recursive: true });
+  return path20.join(dir, "credentials.json");
 }
 function loadStore() {
   const p = getCredsPath();
-  if (!fs18.existsSync(p)) return {};
+  if (!fs20.existsSync(p)) return {};
   try {
-    return JSON.parse(fs18.readFileSync(p, "utf8"));
+    return JSON.parse(fs20.readFileSync(p, "utf8"));
   } catch {
     return {};
   }
 }
 function saveStore(store) {
   const p = getCredsPath();
-  fs18.writeFileSync(p, JSON.stringify(store, null, 2), "utf8");
+  fs20.writeFileSync(p, JSON.stringify(store, null, 2), "utf8");
   try {
-    fs18.chmodSync(p, 384);
+    fs20.chmodSync(p, 384);
   } catch {
   }
 }
@@ -5198,9 +5803,9 @@ function checkMcpTrust(packageName) {
 }
 
 // src/mcp-registry.ts
-import fs19 from "node:fs";
-import path19 from "node:path";
-import { spawnSync as spawnSync5 } from "node:child_process";
+import fs21 from "node:fs";
+import path21 from "node:path";
+import { spawnSync as spawnSync6 } from "node:child_process";
 function parseRegistryResponse(raw) {
   if (!raw || typeof raw !== "object") return [];
   const data = raw;
@@ -5214,7 +5819,7 @@ function parseRegistryResponse(raw) {
 }
 function searchRegistry(query) {
   const url = `https://registry.smithery.ai/servers?q=${encodeURIComponent(query)}&pageSize=10`;
-  const result = spawnSync5("curl", [
+  const result = spawnSync6("curl", [
     "-s",
     "--max-time",
     "10",
@@ -5236,11 +5841,11 @@ function searchRegistry(query) {
 }
 function addMcpFromRegistry(projectRoot2, forgehiveDir2, packageName, envKeys) {
   const serverId = packageName.replace(/^@[^/]+\//, "") || packageName;
-  const mcpPath = path19.join(projectRoot2, ".mcp.json");
+  const mcpPath = path21.join(projectRoot2, ".mcp.json");
   let mcpConfig = { mcpServers: {} };
-  if (fs19.existsSync(mcpPath)) {
+  if (fs21.existsSync(mcpPath)) {
     try {
-      mcpConfig = JSON.parse(fs19.readFileSync(mcpPath, "utf8"));
+      mcpConfig = JSON.parse(fs21.readFileSync(mcpPath, "utf8"));
       if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
     } catch {
       mcpConfig = { mcpServers: {} };
@@ -5255,12 +5860,12 @@ function addMcpFromRegistry(projectRoot2, forgehiveDir2, packageName, envKeys) {
     args: ["-y", packageName],
     ...envKeys.length > 0 ? { env: envObj } : {}
   };
-  fs19.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf8");
-  const skillDir = path19.join(forgehiveDir2, "skills", "workflows");
-  fs19.mkdirSync(skillDir, { recursive: true });
-  const skillPath = path19.join(skillDir, `${serverId}.md`);
-  if (!fs19.existsSync(skillPath)) {
-    fs19.writeFileSync(skillPath, [
+  fs21.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf8");
+  const skillDir = path21.join(forgehiveDir2, "skills", "workflows");
+  fs21.mkdirSync(skillDir, { recursive: true });
+  const skillPath = path21.join(skillDir, `${serverId}.md`);
+  if (!fs21.existsSync(skillPath)) {
+    fs21.writeFileSync(skillPath, [
       `# ${serverId} Workflow Skill`,
       "",
       `## Setup`,
@@ -5275,9 +5880,9 @@ function addMcpFromRegistry(projectRoot2, forgehiveDir2, packageName, envKeys) {
 }
 
 // src/security-scan.ts
-import fs20 from "node:fs";
-import path20 from "node:path";
-import { spawnSync as spawnSync6 } from "node:child_process";
+import fs22 from "node:fs";
+import path22 from "node:path";
+import { spawnSync as spawnSync7 } from "node:child_process";
 var SECRET_PATTERNS = [
   { name: "Anthropic Key", pattern: /sk-ant-[a-zA-Z0-9-]{20,}/g },
   { name: "OpenAI Key", pattern: /sk-(?!ant-)[a-zA-Z0-9]{20,}/g },
@@ -5295,16 +5900,16 @@ function collectScanFiles(dir, exts = SCAN_EXTS) {
   function walk(current) {
     let entries;
     try {
-      entries = fs20.readdirSync(current, { withFileTypes: true });
+      entries = fs22.readdirSync(current, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (IGNORE_DIRS.includes(entry.name)) continue;
-      const full = path20.join(current, entry.name);
+      const full = path22.join(current, entry.name);
       if (entry.isDirectory()) {
         walk(full);
-      } else if (entry.isFile() && exts.includes(path20.extname(entry.name))) {
+      } else if (entry.isFile() && exts.includes(path22.extname(entry.name))) {
         results.push(full);
       }
     }
@@ -5318,7 +5923,7 @@ function scanSecrets(projectRoot2) {
   for (const file of files) {
     let content;
     try {
-      content = fs20.readFileSync(file, "utf8");
+      content = fs22.readFileSync(file, "utf8");
     } catch {
       continue;
     }
@@ -5385,7 +5990,7 @@ function scanSast(projectRoot2) {
   for (const file of files) {
     let content;
     try {
-      content = fs20.readFileSync(file, "utf8");
+      content = fs22.readFileSync(file, "utf8");
     } catch {
       continue;
     }
@@ -5410,9 +6015,9 @@ function scanSast(projectRoot2) {
   return findings;
 }
 function scanDeps(projectRoot2) {
-  const pkgJsonPath = path20.join(projectRoot2, "package.json");
-  if (!fs20.existsSync(pkgJsonPath)) return [];
-  const result = spawnSync6("npm", ["audit", "--json"], {
+  const pkgJsonPath = path22.join(projectRoot2, "package.json");
+  if (!fs22.existsSync(pkgJsonPath)) return [];
+  const result = spawnSync7("npm", ["audit", "--json"], {
     cwd: projectRoot2,
     encoding: "utf8",
     timeout: 3e4
@@ -5440,19 +6045,19 @@ function scanDeps(projectRoot2) {
 }
 
 // src/audit.ts
-import fs21 from "node:fs";
-import path21 from "node:path";
+import fs23 from "node:fs";
+import path23 from "node:path";
 function getAuditPath(forgehiveDir2) {
-  return path21.join(forgehiveDir2, "audit.log");
+  return path23.join(forgehiveDir2, "audit.log");
 }
 function logAuditEvent(forgehiveDir2, event) {
   const line = JSON.stringify(event) + "\n";
-  fs21.appendFileSync(getAuditPath(forgehiveDir2), line, "utf8");
+  fs23.appendFileSync(getAuditPath(forgehiveDir2), line, "utf8");
 }
 function getAuditLog(forgehiveDir2, limit = 50) {
   const p = getAuditPath(forgehiveDir2);
-  if (!fs21.existsSync(p)) return [];
-  const lines = fs21.readFileSync(p, "utf8").trim().split("\n").filter(Boolean);
+  if (!fs23.existsSync(p)) return [];
+  const lines = fs23.readFileSync(p, "utf8").trim().split("\n").filter(Boolean);
   const recent = lines.slice(-limit);
   return recent.map((l) => {
     try {
@@ -5477,19 +6082,19 @@ function formatAuditReport(events) {
 
 // src/spend-limits.ts
 init_js_yaml();
-import fs22 from "node:fs";
-import path22 from "node:path";
+import fs24 from "node:fs";
+import path24 from "node:path";
 function getConfigPath(forgehiveDir2) {
-  return path22.join(forgehiveDir2, "cost-config.yaml");
+  return path24.join(forgehiveDir2, "cost-config.yaml");
 }
 function setSpendLimit(forgehiveDir2, config) {
-  fs22.writeFileSync(getConfigPath(forgehiveDir2), jsYaml.dump(config), "utf8");
+  fs24.writeFileSync(getConfigPath(forgehiveDir2), jsYaml.dump(config), "utf8");
 }
 function getSpendConfig(forgehiveDir2) {
   const p = getConfigPath(forgehiveDir2);
-  if (!fs22.existsSync(p)) return {};
+  if (!fs24.existsSync(p)) return {};
   try {
-    return jsYaml.load(fs22.readFileSync(p, "utf8"));
+    return jsYaml.load(fs24.readFileSync(p, "utf8"));
   } catch {
     return {};
   }
@@ -5584,7 +6189,7 @@ function formatSecurityReport(report) {
 }
 
 // src/ci.ts
-import path23 from "node:path";
+import path25 from "node:path";
 function generateCiReport(projectRoot2, forgehiveDir2, failOn = "high") {
   const secrets = scanSecrets(projectRoot2);
   const sast = scanSast(projectRoot2);
@@ -5601,7 +6206,7 @@ function generateCiReport(projectRoot2, forgehiveDir2, failOn = "high") {
   }
   return {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    project: path23.basename(projectRoot2),
+    project: path25.basename(projectRoot2),
     status: failedOn ? "fail" : "pass",
     secrets,
     sast,
@@ -5675,8 +6280,8 @@ jobs:
 }
 
 // src/map.ts
-import fs23 from "node:fs";
-import path24 from "node:path";
+import fs25 from "node:fs";
+import path26 from "node:path";
 var MAP_EXTS = [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs"];
 var IGNORE_DIRS2 = ["node_modules", ".git", "dist", ".forgehive", "coverage", ".next", "build"];
 var IMPORT_PATTERNS = [
@@ -5698,11 +6303,11 @@ function extractImports(content) {
 function walkFiles(dir) {
   const results = [];
   function walk(current) {
-    for (const entry of fs23.readdirSync(current, { withFileTypes: true })) {
+    for (const entry of fs25.readdirSync(current, { withFileTypes: true })) {
       if (IGNORE_DIRS2.includes(entry.name)) continue;
-      const full = path24.join(current, entry.name);
+      const full = path26.join(current, entry.name);
       if (entry.isDirectory()) walk(full);
-      else if (entry.isFile() && MAP_EXTS.includes(path24.extname(entry.name)))
+      else if (entry.isFile() && MAP_EXTS.includes(path26.extname(entry.name)))
         results.push(full);
     }
   }
@@ -5714,7 +6319,7 @@ function generateMap(projectRoot2) {
   const files = filePaths.map((filePath) => {
     let content = "";
     try {
-      content = fs23.readFileSync(filePath, "utf8");
+      content = fs25.readFileSync(filePath, "utf8");
     } catch {
     }
     const rawLines = content.split("\n");
@@ -5722,7 +6327,7 @@ function generateMap(projectRoot2) {
     const imports = extractImports(content);
     return {
       path: filePath,
-      relativePath: path24.relative(projectRoot2, filePath),
+      relativePath: path26.relative(projectRoot2, filePath),
       lines,
       imports
     };
@@ -5811,8 +6416,8 @@ function formatMap(map2, semantic) {
 }
 
 // src/semantic-map.ts
-import fs24 from "node:fs";
-import path25 from "node:path";
+import fs26 from "node:fs";
+import path27 from "node:path";
 var IGNORE_DIRS3 = ["node_modules", ".git", "dist", ".forgehive", "coverage", ".next", "build"];
 var MAP_EXTS2 = [".ts", ".tsx", ".js", ".jsx", ".py", ".go"];
 var IMPORT_PATTERNS2 = {
@@ -5863,15 +6468,15 @@ function walkFiles2(dir) {
   function walk(current) {
     let entries;
     try {
-      entries = fs24.readdirSync(current, { withFileTypes: true });
+      entries = fs26.readdirSync(current, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (IGNORE_DIRS3.includes(entry.name)) continue;
-      const full = path25.join(current, entry.name);
+      const full = path27.join(current, entry.name);
       if (entry.isDirectory()) walk(full);
-      else if (entry.isFile() && MAP_EXTS2.includes(path25.extname(entry.name))) {
+      else if (entry.isFile() && MAP_EXTS2.includes(path27.extname(entry.name))) {
         results.push(full);
       }
     }
@@ -5917,15 +6522,15 @@ function _extractExports(content, lang) {
 }
 function _resolveImport(fromFile, importPath, allFiles) {
   if (!importPath.startsWith(".")) return null;
-  const fromDir = path25.dirname(fromFile);
-  const base = path25.resolve(fromDir, importPath);
+  const fromDir = path27.dirname(fromFile);
+  const base = path27.resolve(fromDir, importPath);
   if (allFiles.includes(base)) return base;
   for (const ext of [".ts", ".tsx", ".js", ".jsx", ".py", ".go"]) {
     const candidate = base + ext;
     if (allFiles.includes(candidate)) return candidate;
   }
   for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
-    const candidate = path25.join(base, "index" + ext);
+    const candidate = path27.join(base, "index" + ext);
     if (allFiles.includes(candidate)) return candidate;
   }
   return null;
@@ -5973,10 +6578,10 @@ function buildSemanticMap(projectRoot2) {
   for (const filePath of allFiles) {
     let content = "";
     try {
-      content = fs24.readFileSync(filePath, "utf8");
+      content = fs26.readFileSync(filePath, "utf8");
     } catch {
     }
-    const ext = path25.extname(filePath);
+    const ext = path27.extname(filePath);
     const lang = langOf(ext);
     const rawImps = _extractImports(content, lang);
     const resolvedImps = [];
@@ -5994,11 +6599,11 @@ function buildSemanticMap(projectRoot2) {
 
 // src/onboard.ts
 init_js_yaml();
-import fs25 from "node:fs";
-import path26 from "node:path";
-import { spawnSync as spawnSync7 } from "node:child_process";
+import fs27 from "node:fs";
+import path28 from "node:path";
+import { spawnSync as spawnSync8 } from "node:child_process";
 function getRecentCommits(projectRoot2, n = 20) {
-  const result = spawnSync7("git", ["log", `--oneline`, `-${n}`], {
+  const result = spawnSync8("git", ["log", `--oneline`, `-${n}`], {
     cwd: projectRoot2,
     encoding: "utf8"
   });
@@ -6006,30 +6611,30 @@ function getRecentCommits(projectRoot2, n = 20) {
   return result.stdout.trim().split("\n").filter(Boolean);
 }
 function readCapabilities(forgehiveDir2) {
-  const capPath = path26.join(forgehiveDir2, "capabilities.yaml");
-  if (!fs25.existsSync(capPath)) return {};
+  const capPath = path28.join(forgehiveDir2, "capabilities.yaml");
+  if (!fs27.existsSync(capPath)) return {};
   try {
-    return jsYaml.load(fs25.readFileSync(capPath, "utf8")) ?? {};
+    return jsYaml.load(fs27.readFileSync(capPath, "utf8")) ?? {};
   } catch {
     return {};
   }
 }
 function readMemoryFiles(forgehiveDir2) {
-  const memDir = path26.join(forgehiveDir2, "memory");
-  if (!fs25.existsSync(memDir)) return {};
+  const memDir = path28.join(forgehiveDir2, "memory");
+  if (!fs27.existsSync(memDir)) return {};
   const result = {};
-  for (const f of fs25.readdirSync(memDir).filter((f2) => f2.endsWith(".md") && f2 !== "MEMORY.md")) {
-    result[f] = fs25.readFileSync(path26.join(memDir, f), "utf8");
+  for (const f of fs27.readdirSync(memDir).filter((f2) => f2.endsWith(".md") && f2 !== "MEMORY.md")) {
+    result[f] = fs27.readFileSync(path28.join(memDir, f), "utf8");
   }
   return result;
 }
 function listAdrs2(forgehiveDir2) {
-  const adrsDir = path26.join(forgehiveDir2, "memory", "adrs");
-  if (!fs25.existsSync(adrsDir)) return [];
-  return fs25.readdirSync(adrsDir).filter((f) => f.endsWith(".md"));
+  const adrsDir = path28.join(forgehiveDir2, "memory", "adrs");
+  if (!fs27.existsSync(adrsDir)) return [];
+  return fs27.readdirSync(adrsDir).filter((f) => f.endsWith(".md"));
 }
 function generateOnboardingDoc(projectRoot2, forgehiveDir2) {
-  const projectName = path26.basename(projectRoot2);
+  const projectName = path28.basename(projectRoot2);
   const caps = readCapabilities(forgehiveDir2);
   const memFiles = readMemoryFiles(forgehiveDir2);
   const commits = getRecentCommits(projectRoot2);
@@ -6103,7 +6708,7 @@ function generateOnboardingDoc(projectRoot2, forgehiveDir2) {
 }
 
 // src/changelog.ts
-import { spawnSync as spawnSync8 } from "node:child_process";
+import { spawnSync as spawnSync9 } from "node:child_process";
 var TYPE_LABELS = {
   feat: "Added",
   fix: "Fixed",
@@ -6167,12 +6772,12 @@ function formatChangelog(commits, version2) {
 function getGitLogSince(projectRoot2, since) {
   const args = ["log", "--oneline", "--no-merges"];
   if (since) args.push(`${since}..HEAD`);
-  const result = spawnSync8("git", args, { cwd: projectRoot2, encoding: "utf8" });
+  const result = spawnSync9("git", args, { cwd: projectRoot2, encoding: "utf8" });
   if (result.status !== 0) return "";
   return result.stdout.trim();
 }
 function getLatestTag(projectRoot2) {
-  const result = spawnSync8("git", ["describe", "--tags", "--abbrev=0"], {
+  const result = spawnSync9("git", ["describe", "--tags", "--abbrev=0"], {
     cwd: projectRoot2,
     encoding: "utf8"
   });
@@ -6181,7 +6786,7 @@ function getLatestTag(projectRoot2) {
 }
 
 // src/metrics.ts
-import { spawnSync as spawnSync9 } from "node:child_process";
+import { spawnSync as spawnSync10 } from "node:child_process";
 function parseCommitStats(rawLog) {
   const lines = rawLog.split("\n").map((l) => l.trim()).filter(Boolean);
   const byAuthor = {};
@@ -6238,26 +6843,26 @@ function formatMetrics(stats, projectName) {
 function getMetricsGitLog(projectRoot2, since) {
   const args = ["log", "--no-merges", "--format=%as %an %s"];
   if (since) args.push(`--since=${since}`);
-  const result = spawnSync9("git", args, { cwd: projectRoot2, encoding: "utf8" });
+  const result = spawnSync10("git", args, { cwd: projectRoot2, encoding: "utf8" });
   if (result.status !== 0) return "";
   return result.stdout.trim();
 }
 
 // src/sync.ts
-import fs26 from "node:fs";
-import path27 from "node:path";
-import { spawnSync as spawnSync10 } from "node:child_process";
+import fs28 from "node:fs";
+import path29 from "node:path";
+import { spawnSync as spawnSync11 } from "node:child_process";
 function getSyncStatus(forgehiveDir2) {
-  const memDir = path27.join(forgehiveDir2, "memory");
-  const files = fs26.existsSync(memDir) ? fs26.readdirSync(memDir).filter((f) => f.endsWith(".md")).length : 0;
-  const projectRoot2 = path27.dirname(forgehiveDir2);
-  const configResult = spawnSync10(
+  const memDir = path29.join(forgehiveDir2, "memory");
+  const files = fs28.existsSync(memDir) ? fs28.readdirSync(memDir).filter((f) => f.endsWith(".md")).length : 0;
+  const projectRoot2 = path29.dirname(forgehiveDir2);
+  const configResult = spawnSync11(
     "git",
     ["config", "--get", "forgehive.sync-remote"],
     { cwd: projectRoot2, encoding: "utf8" }
   );
   const remote = configResult.status === 0 ? configResult.stdout.trim() : null;
-  const branchResult = spawnSync10(
+  const branchResult = spawnSync11(
     "git",
     ["config", "--get", "forgehive.sync-branch"],
     { cwd: projectRoot2, encoding: "utf8" }
@@ -6266,24 +6871,24 @@ function getSyncStatus(forgehiveDir2) {
   return { files, hasRemote: remote !== null, remote, branch };
 }
 function pushSync(forgehiveDir2, remote = "origin", branch = "forgehive-memory") {
-  const projectRoot2 = path27.dirname(forgehiveDir2);
-  const memDir = path27.join(forgehiveDir2, "memory");
-  if (!fs26.existsSync(memDir)) {
+  const projectRoot2 = path29.dirname(forgehiveDir2);
+  const memDir = path29.join(forgehiveDir2, "memory");
+  if (!fs28.existsSync(memDir)) {
     return { success: false, message: "Kein Memory-Verzeichnis gefunden.", filesCommitted: 0 };
   }
-  const files = fs26.readdirSync(memDir).filter((f) => f.endsWith(".md"));
+  const files = fs28.readdirSync(memDir).filter((f) => f.endsWith(".md"));
   if (files.length === 0) {
     return { success: false, message: "Keine Memory-Dateien gefunden.", filesCommitted: 0 };
   }
-  const addResult = spawnSync10(
+  const addResult = spawnSync11(
     "git",
-    ["add", path27.join(".forgehive", "memory")],
+    ["add", path29.join(".forgehive", "memory")],
     { cwd: projectRoot2, encoding: "utf8" }
   );
   if (addResult.status !== 0) {
     return { success: false, message: `git add failed: ${addResult.stderr}`, filesCommitted: 0 };
   }
-  const commitResult = spawnSync10(
+  const commitResult = spawnSync11(
     "git",
     ["commit", "-m", `chore: sync forgehive memory [${(/* @__PURE__ */ new Date()).toISOString()}]`],
     { cwd: projectRoot2, encoding: "utf8" }
@@ -6292,7 +6897,7 @@ function pushSync(forgehiveDir2, remote = "origin", branch = "forgehive-memory")
   if (!commitOk) {
     return { success: false, message: `git commit failed: ${commitResult.stderr}`, filesCommitted: 0 };
   }
-  const pushResult = spawnSync10(
+  const pushResult = spawnSync11(
     "git",
     ["push", remote, `HEAD:${branch}`],
     { cwd: projectRoot2, encoding: "utf8" }
@@ -6300,15 +6905,15 @@ function pushSync(forgehiveDir2, remote = "origin", branch = "forgehive-memory")
   if (pushResult.status !== 0) {
     return { success: false, message: `git push failed: ${pushResult.stderr}`, filesCommitted: 0 };
   }
-  spawnSync10("git", ["config", "forgehive.sync-remote", remote], { cwd: projectRoot2 });
-  spawnSync10("git", ["config", "forgehive.sync-branch", branch], { cwd: projectRoot2 });
+  spawnSync11("git", ["config", "forgehive.sync-remote", remote], { cwd: projectRoot2 });
+  spawnSync11("git", ["config", "forgehive.sync-branch", branch], { cwd: projectRoot2 });
   return { success: true, message: `Memory gepusht nach ${remote}/${branch}`, filesCommitted: files.length };
 }
 function pullSync(forgehiveDir2, remote = "origin", branch = "forgehive-memory") {
-  const projectRoot2 = path27.dirname(forgehiveDir2);
-  const memDir = path27.join(forgehiveDir2, "memory");
-  fs26.mkdirSync(memDir, { recursive: true });
-  const fetchResult = spawnSync10(
+  const projectRoot2 = path29.dirname(forgehiveDir2);
+  const memDir = path29.join(forgehiveDir2, "memory");
+  fs28.mkdirSync(memDir, { recursive: true });
+  const fetchResult = spawnSync11(
     "git",
     ["fetch", remote, branch],
     { cwd: projectRoot2, encoding: "utf8" }
@@ -6316,7 +6921,7 @@ function pullSync(forgehiveDir2, remote = "origin", branch = "forgehive-memory")
   if (fetchResult.status !== 0) {
     return { success: false, message: `git fetch failed: ${fetchResult.stderr}`, filesImported: [] };
   }
-  const listResult = spawnSync10(
+  const listResult = spawnSync11(
     "git",
     ["ls-tree", "--name-only", `${remote}/${branch}`, ".forgehive/memory/"],
     { cwd: projectRoot2, encoding: "utf8" }
@@ -6327,16 +6932,16 @@ function pullSync(forgehiveDir2, remote = "origin", branch = "forgehive-memory")
   const remoteFiles = listResult.stdout.trim().split("\n").filter(Boolean);
   const imported = [];
   for (const remotePath of remoteFiles) {
-    const filename = path27.basename(remotePath);
-    const localPath = path27.join(memDir, filename);
-    if (!fs26.existsSync(localPath)) {
-      const contentResult = spawnSync10(
+    const filename = path29.basename(remotePath);
+    const localPath = path29.join(memDir, filename);
+    if (!fs28.existsSync(localPath)) {
+      const contentResult = spawnSync11(
         "git",
         ["show", `${remote}/${branch}:${remotePath}`],
         { cwd: projectRoot2, encoding: "utf8" }
       );
       if (contentResult.status === 0) {
-        fs26.writeFileSync(localPath, contentResult.stdout, "utf8");
+        fs28.writeFileSync(localPath, contentResult.stdout, "utf8");
         imported.push(filename);
       }
     }
@@ -6349,8 +6954,8 @@ function pullSync(forgehiveDir2, remote = "origin", branch = "forgehive-memory")
 }
 
 // src/background.ts
-import fs27 from "node:fs";
-import path28 from "node:path";
+import fs29 from "node:fs";
+import path30 from "node:path";
 import { spawn } from "node:child_process";
 var AGENT_ROLES = {
   kai: "Senior Engineer \u2014 implements features and fixes bugs",
@@ -6397,23 +7002,23 @@ Instructions:
 Work autonomously. Do not ask for clarification \u2014 use your best judgment based on the issue description and codebase context.`;
 }
 function runBackgroundAgent(forgehiveDir2, issueUrl, agentId) {
-  const logsDir = path28.join(forgehiveDir2, "background-runs");
-  fs27.mkdirSync(logsDir, { recursive: true });
+  const logsDir = path30.join(forgehiveDir2, "background-runs");
+  fs29.mkdirSync(logsDir, { recursive: true });
   const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const logFile = path28.join(logsDir, `${agentId}-${timestamp2}.log`);
+  const logFile = path30.join(logsDir, `${agentId}-${timestamp2}.log`);
   const prompt = buildAgentPrompt(issueUrl, agentId);
-  const logStream = fs27.openSync(logFile, "w");
+  const logStream = fs29.openSync(logFile, "w");
   const child = spawn(
     "claude",
     ["-p", prompt, "--output-format", "text"],
     {
-      cwd: path28.dirname(forgehiveDir2),
+      cwd: path30.dirname(forgehiveDir2),
       detached: true,
       stdio: ["ignore", logStream, logStream]
     }
   );
   child.unref();
-  fs27.closeSync(logStream);
+  fs29.closeSync(logStream);
   return {
     pid: child.pid,
     logFile,
@@ -6423,11 +7028,11 @@ function runBackgroundAgent(forgehiveDir2, issueUrl, agentId) {
 
 // src/stories.ts
 init_js_yaml();
-import fs28 from "node:fs";
-import path29 from "node:path";
+import fs30 from "node:fs";
+import path31 from "node:path";
 function nextStoryId(storiesDir) {
-  if (!fs28.existsSync(storiesDir)) return "US-1";
-  const existing = fs28.readdirSync(storiesDir).filter((f) => f.match(/^US-\d+\.md$/)).map((f) => parseInt(f.replace("US-", "").replace(".md", ""), 10)).filter((n) => !isNaN(n));
+  if (!fs30.existsSync(storiesDir)) return "US-1";
+  const existing = fs30.readdirSync(storiesDir).filter((f) => f.match(/^US-\d+\.md$/)).map((f) => parseInt(f.replace("US-", "").replace(".md", ""), 10)).filter((n) => !isNaN(n));
   const max = existing.length > 0 ? Math.max(...existing) : 0;
   return `US-${max + 1}`;
 }
@@ -6459,7 +7064,7 @@ ${acLines || "- [ ] (noch nicht definiert)"}
 }
 function parseStoryFile(filePath) {
   try {
-    const content = fs28.readFileSync(filePath, "utf8");
+    const content = fs30.readFileSync(filePath, "utf8");
     const match = content.match(/^---\n([\s\S]*?)\n---/);
     if (!match) return null;
     const data = jsYaml.load(match[1]);
@@ -6479,7 +7084,7 @@ function parseStoryFile(filePath) {
   }
 }
 function createStory(storiesDir, title, epicId) {
-  fs28.mkdirSync(storiesDir, { recursive: true });
+  fs30.mkdirSync(storiesDir, { recursive: true });
   const id = nextStoryId(storiesDir);
   const story = {
     id,
@@ -6492,33 +7097,33 @@ function createStory(storiesDir, title, epicId) {
     epicId: epicId ?? null,
     status: "backlog"
   };
-  fs28.writeFileSync(path29.join(storiesDir, `${id}.md`), storyToMarkdown(story), "utf8");
+  fs30.writeFileSync(path31.join(storiesDir, `${id}.md`), storyToMarkdown(story), "utf8");
   return story;
 }
 function listStories(storiesDir) {
-  if (!fs28.existsSync(storiesDir)) return [];
-  return fs28.readdirSync(storiesDir).filter((f) => f.match(/^US-\d+\.md$/)).map((f) => parseStoryFile(path29.join(storiesDir, f))).filter((s) => s !== null).sort((a, b) => {
+  if (!fs30.existsSync(storiesDir)) return [];
+  return fs30.readdirSync(storiesDir).filter((f) => f.match(/^US-\d+\.md$/)).map((f) => parseStoryFile(path31.join(storiesDir, f))).filter((s) => s !== null).sort((a, b) => {
     const na = parseInt(a.id.replace("US-", ""), 10);
     const nb = parseInt(b.id.replace("US-", ""), 10);
     return na - nb;
   });
 }
 function getStory(storiesDir, id) {
-  const filePath = path29.join(storiesDir, `${id}.md`);
-  if (!fs28.existsSync(filePath)) return null;
+  const filePath = path31.join(storiesDir, `${id}.md`);
+  if (!fs30.existsSync(filePath)) return null;
   return parseStoryFile(filePath);
 }
 function updateStoryPoints(storiesDir, id, points) {
   const story = getStory(storiesDir, id);
   if (!story) throw new Error(`Story ${id} nicht gefunden`);
   story.points = points;
-  fs28.writeFileSync(path29.join(storiesDir, `${id}.md`), storyToMarkdown(story), "utf8");
+  fs30.writeFileSync(path31.join(storiesDir, `${id}.md`), storyToMarkdown(story), "utf8");
 }
 function updateStoryStatus(storiesDir, id, status) {
   const story = getStory(storiesDir, id);
   if (!story) throw new Error(`Story ${id} nicht gefunden`);
   story.status = status;
-  fs28.writeFileSync(path29.join(storiesDir, `${id}.md`), storyToMarkdown(story), "utf8");
+  fs30.writeFileSync(path31.join(storiesDir, `${id}.md`), storyToMarkdown(story), "utf8");
 }
 function formatStoryCard(story) {
   const points = story.points !== null ? ` \xB7 ${story.points} Punkte` : "";
@@ -6537,11 +7142,11 @@ function formatStoryCard(story) {
 
 // src/epics.ts
 init_js_yaml();
-import fs29 from "node:fs";
-import path30 from "node:path";
+import fs31 from "node:fs";
+import path32 from "node:path";
 function nextEpicId(epicsDir) {
-  if (!fs29.existsSync(epicsDir)) return "EPC-1";
-  const existing = fs29.readdirSync(epicsDir).filter((f) => f.match(/^EPC-\d+\.md$/)).map((f) => parseInt(f.replace("EPC-", "").replace(".md", ""), 10)).filter((n) => !isNaN(n));
+  if (!fs31.existsSync(epicsDir)) return "EPC-1";
+  const existing = fs31.readdirSync(epicsDir).filter((f) => f.match(/^EPC-\d+\.md$/)).map((f) => parseInt(f.replace("EPC-", "").replace(".md", ""), 10)).filter((n) => !isNaN(n));
   const max = existing.length > 0 ? Math.max(...existing) : 0;
   return `EPC-${max + 1}`;
 }
@@ -6569,7 +7174,7 @@ ${storyLines || "(noch keine Stories)"}
 }
 function parseEpicFile(filePath) {
   try {
-    const content = fs29.readFileSync(filePath, "utf8");
+    const content = fs31.readFileSync(filePath, "utf8");
     const match = content.match(/^---\n([\s\S]*?)\n---/);
     if (!match) return null;
     const data = jsYaml.load(match[1]);
@@ -6586,23 +7191,23 @@ function parseEpicFile(filePath) {
   }
 }
 function createEpic(epicsDir, title, goal, prdId) {
-  fs29.mkdirSync(epicsDir, { recursive: true });
+  fs31.mkdirSync(epicsDir, { recursive: true });
   const id = nextEpicId(epicsDir);
   const epic = { id, title, goal: goal ?? "", stories: [], status: "active", prdId: prdId ?? null };
-  fs29.writeFileSync(path30.join(epicsDir, `${id}.md`), epicToMarkdown(epic), "utf8");
+  fs31.writeFileSync(path32.join(epicsDir, `${id}.md`), epicToMarkdown(epic), "utf8");
   return epic;
 }
 function listEpics(epicsDir) {
-  if (!fs29.existsSync(epicsDir)) return [];
-  return fs29.readdirSync(epicsDir).filter((f) => f.match(/^EPC-\d+\.md$/)).map((f) => parseEpicFile(path30.join(epicsDir, f))).filter((e) => e !== null).sort((a, b) => {
+  if (!fs31.existsSync(epicsDir)) return [];
+  return fs31.readdirSync(epicsDir).filter((f) => f.match(/^EPC-\d+\.md$/)).map((f) => parseEpicFile(path32.join(epicsDir, f))).filter((e) => e !== null).sort((a, b) => {
     const na = parseInt(a.id.replace("EPC-", ""), 10);
     const nb = parseInt(b.id.replace("EPC-", ""), 10);
     return na - nb;
   });
 }
 function getEpic(epicsDir, id) {
-  const filePath = path30.join(epicsDir, `${id}.md`);
-  if (!fs29.existsSync(filePath)) return null;
+  const filePath = path32.join(epicsDir, `${id}.md`);
+  if (!fs31.existsSync(filePath)) return null;
   return parseEpicFile(filePath);
 }
 function formatEpicCard(epic, stories) {
@@ -6626,14 +7231,14 @@ function formatEpicCard(epic, stories) {
 
 // src/product.ts
 init_js_yaml();
-import fs30 from "node:fs";
-import path31 from "node:path";
+import fs32 from "node:fs";
+import path33 from "node:path";
 function slugify2(title) {
   return title.toLowerCase().replace(/[^a-z0-9\s-]/g, "").trim().replace(/\s+/g, "-");
 }
 function nextPrdId(prdsDir) {
-  if (!fs30.existsSync(prdsDir)) return "PRD-1";
-  const existing = fs30.readdirSync(prdsDir).filter((f) => f.endsWith(".md")).map((f) => parsePrdFile(path31.join(prdsDir, f))).filter((p) => p !== null).map((p) => parseInt(p.id.replace("PRD-", ""), 10)).filter((n) => !isNaN(n));
+  if (!fs32.existsSync(prdsDir)) return "PRD-1";
+  const existing = fs32.readdirSync(prdsDir).filter((f) => f.endsWith(".md")).map((f) => parsePrdFile(path33.join(prdsDir, f))).filter((p) => p !== null).map((p) => parseInt(p.id.replace("PRD-", ""), 10)).filter((n) => !isNaN(n));
   const max = existing.length > 0 ? Math.max(...existing) : 0;
   return `PRD-${max + 1}`;
 }
@@ -6671,7 +7276,7 @@ ${frontmatter}---
 }
 function parsePrdFile(filePath) {
   try {
-    const content = fs30.readFileSync(filePath, "utf8");
+    const content = fs32.readFileSync(filePath, "utf8");
     const match = content.match(/^---\n([\s\S]*?)\n---/);
     if (!match) return null;
     const data = jsYaml.load(match[1]);
@@ -6688,37 +7293,37 @@ function parsePrdFile(filePath) {
   }
 }
 function createPrd(prdsDir, title) {
-  fs30.mkdirSync(prdsDir, { recursive: true });
+  fs32.mkdirSync(prdsDir, { recursive: true });
   const id = nextPrdId(prdsDir);
   const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const slug = slugify2(title);
   const filename = `${today}-${slug}.md`;
-  const filepath = path31.join(prdsDir, filename);
+  const filepath = path33.join(prdsDir, filename);
   const prd = { id, title, date: today, status: "draft", filepath };
-  fs30.writeFileSync(filepath, prdToMarkdown(prd), "utf8");
+  fs32.writeFileSync(filepath, prdToMarkdown(prd), "utf8");
   return prd;
 }
 function listPrds(prdsDir) {
-  if (!fs30.existsSync(prdsDir)) return [];
-  return fs30.readdirSync(prdsDir).filter((f) => f.endsWith(".md")).map((f) => parsePrdFile(path31.join(prdsDir, f))).filter((p) => p !== null && /^PRD-\d+$/.test(p.id)).sort((a, b) => {
+  if (!fs32.existsSync(prdsDir)) return [];
+  return fs32.readdirSync(prdsDir).filter((f) => f.endsWith(".md")).map((f) => parsePrdFile(path33.join(prdsDir, f))).filter((p) => p !== null && /^PRD-\d+$/.test(p.id)).sort((a, b) => {
     const na = parseInt(a.id.replace("PRD-", ""), 10);
     const nb = parseInt(b.id.replace("PRD-", ""), 10);
     return na - nb;
   });
 }
 function getPrd(prdsDir, id) {
-  if (!fs30.existsSync(prdsDir)) return null;
-  const files = fs30.readdirSync(prdsDir).filter((f) => f.endsWith(".md"));
+  if (!fs32.existsSync(prdsDir)) return null;
+  const files = fs32.readdirSync(prdsDir).filter((f) => f.endsWith(".md"));
   for (const f of files) {
-    const prd = parsePrdFile(path31.join(prdsDir, f));
+    const prd = parsePrdFile(path33.join(prdsDir, f));
     if (prd && prd.id === id) return prd;
   }
   return null;
 }
 function generateRoadmap(forgehiveDir2) {
-  const prdsDir = path31.join(forgehiveDir2, "memory", "prds");
-  const epicsDir = path31.join(forgehiveDir2, "memory", "epics");
-  const storiesDir = path31.join(forgehiveDir2, "memory", "stories");
+  const prdsDir = path33.join(forgehiveDir2, "memory", "prds");
+  const epicsDir = path33.join(forgehiveDir2, "memory", "epics");
+  const storiesDir = path33.join(forgehiveDir2, "memory", "stories");
   const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const prds = listPrds(prdsDir);
   const epics = listEpics(epicsDir);
@@ -6788,24 +7393,24 @@ function generateRoadmap(forgehiveDir2) {
 }
 
 // src/velocity.ts
-import fs31 from "node:fs";
-import path32 from "node:path";
+import fs33 from "node:fs";
+import path34 from "node:path";
 var HEADER = "# Sprint Velocity\n\n| Sprint | Datum | Committed | Delivered | Rate |\n|---|---|---|---|---|\n";
 function recordVelocity(velocityFile, sprint, committed, delivered) {
   const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const rate = committed > 0 ? Math.round(delivered / committed * 100) : 0;
   const row = `| Sprint ${sprint} | ${date} | ${committed} | ${delivered} | ${rate}% |
 `;
-  if (!fs31.existsSync(velocityFile)) {
-    fs31.mkdirSync(path32.dirname(velocityFile), { recursive: true });
-    fs31.writeFileSync(velocityFile, HEADER + row, "utf8");
+  if (!fs33.existsSync(velocityFile)) {
+    fs33.mkdirSync(path34.dirname(velocityFile), { recursive: true });
+    fs33.writeFileSync(velocityFile, HEADER + row, "utf8");
   } else {
-    fs31.appendFileSync(velocityFile, row, "utf8");
+    fs33.appendFileSync(velocityFile, row, "utf8");
   }
 }
 function getVelocityHistory(velocityFile) {
-  if (!fs31.existsSync(velocityFile)) return [];
-  const content = fs31.readFileSync(velocityFile, "utf8");
+  if (!fs33.existsSync(velocityFile)) return [];
+  const content = fs33.readFileSync(velocityFile, "utf8");
   const rows = content.split("\n").filter((l) => l.startsWith("| Sprint "));
   return rows.map((row) => {
     const cells = row.split("|").map((c) => c.trim()).filter(Boolean);
@@ -6846,9 +7451,9 @@ function formatVelocityReport(history) {
 
 // src/docs.ts
 init_js_yaml();
-import fs32 from "node:fs";
-import path33 from "node:path";
-import { spawnSync as spawnSync11 } from "node:child_process";
+import fs34 from "node:fs";
+import path35 from "node:path";
+import { spawnSync as spawnSync12 } from "node:child_process";
 var SOURCE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".py", ".go"];
 var IGNORE_DIRS4 = ["node_modules", ".git", "dist", ".forgehive", "coverage", ".next", "build", "test", "__tests__", "spec"];
 var EXPORT_PATTERNS2 = [
@@ -6858,10 +7463,10 @@ var EXPORT_PATTERNS2 = [
   /^export\s+default\s+(?:function\s+)?(\w+)?/gm
 ];
 function readCapabilities2(forgehiveDir2) {
-  const capPath = path33.join(forgehiveDir2, "capabilities.yaml");
-  if (!fs32.existsSync(capPath)) return {};
+  const capPath = path35.join(forgehiveDir2, "capabilities.yaml");
+  if (!fs34.existsSync(capPath)) return {};
   try {
-    return jsYaml.load(fs32.readFileSync(capPath, "utf8")) ?? {};
+    return jsYaml.load(fs34.readFileSync(capPath, "utf8")) ?? {};
   } catch {
     return {};
   }
@@ -6888,16 +7493,16 @@ function extractCapabilityInfo(caps) {
   return { language, packageManager };
 }
 function readMemoryFiles2(forgehiveDir2) {
-  const memDir = path33.join(forgehiveDir2, "memory");
-  if (!fs32.existsSync(memDir)) return {};
+  const memDir = path35.join(forgehiveDir2, "memory");
+  if (!fs34.existsSync(memDir)) return {};
   const result = {};
-  for (const f of fs32.readdirSync(memDir).filter((f2) => f2.endsWith(".md") && f2 !== "MEMORY.md")) {
-    result[f] = fs32.readFileSync(path33.join(memDir, f), "utf8");
+  for (const f of fs34.readdirSync(memDir).filter((f2) => f2.endsWith(".md") && f2 !== "MEMORY.md")) {
+    result[f] = fs34.readFileSync(path35.join(memDir, f), "utf8");
   }
   return result;
 }
 function getRecentCommits2(projectRoot2, n = 10) {
-  const result = spawnSync11("git", ["log", "--oneline", `-${n}`], { cwd: projectRoot2, encoding: "utf8" });
+  const result = spawnSync12("git", ["log", "--oneline", `-${n}`], { cwd: projectRoot2, encoding: "utf8" });
   if (result.status !== 0) return [];
   return result.stdout.trim().split("\n").filter(Boolean);
 }
@@ -6915,19 +7520,19 @@ function extractExports(content) {
 function walkSourceFiles(dir) {
   const results = [];
   function walk(current) {
-    if (!fs32.existsSync(current)) return;
-    for (const entry of fs32.readdirSync(current, { withFileTypes: true })) {
+    if (!fs34.existsSync(current)) return;
+    for (const entry of fs34.readdirSync(current, { withFileTypes: true })) {
       if (IGNORE_DIRS4.includes(entry.name)) continue;
-      const full = path33.join(current, entry.name);
+      const full = path35.join(current, entry.name);
       if (entry.isDirectory()) walk(full);
-      else if (entry.isFile() && SOURCE_EXTS.includes(path33.extname(entry.name))) results.push(full);
+      else if (entry.isFile() && SOURCE_EXTS.includes(path35.extname(entry.name))) results.push(full);
     }
   }
   walk(dir);
   return results;
 }
 function generateUserGuide(projectRoot2, forgehiveDir2) {
-  const projectName = path33.basename(projectRoot2);
+  const projectName = path35.basename(projectRoot2);
   const caps = readCapabilities2(forgehiveDir2);
   const { language: lang, packageManager, entryPoints } = extractCapabilityInfo(caps);
   const memFiles = readMemoryFiles2(forgehiveDir2);
@@ -7006,8 +7611,8 @@ function generateUserGuide(projectRoot2, forgehiveDir2) {
   return lines.join("\n");
 }
 function generateApiReference(projectRoot2) {
-  const srcDir = path33.join(projectRoot2, "src");
-  const searchDir = fs32.existsSync(srcDir) ? srcDir : projectRoot2;
+  const srcDir = path35.join(projectRoot2, "src");
+  const searchDir = fs34.existsSync(srcDir) ? srcDir : projectRoot2;
   const files = walkSourceFiles(searchDir);
   const lines = [];
   lines.push("# API Reference");
@@ -7021,13 +7626,13 @@ function generateApiReference(projectRoot2) {
   for (const filePath of files) {
     let content = "";
     try {
-      content = fs32.readFileSync(filePath, "utf8");
+      content = fs34.readFileSync(filePath, "utf8");
     } catch {
       continue;
     }
     const exports = extractExports(content);
     if (exports.length === 0) continue;
-    const relPath = path33.relative(projectRoot2, filePath);
+    const relPath = path35.relative(projectRoot2, filePath);
     lines.push(`## \`${relPath}\``);
     lines.push("");
     lines.push("**Exports:**");
@@ -7039,23 +7644,23 @@ function generateApiReference(projectRoot2) {
 }
 function listExistingDocs(projectRoot2) {
   const docs = [];
-  const docsDir = path33.join(projectRoot2, "docs");
-  if (fs32.existsSync(docsDir)) {
-    for (const f of fs32.readdirSync(docsDir)) {
-      if (f.endsWith(".md")) docs.push(path33.join(docsDir, f));
+  const docsDir = path35.join(projectRoot2, "docs");
+  if (fs34.existsSync(docsDir)) {
+    for (const f of fs34.readdirSync(docsDir)) {
+      if (f.endsWith(".md")) docs.push(path35.join(docsDir, f));
     }
   }
   const rootDocs = ["README.md", "CHANGELOG.md", "ONBOARDING.md", "CONTRIBUTING.md"];
   for (const f of rootDocs) {
-    const full = path33.join(projectRoot2, f);
-    if (fs32.existsSync(full)) docs.push(full);
+    const full = path35.join(projectRoot2, f);
+    if (fs34.existsSync(full)) docs.push(full);
   }
   return docs;
 }
 
 // src/router.ts
-import fs33 from "node:fs";
-import path34 from "node:path";
+import fs35 from "node:fs";
+import path36 from "node:path";
 var AGENT_KEYWORDS = {
   vera: ["security", "auth", "vulnerability", "owasp", "cve", "gdpr", "compliance", "penetration", "exploit"],
   sam: ["test", "coverage", "qa", "quality", "spec", "regression", "fixture", "assertion", "e2e"],
@@ -7164,9 +7769,9 @@ function routeTask(task) {
 }
 function resolveWorktreePath(forgehiveDir2, agent) {
   if (!agent) return void 0;
-  const worktreeFile = path34.join(forgehiveDir2, "agents", agent, "worktree");
-  if (fs33.existsSync(worktreeFile)) {
-    return fs33.readFileSync(worktreeFile, "utf8").trim();
+  const worktreeFile = path36.join(forgehiveDir2, "agents", agent, "worktree");
+  if (fs35.existsSync(worktreeFile)) {
+    return fs35.readFileSync(worktreeFile, "utf8").trim();
   }
   return void 0;
 }
@@ -7195,17 +7800,18 @@ function formatRoutingResult(result, worktreePath) {
 
 // src/github.ts
 init_js_yaml();
-import fs34 from "node:fs";
-import path35 from "node:path";
+import fs36 from "node:fs";
+import path37 from "node:path";
 import https from "node:https";
+import { spawnSync as spawnSync13 } from "node:child_process";
 function loadGitHubConfig(forgehiveDir2) {
-  const configPath = path35.join(forgehiveDir2, "github.yaml");
-  if (!fs34.existsSync(configPath)) {
+  const configPath = path37.join(forgehiveDir2, "github.yaml");
+  if (!fs36.existsSync(configPath)) {
     throw new Error("Nicht konfiguriert. F\xFChre zuerst aus: fh github setup");
   }
   let parsed;
   try {
-    parsed = jsYaml.load(fs34.readFileSync(configPath, "utf8"));
+    parsed = jsYaml.load(fs36.readFileSync(configPath, "utf8"));
   } catch {
     throw new Error("Ung\xFCltige Konfigurationsdatei: .forgehive/github.yaml ist kein g\xFCltiges YAML.");
   }
@@ -7219,9 +7825,9 @@ function loadGitHubConfig(forgehiveDir2) {
   return { repo: data.repo };
 }
 function saveGitHubConfig(forgehiveDir2, config) {
-  fs34.mkdirSync(forgehiveDir2, { recursive: true });
-  const configPath = path35.join(forgehiveDir2, "github.yaml");
-  fs34.writeFileSync(configPath, jsYaml.dump({ repo: config.repo }), "utf8");
+  fs36.mkdirSync(forgehiveDir2, { recursive: true });
+  const configPath = path37.join(forgehiveDir2, "github.yaml");
+  fs36.writeFileSync(configPath, jsYaml.dump({ repo: config.repo }), "utf8");
 }
 function githubGet(apiPath, token) {
   return new Promise((resolve, reject) => {
@@ -7303,22 +7909,22 @@ async function fetchPRFiles(owner, repo, number, token) {
   return files;
 }
 function issueAlreadySynced(storiesDir, issueNumber) {
-  if (!fs34.existsSync(storiesDir)) return false;
+  if (!fs36.existsSync(storiesDir)) return false;
   const pattern = new RegExp(`GitHub: #${issueNumber}(?![\\d\\w])`);
-  return fs34.readdirSync(storiesDir).filter((f) => f.endsWith(".md")).some((f) => pattern.test(fs34.readFileSync(path35.join(storiesDir, f), "utf8")));
+  return fs36.readdirSync(storiesDir).filter((f) => f.endsWith(".md")).some((f) => pattern.test(fs36.readFileSync(path37.join(storiesDir, f), "utf8")));
 }
 function appendGitHubRef(storiesDir, storyId, issue, repoFullName) {
-  const filePath = path35.join(storiesDir, `${storyId}.md`);
-  if (!fs34.existsSync(filePath)) {
+  const filePath = path37.join(storiesDir, `${storyId}.md`);
+  if (!fs36.existsSync(filePath)) {
     throw new Error(`Story-Datei nicht gefunden: ${storyId}.md`);
   }
-  const existing = fs34.readFileSync(filePath, "utf8");
+  const existing = fs36.readFileSync(filePath, "utf8");
   const ref = `
 ## GitHub
 
 GitHub: #${issue.number} \u2014 ${issue.html_url}
 `;
-  fs34.writeFileSync(filePath, existing.trimEnd() + "\n" + ref, "utf8");
+  fs36.writeFileSync(filePath, existing.trimEnd() + "\n" + ref, "utf8");
 }
 function formatPRContext(pr, files, repoFullName) {
   const body = pr.body?.trim() || "(keine Beschreibung)";
@@ -7339,6 +7945,381 @@ function formatPRContext(pr, files, repoFullName) {
     fileLines || "(keine Dateien)"
   ].join("\n");
 }
+async function fetchOpenPRs(owner, repo, token) {
+  const prs = [];
+  let page = 1;
+  while (true) {
+    const batch = await githubGet(
+      `/repos/${owner}/${repo}/pulls?state=open&per_page=100&page=${page}`,
+      token
+    );
+    if (batch.length === 0) break;
+    prs.push(...batch);
+    if (batch.length < 100) break;
+    page++;
+  }
+  return prs.map((pr) => pr.number);
+}
+function createPR(branch, title, body) {
+  const result = spawnSync13(
+    "gh",
+    ["pr", "create", "--title", title, "--body", body, "--head", branch],
+    { encoding: "utf8" }
+  );
+  if (result.status !== 0) {
+    throw new Error(`gh pr create fehlgeschlagen: ${result.stderr?.trim() ?? "unbekannter Fehler"}`);
+  }
+  return result.stdout.trim();
+}
+
+// src/autonomous.ts
+init_js_yaml();
+import fs38 from "node:fs";
+import path39 from "node:path";
+import { spawnSync as spawnSync14 } from "node:child_process";
+import { createInterface } from "node:readline";
+
+// src/prompt-builder.ts
+import fs37 from "node:fs";
+import path38 from "node:path";
+function buildPlanningPrompt(storyContent, capabilitiesPath, forgehiveDir2) {
+  const capabilities = fs37.existsSync(capabilitiesPath) ? fs37.readFileSync(capabilitiesPath, "utf8") : "";
+  const feedbackPath = path38.join(forgehiveDir2, "memory", "feedback.md");
+  const projectPath = path38.join(forgehiveDir2, "memory", "project.md");
+  const memory = [feedbackPath, projectPath].filter((p) => fs37.existsSync(p)).map((p) => fs37.readFileSync(p, "utf8")).join("\n\n");
+  return [
+    "Du bist ein Planungs-Agent. Produziere einen Implementierungsplan als Markdown.",
+    "",
+    "## Story",
+    storyContent,
+    "",
+    "## Stack",
+    capabilities,
+    ...memory ? ["", "## Memory", memory] : [],
+    "",
+    "## Ausgabeformat",
+    "### Files",
+    "(Liste der zu \xE4ndernden/erstellenden Dateipfade, einer pro Zeile)",
+    "### Ansatz",
+    "(2-3 S\xE4tze Beschreibung des Vorgehens)",
+    "### Tests",
+    "(Liste der erwarteten Tests die danach gr\xFCn sein m\xFCssen)"
+  ].join("\n");
+}
+function buildImplementationPrompt(storyContent, planContent, capabilitiesPath, forgehiveDir2) {
+  const capabilities = fs37.existsSync(capabilitiesPath) ? fs37.readFileSync(capabilitiesPath, "utf8") : "";
+  const skillsDir = path38.join(forgehiveDir2, "skills", "expert");
+  const skills = fs37.existsSync(skillsDir) ? fs37.readdirSync(skillsDir).filter((f) => f.endsWith(".md")).slice(0, 3).map((f) => fs37.readFileSync(path38.join(skillsDir, f), "utf8")).join("\n\n---\n\n") : "";
+  return [
+    "Du bist Kai, Senior Software Engineer. Implementiere den folgenden Plan.",
+    "Erstelle einen git-Commit wenn du fertig bist.",
+    "\xC4ndere NUR die Dateien die im Plan aufgelistet sind.",
+    "",
+    "## Story",
+    storyContent,
+    "",
+    "## Plan",
+    planContent,
+    "",
+    "## Stack",
+    capabilities,
+    ...skills ? ["", "## Skills", skills] : []
+  ].join("\n");
+}
+function buildEscalationPrompt(planContent, diff, testError) {
+  return [
+    "Du bist Sam, QA Architect. Kai hat versucht den Plan umzusetzen aber die Tests schlagen fehl.",
+    "Analysiere was schiefgelaufen ist und produziere einen minimalen Fix.",
+    "Kein neuer Plan \u2014 nur der Fix. Committe danach.",
+    "",
+    "## Originaler Plan",
+    planContent,
+    "",
+    "## Was produziert wurde (git diff)",
+    diff,
+    "",
+    "## Test-Fehler",
+    testError
+  ].join("\n");
+}
+
+// src/autonomous.ts
+function generateRunId() {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return `run-${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+}
+function getRunDir(forgehiveDir2, runId) {
+  return path39.join(forgehiveDir2, "runs", runId);
+}
+function saveRunState(forgehiveDir2, state) {
+  const runDir = getRunDir(forgehiveDir2, state.runId);
+  fs38.mkdirSync(runDir, { recursive: true });
+  fs38.writeFileSync(path39.join(runDir, "state.yaml"), jsYaml.dump(state), "utf8");
+}
+function loadRunState(forgehiveDir2, runId) {
+  const statePath = path39.join(getRunDir(forgehiveDir2, runId), "state.yaml");
+  if (!fs38.existsSync(statePath)) {
+    throw new Error(`Run ${runId} nicht gefunden`);
+  }
+  return jsYaml.load(fs38.readFileSync(statePath, "utf8"));
+}
+function listRuns(forgehiveDir2) {
+  const runsDir = path39.join(forgehiveDir2, "runs");
+  if (!fs38.existsSync(runsDir)) return [];
+  return fs38.readdirSync(runsDir).filter((d) => d.startsWith("run-")).sort().reverse().map((d) => {
+    try {
+      return loadRunState(forgehiveDir2, d);
+    } catch {
+      return null;
+    }
+  }).filter((s) => s !== null);
+}
+function nextPhase(current, ctx) {
+  switch (current) {
+    case "analyzing":
+      return "planning";
+    case "planning":
+      return "gate-1";
+    case "gate-1":
+      return "implementing";
+    case "implementing":
+      return "testing";
+    case "testing":
+      if (ctx.testsPassed) return "gate-2";
+      return ctx.attempts >= 2 ? "gate-stuck" : "escalating";
+    case "escalating":
+      return "testing";
+    case "gate-2":
+      return "pr-creating";
+    case "pr-creating":
+      return "done";
+    default:
+      return current;
+  }
+}
+function generateBranchName(entryPoint) {
+  if (/^US-\d+$/.test(entryPoint)) return `feat/${entryPoint}`;
+  const slug = entryPoint.toLowerCase().replace(/[^a-z0-9\s-]/g, "").trim().replace(/\s+/g, "-").slice(0, 40).replace(/-+$/, "");
+  return `feat/${slug}`;
+}
+function shouldSkipGate(phase, auto) {
+  if (phase === "gate-stuck") return false;
+  return auto && (phase === "gate-1" || phase === "gate-2");
+}
+function formatRunStatus(state) {
+  const lines = [
+    "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    `fh auto \u203A ${state.entryPoint} \u203A ${state.status}`,
+    `Run-ID: ${state.runId}`,
+    `Branch: ${state.branch}`,
+    `Agent:  ${state.agent}`,
+    `Start:  ${state.startedAt}`,
+    "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"
+  ];
+  return lines.join("\n");
+}
+async function promptUser(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function runClaudeP(prompt) {
+  const result = spawnSync14("claude", ["-p", prompt], { encoding: "utf8", maxBuffer: 10 * 1024 * 1024 });
+  return {
+    stdout: result.stdout ?? "",
+    success: result.status === 0
+  };
+}
+function getTestCmd(forgehiveDir2) {
+  const capPath = path39.join(forgehiveDir2, "capabilities.yaml");
+  if (!fs38.existsSync(capPath)) return "npm test";
+  try {
+    const caps = jsYaml.load(fs38.readFileSync(capPath, "utf8"));
+    return caps?.testCmd ?? "npm test";
+  } catch {
+    return "npm test";
+  }
+}
+function getDiff(projectRoot2) {
+  const result = spawnSync14("git", ["diff", "HEAD"], { cwd: projectRoot2, encoding: "utf8" });
+  return result.stdout ?? "";
+}
+async function startRun(entryPoint, forgehiveDir2, projectRoot2, auto) {
+  const runId = generateRunId();
+  const capPath = path39.join(forgehiveDir2, "capabilities.yaml");
+  let storyContent;
+  if (/^US-\d+$/.test(entryPoint)) {
+    const storiesDir = path39.join(forgehiveDir2, "memory", "stories");
+    const story = getStory(storiesDir, entryPoint);
+    storyContent = story ? `${story.id}: ${story.title}` : entryPoint;
+  } else {
+    const storiesDir = path39.join(forgehiveDir2, "memory", "stories");
+    fs38.mkdirSync(storiesDir, { recursive: true });
+    const story = createStory(storiesDir, entryPoint);
+    storyContent = `${story.id}: ${story.title}`;
+    entryPoint = story.id;
+  }
+  const routing = routeTask(storyContent);
+  const agent = routing.type === "agent" ? routing.agent ?? "kai" : "kai";
+  const branch = generateBranchName(entryPoint);
+  const state = {
+    runId,
+    entryPoint,
+    status: "planning",
+    agent,
+    branch,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    attempts: 0,
+    auto
+  };
+  saveRunState(forgehiveDir2, state);
+  await executeRun(state, storyContent, forgehiveDir2, projectRoot2, capPath);
+}
+async function resumeRun(runId, forgehiveDir2, projectRoot2) {
+  const state = loadRunState(forgehiveDir2, runId);
+  const capPath = path39.join(forgehiveDir2, "capabilities.yaml");
+  const storyContent = state.entryPoint;
+  await executeRun(state, storyContent, forgehiveDir2, projectRoot2, capPath);
+}
+async function executeRun(state, storyContent, forgehiveDir2, projectRoot2, capPath) {
+  const runDir = path39.join(forgehiveDir2, "runs", state.runId);
+  if (state.status === "planning") {
+    console.log(`
+[fh auto] Planning...`);
+    const planPrompt = buildPlanningPrompt(storyContent, capPath, forgehiveDir2);
+    const { stdout: planMd } = runClaudeP(planPrompt);
+    fs38.writeFileSync(path39.join(runDir, "plan.md"), planMd, "utf8");
+    state.status = "gate-1";
+    saveRunState(forgehiveDir2, state);
+  }
+  if (state.status === "gate-1") {
+    const planMd = fs38.readFileSync(path39.join(runDir, "plan.md"), "utf8");
+    if (!shouldSkipGate("gate-1", state.auto)) {
+      console.log(`
+\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+      console.log(`fh auto \u203A ${state.entryPoint} \u203A Plan bereit`);
+      console.log(`\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+      console.log(planMd);
+      const answer = await promptUser("Fortfahren? [j / n / anpassen: <freitext>]\n> ");
+      if (answer.toLowerCase() === "n") {
+        console.log("Abgebrochen.");
+        return;
+      }
+      if (answer.toLowerCase() !== "j" && answer.toLowerCase() !== "ja") {
+        const revisedPrompt = buildPlanningPrompt(
+          `${storyContent}
+
+Feedback: ${answer}`,
+          capPath,
+          forgehiveDir2
+        );
+        const { stdout: revisedPlan } = runClaudeP(revisedPrompt);
+        fs38.writeFileSync(path39.join(runDir, "plan.md"), revisedPlan, "utf8");
+      }
+    }
+    state.status = "implementing";
+    saveRunState(forgehiveDir2, state);
+  }
+  if (state.status === "implementing") {
+    console.log(`
+[fh auto] Implementing (${state.agent})...`);
+    const planMd = fs38.readFileSync(path39.join(runDir, "plan.md"), "utf8");
+    const implPrompt = buildImplementationPrompt(storyContent, planMd, capPath, forgehiveDir2);
+    const branchResult = spawnSync14("git", ["checkout", "-b", state.branch], { cwd: projectRoot2, encoding: "utf8" });
+    if (branchResult.status !== 0) {
+      spawnSync14("git", ["checkout", state.branch], { cwd: projectRoot2, encoding: "utf8" });
+    }
+    runClaudeP(implPrompt);
+    state.status = "testing";
+    state.attempts += 1;
+    saveRunState(forgehiveDir2, state);
+  }
+  if (state.status === "testing") {
+    console.log(`
+[fh auto] Running tests...`);
+    const testCmd = getTestCmd(forgehiveDir2);
+    const [cmd, ...args] = testCmd.split(" ");
+    const testResult = spawnSync14(cmd, args, { cwd: projectRoot2, encoding: "utf8" });
+    const testsPassed = testResult.status === 0;
+    const ctx = { testsPassed, attempts: state.attempts };
+    state.status = nextPhase("testing", ctx);
+    saveRunState(forgehiveDir2, state);
+    if (!testsPassed && state.status === "escalating") {
+      console.log(`
+[fh auto] Tests failed. Escalating to Sam...`);
+      const planMd = fs38.readFileSync(path39.join(runDir, "plan.md"), "utf8");
+      const diff = getDiff(projectRoot2);
+      const escalationPrompt = buildEscalationPrompt(planMd, diff, testResult.stdout + testResult.stderr);
+      runClaudeP(escalationPrompt);
+      state.status = "testing";
+      state.attempts += 1;
+      saveRunState(forgehiveDir2, state);
+      const retestResult = spawnSync14(cmd, args, { cwd: projectRoot2, encoding: "utf8" });
+      const retestPassed = retestResult.status === 0;
+      state.status = nextPhase("testing", { testsPassed: retestPassed, attempts: state.attempts });
+      saveRunState(forgehiveDir2, state);
+      if (!retestPassed && state.status === "gate-stuck") {
+        const diff2 = getDiff(projectRoot2);
+        fs38.writeFileSync(path39.join(runDir, "diff.patch"), diff2, "utf8");
+        console.log(`
+\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+        console.log(`fh auto \u203A ${state.entryPoint} \u203A Stuck nach 2 Versuchen`);
+        console.log(`\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+        console.log(`\u2717 ${retestResult.stderr?.trim().split("\n")[0] ?? "Tests fehlgeschlagen"}`);
+        console.log(`
+Diff: ${path39.join(forgehiveDir2, "runs", state.runId, "diff.patch")}`);
+        console.log(`Run pausiert. Wenn du bereit bist:
+  fh auto resume ${state.runId}`);
+        return;
+      }
+    }
+  }
+  if (state.status === "gate-2") {
+    const diff = getDiff(projectRoot2);
+    fs38.writeFileSync(path39.join(runDir, "diff.patch"), diff, "utf8");
+    const additions = (diff.match(/^\+[^+]/mg) ?? []).length;
+    const deletions = (diff.match(/^-[^-]/mg) ?? []).length;
+    if (!shouldSkipGate("gate-2", state.auto)) {
+      console.log(`
+\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+      console.log(`fh auto \u203A ${state.entryPoint} \u203A Tests gr\xFCn`);
+      console.log(`\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+      console.log(`\u2713 Tests passing`);
+      console.log(`Branch: ${state.branch}`);
+      console.log(`Diff:   +${additions} / -${deletions} Zeilen`);
+      const answer = await promptUser("\nPR erstellen? [j / n]\n> ");
+      if (answer.toLowerCase() === "n") {
+        console.log("Branch behalten. Kein PR erstellt.");
+        return;
+      }
+    }
+    state.status = "pr-creating";
+    saveRunState(forgehiveDir2, state);
+  }
+  if (state.status === "pr-creating") {
+    console.log(`
+[fh auto] Creating PR...`);
+    const planMd = fs38.readFileSync(path39.join(runDir, "plan.md"), "utf8");
+    try {
+      spawnSync14("git", ["push", "-u", "origin", state.branch], { cwd: projectRoot2, encoding: "utf8" });
+      const prUrl = createPR(state.branch, `${state.entryPoint}: ${storyContent}`, planMd);
+      state.status = "done";
+      saveRunState(forgehiveDir2, state);
+      console.log(`
+\u2713 PR erstellt: ${prUrl}`);
+    } catch (e) {
+      console.warn(`PR konnte nicht erstellt werden: ${e.message}`);
+      console.warn("Branch ist lokal verf\xFCgbar. Erstelle den PR manuell.");
+      state.status = "done";
+      saveRunState(forgehiveDir2, state);
+    }
+  }
+}
 
 // src/cli.ts
 import { createRequire } from "node:module";
@@ -7346,7 +8327,7 @@ var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
 var [, , command, subcommand, ...rest] = process.argv;
 var projectRoot = process.cwd();
-var forgehiveDir = path36.join(projectRoot, ".forgehive");
+var forgehiveDir = path40.join(projectRoot, ".forgehive");
 if (command === "--version" || command === "-v") {
   console.log(version);
   process.exit(0);
@@ -7362,7 +8343,15 @@ SETUP
   fh init [--yes]                  Set up forgehive in the current project
   fh confirm                       Activate capabilities (draft \u2192 confirmed)
   fh rollback                      Remove forgehive from the project
+  fh auto <US-N|text>              Autonomer Pipeline-Run (plan \u2192 implement \u2192 test \u2192 PR)
+  fh auto --auto <US-N|text>       Ohne Gates (CI/overnight)
+  fh auto resume <run-id>          Unterbrochenen Run fortsetzen
+  fh auto status                   Aktive und letzte Runs
+  fh auto list                     Alle Runs auflisten
+
   fh status                        Show current project state
+  fh next                          Zeigt n\xE4chste empfohlene Aktion (Phase + Befehl)
+  fh watch [--smart]               Observe project; --smart runs tests on change and suggests agents
   fh scan --update                 Re-scan project after changes
   fh scan --check                  Check if scan is still current
 
@@ -7418,6 +8407,7 @@ TEAM
 
 AGENTS & MCP
   fh party [--set name|run|status|cleanup]
+  fh outcomes                      Show party/auto run statistics and last 5 runs
   fh wire <service>                Configure MCP server
   fh mcp auth add|list|remove      Manage credentials
   fh mcp search <query>            Search MCP registry
@@ -7433,24 +8423,24 @@ COST
   process.exit(0);
 }
 function loadClaudeMdBlock() {
-  const templatePath = path36.join(
-    path36.dirname(new URL(import.meta.url).pathname),
+  const templatePath = path40.join(
+    path40.dirname(new URL(import.meta.url).pathname),
     "..",
     "forgehive",
     "templates",
     "claude-md.block.md"
   );
-  if (!fs35.existsSync(templatePath)) return "## forgehive\n\nSee .forgehive/ for configuration.";
-  return fs35.readFileSync(templatePath, "utf8");
+  if (!fs39.existsSync(templatePath)) return "## forgehive\n\nSee .forgehive/ for configuration.";
+  return fs39.readFileSync(templatePath, "utf8");
 }
 async function promptConfirm(question) {
   if (!process.stdin.isTTY) return false;
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
   return new Promise((resolve) => {
     rl.question(question, (answer) => {
       rl.close();
       const a = answer.trim().toLowerCase();
-      resolve(a === "y" || a === "yes" || a === "");
+      resolve(a === "y" || a === "yes" || a === "j" || a === "ja" || a === "");
     });
   });
 }
@@ -7464,13 +8454,13 @@ function buildCapabilitySummary(ids) {
 }
 if (command === "init") {
   (async () => {
-    const gitCheck = spawnSync12("git", ["--version"], { stdio: "ignore" });
+    const gitCheck = spawnSync15("git", ["--version"], { stdio: "ignore" });
     if (gitCheck.error || gitCheck.status !== 0) {
       console.error("Fehler: git nicht gefunden.");
       console.error("  Installation: https://git-scm.com");
       process.exit(1);
     }
-    const forgehiveDirExists = fs35.existsSync(forgehiveDir);
+    const forgehiveDirExists = fs39.existsSync(forgehiveDir);
     if (forgehiveDirExists && subcommand !== "--force" && !rest.includes("--force")) {
       console.log(`\u26A0 .forgehive/ existiert bereits in diesem Projekt.`);
       console.log(`  Nutze 'fh init --force' um neu zu initialisieren (\xFCberschreibt capabilities.yaml).`);
@@ -7488,9 +8478,9 @@ if (command === "init") {
     const block = loadClaudeMdBlock();
     writeForgehiveDir(projectRoot, scanResult, capMap, block);
     const hash = computeHash(projectRoot);
-    fs35.writeFileSync(path36.join(forgehiveDir, ".scan-hash"), hash, "utf8");
-    const runtimeDir = path36.join(
-      path36.dirname(new URL(import.meta.url).pathname),
+    fs39.writeFileSync(path40.join(forgehiveDir, ".scan-hash"), hash, "utf8");
+    const runtimeDir = path40.join(
+      path40.dirname(new URL(import.meta.url).pathname),
       "..",
       "forgehive"
     );
@@ -7532,7 +8522,7 @@ if (command === "init") {
     process.exit(1);
   }
 } else if (command === "memory") {
-  if (!fs35.existsSync(forgehiveDir)) {
+  if (!fs39.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -7541,7 +8531,7 @@ if (command === "init") {
   } else if (subcommand === "clean") {
     cleanMemory(forgehiveDir);
   } else if (subcommand === "export") {
-    const outputPath = rest[0] ?? path36.join(projectRoot, "forgehive-memory-export.md");
+    const outputPath = rest[0] ?? path40.join(projectRoot, "forgehive-memory-export.md");
     try {
       exportMemory(forgehiveDir, outputPath);
     } catch (err) {
@@ -7589,7 +8579,7 @@ Ausf\xFChren mit --remove um zu l\xF6schen: fh memory prune ${days} --remove`);
   } else if (subcommand === "snapshot") {
     const snapAction = rest[0];
     if (snapAction === "export") {
-      const outPath = rest[1] ?? path36.join(
+      const outPath = rest[1] ?? path40.join(
         projectRoot,
         `forgehive-snapshot-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.json`
       );
@@ -7629,11 +8619,11 @@ Ausf\xFChren mit --remove um zu l\xF6schen: fh memory prune ${days} --remove`);
     process.exit(1);
   }
 } else if (command === "scan" && subcommand === "--update") {
-  if (!fs35.existsSync(forgehiveDir)) {
+  if (!fs39.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
-  const savedHash = fs35.existsSync(path36.join(forgehiveDir, ".scan-hash")) ? fs35.readFileSync(path36.join(forgehiveDir, ".scan-hash"), "utf8").trim() : null;
+  const savedHash = fs39.existsSync(path40.join(forgehiveDir, ".scan-hash")) ? fs39.readFileSync(path40.join(forgehiveDir, ".scan-hash"), "utf8").trim() : null;
   const currentHash = computeHash(projectRoot);
   if (savedHash === currentHash) {
     console.log("\u2713 Keine \xC4nderungen erkannt \u2014 capabilities.yaml ist aktuell");
@@ -7641,7 +8631,7 @@ Ausf\xFChren mit --remove um zu l\xF6schen: fh memory prune ${days} --remove`);
   }
   console.log("\u{1F50D} \xC4nderungen erkannt \u2014 scanne erneut...\n");
   const oldDoc = jsYaml.load(
-    fs35.readFileSync(path36.join(forgehiveDir, "capabilities.yaml"), "utf8")
+    fs39.readFileSync(path40.join(forgehiveDir, "capabilities.yaml"), "utf8")
   );
   const oldMap = { confirmed: oldDoc.capabilities.confirmed ?? [], inferred: [] };
   const scanResult = scan(projectRoot);
@@ -7661,16 +8651,16 @@ Ausf\xFChren mit --remove um zu l\xF6schen: fh memory prune ${days} --remove`);
     console.log();
     const block = loadClaudeMdBlock();
     writeForgehiveDir(projectRoot, scanResult, newMap, block);
-    fs35.writeFileSync(path36.join(forgehiveDir, ".scan-hash"), currentHash, "utf8");
+    fs39.writeFileSync(path40.join(forgehiveDir, ".scan-hash"), currentHash, "utf8");
     console.log("\u2713 scan-result.yaml und capabilities.yaml aktualisiert");
     console.log("  F\xFChre `fh confirm` aus um die \xC4nderungen zu best\xE4tigen");
   }
 } else if (command === "scan" && subcommand === "--check") {
-  if (!fs35.existsSync(path36.join(forgehiveDir, ".scan-hash"))) {
+  if (!fs39.existsSync(path40.join(forgehiveDir, ".scan-hash"))) {
     console.log("Warnung: Kein Scan-Hash gefunden. F\xFChre `fh init` aus.");
     process.exit(1);
   }
-  const saved = fs35.readFileSync(path36.join(forgehiveDir, ".scan-hash"), "utf8").trim();
+  const saved = fs39.readFileSync(path40.join(forgehiveDir, ".scan-hash"), "utf8").trim();
   const current = computeHash(projectRoot);
   if (saved !== current) {
     console.log("\u26A0 Codebase hat sich seit letztem Scan ge\xE4ndert.");
@@ -7679,7 +8669,7 @@ Ausf\xFChren mit --remove um zu l\xF6schen: fh memory prune ${days} --remove`);
   }
   console.log("\u2713 capabilities.yaml ist aktuell");
 } else if (command === "skills") {
-  if (!fs35.existsSync(forgehiveDir)) {
+  if (!fs39.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -7715,7 +8705,7 @@ Ausf\xFChren mit --remove um zu l\xF6schen: fh memory prune ${days} --remove`);
     process.exit(1);
   }
 } else if (command === "party") {
-  if (!fs35.existsSync(forgehiveDir)) {
+  if (!fs39.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -7836,7 +8826,7 @@ Ausf\xFChren mit --remove um zu l\xF6schen: fh memory prune ${days} --remove`);
     }
   }
 } else if (command === "wire") {
-  if (!fs35.existsSync(forgehiveDir)) {
+  if (!fs39.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -7868,14 +8858,47 @@ N\xE4chster Schritt: Setze die erforderlichen Umgebungsvariablen und starte Clau
     console.error(`Fehler: ${err.message}`);
     process.exit(1);
   }
+} else if (command === "auto") {
+  if (subcommand === "status" || subcommand === "list") {
+    const runs = listRuns(forgehiveDir);
+    if (runs.length === 0) {
+      console.log("Keine Runs gefunden.");
+    } else {
+      runs.slice(0, 10).forEach((r) => console.log(formatRunStatus(r)));
+    }
+    process.exit(0);
+  }
+  if (subcommand === "resume") {
+    const runId = rest[0];
+    if (!runId) {
+      console.error("Usage: fh auto resume <run-id>");
+      process.exit(1);
+    }
+    await resumeRun(runId, forgehiveDir, projectRoot);
+    process.exit(0);
+  }
+  const autoFlag = subcommand === "--auto";
+  const entryPoint = autoFlag ? rest[0] : subcommand;
+  if (!entryPoint) {
+    console.error("Usage: fh auto <US-N|text>");
+    process.exit(1);
+  }
+  await startRun(entryPoint, forgehiveDir, projectRoot, autoFlag);
+  process.exit(0);
 } else if (command === "status") {
   console.log(projectStatus(projectRoot, forgehiveDir));
+  const dashboard = formatDashboard(projectRoot, forgehiveDir);
+  if (dashboard) console.log(dashboard);
+} else if (command === "next") {
+  const { formatNextFull: formatNextFull2 } = await Promise.resolve().then(() => (init_next(), next_exports));
+  console.log(formatNextFull2(projectRoot, forgehiveDir));
+  process.exit(0);
 } else if (command === "cost") {
   const allArgs = [subcommand, ...rest].filter((a) => Boolean(a));
   const limitIdx = allArgs.indexOf("--limit");
   const alertIdx = allArgs.indexOf("--alert");
   if (limitIdx !== -1) {
-    if (!fs35.existsSync(forgehiveDir)) {
+    if (!fs39.existsSync(forgehiveDir)) {
       console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
       process.exit(1);
     }
@@ -7901,30 +8924,57 @@ N\xE4chster Schritt: Setze die erforderlichen Umgebungsvariablen und starte Clau
     }
     const sessions = parseCostSessions(projectRoot);
     console.log(formatCostReport(sessions, range));
-    if (fs35.existsSync(forgehiveDir)) {
+    if (fs39.existsSync(forgehiveDir)) {
       const total = sessions.reduce((s, x) => s + x.estimatedCostUsd, 0);
       const status = checkSpendStatus(forgehiveDir, total);
       if (status.message) console.log("\n" + status.message);
     }
   }
 } else if (command === "watch") {
-  if (!fs35.existsSync(forgehiveDir)) {
+  if (!fs39.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
-  const block = loadClaudeMdBlock();
-  console.log("\u{1F441}  ForgeHive watch gestartet \u2014 beobachte Projekt-Dateien (Ctrl+C zum Beenden)\n");
-  const stop = watchProject(projectRoot, forgehiveDir, block);
-  process.on("SIGINT", () => {
-    stop();
-    process.exit(0);
-  });
-  process.on("SIGTERM", () => {
-    stop();
-    process.exit(0);
-  });
+  const isSmartMode = subcommand === "--smart" || rest.includes("--smart");
+  if (isSmartMode) {
+    let testCmd = "npm test";
+    const capsPath = path40.join(forgehiveDir, "capabilities.yaml");
+    if (fs39.existsSync(capsPath)) {
+      try {
+        const caps = jsYaml.load(fs39.readFileSync(capsPath, "utf8"));
+        if (caps?.test_command) testCmd = caps.test_command;
+      } catch {
+      }
+    }
+    console.log(`\u{1F441}  ForgeHive Smart Watch \u2014 Testbefehl: ${testCmd}`);
+    console.log("  \xDCberwache src/ und test/ auf \xC4nderungen (Ctrl+C zum Beenden)\n");
+    const stop = smartWatch(projectRoot, forgehiveDir, testCmd, async (agent, _reason, file) => {
+      console.log(`  Soll ich ${agent} starten f\xFCr ${file}?`);
+      return promptConfirm("  [j/n] ");
+    });
+    process.on("SIGINT", () => {
+      stop();
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      stop();
+      process.exit(0);
+    });
+  } else {
+    const block = loadClaudeMdBlock();
+    console.log("\u{1F441}  ForgeHive watch gestartet \u2014 beobachte Projekt-Dateien (Ctrl+C zum Beenden)\n");
+    const stop = watchProject(projectRoot, forgehiveDir, block);
+    process.on("SIGINT", () => {
+      stop();
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      stop();
+      process.exit(0);
+    });
+  }
 } else if (command === "mcp") {
-  if (!fs35.existsSync(forgehiveDir)) {
+  if (!fs39.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -8035,7 +9085,7 @@ Setze diese Umgebungsvariablen:`);
     process.exit(1);
   }
 } else if (command === "security") {
-  if (!fs35.existsSync(forgehiveDir)) {
+  if (!fs39.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -8088,6 +9138,11 @@ Setze diese Umgebungsvariablen:`);
         high: high.length
       }
     });
+    fs39.writeFileSync(
+      path40.join(forgehiveDir, "security-last-scan.txt"),
+      (/* @__PURE__ */ new Date()).toISOString(),
+      "utf8"
+    );
     if (secrets.length > 0 || critical.length > 0 || high.length > 0) {
       process.exit(1);
     }
@@ -8121,8 +9176,8 @@ Setze diese Umgebungsvariablen:`);
 `);
     const report = generateSecurityReport(projectRoot, forgehiveDir, mode);
     const text = formatSecurityReport(report);
-    const reportPath = path36.join(forgehiveDir, "security-report.md");
-    fs35.writeFileSync(reportPath, text, "utf8");
+    const reportPath = path40.join(forgehiveDir, "security-report.md");
+    fs39.writeFileSync(reportPath, text, "utf8");
     console.log(text);
     console.log(`
 \u2713 Report gespeichert: ${reportPath}`);
@@ -8134,8 +9189,8 @@ Setze diese Umgebungsvariablen:`);
   } else if (subcommand === "permissions") {
     const { writePermissions: writePermissions2 } = await Promise.resolve().then(() => (init_harness(), harness_exports));
     writePermissions2(forgehiveDir);
-    const permPath = path36.join(forgehiveDir, "harness", "permissions.yaml");
-    console.log(fs35.readFileSync(permPath, "utf8"));
+    const permPath = path40.join(forgehiveDir, "harness", "permissions.yaml");
+    console.log(fs39.readFileSync(permPath, "utf8"));
   } else {
     console.error(`Unbekannter security-Subcommand: ${subcommand}`);
     console.error("Verf\xFCgbar: scan | deps | audit | report [gdpr|soc2|hipaa|none] | permissions");
@@ -8147,18 +9202,18 @@ Setze diese Umgebungsvariablen:`);
   const failOnArg = allCiArgs.includes("--fail-on") ? allCiArgs[allCiArgs.indexOf("--fail-on") + 1] : "high";
   const initFlag = allCiArgs.includes("--init");
   if (initFlag) {
-    const ghDir = path36.join(projectRoot, ".github", "workflows");
-    fs35.mkdirSync(ghDir, { recursive: true });
-    const outPath = path36.join(ghDir, "forgehive.yml");
-    fs35.writeFileSync(outPath, getGithubActionsTemplate(), "utf8");
+    const ghDir = path40.join(projectRoot, ".github", "workflows");
+    fs39.mkdirSync(ghDir, { recursive: true });
+    const outPath = path40.join(ghDir, "forgehive.yml");
+    fs39.writeFileSync(outPath, getGithubActionsTemplate(), "utf8");
     console.log(`\u2714 GitHub Actions workflow geschrieben: ${outPath}`);
   } else {
     const report = generateCiReport(projectRoot, forgehiveDir, failOnArg);
     const output = formatCiReport(report, format);
     console.log(output);
     if (format === "json") {
-      fs35.mkdirSync(forgehiveDir, { recursive: true });
-      fs35.writeFileSync(path36.join(forgehiveDir, "ci-report.json"), output, "utf8");
+      fs39.mkdirSync(forgehiveDir, { recursive: true });
+      fs39.writeFileSync(path40.join(forgehiveDir, "ci-report.json"), output, "utf8");
     }
     if (report.status === "fail") process.exit(1);
   }
@@ -8166,29 +9221,29 @@ Setze diese Umgebungsvariablen:`);
   const semanticFlag = rest.includes("--semantic");
   const map2 = generateMap(projectRoot);
   const semantic = buildSemanticMap(projectRoot);
-  const mapPath = path36.join(forgehiveDir, "map.md");
-  fs35.mkdirSync(forgehiveDir, { recursive: true });
+  const mapPath = path40.join(forgehiveDir, "map.md");
+  fs39.mkdirSync(forgehiveDir, { recursive: true });
   if (semanticFlag) {
     const fullMd = formatMap(map2, semantic);
     const marker = "\n## Semantic Graph\n";
     const markerIdx = fullMd.indexOf(marker);
     const semanticMd = markerIdx >= 0 ? "## Semantic Graph\n" + fullMd.slice(markerIdx + marker.length) : fullMd;
-    fs35.writeFileSync(mapPath, fullMd, "utf8");
+    fs39.writeFileSync(mapPath, fullMd, "utf8");
     console.log(semanticMd);
     console.log(`
 \u2714 Codebase-Map gespeichert (Semantic Graph hervorgehoben): ${mapPath}`);
   } else {
     const md = formatMap(map2, semantic);
-    fs35.writeFileSync(mapPath, md, "utf8");
+    fs39.writeFileSync(mapPath, md, "utf8");
     console.log(md);
     console.log(`
 \u2714 Codebase-Map gespeichert: ${mapPath}`);
   }
 } else if (command === "onboard") {
   const outputArg = rest.includes("--output") ? rest[rest.indexOf("--output") + 1] : null;
-  const outputPath = outputArg ?? path36.join(projectRoot, "ONBOARDING.md");
+  const outputPath = outputArg ?? path40.join(projectRoot, "ONBOARDING.md");
   const doc = generateOnboardingDoc(projectRoot, forgehiveDir);
-  fs35.writeFileSync(outputPath, doc, "utf8");
+  fs39.writeFileSync(outputPath, doc, "utf8");
   console.log(`\u2714 Onboarding-Dokument geschrieben: ${outputPath}`);
 } else if (command === "ask") {
   const taskArg = subcommand ? [subcommand, ...rest.filter((r) => !r.startsWith("--"))].join(" ") : rest.filter((r) => !r.startsWith("--")).join(" ");
@@ -8211,28 +9266,28 @@ Task: "${taskArg}"
   const commits = parseGitLog(rawLog);
   let version2 = "unreleased";
   try {
-    const pkgPath = path36.join(projectRoot, "package.json");
-    if (fs35.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs35.readFileSync(pkgPath, "utf8").replace(/^\s*\/\/.*$/gm, ""));
+    const pkgPath = path40.join(projectRoot, "package.json");
+    if (fs39.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs39.readFileSync(pkgPath, "utf8").replace(/^\s*\/\/.*$/gm, ""));
       version2 = pkg.version ?? "unreleased";
     }
   } catch {
   }
   const md = formatChangelog(commits, version2);
-  const outputPath = outputArg ?? path36.join(projectRoot, "CHANGELOG.md");
+  const outputPath = outputArg ?? path40.join(projectRoot, "CHANGELOG.md");
   let existing = "";
-  if (fs35.existsSync(outputPath)) existing = fs35.readFileSync(outputPath, "utf8");
-  fs35.writeFileSync(outputPath, md + "\n\n" + existing, "utf8");
+  if (fs39.existsSync(outputPath)) existing = fs39.readFileSync(outputPath, "utf8");
+  fs39.writeFileSync(outputPath, md + "\n\n" + existing, "utf8");
   console.log(`\u2714 CHANGELOG.md aktualisiert: ${outputPath}`);
   console.log(`  ${commits.length} Commits verarbeitet`);
 } else if (command === "metrics") {
   const sinceArg = rest.includes("--since") ? rest[rest.indexOf("--since") + 1] : void 0;
   const rawLog = getMetricsGitLog(projectRoot, sinceArg);
   const stats = parseCommitStats(rawLog);
-  const md = formatMetrics(stats, path36.basename(projectRoot));
-  const metricsPath = path36.join(forgehiveDir, "metrics.md");
-  fs35.mkdirSync(forgehiveDir, { recursive: true });
-  fs35.writeFileSync(metricsPath, md, "utf8");
+  const md = formatMetrics(stats, path40.basename(projectRoot));
+  const metricsPath = path40.join(forgehiveDir, "metrics.md");
+  fs39.mkdirSync(forgehiveDir, { recursive: true });
+  fs39.writeFileSync(metricsPath, md, "utf8");
   console.log(md);
   console.log(`
 \u2714 Metrics gespeichert: ${metricsPath}`);
@@ -8279,7 +9334,7 @@ Task: "${taskDescription}"
     console.log(`  fh run status   \u2014 aktive Sessions anzeigen`);
   }
 } else if (command === "story") {
-  const storiesDir = path36.join(forgehiveDir, "memory", "stories");
+  const storiesDir = path40.join(forgehiveDir, "memory", "stories");
   if (subcommand === "create") {
     const title = rest.filter((r) => !r.startsWith("--")).join(" ");
     const epicArg = rest.includes("--epic") ? rest[rest.indexOf("--epic") + 1] : void 0;
@@ -8290,7 +9345,7 @@ Task: "${taskDescription}"
     }
     const story = createStory(storiesDir, title, epicArg);
     if (pointsArg) updateStoryPoints(storiesDir, story.id, pointsArg);
-    console.log(`\u2714 ${story.id} erstellt: ${path36.join(storiesDir, story.id + ".md")}`);
+    console.log(`\u2714 ${story.id} erstellt: ${path40.join(storiesDir, story.id + ".md")}`);
     console.log(`  Bearbeite die Datei um Acceptance Criteria hinzuzuf\xFCgen.`);
   } else if (subcommand === "list") {
     const epicFilter = rest.includes("--epic") ? rest[rest.indexOf("--epic") + 1] : null;
@@ -8339,8 +9394,8 @@ Task: "${taskDescription}"
     console.error("Verf\xFCgbar: fh story create | list | show | done");
   }
 } else if (command === "epic") {
-  const epicsDir = path36.join(forgehiveDir, "memory", "epics");
-  const storiesDir = path36.join(forgehiveDir, "memory", "stories");
+  const epicsDir = path40.join(forgehiveDir, "memory", "epics");
+  const storiesDir = path40.join(forgehiveDir, "memory", "stories");
   if (subcommand === "create") {
     const goalArg = rest.includes("--goal") ? rest[rest.indexOf("--goal") + 1] : void 0;
     const prdArg = rest.includes("--prd") ? rest[rest.indexOf("--prd") + 1] : void 0;
@@ -8358,12 +9413,12 @@ Task: "${taskDescription}"
       process.exit(1);
     }
     if (prdArg) {
-      const prdsDir = path36.join(forgehiveDir, "memory", "prds");
+      const prdsDir = path40.join(forgehiveDir, "memory", "prds");
       const prd = getPrd(prdsDir, prdArg);
       if (!prd) console.warn(`\u26A0 PRD ${prdArg} nicht gefunden \u2014 Epic wird trotzdem erstellt`);
     }
     const epic = createEpic(epicsDir, title, goalArg, prdArg);
-    console.log(`\u2714 ${epic.id} erstellt: ${path36.join(epicsDir, epic.id + ".md")}`);
+    console.log(`\u2714 ${epic.id} erstellt: ${path40.join(epicsDir, epic.id + ".md")}`);
     if (prdArg) console.log(`  Verkn\xFCpft mit: ${prdArg}`);
   } else if (subcommand === "list") {
     const epics = listEpics(epicsDir);
@@ -8390,7 +9445,7 @@ Task: "${taskDescription}"
     console.error("Verf\xFCgbar: fh epic create | list | show");
   }
 } else if (command === "product") {
-  const prdsDir = path36.join(forgehiveDir, "memory", "prds");
+  const prdsDir = path40.join(forgehiveDir, "memory", "prds");
   if (subcommand === "prd") {
     const title = rest.filter((r) => !r.startsWith("--")).join(" ");
     if (!title) {
@@ -8398,7 +9453,7 @@ Task: "${taskDescription}"
       process.exit(1);
     }
     const prd = createPrd(prdsDir, title);
-    const relPath = path36.relative(projectRoot, prd.filepath);
+    const relPath = path40.relative(projectRoot, prd.filepath);
     console.log(`\u2714 ${prd.id} erstellt: ${relPath}`);
     console.log(`  Bearbeite die Datei um Anforderungen zu definieren.`);
   } else if (subcommand === "list") {
@@ -8423,10 +9478,10 @@ Task: "${taskDescription}"
       console.error(`${id} nicht gefunden`);
       process.exit(1);
     }
-    console.log(fs35.readFileSync(prd.filepath, "utf8"));
+    console.log(fs39.readFileSync(prd.filepath, "utf8"));
   } else if (subcommand === "status") {
-    const epicsDir = path36.join(forgehiveDir, "memory", "epics");
-    const storiesDir = path36.join(forgehiveDir, "memory", "stories");
+    const epicsDir = path40.join(forgehiveDir, "memory", "epics");
+    const storiesDir = path40.join(forgehiveDir, "memory", "stories");
     const prds = listPrds(prdsDir);
     const epics = listEpics(epicsDir);
     const stories = listStories(storiesDir);
@@ -8469,14 +9524,14 @@ Task: "${taskDescription}"
     }
   } else if (subcommand === "roadmap") {
     const content = generateRoadmap(forgehiveDir);
-    const roadmapPath = path36.join(projectRoot, "ROADMAP.md");
-    fs35.writeFileSync(roadmapPath, content, "utf8");
+    const roadmapPath = path40.join(projectRoot, "ROADMAP.md");
+    fs39.writeFileSync(roadmapPath, content, "utf8");
     console.log(`\u2714 ROADMAP.md generiert: ${roadmapPath}`);
   } else {
     console.error("Verf\xFCgbar: fh product prd | list | show | status | roadmap");
   }
 } else if (command === "velocity") {
-  const velocityFile = path36.join(forgehiveDir, "memory", "velocity.md");
+  const velocityFile = path40.join(forgehiveDir, "memory", "velocity.md");
   if (subcommand === "record") {
     const sprintNum = parseInt(rest[0] ?? "0", 10);
     const committed = rest.includes("--committed") ? parseInt(rest[rest.indexOf("--committed") + 1], 10) : NaN;
@@ -8495,7 +9550,7 @@ Task: "${taskDescription}"
     console.error("Verf\xFCgbar: fh velocity show | record <N> --committed N --delivered N");
   }
 } else if (command === "docs") {
-  const docsDir = path36.join(projectRoot, "docs");
+  const docsDir = path40.join(projectRoot, "docs");
   if (!subcommand || subcommand === "list") {
     const existing = listExistingDocs(projectRoot);
     if (existing.length === 0) {
@@ -8509,29 +9564,29 @@ Task: "${taskDescription}"
       console.log("  fh docs adr <titel> \u2014 Architecture Decision Record");
     } else {
       console.log(`Vorhandene Dokumentation (${existing.length} Dateien):`);
-      for (const d of existing) console.log(`  ${path36.relative(projectRoot, d)}`);
+      for (const d of existing) console.log(`  ${path40.relative(projectRoot, d)}`);
       console.log("");
       console.log("Aktualisieren: fh docs user | api | onboard | changelog");
     }
   } else if (subcommand === "user") {
-    fs35.mkdirSync(docsDir, { recursive: true });
+    fs39.mkdirSync(docsDir, { recursive: true });
     const outputArg = rest.includes("--output") ? rest[rest.indexOf("--output") + 1] : null;
-    const outputPath = outputArg ?? path36.join(docsDir, "user-guide.md");
+    const outputPath = outputArg ?? path40.join(docsDir, "user-guide.md");
     const guide = generateUserGuide(projectRoot, forgehiveDir);
-    fs35.writeFileSync(outputPath, guide, "utf8");
+    fs39.writeFileSync(outputPath, guide, "utf8");
     console.log(`\u2714 User Guide geschrieben: ${outputPath}`);
   } else if (subcommand === "api") {
-    fs35.mkdirSync(docsDir, { recursive: true });
+    fs39.mkdirSync(docsDir, { recursive: true });
     const outputArg = rest.includes("--output") ? rest[rest.indexOf("--output") + 1] : null;
-    const outputPath = outputArg ?? path36.join(docsDir, "api.md");
+    const outputPath = outputArg ?? path40.join(docsDir, "api.md");
     const ref = generateApiReference(projectRoot);
-    fs35.writeFileSync(outputPath, ref, "utf8");
+    fs39.writeFileSync(outputPath, ref, "utf8");
     console.log(`\u2714 API-Referenz geschrieben: ${outputPath}`);
   } else if (subcommand === "onboard") {
     const outputArg = rest.includes("--output") ? rest[rest.indexOf("--output") + 1] : null;
-    const outputPath = outputArg ?? path36.join(projectRoot, "ONBOARDING.md");
+    const outputPath = outputArg ?? path40.join(projectRoot, "ONBOARDING.md");
     const doc = generateOnboardingDoc(projectRoot, forgehiveDir);
-    fs35.writeFileSync(outputPath, doc, "utf8");
+    fs39.writeFileSync(outputPath, doc, "utf8");
     console.log(`\u2714 Onboarding-Dokument geschrieben: ${outputPath}`);
   } else if (subcommand === "changelog") {
     const sinceArg = rest.includes("--since") ? rest[rest.indexOf("--since") + 1] : null;
@@ -8541,15 +9596,15 @@ Task: "${taskDescription}"
     const commits = parseGitLog(rawLog);
     let pkg = {};
     try {
-      pkg = JSON.parse(fs35.readFileSync(path36.join(projectRoot, "package.json"), "utf8"));
+      pkg = JSON.parse(fs39.readFileSync(path40.join(projectRoot, "package.json"), "utf8"));
     } catch {
     }
     const pkgVersion = pkg.version ?? "unreleased";
     const md = formatChangelog(commits, pkgVersion);
-    const outputPath = outputArg ?? path36.join(projectRoot, "CHANGELOG.md");
+    const outputPath = outputArg ?? path40.join(projectRoot, "CHANGELOG.md");
     let existing = "";
-    if (fs35.existsSync(outputPath)) existing = fs35.readFileSync(outputPath, "utf8");
-    fs35.writeFileSync(outputPath, md + "\n\n" + existing, "utf8");
+    if (fs39.existsSync(outputPath)) existing = fs39.readFileSync(outputPath, "utf8");
+    fs39.writeFileSync(outputPath, md + "\n\n" + existing, "utf8");
     console.log(`\u2714 CHANGELOG.md aktualisiert (${commits.length} Commits)`);
   } else if (subcommand === "adr") {
     const title = rest.join(" ");
@@ -8557,9 +9612,9 @@ Task: "${taskDescription}"
       console.error("Usage: fh docs adr <titel>");
       process.exit(1);
     }
-    const adrsDir = path36.join(forgehiveDir, "memory", "adrs");
-    fs35.mkdirSync(adrsDir, { recursive: true });
-    const existing = fs35.readdirSync(adrsDir).filter((f) => f.endsWith(".md")).length;
+    const adrsDir = path40.join(forgehiveDir, "memory", "adrs");
+    fs39.mkdirSync(adrsDir, { recursive: true });
+    const existing = fs39.readdirSync(adrsDir).filter((f) => f.endsWith(".md")).length;
     const adrId = String(existing + 1).padStart(4, "0");
     const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
     const filename = `${adrId}-${slug}.md`;
@@ -8580,13 +9635,13 @@ Task: "${taskDescription}"
 
 (Beschreibe die Auswirkungen dieser Entscheidung.)
 `;
-    fs35.writeFileSync(path36.join(adrsDir, filename), content, "utf8");
+    fs39.writeFileSync(path40.join(adrsDir, filename), content, "utf8");
     console.log(`\u2714 ADR erstellt: .forgehive/memory/adrs/${filename}`);
   } else {
     console.error("Verf\xFCgbar: fh docs [list|user|api|onboard|changelog|adr <titel>]");
   }
 } else if (command === "github") {
-  const storiesDir = path36.join(forgehiveDir, "memory", "stories");
+  const storiesDir = path40.join(forgehiveDir, "memory", "stories");
   if (subcommand === "setup") {
     const readline = await import("node:readline/promises");
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -8654,6 +9709,16 @@ Task: "${taskDescription}"
     }
     console.log(`
   ${created} ${created === 1 ? "Story" : "Stories"} erstellt, ${skipped} \xFCbersprungen.`);
+    try {
+      const [syncOwner, syncRepo] = config.repo.split("/");
+      const openPrNumbers = await fetchOpenPRs(syncOwner, syncRepo, creds.GITHUB_TOKEN);
+      fs39.writeFileSync(
+        path40.join(forgehiveDir, "github-pr-cache.json"),
+        JSON.stringify({ open: openPrNumbers, ts: (/* @__PURE__ */ new Date()).toISOString() }),
+        "utf8"
+      );
+    } catch {
+    }
   } else if (subcommand === "pr") {
     const prNumberRaw = rest[0];
     if (!prNumberRaw || isNaN(parseInt(prNumberRaw, 10))) {
@@ -8686,9 +9751,9 @@ Task: "${taskDescription}"
       process.exit(1);
     }
     const contextMd = formatPRContext(pr, files, config.repo);
-    fs35.mkdirSync(forgehiveDir, { recursive: true });
-    const outputPath = path36.join(forgehiveDir, `github-pr-${prNumber}.md`);
-    fs35.writeFileSync(outputPath, contextMd, "utf8");
+    fs39.mkdirSync(forgehiveDir, { recursive: true });
+    const outputPath = path40.join(forgehiveDir, `github-pr-${prNumber}.md`);
+    fs39.writeFileSync(outputPath, contextMd, "utf8");
     console.log(`  \u2713 PR-Kontext gespeichert: .forgehive/github-pr-${prNumber}.md`);
     console.log("");
     console.log(`  PR context gespeichert. Starte Review: fh party run review`);
@@ -8696,9 +9761,45 @@ Task: "${taskDescription}"
     console.log("Verf\xFCgbar: fh github setup | fh github sync | fh github pr <number>");
     console.log("Hilfe: fh --help");
   }
+} else if (command === "outcomes") {
+  if (!fs39.existsSync(forgehiveDir)) {
+    console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
+    process.exit(1);
+  }
+  const { aggregateByAgent: aggregateByAgent2, aggregateByTaskType: aggregateByTaskType2, readOutcomes: readOutcomes2 } = await Promise.resolve().then(() => (init_outcomes(), outcomes_exports));
+  const entries = readOutcomes2(forgehiveDir);
+  if (entries.length === 0) {
+    console.log("Keine Outcome-Daten vorhanden. Starte 'fh auto' oder 'fh party run' um Daten zu sammeln.");
+    process.exit(0);
+  }
+  const byAgent = aggregateByAgent2(forgehiveDir);
+  const byType = aggregateByTaskType2(forgehiveDir);
+  console.log(`
+Outcome-\xDCbersicht (${entries.length} Runs)
+`);
+  console.log("\u2500\u2500 Agenten \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  for (const [agent, stats] of Object.entries(byAgent)) {
+    const avgMin = (stats.avgDurationMs / 6e4).toFixed(1);
+    const rating = stats.avgRating !== null ? `  \u2605 ${stats.avgRating.toFixed(1)}` : "";
+    const types2 = Object.keys(stats.taskTypes).join(", ");
+    console.log(`  ${agent.padEnd(8)} \xD8 ${avgMin} min  [${types2}]${rating}`);
+  }
+  console.log("\n\u2500\u2500 Task-Typen \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  for (const [type2, agg] of Object.entries(byType)) {
+    console.log(`  ${type2.padEnd(16)} ${agg.count}x`);
+  }
+  const last = entries.slice(-5).reverse();
+  console.log("\n\u2500\u2500 Letzte 5 Runs \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  for (const e of last) {
+    const mins = (e.durationMs / 6e4).toFixed(1);
+    const rating = e.rating !== null ? `  \u2605 ${e.rating}` : "";
+    const agents = e.agents.join("+");
+    console.log(`  ${e.runId}  ${e.taskType}  ${agents}  ${mins} min${rating}`);
+  }
+  process.exit(0);
 } else {
   console.error("Unbekannter Befehl: " + command);
-  console.error("Verf\xFCgbar: init | confirm | rollback | scan | status | ci | map | onboard | changelog | metrics | docs | story [create|list|show|sprint|done] | epic [create|list|show] | velocity [show|record] | sync [push|pull] | run <issue-url> | github [setup|sync|pr] | cost | memory | skills | party | wire | mcp | security");
+  console.error("Verf\xFCgbar: init | confirm | rollback | scan | status | auto | ci | map | onboard | changelog | metrics | docs | story [create|list|show|sprint|done] | epic [create|list|show] | velocity [show|record] | sync [push|pull] | run <issue-url> | github [setup|sync|pr] | cost | memory | skills | party | outcomes | wire | mcp | security");
   console.error("Hilfe: fh --help");
   process.exit(1);
 }