forgehive 0.7.8 → 0.8.0

package/dist/cli.js

@@ -2751,8 +2751,10 @@ var init_harness = __esm({
 
 // src/cli.ts
 init_js_yaml();
-import fs31 from "node:fs";
-import path32 from "node:path";
+import fs35 from "node:fs";
+import path36 from "node:path";
+import { spawnSync as spawnSync12 } from "node:child_process";
+import { createInterface } from "node:readline";
 
 // src/scanner.ts
 import fs from "node:fs";
@@ -5734,7 +5736,44 @@ function generateMap(projectRoot2) {
     totalLines: files.reduce((sum, f) => sum + f.lines, 0)
   };
 }
-function formatMap(map2) {
+function formatSemanticBlock(semantic, projectRoot2) {
+  const lines = [];
+  lines.push("## Semantic Graph");
+  lines.push("");
+  lines.push("### Hotspots (meistimportiert)");
+  if (semantic.hotspots.length === 0) {
+    lines.push("Keine Hotspot-Dateien gefunden (Schwellenwert: 3+ Imports).");
+  } else {
+    for (const h of semantic.hotspots) {
+      const rel = h.file.startsWith(projectRoot2) ? h.file.slice(projectRoot2.length + 1) : h.file;
+      lines.push(`- \`${rel}\` \u2014 importiert von ${h.importedBy} Dateien`);
+    }
+  }
+  lines.push("");
+  lines.push("### Zirkul\xE4re Abh\xE4ngigkeiten");
+  if (semantic.cycles.length === 0) {
+    lines.push("Keine gefunden.");
+  } else {
+    for (const cycle of semantic.cycles) {
+      const relCycle = cycle.map(
+        (f) => f.startsWith(projectRoot2) ? f.slice(projectRoot2.length + 1) : f
+      );
+      lines.push(`- ${relCycle.map((f) => `\`${f}\``).join(" \u2192 ")}`);
+    }
+  }
+  lines.push("");
+  const fileCount = Object.keys(semantic.imports).length;
+  const relationCount = Object.values(semantic.imports).reduce(
+    (sum, deps) => sum + deps.length,
+    0
+  );
+  lines.push("### Abh\xE4ngigkeits\xFCbersicht");
+  lines.push(`- ${fileCount} Dateien analysiert`);
+  lines.push(`- ${relationCount} Import-Beziehungen`);
+  lines.push(`- ${semantic.hotspots.length} Hotspot-Dateien (importiert von 3+ anderen)`);
+  return lines.join("\n");
+}
+function formatMap(map2, semantic) {
   const lines = [];
   lines.push("# Codebase Map");
   lines.push(`Generated: ${map2.generatedAt}`);
@@ -5764,13 +5803,199 @@ function formatMap(map2) {
   } else {
     lines.push("No internal imports detected.");
   }
+  if (semantic) {
+    lines.push("");
+    lines.push(formatSemanticBlock(semantic, map2.projectRoot));
+  }
   return lines.join("\n");
 }
 
-// src/onboard.ts
-init_js_yaml();
+// src/semantic-map.ts
 import fs24 from "node:fs";
 import path25 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 = {
+  ts: [
+    /^import\s+[\s\S]*?from\s+['"]([^'"]+)['"]/gm,
+    /^import\s+['"]([^'"]+)['"]/gm,
+    /require\s*\(\s*['"]([^'"]+)['"]\s*\)/gm
+  ],
+  js: [
+    /^import\s+[\s\S]*?from\s+['"]([^'"]+)['"]/gm,
+    /^import\s+['"]([^'"]+)['"]/gm,
+    /require\s*\(\s*['"]([^'"]+)['"]\s*\)/gm
+  ],
+  py: [
+    /^import\s+(\S+)/gm,
+    /^from\s+(\S+)\s+import/gm
+  ],
+  go: [
+    /^\s+"([^"]+)"/gm
+  ]
+};
+var EXPORT_PATTERNS = {
+  ts: [
+    /export\s+(?:default\s+)?(?:async\s+)?(?:function\*?|class|const|let|var|type|interface|enum)\s+(\w+)/gm,
+    /export\s*\{\s*([^}]+)\s*\}/gm
+  ],
+  js: [
+    /export\s+(?:default\s+)?(?:async\s+)?(?:function\*?|class|const|let|var)\s+(\w+)/gm,
+    /export\s*\{\s*([^}]+)\s*\}/gm
+  ],
+  py: [
+    /^def\s+(\w+)/gm,
+    /^class\s+(\w+)/gm
+  ],
+  go: [
+    /^func\s+([A-Z]\w*)/gm
+  ]
+};
+function langOf(ext) {
+  if (ext === ".ts" || ext === ".tsx") return "ts";
+  if (ext === ".js" || ext === ".jsx") return "js";
+  if (ext === ".py") return "py";
+  if (ext === ".go") return "go";
+  return "";
+}
+function walkFiles2(dir) {
+  const results = [];
+  function walk(current) {
+    let entries;
+    try {
+      entries = fs24.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);
+      if (entry.isDirectory()) walk(full);
+      else if (entry.isFile() && MAP_EXTS2.includes(path25.extname(entry.name))) {
+        results.push(full);
+      }
+    }
+  }
+  walk(dir);
+  return results;
+}
+function _extractImports(content, lang) {
+  const patterns = IMPORT_PATTERNS2[lang] ?? [];
+  const found = [];
+  for (const pattern of patterns) {
+    const re = new RegExp(pattern.source, pattern.flags);
+    let m;
+    while ((m = re.exec(content)) !== null) {
+      const imp = m[1].trim();
+      if (lang === "py" && !imp.startsWith(".")) continue;
+      if ((lang === "ts" || lang === "js") && !imp.startsWith(".")) continue;
+      found.push(imp);
+    }
+  }
+  return [...new Set(found)];
+}
+function _extractExports(content, lang) {
+  const patterns = EXPORT_PATTERNS[lang] ?? [];
+  const found = [];
+  for (const pattern of patterns) {
+    const re = new RegExp(pattern.source, pattern.flags);
+    let m;
+    while ((m = re.exec(content)) !== null) {
+      const raw = m[1];
+      if (raw.includes(",") || pattern.source.includes("{")) {
+        for (const name of raw.split(",")) {
+          const trimmed = name.trim().split(/\s+as\s+/)[0].trim();
+          if (trimmed) found.push(trimmed);
+        }
+      } else {
+        const name = raw.trim();
+        if (name) found.push(name);
+      }
+    }
+  }
+  return [...new Set(found)];
+}
+function _resolveImport(fromFile, importPath, allFiles) {
+  if (!importPath.startsWith(".")) return null;
+  const fromDir = path25.dirname(fromFile);
+  const base = path25.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);
+    if (allFiles.includes(candidate)) return candidate;
+  }
+  return null;
+}
+function _detectCycles(imports) {
+  const cycles = [];
+  const visited = /* @__PURE__ */ new Set();
+  const stack = [];
+  const onStack = /* @__PURE__ */ new Set();
+  function dfs(node) {
+    if (onStack.has(node)) {
+      const cycleStart = stack.indexOf(node);
+      cycles.push([...stack.slice(cycleStart), node]);
+      return;
+    }
+    if (visited.has(node)) return;
+    visited.add(node);
+    onStack.add(node);
+    stack.push(node);
+    for (const neighbour of imports[node] ?? []) {
+      dfs(neighbour);
+    }
+    stack.pop();
+    onStack.delete(node);
+  }
+  for (const node of Object.keys(imports)) {
+    dfs(node);
+  }
+  return cycles;
+}
+function _findHotspots(imports) {
+  const THRESHOLD = 3;
+  const counts = {};
+  for (const deps of Object.values(imports)) {
+    for (const dep of deps) {
+      counts[dep] = (counts[dep] ?? 0) + 1;
+    }
+  }
+  return Object.entries(counts).filter(([, count]) => count >= THRESHOLD).map(([file, importedBy]) => ({ file, importedBy })).sort((a, b) => b.importedBy - a.importedBy);
+}
+function buildSemanticMap(projectRoot2) {
+  const allFiles = walkFiles2(projectRoot2);
+  const imports = {};
+  const exports = {};
+  for (const filePath of allFiles) {
+    let content = "";
+    try {
+      content = fs24.readFileSync(filePath, "utf8");
+    } catch {
+    }
+    const ext = path25.extname(filePath);
+    const lang = langOf(ext);
+    const rawImps = _extractImports(content, lang);
+    const resolvedImps = [];
+    for (const imp of rawImps) {
+      const resolved = _resolveImport(filePath, imp, allFiles);
+      if (resolved) resolvedImps.push(resolved);
+    }
+    imports[filePath] = resolvedImps;
+    exports[filePath] = lang ? _extractExports(content, lang) : [];
+  }
+  const cycles = _detectCycles(imports);
+  const hotspots = _findHotspots(imports);
+  return { imports, exports, hotspots, cycles };
+}
+
+// src/onboard.ts
+init_js_yaml();
+import fs25 from "node:fs";
+import path26 from "node:path";
 import { spawnSync as spawnSync7 } from "node:child_process";
 function getRecentCommits(projectRoot2, n = 20) {
   const result = spawnSync7("git", ["log", `--oneline`, `-${n}`], {
@@ -5781,30 +6006,30 @@ function getRecentCommits(projectRoot2, n = 20) {
   return result.stdout.trim().split("\n").filter(Boolean);
 }
 function readCapabilities(forgehiveDir2) {
-  const capPath = path25.join(forgehiveDir2, "capabilities.yaml");
-  if (!fs24.existsSync(capPath)) return {};
+  const capPath = path26.join(forgehiveDir2, "capabilities.yaml");
+  if (!fs25.existsSync(capPath)) return {};
   try {
-    return jsYaml.load(fs24.readFileSync(capPath, "utf8")) ?? {};
+    return jsYaml.load(fs25.readFileSync(capPath, "utf8")) ?? {};
   } catch {
     return {};
   }
 }
 function readMemoryFiles(forgehiveDir2) {
-  const memDir = path25.join(forgehiveDir2, "memory");
-  if (!fs24.existsSync(memDir)) return {};
+  const memDir = path26.join(forgehiveDir2, "memory");
+  if (!fs25.existsSync(memDir)) return {};
   const result = {};
-  for (const f of fs24.readdirSync(memDir).filter((f2) => f2.endsWith(".md") && f2 !== "MEMORY.md")) {
-    result[f] = fs24.readFileSync(path25.join(memDir, f), "utf8");
+  for (const f of fs25.readdirSync(memDir).filter((f2) => f2.endsWith(".md") && f2 !== "MEMORY.md")) {
+    result[f] = fs25.readFileSync(path26.join(memDir, f), "utf8");
   }
   return result;
 }
 function listAdrs2(forgehiveDir2) {
-  const adrsDir = path25.join(forgehiveDir2, "memory", "adrs");
-  if (!fs24.existsSync(adrsDir)) return [];
-  return fs24.readdirSync(adrsDir).filter((f) => f.endsWith(".md"));
+  const adrsDir = path26.join(forgehiveDir2, "memory", "adrs");
+  if (!fs25.existsSync(adrsDir)) return [];
+  return fs25.readdirSync(adrsDir).filter((f) => f.endsWith(".md"));
 }
 function generateOnboardingDoc(projectRoot2, forgehiveDir2) {
-  const projectName = path25.basename(projectRoot2);
+  const projectName = path26.basename(projectRoot2);
   const caps = readCapabilities(forgehiveDir2);
   const memFiles = readMemoryFiles(forgehiveDir2);
   const commits = getRecentCommits(projectRoot2);
@@ -6019,13 +6244,13 @@ function getMetricsGitLog(projectRoot2, since) {
 }
 
 // src/sync.ts
-import fs25 from "node:fs";
-import path26 from "node:path";
+import fs26 from "node:fs";
+import path27 from "node:path";
 import { spawnSync as spawnSync10 } from "node:child_process";
 function getSyncStatus(forgehiveDir2) {
-  const memDir = path26.join(forgehiveDir2, "memory");
-  const files = fs25.existsSync(memDir) ? fs25.readdirSync(memDir).filter((f) => f.endsWith(".md")).length : 0;
-  const projectRoot2 = path26.dirname(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(
     "git",
     ["config", "--get", "forgehive.sync-remote"],
@@ -6041,18 +6266,18 @@ function getSyncStatus(forgehiveDir2) {
   return { files, hasRemote: remote !== null, remote, branch };
 }
 function pushSync(forgehiveDir2, remote = "origin", branch = "forgehive-memory") {
-  const projectRoot2 = path26.dirname(forgehiveDir2);
-  const memDir = path26.join(forgehiveDir2, "memory");
-  if (!fs25.existsSync(memDir)) {
+  const projectRoot2 = path27.dirname(forgehiveDir2);
+  const memDir = path27.join(forgehiveDir2, "memory");
+  if (!fs26.existsSync(memDir)) {
     return { success: false, message: "Kein Memory-Verzeichnis gefunden.", filesCommitted: 0 };
   }
-  const files = fs25.readdirSync(memDir).filter((f) => f.endsWith(".md"));
+  const files = fs26.readdirSync(memDir).filter((f) => f.endsWith(".md"));
   if (files.length === 0) {
     return { success: false, message: "Keine Memory-Dateien gefunden.", filesCommitted: 0 };
   }
   const addResult = spawnSync10(
     "git",
-    ["add", path26.join(".forgehive", "memory")],
+    ["add", path27.join(".forgehive", "memory")],
     { cwd: projectRoot2, encoding: "utf8" }
   );
   if (addResult.status !== 0) {
@@ -6080,9 +6305,9 @@ function pushSync(forgehiveDir2, remote = "origin", branch = "forgehive-memory")
   return { success: true, message: `Memory gepusht nach ${remote}/${branch}`, filesCommitted: files.length };
 }
 function pullSync(forgehiveDir2, remote = "origin", branch = "forgehive-memory") {
-  const projectRoot2 = path26.dirname(forgehiveDir2);
-  const memDir = path26.join(forgehiveDir2, "memory");
-  fs25.mkdirSync(memDir, { recursive: true });
+  const projectRoot2 = path27.dirname(forgehiveDir2);
+  const memDir = path27.join(forgehiveDir2, "memory");
+  fs26.mkdirSync(memDir, { recursive: true });
   const fetchResult = spawnSync10(
     "git",
     ["fetch", remote, branch],
@@ -6102,16 +6327,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 = path26.basename(remotePath);
-    const localPath = path26.join(memDir, filename);
-    if (!fs25.existsSync(localPath)) {
+    const filename = path27.basename(remotePath);
+    const localPath = path27.join(memDir, filename);
+    if (!fs26.existsSync(localPath)) {
       const contentResult = spawnSync10(
         "git",
         ["show", `${remote}/${branch}:${remotePath}`],
         { cwd: projectRoot2, encoding: "utf8" }
       );
       if (contentResult.status === 0) {
-        fs25.writeFileSync(localPath, contentResult.stdout, "utf8");
+        fs26.writeFileSync(localPath, contentResult.stdout, "utf8");
         imported.push(filename);
       }
     }
@@ -6124,8 +6349,8 @@ function pullSync(forgehiveDir2, remote = "origin", branch = "forgehive-memory")
 }
 
 // src/background.ts
-import fs26 from "node:fs";
-import path27 from "node:path";
+import fs27 from "node:fs";
+import path28 from "node:path";
 import { spawn } from "node:child_process";
 var AGENT_ROLES = {
   kai: "Senior Engineer \u2014 implements features and fixes bugs",
@@ -6172,23 +6397,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 = path27.join(forgehiveDir2, "background-runs");
-  fs26.mkdirSync(logsDir, { recursive: true });
+  const logsDir = path28.join(forgehiveDir2, "background-runs");
+  fs27.mkdirSync(logsDir, { recursive: true });
   const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const logFile = path27.join(logsDir, `${agentId}-${timestamp2}.log`);
+  const logFile = path28.join(logsDir, `${agentId}-${timestamp2}.log`);
   const prompt = buildAgentPrompt(issueUrl, agentId);
-  const logStream = fs26.openSync(logFile, "w");
+  const logStream = fs27.openSync(logFile, "w");
   const child = spawn(
     "claude",
     ["-p", prompt, "--output-format", "text"],
     {
-      cwd: path27.dirname(forgehiveDir2),
+      cwd: path28.dirname(forgehiveDir2),
       detached: true,
       stdio: ["ignore", logStream, logStream]
     }
   );
   child.unref();
-  fs26.closeSync(logStream);
+  fs27.closeSync(logStream);
   return {
     pid: child.pid,
     logFile,
@@ -6198,11 +6423,11 @@ function runBackgroundAgent(forgehiveDir2, issueUrl, agentId) {
 
 // src/stories.ts
 init_js_yaml();
-import fs27 from "node:fs";
-import path28 from "node:path";
+import fs28 from "node:fs";
+import path29 from "node:path";
 function nextStoryId(storiesDir) {
-  if (!fs27.existsSync(storiesDir)) return "US-1";
-  const existing = fs27.readdirSync(storiesDir).filter((f) => f.match(/^US-\d+\.md$/)).map((f) => parseInt(f.replace("US-", "").replace(".md", ""), 10)).filter((n) => !isNaN(n));
+  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));
   const max = existing.length > 0 ? Math.max(...existing) : 0;
   return `US-${max + 1}`;
 }
@@ -6234,7 +6459,7 @@ ${acLines || "- [ ] (noch nicht definiert)"}
 }
 function parseStoryFile(filePath) {
   try {
-    const content = fs27.readFileSync(filePath, "utf8");
+    const content = fs28.readFileSync(filePath, "utf8");
     const match = content.match(/^---\n([\s\S]*?)\n---/);
     if (!match) return null;
     const data = jsYaml.load(match[1]);
@@ -6254,7 +6479,7 @@ function parseStoryFile(filePath) {
   }
 }
 function createStory(storiesDir, title, epicId) {
-  fs27.mkdirSync(storiesDir, { recursive: true });
+  fs28.mkdirSync(storiesDir, { recursive: true });
   const id = nextStoryId(storiesDir);
   const story = {
     id,
@@ -6267,33 +6492,33 @@ function createStory(storiesDir, title, epicId) {
     epicId: epicId ?? null,
     status: "backlog"
   };
-  fs27.writeFileSync(path28.join(storiesDir, `${id}.md`), storyToMarkdown(story), "utf8");
+  fs28.writeFileSync(path29.join(storiesDir, `${id}.md`), storyToMarkdown(story), "utf8");
   return story;
 }
 function listStories(storiesDir) {
-  if (!fs27.existsSync(storiesDir)) return [];
-  return fs27.readdirSync(storiesDir).filter((f) => f.match(/^US-\d+\.md$/)).map((f) => parseStoryFile(path28.join(storiesDir, f))).filter((s) => s !== null).sort((a, b) => {
+  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) => {
     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 = path28.join(storiesDir, `${id}.md`);
-  if (!fs27.existsSync(filePath)) return null;
+  const filePath = path29.join(storiesDir, `${id}.md`);
+  if (!fs28.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;
-  fs27.writeFileSync(path28.join(storiesDir, `${id}.md`), storyToMarkdown(story), "utf8");
+  fs28.writeFileSync(path29.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;
-  fs27.writeFileSync(path28.join(storiesDir, `${id}.md`), storyToMarkdown(story), "utf8");
+  fs28.writeFileSync(path29.join(storiesDir, `${id}.md`), storyToMarkdown(story), "utf8");
 }
 function formatStoryCard(story) {
   const points = story.points !== null ? ` \xB7 ${story.points} Punkte` : "";
@@ -6312,11 +6537,11 @@ function formatStoryCard(story) {
 
 // src/epics.ts
 init_js_yaml();
-import fs28 from "node:fs";
-import path29 from "node:path";
+import fs29 from "node:fs";
+import path30 from "node:path";
 function nextEpicId(epicsDir) {
-  if (!fs28.existsSync(epicsDir)) return "EPC-1";
-  const existing = fs28.readdirSync(epicsDir).filter((f) => f.match(/^EPC-\d+\.md$/)).map((f) => parseInt(f.replace("EPC-", "").replace(".md", ""), 10)).filter((n) => !isNaN(n));
+  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));
   const max = existing.length > 0 ? Math.max(...existing) : 0;
   return `EPC-${max + 1}`;
 }
@@ -6326,7 +6551,8 @@ function epicToMarkdown(epic) {
     title: epic.title,
     goal: epic.goal,
     stories: epic.stories,
-    status: epic.status
+    status: epic.status,
+    prdId: epic.prdId
   });
   const storyLines = epic.stories.map((s) => `- ${s}`).join("\n");
   return `---
@@ -6343,7 +6569,7 @@ ${storyLines || "(noch keine Stories)"}
 }
 function parseEpicFile(filePath) {
   try {
-    const content = fs28.readFileSync(filePath, "utf8");
+    const content = fs29.readFileSync(filePath, "utf8");
     const match = content.match(/^---\n([\s\S]*?)\n---/);
     if (!match) return null;
     const data = jsYaml.load(match[1]);
@@ -6352,30 +6578,31 @@ function parseEpicFile(filePath) {
       title: data.title ?? "",
       goal: data.goal ?? "",
       stories: data.stories ?? [],
-      status: data.status ?? "active"
+      status: data.status ?? "active",
+      prdId: data.prdId ?? null
     };
   } catch {
     return null;
   }
 }
-function createEpic(epicsDir, title, goal) {
-  fs28.mkdirSync(epicsDir, { recursive: true });
+function createEpic(epicsDir, title, goal, prdId) {
+  fs29.mkdirSync(epicsDir, { recursive: true });
   const id = nextEpicId(epicsDir);
-  const epic = { id, title, goal: goal ?? "", stories: [], status: "active" };
-  fs28.writeFileSync(path29.join(epicsDir, `${id}.md`), epicToMarkdown(epic), "utf8");
+  const epic = { id, title, goal: goal ?? "", stories: [], status: "active", prdId: prdId ?? null };
+  fs29.writeFileSync(path30.join(epicsDir, `${id}.md`), epicToMarkdown(epic), "utf8");
   return epic;
 }
 function listEpics(epicsDir) {
-  if (!fs28.existsSync(epicsDir)) return [];
-  return fs28.readdirSync(epicsDir).filter((f) => f.match(/^EPC-\d+\.md$/)).map((f) => parseEpicFile(path29.join(epicsDir, f))).filter((e) => e !== null).sort((a, b) => {
+  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) => {
     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 = path29.join(epicsDir, `${id}.md`);
-  if (!fs28.existsSync(filePath)) return null;
+  const filePath = path30.join(epicsDir, `${id}.md`);
+  if (!fs29.existsSync(filePath)) return null;
   return parseEpicFile(filePath);
 }
 function formatEpicCard(epic, stories) {
@@ -6397,25 +6624,188 @@ function formatEpicCard(epic, stories) {
   return lines.join("\n");
 }
 
+// src/product.ts
+init_js_yaml();
+import fs30 from "node:fs";
+import path31 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));
+  const max = existing.length > 0 ? Math.max(...existing) : 0;
+  return `PRD-${max + 1}`;
+}
+function prdToMarkdown(prd) {
+  const frontmatter = jsYaml.dump({
+    id: prd.id,
+    title: prd.title,
+    date: prd.date,
+    status: prd.status
+  });
+  return `---
+${frontmatter}---
+
+# PRD: ${prd.title}
+
+## Problem Statement
+<!-- Was ist das Problem? -->
+
+## Target Users
+<!-- Wer sind die Nutzer? -->
+
+## Goals
+<!-- Messbare Ziele -->
+
+## Non-Goals
+<!-- Explizit nicht in Scope -->
+
+## Requirements
+1.
+
+## Success Metrics
+
+## Open Questions
+`;
+}
+function parsePrdFile(filePath) {
+  try {
+    const content = fs30.readFileSync(filePath, "utf8");
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match) return null;
+    const data = jsYaml.load(match[1]);
+    if (!data || typeof data.id !== "string") return null;
+    return {
+      id: data.id,
+      title: typeof data.title === "string" ? data.title : "",
+      date: typeof data.date === "string" ? data.date : "",
+      status: data.status ?? "draft",
+      filepath: filePath
+    };
+  } catch {
+    return null;
+  }
+}
+function createPrd(prdsDir, title) {
+  fs30.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 prd = { id, title, date: today, status: "draft", filepath };
+  fs30.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) => {
+    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"));
+  for (const f of files) {
+    const prd = parsePrdFile(path31.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 today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const prds = listPrds(prdsDir);
+  const epics = listEpics(epicsDir);
+  const stories = listStories(storiesDir);
+  const lines = [];
+  lines.push("# Roadmap");
+  lines.push("");
+  lines.push(`_Generiert am ${today} von fh product roadmap_`);
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  for (const prd of prds) {
+    lines.push(`## ${prd.id}: ${prd.title} [${prd.status}]`);
+    lines.push("");
+    lines.push(`> PRD-Datum: ${prd.date}`);
+    lines.push("");
+    const linkedEpics = epics.filter((e) => e.prdId === prd.id);
+    if (linkedEpics.length === 0) {
+      lines.push("_Keine Epics verkn\xFCpft_");
+    } else {
+      for (const epic of linkedEpics) {
+        lines.push(`### ${epic.id}: ${epic.title} [${epic.status}]`);
+        lines.push("");
+        const epicStories = stories.filter((s) => s.epicId === epic.id);
+        if (epicStories.length === 0) {
+          lines.push("_Keine Stories_");
+        } else {
+          lines.push("| Story | Status | Punkte |");
+          lines.push("|---|---|---|");
+          let total = 0;
+          for (const s of epicStories) {
+            const pts = s.points !== null ? String(s.points) : "?";
+            total += s.points ?? 0;
+            lines.push(`| ${s.id}: ${s.title} | ${s.status} | ${pts} |`);
+          }
+          lines.push("");
+          lines.push(`**Gesamt: ${total} Punkte**`);
+        }
+        lines.push("");
+      }
+    }
+    lines.push("---");
+    lines.push("");
+  }
+  const orphanEpics = epics.filter((e) => !e.prdId);
+  if (orphanEpics.length > 0) {
+    lines.push("## Ohne PRD");
+    lines.push("");
+    for (const epic of orphanEpics) {
+      lines.push(`### ${epic.id}: ${epic.title} [${epic.status}]`);
+      lines.push("");
+      const epicStories = stories.filter((s) => s.epicId === epic.id);
+      if (epicStories.length === 0) {
+        lines.push("_Keine Stories_");
+      } else {
+        lines.push("| Story | Status | Punkte |");
+        lines.push("|---|---|---|");
+        for (const s of epicStories) {
+          const pts = s.points !== null ? String(s.points) : "?";
+          lines.push(`| ${s.id}: ${s.title} | ${s.status} | ${pts} |`);
+        }
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+
 // src/velocity.ts
-import fs29 from "node:fs";
-import path30 from "node:path";
+import fs31 from "node:fs";
+import path32 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 (!fs29.existsSync(velocityFile)) {
-    fs29.mkdirSync(path30.dirname(velocityFile), { recursive: true });
-    fs29.writeFileSync(velocityFile, HEADER + row, "utf8");
+  if (!fs31.existsSync(velocityFile)) {
+    fs31.mkdirSync(path32.dirname(velocityFile), { recursive: true });
+    fs31.writeFileSync(velocityFile, HEADER + row, "utf8");
   } else {
-    fs29.appendFileSync(velocityFile, row, "utf8");
+    fs31.appendFileSync(velocityFile, row, "utf8");
   }
 }
 function getVelocityHistory(velocityFile) {
-  if (!fs29.existsSync(velocityFile)) return [];
-  const content = fs29.readFileSync(velocityFile, "utf8");
+  if (!fs31.existsSync(velocityFile)) return [];
+  const content = fs31.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);
@@ -6456,22 +6846,22 @@ function formatVelocityReport(history) {
 
 // src/docs.ts
 init_js_yaml();
-import fs30 from "node:fs";
-import path31 from "node:path";
+import fs32 from "node:fs";
+import path33 from "node:path";
 import { spawnSync as spawnSync11 } from "node:child_process";
 var SOURCE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".py", ".go"];
-var IGNORE_DIRS3 = ["node_modules", ".git", "dist", ".forgehive", "coverage", ".next", "build", "test", "__tests__", "spec"];
-var EXPORT_PATTERNS = [
+var IGNORE_DIRS4 = ["node_modules", ".git", "dist", ".forgehive", "coverage", ".next", "build", "test", "__tests__", "spec"];
+var EXPORT_PATTERNS2 = [
   /^export\s+(?:async\s+)?function\s+(\w+)/gm,
   /^export\s+(?:const|let|var)\s+(\w+)/gm,
   /^export\s+(?:class|interface|type|enum)\s+(\w+)/gm,
   /^export\s+default\s+(?:function\s+)?(\w+)?/gm
 ];
 function readCapabilities2(forgehiveDir2) {
-  const capPath = path31.join(forgehiveDir2, "capabilities.yaml");
-  if (!fs30.existsSync(capPath)) return {};
+  const capPath = path33.join(forgehiveDir2, "capabilities.yaml");
+  if (!fs32.existsSync(capPath)) return {};
   try {
-    return jsYaml.load(fs30.readFileSync(capPath, "utf8")) ?? {};
+    return jsYaml.load(fs32.readFileSync(capPath, "utf8")) ?? {};
   } catch {
     return {};
   }
@@ -6498,11 +6888,11 @@ function extractCapabilityInfo(caps) {
   return { language, packageManager };
 }
 function readMemoryFiles2(forgehiveDir2) {
-  const memDir = path31.join(forgehiveDir2, "memory");
-  if (!fs30.existsSync(memDir)) return {};
+  const memDir = path33.join(forgehiveDir2, "memory");
+  if (!fs32.existsSync(memDir)) return {};
   const result = {};
-  for (const f of fs30.readdirSync(memDir).filter((f2) => f2.endsWith(".md") && f2 !== "MEMORY.md")) {
-    result[f] = fs30.readFileSync(path31.join(memDir, f), "utf8");
+  for (const f of fs32.readdirSync(memDir).filter((f2) => f2.endsWith(".md") && f2 !== "MEMORY.md")) {
+    result[f] = fs32.readFileSync(path33.join(memDir, f), "utf8");
   }
   return result;
 }
@@ -6513,7 +6903,7 @@ function getRecentCommits2(projectRoot2, n = 10) {
 }
 function extractExports(content) {
   const exports = [];
-  for (const pattern of EXPORT_PATTERNS) {
+  for (const pattern of EXPORT_PATTERNS2) {
     pattern.lastIndex = 0;
     let m;
     while ((m = pattern.exec(content)) !== null) {
@@ -6525,19 +6915,19 @@ function extractExports(content) {
 function walkSourceFiles(dir) {
   const results = [];
   function walk(current) {
-    if (!fs30.existsSync(current)) return;
-    for (const entry of fs30.readdirSync(current, { withFileTypes: true })) {
-      if (IGNORE_DIRS3.includes(entry.name)) continue;
-      const full = path31.join(current, entry.name);
+    if (!fs32.existsSync(current)) return;
+    for (const entry of fs32.readdirSync(current, { withFileTypes: true })) {
+      if (IGNORE_DIRS4.includes(entry.name)) continue;
+      const full = path33.join(current, entry.name);
       if (entry.isDirectory()) walk(full);
-      else if (entry.isFile() && SOURCE_EXTS.includes(path31.extname(entry.name))) results.push(full);
+      else if (entry.isFile() && SOURCE_EXTS.includes(path33.extname(entry.name))) results.push(full);
     }
   }
   walk(dir);
   return results;
 }
 function generateUserGuide(projectRoot2, forgehiveDir2) {
-  const projectName = path31.basename(projectRoot2);
+  const projectName = path33.basename(projectRoot2);
   const caps = readCapabilities2(forgehiveDir2);
   const { language: lang, packageManager, entryPoints } = extractCapabilityInfo(caps);
   const memFiles = readMemoryFiles2(forgehiveDir2);
@@ -6616,8 +7006,8 @@ function generateUserGuide(projectRoot2, forgehiveDir2) {
   return lines.join("\n");
 }
 function generateApiReference(projectRoot2) {
-  const srcDir = path31.join(projectRoot2, "src");
-  const searchDir = fs30.existsSync(srcDir) ? srcDir : projectRoot2;
+  const srcDir = path33.join(projectRoot2, "src");
+  const searchDir = fs32.existsSync(srcDir) ? srcDir : projectRoot2;
   const files = walkSourceFiles(searchDir);
   const lines = [];
   lines.push("# API Reference");
@@ -6631,13 +7021,13 @@ function generateApiReference(projectRoot2) {
   for (const filePath of files) {
     let content = "";
     try {
-      content = fs30.readFileSync(filePath, "utf8");
+      content = fs32.readFileSync(filePath, "utf8");
     } catch {
       continue;
     }
     const exports = extractExports(content);
     if (exports.length === 0) continue;
-    const relPath = path31.relative(projectRoot2, filePath);
+    const relPath = path33.relative(projectRoot2, filePath);
     lines.push(`## \`${relPath}\``);
     lines.push("");
     lines.push("**Exports:**");
@@ -6649,27 +7039,314 @@ function generateApiReference(projectRoot2) {
 }
 function listExistingDocs(projectRoot2) {
   const docs = [];
-  const docsDir = path31.join(projectRoot2, "docs");
-  if (fs30.existsSync(docsDir)) {
-    for (const f of fs30.readdirSync(docsDir)) {
-      if (f.endsWith(".md")) docs.push(path31.join(docsDir, f));
+  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 rootDocs = ["README.md", "CHANGELOG.md", "ONBOARDING.md", "CONTRIBUTING.md"];
   for (const f of rootDocs) {
-    const full = path31.join(projectRoot2, f);
-    if (fs30.existsSync(full)) docs.push(full);
+    const full = path33.join(projectRoot2, f);
+    if (fs32.existsSync(full)) docs.push(full);
   }
   return docs;
 }
 
+// src/router.ts
+import fs33 from "node:fs";
+import path34 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"],
+  suki: ["design", "ux", "user experience", "wireframe", "flow", "empathy", "persona", "interface"],
+  viktor: ["architecture", "refactor", "structure", "pattern", "scalability", "coupling", "abstraction"],
+  eli: ["docs", "documentation", "readme", "onboarding", "guide", "tutorial", "wiki", "changelog"],
+  nora: ["research", "analyze", "compare", "benchmark", "investigate", "evidence", "survey"],
+  remy: ["product", "feature", "requirement", "roadmap", "user story", "prd", "launch", "strategy"],
+  kai: ["bug", "fix", "implement", "function", "error", "crash", "broken", "failing"]
+};
+var AGENT_DESCRIPTIONS = {
+  vera: "Security Analyst",
+  sam: "QA & Test Architect",
+  suki: "UX Designer",
+  viktor: "System Architect",
+  eli: "Technical Writer",
+  nora: "Senior Research Analyst",
+  remy: "Creative Strategist",
+  kai: "Senior Engineer"
+};
+var PARTY_DESCRIPTIONS = {
+  build: "Viktor + Kai + Sam \u2014 Architecture + Engineering + QA",
+  review: "Kai + Sam + Eli \u2014 Code Review + QA + Docs",
+  refactor: "Viktor + Sam + Eli \u2014 Refactor + Tests + Docs",
+  security: "Vera + Sam \u2014 Security Review + QA",
+  full: "All agents"
+};
+function scoreAgents(task) {
+  const lower = task.toLowerCase();
+  const scores = /* @__PURE__ */ new Map();
+  for (const [agent, keywords] of Object.entries(AGENT_KEYWORDS)) {
+    const matched = [];
+    for (const kw of keywords) {
+      if (lower.includes(kw)) {
+        matched.push(kw);
+      }
+    }
+    if (matched.length > 0) {
+      scores.set(agent, matched);
+    }
+  }
+  return scores;
+}
+var _lastTask = "";
+function resolvePartySet(scores) {
+  const activeAgents = [...scores.keys()];
+  if (activeAgents.length >= 3) {
+    return "full";
+  }
+  if (scores.has("vera") && _lastTask.toLowerCase().includes("review")) {
+    return "security";
+  }
+  if (scores.has("viktor") && scores.has("sam")) {
+    return "refactor";
+  }
+  if (scores.has("viktor") && scores.has("kai")) {
+    return "build";
+  }
+  if (scores.has("suki") && scores.has("kai")) {
+    return "build";
+  }
+  return null;
+}
+function routeTask(task) {
+  _lastTask = task;
+  const scores = scoreAgents(task);
+  const partySet = resolvePartySet(scores);
+  if (partySet) {
+    const agentList = [...scores.keys()];
+    const matchedKws = agentList.flatMap((a) => scores.get(a) ?? []);
+    return {
+      type: "party",
+      partySet,
+      confidence: "high",
+      reasoning: `Multi-domain keywords erkannt (${matchedKws.slice(0, 4).join(", ")})`
+    };
+  }
+  if (scores.size === 0) {
+    return {
+      type: "agent",
+      agent: "kai",
+      confidence: "low",
+      reasoning: "Keine spezifischen Keywords erkannt \u2014 Fallback zu Kai"
+    };
+  }
+  let topAgent = "kai";
+  let topCount = 0;
+  let secondCount = 0;
+  for (const [agent, kws] of scores.entries()) {
+    if (kws.length > topCount) {
+      secondCount = topCount;
+      topCount = kws.length;
+      topAgent = agent;
+    } else if (kws.length > secondCount) {
+      secondCount = kws.length;
+    }
+  }
+  const topKeywords = scores.get(topAgent) ?? [];
+  const confidence = topCount >= 2 && topCount > secondCount ? "high" : "medium";
+  return {
+    type: "agent",
+    agent: topAgent,
+    confidence,
+    reasoning: `Keywords erkannt: ${topKeywords.join(", ")}`
+  };
+}
+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();
+  }
+  return void 0;
+}
+function formatRoutingResult(result, worktreePath) {
+  const lines = [];
+  if (result.type === "party" && result.partySet) {
+    const desc = PARTY_DESCRIPTIONS[result.partySet] ?? result.partySet;
+    lines.push(`Empfehlung: Party-Set "${result.partySet}" \u2014 ${desc}`);
+    lines.push(`Begr\xFCndung: ${result.reasoning}`);
+    lines.push("");
+    lines.push("Starten:");
+    lines.push(`  fh party run ${result.partySet}`);
+  } else {
+    const agent = result.agent ?? "kai";
+    const desc = AGENT_DESCRIPTIONS[agent] ?? agent;
+    lines.push(`Empfehlung: ${agent.charAt(0).toUpperCase() + agent.slice(1)} \u2014 ${desc}`);
+    lines.push(`Begr\xFCndung: ${result.reasoning}`);
+    lines.push(`Confidence: ${result.confidence}`);
+    lines.push("");
+    lines.push("Starten:");
+    const wtPath = worktreePath ?? `<${agent}-worktree>`;
+    lines.push(`  cd ${wtPath} && claude`);
+  }
+  return lines.join("\n");
+}
+
+// src/github.ts
+init_js_yaml();
+import fs34 from "node:fs";
+import path35 from "node:path";
+import https from "node:https";
+function loadGitHubConfig(forgehiveDir2) {
+  const configPath = path35.join(forgehiveDir2, "github.yaml");
+  if (!fs34.existsSync(configPath)) {
+    throw new Error("Nicht konfiguriert. F\xFChre zuerst aus: fh github setup");
+  }
+  let parsed;
+  try {
+    parsed = jsYaml.load(fs34.readFileSync(configPath, "utf8"));
+  } catch {
+    throw new Error("Ung\xFCltige Konfigurationsdatei: .forgehive/github.yaml ist kein g\xFCltiges YAML.");
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error("Ung\xFCltige Konfigurationsdatei: .forgehive/github.yaml enth\xE4lt kein Objekt.");
+  }
+  const data = parsed;
+  if (!data.repo) {
+    throw new Error("Nicht konfiguriert. F\xFChre zuerst aus: fh github setup");
+  }
+  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");
+}
+function githubGet(apiPath, token) {
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: "api.github.com",
+      path: apiPath,
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "User-Agent": "forgehive-cli",
+        "Accept": "application/vnd.github.v3+json"
+      }
+    };
+    https.get(options, (res) => {
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+      res.on("error", reject);
+      res.on("end", () => {
+        if (res.statusCode === 401) {
+          reject(new Error("Ung\xFCltiger Token. \xDCberpr\xFCfe dein GitHub-Token."));
+          return;
+        }
+        if (res.statusCode === 404) {
+          reject(new Error(`Repository oder Ressource nicht gefunden.`));
+          return;
+        }
+        if (res.statusCode === 403) {
+          const reset = res.headers["x-ratelimit-reset"];
+          const resetTime = reset ? new Date(parseInt(reset, 10) * 1e3).toLocaleTimeString() : "unbekannt";
+          reject(new Error(`Rate Limit erreicht. Wird zur\xFCckgesetzt um ${resetTime}.`));
+          return;
+        }
+        if ((res.statusCode ?? 0) >= 400) {
+          reject(new Error(`GitHub API ${res.statusCode}: ${data}`));
+          return;
+        }
+        try {
+          resolve(JSON.parse(data));
+        } catch (e) {
+          reject(new Error(`JSON parse error: ${e.message}`));
+        }
+      });
+    }).on("error", reject);
+  });
+}
+async function fetchOpenIssues(owner, repo, token) {
+  const issues = [];
+  let page = 1;
+  while (true) {
+    const batch = await githubGet(
+      `/repos/${owner}/${repo}/issues?state=open&per_page=100&page=${page}&filter=issues`,
+      token
+    );
+    if (batch.length === 0) break;
+    const filtered = batch.filter((i) => !i.pull_request);
+    issues.push(...filtered);
+    if (batch.length < 100) break;
+    page++;
+  }
+  return issues;
+}
+async function fetchPR(owner, repo, number, token) {
+  return githubGet(`/repos/${owner}/${repo}/pulls/${number}`, token);
+}
+async function fetchPRFiles(owner, repo, number, token) {
+  const files = [];
+  let page = 1;
+  while (true) {
+    const batch = await githubGet(
+      `/repos/${owner}/${repo}/pulls/${number}/files?per_page=100&page=${page}`,
+      token
+    );
+    if (batch.length === 0) break;
+    files.push(...batch);
+    if (batch.length < 100) break;
+    page++;
+  }
+  return files;
+}
+function issueAlreadySynced(storiesDir, issueNumber) {
+  if (!fs34.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")));
+}
+function appendGitHubRef(storiesDir, storyId, issue, repoFullName) {
+  const filePath = path35.join(storiesDir, `${storyId}.md`);
+  if (!fs34.existsSync(filePath)) {
+    throw new Error(`Story-Datei nicht gefunden: ${storyId}.md`);
+  }
+  const existing = fs34.readFileSync(filePath, "utf8");
+  const ref = `
+## GitHub
+
+GitHub: #${issue.number} \u2014 ${issue.html_url}
+`;
+  fs34.writeFileSync(filePath, existing.trimEnd() + "\n" + ref, "utf8");
+}
+function formatPRContext(pr, files, repoFullName) {
+  const body = pr.body?.trim() || "(keine Beschreibung)";
+  const fileLines = files.map((f) => `- \`${f.filename}\` (${f.status})`).join("\n");
+  return [
+    `# PR #${pr.number}: ${pr.title}`,
+    "",
+    `**Branch:** ${pr.head.ref} \u2192 ${pr.base.ref}`,
+    `**Autor:** @${pr.user.login}`,
+    `**Diff-URL:** https://github.com/${repoFullName}/pull/${pr.number}/files`,
+    "",
+    "## Beschreibung",
+    "",
+    body,
+    "",
+    "## Ge\xE4nderte Dateien",
+    "",
+    fileLines || "(keine Dateien)"
+  ].join("\n");
+}
+
 // src/cli.ts
 import { createRequire } from "node:module";
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
 var [, , command, subcommand, ...rest] = process.argv;
 var projectRoot = process.cwd();
-var forgehiveDir = path32.join(projectRoot, ".forgehive");
+var forgehiveDir = path36.join(projectRoot, ".forgehive");
 if (command === "--version" || command === "-v") {
   console.log(version);
   process.exit(0);
@@ -6682,7 +7359,7 @@ USAGE
   fh <command> [subcommand] [options]
 
 SETUP
-  fh init                          Set up forgehive in the current project
+  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 status                        Show current project state
@@ -6703,7 +7380,7 @@ CI
   fh ci --init                     Generate GitHub Actions workflow
 
 CODEBASE
-  fh map                           Codebase structure map
+  fh map [--semantic]              Codebase structure map + semantic graph
   fh onboard [--output path]       Generate ONBOARDING.md
   fh changelog [--since tag]       Semantic changelog from git
   fh metrics [--since date]        Developer productivity metrics
@@ -6714,6 +7391,11 @@ CODEBASE
   fh docs changelog [--since tag]  Generate changelog
   fh docs adr "<title>"            Create Architecture Decision Record
 
+GITHUB
+  fh github setup                  Configure GitHub token and repository
+  fh github sync                   Import open Issues as Stories (idempotent)
+  fh github pr <number>            Fetch PR context for code review
+
 SPRINT PLANNING
   fh story create <title> [--epic EPC-N] [--points N]
   fh story list [--epic EPC-N]
@@ -6727,8 +7409,10 @@ SPRINT PLANNING
   fh velocity record <N> --committed N --delivered N
 
 TEAM
+  fh ask "<task>"                  Route a task to the right agent or party set
   fh sync push|pull [--remote origin --branch forgehive-memory]
   fh run <issue-url> [--agent name] [--label label]
+  fh run "<task>"                  Freetext task \u2014 auto-routes like fh ask
   fh memory show|clean|export|prune|snapshot
   fh memory adr list|"<title>"
 
@@ -6749,51 +7433,87 @@ COST
   process.exit(0);
 }
 function loadClaudeMdBlock() {
-  const templatePath = path32.join(
-    path32.dirname(new URL(import.meta.url).pathname),
+  const templatePath = path36.join(
+    path36.dirname(new URL(import.meta.url).pathname),
     "..",
     "forgehive",
     "templates",
     "claude-md.block.md"
   );
-  if (!fs31.existsSync(templatePath)) return "## forgehive\n\nSee .forgehive/ for configuration.";
-  return fs31.readFileSync(templatePath, "utf8");
+  if (!fs35.existsSync(templatePath)) return "## forgehive\n\nSee .forgehive/ for configuration.";
+  return fs35.readFileSync(templatePath, "utf8");
+}
+async function promptConfirm(question) {
+  if (!process.stdin.isTTY) return false;
+  const rl = createInterface({ 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 === "");
+    });
+  });
 }
-if (command === "init") {
-  const forgehiveDirExists = fs31.existsSync(forgehiveDir);
-  if (forgehiveDirExists && !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).`);
-    console.log(`  Nutze 'fh scan --update' um nur den Scan zu aktualisieren.`);
-    process.exit(0);
+function buildCapabilitySummary(ids) {
+  if (ids.length === 0) return "  Erkannt: (keine Capabilities)";
+  const lines = [];
+  for (let i = 0; i < ids.length && lines.length < 4; i += 4) {
+    lines.push("  \u2022 " + ids.slice(i, i + 4).join(" \xB7 "));
   }
-  console.log("\u{1F50D} Analysiere Projekt...\n");
-  const scanResult = scan(projectRoot);
-  const tierCount = [1, 2, 3].map((t) => scanResult.signals.filter((s) => s.tier === t).length);
-  console.log(`  \u2713 ${tierCount[0]} Technologie-Signale erkannt`);
-  console.log(`  \u2713 ${tierCount[1]} Infrastruktur-Signale erkannt`);
-  console.log(`  \u2713 ${tierCount[2]} Kontext-Signale erkannt`);
-  console.log();
-  const capMap = mapSignalsToCapabilities(scanResult);
-  const block = loadClaudeMdBlock();
-  writeForgehiveDir(projectRoot, scanResult, capMap, block);
-  const hash = computeHash(projectRoot);
-  fs31.writeFileSync(path32.join(forgehiveDir, ".scan-hash"), hash, "utf8");
-  const runtimeDir = path32.join(
-    path32.dirname(new URL(import.meta.url).pathname),
-    "..",
-    "forgehive"
-  );
-  initForgehiveRuntime(forgehiveDir, runtimeDir);
-  console.log("\u2713 .forgehive/ eingerichtet");
-  console.log("\u2713 CLAUDE.md aktualisiert\n");
-  console.log("Erkannte Capabilities:");
-  for (const cap of capMap.confirmed) {
-    console.log(`  + ${cap.id} (aus ${cap.source})`);
-  }
-  console.log("\nN\xE4chster Schritt:");
-  console.log("  Pr\xFCfe .forgehive/capabilities.yaml und f\xFChre dann aus:");
-  console.log("  fh confirm\n");
+  return "  Erkannt:\n" + lines.join("\n");
+}
+if (command === "init") {
+  (async () => {
+    const gitCheck = spawnSync12("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);
+    if (forgehiveDirExists && !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).`);
+      console.log(`  Nutze 'fh scan --update' um nur den Scan zu aktualisieren.`);
+      process.exit(0);
+    }
+    console.log("\u{1F50D} Analysiere Projekt...\n");
+    const scanResult = scan(projectRoot);
+    const tierCount = [1, 2, 3].map((t) => scanResult.signals.filter((s) => s.tier === t).length);
+    console.log(`  \u2713 ${tierCount[0]} Technologie-Signale erkannt`);
+    console.log(`  \u2713 ${tierCount[1]} Infrastruktur-Signale erkannt`);
+    console.log(`  \u2713 ${tierCount[2]} Kontext-Signale erkannt`);
+    console.log();
+    const capMap = mapSignalsToCapabilities(scanResult);
+    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),
+      "..",
+      "forgehive"
+    );
+    initForgehiveRuntime(forgehiveDir, runtimeDir);
+    console.log("\u2713 forgehive initialisiert\n");
+    console.log(buildCapabilitySummary(capMap.confirmed.map((c) => c.id)));
+    console.log();
+    if (subcommand === "--yes" || rest.includes("--yes")) {
+      confirm(projectRoot);
+      console.log("\u2713 Capabilities best\xE4tigt\n");
+    } else {
+      const ok = await promptConfirm("  Capabilities best\xE4tigen? [Y/n] ");
+      if (ok) {
+        confirm(projectRoot);
+        console.log("\u2713 Capabilities best\xE4tigt\n");
+      } else {
+        console.log("  \xDCberpr\xFCfe .forgehive/capabilities.yaml, dann: fh confirm\n");
+      }
+    }
+  })().catch((err) => {
+    console.error(`Fehler: ${err.message}`);
+    process.exit(1);
+  });
 } else if (command === "confirm") {
   try {
     confirm(projectRoot);
@@ -6812,7 +7532,7 @@ if (command === "init") {
     process.exit(1);
   }
 } else if (command === "memory") {
-  if (!fs31.existsSync(forgehiveDir)) {
+  if (!fs35.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -6821,7 +7541,7 @@ if (command === "init") {
   } else if (subcommand === "clean") {
     cleanMemory(forgehiveDir);
   } else if (subcommand === "export") {
-    const outputPath = rest[0] ?? path32.join(projectRoot, "forgehive-memory-export.md");
+    const outputPath = rest[0] ?? path36.join(projectRoot, "forgehive-memory-export.md");
     try {
       exportMemory(forgehiveDir, outputPath);
     } catch (err) {
@@ -6869,7 +7589,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] ?? path32.join(
+      const outPath = rest[1] ?? path36.join(
         projectRoot,
         `forgehive-snapshot-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.json`
       );
@@ -6909,11 +7629,11 @@ Ausf\xFChren mit --remove um zu l\xF6schen: fh memory prune ${days} --remove`);
     process.exit(1);
   }
 } else if (command === "scan" && subcommand === "--update") {
-  if (!fs31.existsSync(forgehiveDir)) {
+  if (!fs35.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
-  const savedHash = fs31.existsSync(path32.join(forgehiveDir, ".scan-hash")) ? fs31.readFileSync(path32.join(forgehiveDir, ".scan-hash"), "utf8").trim() : null;
+  const savedHash = fs35.existsSync(path36.join(forgehiveDir, ".scan-hash")) ? fs35.readFileSync(path36.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");
@@ -6921,7 +7641,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(
-    fs31.readFileSync(path32.join(forgehiveDir, "capabilities.yaml"), "utf8")
+    fs35.readFileSync(path36.join(forgehiveDir, "capabilities.yaml"), "utf8")
   );
   const oldMap = { confirmed: oldDoc.capabilities.confirmed ?? [], inferred: [] };
   const scanResult = scan(projectRoot);
@@ -6941,16 +7661,16 @@ Ausf\xFChren mit --remove um zu l\xF6schen: fh memory prune ${days} --remove`);
     console.log();
     const block = loadClaudeMdBlock();
     writeForgehiveDir(projectRoot, scanResult, newMap, block);
-    fs31.writeFileSync(path32.join(forgehiveDir, ".scan-hash"), currentHash, "utf8");
+    fs35.writeFileSync(path36.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 (!fs31.existsSync(path32.join(forgehiveDir, ".scan-hash"))) {
+  if (!fs35.existsSync(path36.join(forgehiveDir, ".scan-hash"))) {
     console.log("Warnung: Kein Scan-Hash gefunden. F\xFChre `fh init` aus.");
     process.exit(1);
   }
-  const saved = fs31.readFileSync(path32.join(forgehiveDir, ".scan-hash"), "utf8").trim();
+  const saved = fs35.readFileSync(path36.join(forgehiveDir, ".scan-hash"), "utf8").trim();
   const current = computeHash(projectRoot);
   if (saved !== current) {
     console.log("\u26A0 Codebase hat sich seit letztem Scan ge\xE4ndert.");
@@ -6959,7 +7679,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 (!fs31.existsSync(forgehiveDir)) {
+  if (!fs35.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -6995,7 +7715,7 @@ Ausf\xFChren mit --remove um zu l\xF6schen: fh memory prune ${days} --remove`);
     process.exit(1);
   }
 } else if (command === "party") {
-  if (!fs31.existsSync(forgehiveDir)) {
+  if (!fs35.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -7116,7 +7836,7 @@ Ausf\xFChren mit --remove um zu l\xF6schen: fh memory prune ${days} --remove`);
     }
   }
 } else if (command === "wire") {
-  if (!fs31.existsSync(forgehiveDir)) {
+  if (!fs35.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -7155,7 +7875,7 @@ N\xE4chster Schritt: Setze die erforderlichen Umgebungsvariablen und starte Clau
   const limitIdx = allArgs.indexOf("--limit");
   const alertIdx = allArgs.indexOf("--alert");
   if (limitIdx !== -1) {
-    if (!fs31.existsSync(forgehiveDir)) {
+    if (!fs35.existsSync(forgehiveDir)) {
       console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
       process.exit(1);
     }
@@ -7181,14 +7901,14 @@ N\xE4chster Schritt: Setze die erforderlichen Umgebungsvariablen und starte Clau
     }
     const sessions = parseCostSessions(projectRoot);
     console.log(formatCostReport(sessions, range));
-    if (fs31.existsSync(forgehiveDir)) {
+    if (fs35.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 (!fs31.existsSync(forgehiveDir)) {
+  if (!fs35.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -7204,7 +7924,7 @@ N\xE4chster Schritt: Setze die erforderlichen Umgebungsvariablen und starte Clau
     process.exit(0);
   });
 } else if (command === "mcp") {
-  if (!fs31.existsSync(forgehiveDir)) {
+  if (!fs35.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -7315,7 +8035,7 @@ Setze diese Umgebungsvariablen:`);
     process.exit(1);
   }
 } else if (command === "security") {
-  if (!fs31.existsSync(forgehiveDir)) {
+  if (!fs35.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -7401,8 +8121,8 @@ Setze diese Umgebungsvariablen:`);
 `);
     const report = generateSecurityReport(projectRoot, forgehiveDir, mode);
     const text = formatSecurityReport(report);
-    const reportPath = path32.join(forgehiveDir, "security-report.md");
-    fs31.writeFileSync(reportPath, text, "utf8");
+    const reportPath = path36.join(forgehiveDir, "security-report.md");
+    fs35.writeFileSync(reportPath, text, "utf8");
     console.log(text);
     console.log(`
 \u2713 Report gespeichert: ${reportPath}`);
@@ -7414,8 +8134,8 @@ Setze diese Umgebungsvariablen:`);
   } else if (subcommand === "permissions") {
     const { writePermissions: writePermissions2 } = await Promise.resolve().then(() => (init_harness(), harness_exports));
     writePermissions2(forgehiveDir);
-    const permPath = path32.join(forgehiveDir, "harness", "permissions.yaml");
-    console.log(fs31.readFileSync(permPath, "utf8"));
+    const permPath = path36.join(forgehiveDir, "harness", "permissions.yaml");
+    console.log(fs35.readFileSync(permPath, "utf8"));
   } else {
     console.error(`Unbekannter security-Subcommand: ${subcommand}`);
     console.error("Verf\xFCgbar: scan | deps | audit | report [gdpr|soc2|hipaa|none] | permissions");
@@ -7427,36 +8147,62 @@ 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 = path32.join(projectRoot, ".github", "workflows");
-    fs31.mkdirSync(ghDir, { recursive: true });
-    const outPath = path32.join(ghDir, "forgehive.yml");
-    fs31.writeFileSync(outPath, getGithubActionsTemplate(), "utf8");
+    const ghDir = path36.join(projectRoot, ".github", "workflows");
+    fs35.mkdirSync(ghDir, { recursive: true });
+    const outPath = path36.join(ghDir, "forgehive.yml");
+    fs35.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") {
-      fs31.mkdirSync(forgehiveDir, { recursive: true });
-      fs31.writeFileSync(path32.join(forgehiveDir, "ci-report.json"), output, "utf8");
+      fs35.mkdirSync(forgehiveDir, { recursive: true });
+      fs35.writeFileSync(path36.join(forgehiveDir, "ci-report.json"), output, "utf8");
     }
     if (report.status === "fail") process.exit(1);
   }
 } else if (command === "map") {
+  const semanticFlag = rest.includes("--semantic");
   const map2 = generateMap(projectRoot);
-  const md = formatMap(map2);
-  const mapPath = path32.join(forgehiveDir, "map.md");
-  fs31.mkdirSync(forgehiveDir, { recursive: true });
-  fs31.writeFileSync(mapPath, md, "utf8");
-  console.log(md);
-  console.log(`
+  const semantic = buildSemanticMap(projectRoot);
+  const mapPath = path36.join(forgehiveDir, "map.md");
+  fs35.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");
+    console.log(semanticMd);
+    console.log(`
+\u2714 Codebase-Map gespeichert (Semantic Graph hervorgehoben): ${mapPath}`);
+  } else {
+    const md = formatMap(map2, semantic);
+    fs35.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 ?? path32.join(projectRoot, "ONBOARDING.md");
+  const outputPath = outputArg ?? path36.join(projectRoot, "ONBOARDING.md");
   const doc = generateOnboardingDoc(projectRoot, forgehiveDir);
-  fs31.writeFileSync(outputPath, doc, "utf8");
+  fs35.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(" ");
+  if (!taskArg.trim()) {
+    console.error('Usage: fh ask "<aufgabenbeschreibung>"');
+    process.exit(1);
+  }
+  const askResult = routeTask(taskArg);
+  const askWorktree = resolveWorktreePath(forgehiveDir, askResult.agent);
+  console.log(`
+Task: "${taskArg}"
+`);
+  console.log(formatRoutingResult(askResult, askWorktree));
+  console.log();
 } else if (command === "changelog") {
   const sinceArg = rest.includes("--since") ? rest[rest.indexOf("--since") + 1] : null;
   const outputArg = rest.includes("--output") ? rest[rest.indexOf("--output") + 1] : null;
@@ -7465,28 +8211,28 @@ Setze diese Umgebungsvariablen:`);
   const commits = parseGitLog(rawLog);
   let version2 = "unreleased";
   try {
-    const pkgPath = path32.join(projectRoot, "package.json");
-    if (fs31.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs31.readFileSync(pkgPath, "utf8").replace(/^\s*\/\/.*$/gm, ""));
+    const pkgPath = path36.join(projectRoot, "package.json");
+    if (fs35.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs35.readFileSync(pkgPath, "utf8").replace(/^\s*\/\/.*$/gm, ""));
       version2 = pkg.version ?? "unreleased";
     }
   } catch {
   }
   const md = formatChangelog(commits, version2);
-  const outputPath = outputArg ?? path32.join(projectRoot, "CHANGELOG.md");
+  const outputPath = outputArg ?? path36.join(projectRoot, "CHANGELOG.md");
   let existing = "";
-  if (fs31.existsSync(outputPath)) existing = fs31.readFileSync(outputPath, "utf8");
-  fs31.writeFileSync(outputPath, md + "\n\n" + existing, "utf8");
+  if (fs35.existsSync(outputPath)) existing = fs35.readFileSync(outputPath, "utf8");
+  fs35.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, path32.basename(projectRoot));
-  const metricsPath = path32.join(forgehiveDir, "metrics.md");
-  fs31.mkdirSync(forgehiveDir, { recursive: true });
-  fs31.writeFileSync(metricsPath, md, "utf8");
+  const md = formatMetrics(stats, path36.basename(projectRoot));
+  const metricsPath = path36.join(forgehiveDir, "metrics.md");
+  fs35.mkdirSync(forgehiveDir, { recursive: true });
+  fs35.writeFileSync(metricsPath, md, "utf8");
   console.log(md);
   console.log(`
 \u2714 Metrics gespeichert: ${metricsPath}`);
@@ -7514,14 +8260,26 @@ Setze diese Umgebungsvariablen:`);
     console.error("Usage: fh run <issue-url> [--agent <name>]");
     process.exit(1);
   }
-  const agentArg = rest.includes("--agent") ? rest[rest.indexOf("--agent") + 1] : void 0;
-  const labelArg = rest.includes("--label") ? rest[rest.indexOf("--label") + 1] : void 0;
-  const agentId = agentArg ?? resolveAgent(labelArg);
-  const result = runBackgroundAgent(forgehiveDir, issueUrl, agentId);
-  console.log(`\u2714 ${result.message}`);
-  console.log(`  fh run status   \u2014 aktive Sessions anzeigen`);
+  const looksLikeUrl = issueUrl.startsWith("http://") || issueUrl.startsWith("https://") || /^[\w.-]+\/[\w.-]+#\d+$/.test(issueUrl);
+  if (!looksLikeUrl) {
+    const taskDescription = [issueUrl, ...rest.filter((r) => !r.startsWith("--"))].join(" ");
+    const runRouteResult = routeTask(taskDescription);
+    const runWorktree = resolveWorktreePath(forgehiveDir, runRouteResult.agent);
+    console.log(`
+Task: "${taskDescription}"
+`);
+    console.log(formatRoutingResult(runRouteResult, runWorktree));
+    console.log();
+  } else {
+    const agentArg = rest.includes("--agent") ? rest[rest.indexOf("--agent") + 1] : void 0;
+    const labelArg = rest.includes("--label") ? rest[rest.indexOf("--label") + 1] : void 0;
+    const agentId = agentArg ?? resolveAgent(labelArg);
+    const result = runBackgroundAgent(forgehiveDir, issueUrl, agentId);
+    console.log(`\u2714 ${result.message}`);
+    console.log(`  fh run status   \u2014 aktive Sessions anzeigen`);
+  }
 } else if (command === "story") {
-  const storiesDir = path32.join(forgehiveDir, "memory", "stories");
+  const storiesDir = path36.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;
@@ -7532,7 +8290,7 @@ Setze diese Umgebungsvariablen:`);
     }
     const story = createStory(storiesDir, title, epicArg);
     if (pointsArg) updateStoryPoints(storiesDir, story.id, pointsArg);
-    console.log(`\u2714 ${story.id} erstellt: ${path32.join(storiesDir, story.id + ".md")}`);
+    console.log(`\u2714 ${story.id} erstellt: ${path36.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;
@@ -7581,17 +8339,32 @@ Setze diese Umgebungsvariablen:`);
     console.error("Verf\xFCgbar: fh story create | list | show | done");
   }
 } else if (command === "epic") {
-  const epicsDir = path32.join(forgehiveDir, "memory", "epics");
-  const storiesDir = path32.join(forgehiveDir, "memory", "stories");
+  const epicsDir = path36.join(forgehiveDir, "memory", "epics");
+  const storiesDir = path36.join(forgehiveDir, "memory", "stories");
   if (subcommand === "create") {
-    const title = rest.filter((r) => !r.startsWith("--")).join(" ");
     const goalArg = rest.includes("--goal") ? rest[rest.indexOf("--goal") + 1] : void 0;
+    const prdArg = rest.includes("--prd") ? rest[rest.indexOf("--prd") + 1] : void 0;
+    const flagsWithValues = /* @__PURE__ */ new Set();
+    for (const flag of ["--goal", "--prd"]) {
+      const idx = rest.indexOf(flag);
+      if (idx >= 0) {
+        flagsWithValues.add(flag);
+        if (rest[idx + 1]) flagsWithValues.add(rest[idx + 1]);
+      }
+    }
+    const title = rest.filter((r) => !flagsWithValues.has(r) && !r.startsWith("--")).join(" ");
     if (!title) {
-      console.error("Usage: fh epic create <titel> [--goal <ziel>]");
+      console.error("Usage: fh epic create <titel> [--goal <ziel>] [--prd PRD-N]");
       process.exit(1);
     }
-    const epic = createEpic(epicsDir, title, goalArg);
-    console.log(`\u2714 ${epic.id} erstellt: ${path32.join(epicsDir, epic.id + ".md")}`);
+    if (prdArg) {
+      const prdsDir = path36.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")}`);
+    if (prdArg) console.log(`  Verkn\xFCpft mit: ${prdArg}`);
   } else if (subcommand === "list") {
     const epics = listEpics(epicsDir);
     if (epics.length === 0) {
@@ -7616,8 +8389,94 @@ Setze diese Umgebungsvariablen:`);
   } else {
     console.error("Verf\xFCgbar: fh epic create | list | show");
   }
+} else if (command === "product") {
+  const prdsDir = path36.join(forgehiveDir, "memory", "prds");
+  if (subcommand === "prd") {
+    const title = rest.filter((r) => !r.startsWith("--")).join(" ");
+    if (!title) {
+      console.error('Usage: fh product prd "<titel>"');
+      process.exit(1);
+    }
+    const prd = createPrd(prdsDir, title);
+    const relPath = path36.relative(projectRoot, prd.filepath);
+    console.log(`\u2714 ${prd.id} erstellt: ${relPath}`);
+    console.log(`  Bearbeite die Datei um Anforderungen zu definieren.`);
+  } else if (subcommand === "list") {
+    const prds = listPrds(prdsDir);
+    if (prds.length === 0) {
+      console.log("Keine PRDs gefunden.");
+    } else {
+      console.log("PRDs:");
+      for (const p of prds) {
+        const status = `[${p.status}]`.padEnd(12);
+        console.log(`  ${p.id.padEnd(6)} ${status} ${p.date}  ${p.title}`);
+      }
+    }
+  } else if (subcommand === "show") {
+    const id = rest[0];
+    if (!id) {
+      console.error("Usage: fh product show <PRD-N>");
+      process.exit(1);
+    }
+    const prd = getPrd(prdsDir, id);
+    if (!prd) {
+      console.error(`${id} nicht gefunden`);
+      process.exit(1);
+    }
+    console.log(fs35.readFileSync(prd.filepath, "utf8"));
+  } else if (subcommand === "status") {
+    const epicsDir = path36.join(forgehiveDir, "memory", "epics");
+    const storiesDir = path36.join(forgehiveDir, "memory", "stories");
+    const prds = listPrds(prdsDir);
+    const epics = listEpics(epicsDir);
+    const stories = listStories(storiesDir);
+    console.log("Pipeline:\n");
+    for (const prd of prds) {
+      console.log(`  ${prd.id}: ${prd.title} [${prd.status}]`);
+      const linkedEpics = epics.filter((e) => e.prdId === prd.id);
+      if (linkedEpics.length === 0) {
+        console.log(`    \u2514\u2500\u2500 Keine Epics verkn\xFCpft`);
+      } else {
+        for (let ei = 0; ei < linkedEpics.length; ei++) {
+          const epic = linkedEpics[ei];
+          const epicPrefix = ei < linkedEpics.length - 1 ? "\u251C\u2500\u2500" : "\u2514\u2500\u2500";
+          console.log(`    ${epicPrefix} ${epic.id}: ${epic.title} [${epic.status}]`);
+          const epicStories = stories.filter((s) => s.epicId === epic.id);
+          const isLastEpic = ei === linkedEpics.length - 1;
+          if (epicStories.length === 0) {
+            const pipeOrSpaceEmpty = isLastEpic ? "    " : "\u2502   ";
+            console.log(`    ${pipeOrSpaceEmpty}\u2514\u2500\u2500 Keine Stories`);
+          } else {
+            for (let si = 0; si < epicStories.length; si++) {
+              const story = epicStories[si];
+              const storyPrefix = si < epicStories.length - 1 ? "\u251C\u2500\u2500" : "\u2514\u2500\u2500";
+              const doneMark = story.status === "done" ? " \u2713" : "";
+              const pipeOrSpace = isLastEpic ? "    " : "\u2502   ";
+              console.log(`    ${pipeOrSpace}${storyPrefix} ${story.id}: ${story.title} [${story.status}]${doneMark}`);
+            }
+          }
+        }
+      }
+      console.log();
+    }
+    const orphanEpics = epics.filter((e) => !e.prdId);
+    if (orphanEpics.length > 0) {
+      console.log("  Epics ohne PRD:");
+      for (const epic of orphanEpics) {
+        const epicStories = stories.filter((s) => s.epicId === epic.id);
+        console.log(`    ${epic.id}: ${epic.title} [${epic.status}] (${epicStories.length} Stories)`);
+      }
+    }
+  } else if (subcommand === "roadmap") {
+    const content = generateRoadmap(forgehiveDir);
+    const roadmapPath = path36.join(projectRoot, "ROADMAP.md");
+    fs35.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 = path32.join(forgehiveDir, "memory", "velocity.md");
+  const velocityFile = path36.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;
@@ -7636,7 +8495,7 @@ Setze diese Umgebungsvariablen:`);
     console.error("Verf\xFCgbar: fh velocity show | record <N> --committed N --delivered N");
   }
 } else if (command === "docs") {
-  const docsDir = path32.join(projectRoot, "docs");
+  const docsDir = path36.join(projectRoot, "docs");
   if (!subcommand || subcommand === "list") {
     const existing = listExistingDocs(projectRoot);
     if (existing.length === 0) {
@@ -7650,30 +8509,29 @@ Setze diese Umgebungsvariablen:`);
       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(`  ${path32.relative(projectRoot, d)}`);
+      for (const d of existing) console.log(`  ${path36.relative(projectRoot, d)}`);
       console.log("");
       console.log("Aktualisieren: fh docs user | api | onboard | changelog");
     }
   } else if (subcommand === "user") {
-    fs31.mkdirSync(docsDir, { recursive: true });
+    fs35.mkdirSync(docsDir, { recursive: true });
     const outputArg = rest.includes("--output") ? rest[rest.indexOf("--output") + 1] : null;
-    const outputPath = outputArg ?? path32.join(docsDir, "user-guide.md");
+    const outputPath = outputArg ?? path36.join(docsDir, "user-guide.md");
     const guide = generateUserGuide(projectRoot, forgehiveDir);
-    fs31.writeFileSync(outputPath, guide, "utf8");
+    fs35.writeFileSync(outputPath, guide, "utf8");
     console.log(`\u2714 User Guide geschrieben: ${outputPath}`);
   } else if (subcommand === "api") {
-    fs31.mkdirSync(docsDir, { recursive: true });
+    fs35.mkdirSync(docsDir, { recursive: true });
     const outputArg = rest.includes("--output") ? rest[rest.indexOf("--output") + 1] : null;
-    const outputPath = outputArg ?? path32.join(docsDir, "api.md");
+    const outputPath = outputArg ?? path36.join(docsDir, "api.md");
     const ref = generateApiReference(projectRoot);
-    fs31.writeFileSync(outputPath, ref, "utf8");
+    fs35.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 ?? path32.join(projectRoot, "ONBOARDING.md");
-    fs31.mkdirSync(path32.dirname(outputPath), { recursive: true });
+    const outputPath = outputArg ?? path36.join(projectRoot, "ONBOARDING.md");
     const doc = generateOnboardingDoc(projectRoot, forgehiveDir);
-    fs31.writeFileSync(outputPath, doc, "utf8");
+    fs35.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;
@@ -7681,16 +8539,17 @@ Setze diese Umgebungsvariablen:`);
     const since = sinceArg ?? getLatestTag(projectRoot) ?? void 0;
     const rawLog = getGitLogSince(projectRoot, since);
     const commits = parseGitLog(rawLog);
-    let pkgVersion = "unreleased";
+    let pkg = {};
     try {
-      pkgVersion = JSON.parse(fs31.readFileSync(path32.join(projectRoot, "package.json"), "utf8")).version ?? "unreleased";
+      pkg = JSON.parse(fs35.readFileSync(path36.join(projectRoot, "package.json"), "utf8"));
     } catch {
     }
+    const pkgVersion = pkg.version ?? "unreleased";
     const md = formatChangelog(commits, pkgVersion);
-    const outputPath = outputArg ?? path32.join(projectRoot, "CHANGELOG.md");
+    const outputPath = outputArg ?? path36.join(projectRoot, "CHANGELOG.md");
     let existing = "";
-    if (fs31.existsSync(outputPath)) existing = fs31.readFileSync(outputPath, "utf8");
-    fs31.writeFileSync(outputPath, md + "\n\n" + existing, "utf8");
+    if (fs35.existsSync(outputPath)) existing = fs35.readFileSync(outputPath, "utf8");
+    fs35.writeFileSync(outputPath, md + "\n\n" + existing, "utf8");
     console.log(`\u2714 CHANGELOG.md aktualisiert (${commits.length} Commits)`);
   } else if (subcommand === "adr") {
     const title = rest.join(" ");
@@ -7698,15 +8557,148 @@ Setze diese Umgebungsvariablen:`);
       console.error("Usage: fh docs adr <titel>");
       process.exit(1);
     }
-    const adrPath = createAdr(forgehiveDir, projectRoot, title);
-    const adrFilename = path32.relative(projectRoot, adrPath);
-    console.log(`\u2714 ADR erstellt: ${adrFilename}`);
+    const adrsDir = path36.join(forgehiveDir, "memory", "adrs");
+    fs35.mkdirSync(adrsDir, { recursive: true });
+    const existing = fs35.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`;
+    const content = `# ADR-${adrId}: ${title}
+
+**Datum:** ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}
+**Status:** proposed
+
+## Kontext
+
+(Beschreibe das Problem oder die Situation.)
+
+## Entscheidung
+
+(Beschreibe die getroffene Entscheidung.)
+
+## Konsequenzen
+
+(Beschreibe die Auswirkungen dieser Entscheidung.)
+`;
+    fs35.writeFileSync(path36.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");
+  if (subcommand === "setup") {
+    const readline = await import("node:readline/promises");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    let token;
+    let repo;
+    try {
+      token = (await rl.question("  GitHub-Token (ghp_...): ")).trim();
+      repo = (await rl.question("  Repository (owner/repo): ")).trim();
+    } catch (e) {
+      console.error(`  \u2717 Eingabe fehlgeschlagen: ${e.message}`);
+      process.exit(1);
+    } finally {
+      rl.close();
+    }
+    if (!token) {
+      console.error("  \u2717 Kein Token eingegeben.");
+      process.exit(1);
+    }
+    if (!token.startsWith("ghp_") && !token.startsWith("github_pat_") && !token.startsWith("gho_")) {
+      console.warn("  \u26A0 Token-Format unbekannt \u2014 erwartet ghp_*, github_pat_*, oder gho_*");
+    }
+    const repoParts = repo.split("/");
+    if (repoParts.length !== 2 || repoParts[0].length === 0 || repoParts[1].length === 0) {
+      console.error(`  \u2717 Ung\xFCltiges Repo-Format: "${repo}" \u2014 erwartet: owner/repo`);
+      process.exit(1);
+    }
+    setCredentials("github", { GITHUB_TOKEN: token });
+    saveGitHubConfig(forgehiveDir, { repo });
+    console.log("  \u2713 Token gespeichert");
+    console.log("  \u2713 Repo gespeichert in .forgehive/github.yaml");
+  } else if (subcommand === "sync") {
+    let config;
+    try {
+      config = loadGitHubConfig(forgehiveDir);
+    } catch (e) {
+      console.error(`  \u2717 ${e.message}`);
+      process.exit(1);
+    }
+    const creds = getCredentials("github");
+    if (!creds?.GITHUB_TOKEN) {
+      console.error("  \u2717 Kein GitHub-Token gefunden. F\xFChre zuerst aus: fh github setup");
+      process.exit(1);
+    }
+    const [owner, repo] = config.repo.split("/");
+    console.log(`  Lade Issues von ${config.repo}...`);
+    let issues;
+    try {
+      issues = await fetchOpenIssues(owner, repo, creds.GITHUB_TOKEN);
+    } catch (e) {
+      console.error(`  \u2717 ${e.message}`);
+      process.exit(1);
+    }
+    let created = 0;
+    let skipped = 0;
+    for (const issue of issues) {
+      if (issueAlreadySynced(storiesDir, issue.number)) {
+        console.log(`  \u2013 #${issue.number} "${issue.title}" \u2192 bereits vorhanden (\xFCbersprungen)`);
+        skipped++;
+        continue;
+      }
+      const story = createStory(storiesDir, issue.title);
+      appendGitHubRef(storiesDir, story.id, issue, config.repo);
+      console.log(`  \u2713 #${issue.number} "${issue.title}" \u2192 ${story.id} erstellt`);
+      created++;
+    }
+    console.log(`
+  ${created} ${created === 1 ? "Story" : "Stories"} erstellt, ${skipped} \xFCbersprungen.`);
+  } else if (subcommand === "pr") {
+    const prNumberRaw = rest[0];
+    if (!prNumberRaw || isNaN(parseInt(prNumberRaw, 10))) {
+      console.error("  Usage: fh github pr <number>");
+      process.exit(1);
+    }
+    const prNumber = parseInt(prNumberRaw, 10);
+    let config;
+    try {
+      config = loadGitHubConfig(forgehiveDir);
+    } catch (e) {
+      console.error(`  \u2717 ${e.message}`);
+      process.exit(1);
+    }
+    const creds = getCredentials("github");
+    if (!creds?.GITHUB_TOKEN) {
+      console.error("  \u2717 Kein GitHub-Token gefunden. F\xFChre zuerst aus: fh github setup");
+      process.exit(1);
+    }
+    const [owner, repo] = config.repo.split("/");
+    console.log(`  Lade PR #${prNumber} von ${config.repo}...`);
+    let pr, files;
+    try {
+      [pr, files] = await Promise.all([
+        fetchPR(owner, repo, prNumber, creds.GITHUB_TOKEN),
+        fetchPRFiles(owner, repo, prNumber, creds.GITHUB_TOKEN)
+      ]);
+    } catch (e) {
+      console.error(`  \u2717 ${e.message}`);
+      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");
+    console.log(`  \u2713 PR-Kontext gespeichert: .forgehive/github-pr-${prNumber}.md`);
+    console.log("");
+    console.log(`  PR context gespeichert. Starte Review: fh party run review`);
+  } else {
+    console.log("Verf\xFCgbar: fh github setup | fh github sync | fh github pr <number>");
+    console.log("Hilfe: fh --help");
+  }
 } 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> | cost | memory | skills | party | wire | mcp | security");
+  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("Hilfe: fh --help");
   process.exit(1);
 }