forgehive 0.6.3 → 0.7.1

package/dist/cli.js

@@ -2751,8 +2751,8 @@ var init_harness = __esm({
 
 // src/cli.ts
 init_js_yaml();
-import fs23 from "node:fs";
-import path23 from "node:path";
+import fs30 from "node:fs";
+import path31 from "node:path";
 
 // src/scanner.ts
 import fs from "node:fs";
@@ -5581,24 +5581,897 @@ function formatSecurityReport(report) {
   return lines.join("\n");
 }
 
+// src/ci.ts
+import path23 from "node:path";
+function generateCiReport(projectRoot2, forgehiveDir2, failOn = "high") {
+  const secrets = scanSecrets(projectRoot2);
+  const sast = scanSast(projectRoot2);
+  const deps = scanDeps(projectRoot2);
+  let failedOn = null;
+  if (secrets.length > 0) {
+    failedOn = "secrets";
+  } else if (failOn === "critical" && (sast.some((f) => f.severity === "CRITICAL") || deps.some((d) => d.severity === "critical"))) {
+    failedOn = "critical-severity";
+  } else if (failOn === "high" && (sast.some((f) => f.severity === "CRITICAL" || f.severity === "HIGH") || deps.some((d) => d.severity === "critical" || d.severity === "high"))) {
+    failedOn = "high-severity";
+  } else if (failOn === "any" && (sast.length > 0 || deps.length > 0)) {
+    failedOn = "findings";
+  }
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    project: path23.basename(projectRoot2),
+    status: failedOn ? "fail" : "pass",
+    secrets,
+    sast,
+    deps,
+    failedOn
+  };
+}
+function formatCiReport(report, format = "markdown") {
+  if (format === "json") return JSON.stringify(report, null, 2);
+  const lines = [];
+  lines.push("# forgehive CI Report");
+  lines.push(`**Project:** ${report.project}`);
+  lines.push(
+    `**Status:** ${report.status === "pass" ? "PASS" : "FAIL"}`
+  );
+  lines.push(`**Time:** ${report.timestamp}`);
+  lines.push("");
+  if (report.secrets.length > 0) {
+    lines.push("## Secrets Found");
+    for (const s of report.secrets)
+      lines.push(
+        `- **${s.patternName}** in \`${s.file}:${s.line}\` \u2014 \`${s.match}\``
+      );
+    lines.push("");
+  }
+  if (report.sast.length > 0) {
+    lines.push("## SAST Findings");
+    for (const f of report.sast)
+      lines.push(
+        `- **${f.severity}** \`${f.ruleId}\` in \`${f.file}:${f.line}\` \u2014 ${f.snippet.slice(0, 80)}`
+      );
+    lines.push("");
+  }
+  if (report.deps.length > 0) {
+    lines.push("## Dependency Vulnerabilities");
+    for (const d of report.deps)
+      lines.push(
+        `- **${d.severity}** ${d.package} \u2014 ${d.description}`
+      );
+    lines.push("");
+  }
+  if (report.status === "pass") lines.push("All checks passed.");
+  return lines.join("\n");
+}
+function getGithubActionsTemplate() {
+  return `name: forgehive CI
+
+on:
+  pull_request:
+    branches: [main, master]
+  push:
+    branches: [main, master]
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+      - run: npm install -g forgehive
+      - run: fh ci --format json --fail-on high
+      - name: Upload CI report
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: forgehive-ci-report
+          path: .forgehive/ci-report.json
+`;
+}
+
+// src/map.ts
+import fs23 from "node:fs";
+import path24 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 = [
+  /^import\s+.*?from\s+['"]([^'"]+)['"]/gm,
+  /^import\s+['"]([^'"]+)['"]/gm,
+  /require\s*\(\s*['"]([^'"]+)['"]\s*\)/gm
+];
+function extractImports(content) {
+  const imports = [];
+  for (const pattern of IMPORT_PATTERNS) {
+    pattern.lastIndex = 0;
+    let m;
+    while ((m = pattern.exec(content)) !== null) {
+      if (m[1].startsWith(".")) imports.push(m[1]);
+    }
+  }
+  return [...new Set(imports)];
+}
+function walkFiles(dir) {
+  const results = [];
+  function walk(current) {
+    for (const entry of fs23.readdirSync(current, { withFileTypes: true })) {
+      if (IGNORE_DIRS2.includes(entry.name)) continue;
+      const full = path24.join(current, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else if (entry.isFile() && MAP_EXTS.includes(path24.extname(entry.name)))
+        results.push(full);
+    }
+  }
+  walk(dir);
+  return results;
+}
+function generateMap(projectRoot2) {
+  const filePaths = walkFiles(projectRoot2);
+  const files = filePaths.map((filePath) => {
+    let content = "";
+    try {
+      content = fs23.readFileSync(filePath, "utf8");
+    } catch {
+    }
+    const rawLines = content.split("\n");
+    const lines = rawLines[rawLines.length - 1] === "" ? rawLines.length - 1 : rawLines.length;
+    const imports = extractImports(content);
+    return {
+      path: filePath,
+      relativePath: path24.relative(projectRoot2, filePath),
+      lines,
+      imports
+    };
+  });
+  files.sort((a, b) => b.lines - a.lines);
+  return {
+    projectRoot: projectRoot2,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files,
+    totalFiles: files.length,
+    totalLines: files.reduce((sum, f) => sum + f.lines, 0)
+  };
+}
+function formatMap(map2) {
+  const lines = [];
+  lines.push("# Codebase Map");
+  lines.push(`Generated: ${map2.generatedAt}`);
+  lines.push(`Total: ${map2.totalFiles} files, ${map2.totalLines} lines`);
+  lines.push("");
+  lines.push("## Files");
+  lines.push("");
+  lines.push("| File | Lines | Imports |");
+  lines.push("|---|---|---|");
+  for (const f of map2.files) {
+    const imps = f.imports.length > 0 ? f.imports.slice(0, 3).join(", ") : "\u2014";
+    lines.push(`| \`${f.relativePath}\` | ${f.lines} | ${imps} |`);
+  }
+  lines.push("");
+  lines.push("## Most Imported");
+  lines.push("");
+  const importCounts = {};
+  for (const f of map2.files) {
+    for (const imp of f.imports) {
+      importCounts[imp] = (importCounts[imp] || 0) + 1;
+    }
+  }
+  const sorted = Object.entries(importCounts).sort((a, b) => b[1] - a[1]).slice(0, 10);
+  if (sorted.length > 0) {
+    for (const [imp, count] of sorted)
+      lines.push(`- \`${imp}\` \u2014 imported ${count}\xD7`);
+  } else {
+    lines.push("No internal imports detected.");
+  }
+  return lines.join("\n");
+}
+
+// src/onboard.ts
+init_js_yaml();
+import fs24 from "node:fs";
+import path25 from "node:path";
+import { spawnSync as spawnSync7 } from "node:child_process";
+function getRecentCommits(projectRoot2, n = 20) {
+  const result = spawnSync7("git", ["log", `--oneline`, `-${n}`], {
+    cwd: projectRoot2,
+    encoding: "utf8"
+  });
+  if (result.status !== 0) return [];
+  return result.stdout.trim().split("\n").filter(Boolean);
+}
+function readCapabilities(forgehiveDir2) {
+  const capPath = path25.join(forgehiveDir2, "capabilities.yaml");
+  if (!fs24.existsSync(capPath)) return {};
+  try {
+    return jsYaml.load(fs24.readFileSync(capPath, "utf8")) ?? {};
+  } catch {
+    return {};
+  }
+}
+function readMemoryFiles(forgehiveDir2) {
+  const memDir = path25.join(forgehiveDir2, "memory");
+  if (!fs24.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");
+  }
+  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"));
+}
+function generateOnboardingDoc(projectRoot2, forgehiveDir2) {
+  const projectName = path25.basename(projectRoot2);
+  const caps = readCapabilities(forgehiveDir2);
+  const memFiles = readMemoryFiles(forgehiveDir2);
+  const commits = getRecentCommits(projectRoot2);
+  const adrs = listAdrs2(forgehiveDir2);
+  const lines = [];
+  lines.push(`# Onboarding: ${projectName}`);
+  lines.push("");
+  lines.push(`> Generated by forgehive on ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`);
+  lines.push("");
+  lines.push("## Tech Stack");
+  lines.push("");
+  if (caps.language) lines.push(`- **Language:** ${caps.language}`);
+  if (caps.framework) lines.push(`- **Framework:** ${caps.framework}`);
+  if (caps.packageManager) lines.push(`- **Package Manager:** ${caps.packageManager}`);
+  if (caps.testFramework) lines.push(`- **Tests:** ${caps.testFramework}`);
+  if (caps.entryPoints) {
+    const eps = caps.entryPoints;
+    if (Array.isArray(eps) && eps.length > 0)
+      lines.push(`- **Entry Points:** ${eps.join(", ")}`);
+  }
+  lines.push("");
+  lines.push("## Getting Started");
+  lines.push("");
+  lines.push("```bash");
+  lines.push("# Clone the repo");
+  lines.push(`git clone <repo-url>`);
+  lines.push(`cd ${projectName}`);
+  lines.push("");
+  const pm = caps.packageManager || "npm";
+  lines.push(`# Install dependencies`);
+  lines.push(pm === "yarn" ? "yarn" : pm === "pnpm" ? "pnpm install" : "npm install");
+  lines.push("```");
+  lines.push("");
+  if (memFiles["project.md"]) {
+    lines.push("## Project Context");
+    lines.push("");
+    const projectContent = memFiles["project.md"].replace(/^---[\s\S]*?---\n/m, "").trim();
+    lines.push(projectContent);
+    lines.push("");
+  }
+  if (memFiles["stack.md"]) {
+    lines.push("## Stack Notes");
+    lines.push("");
+    const stackContent = memFiles["stack.md"].replace(/^---[\s\S]*?---\n/m, "").trim();
+    lines.push(stackContent);
+    lines.push("");
+  }
+  if (adrs.length > 0) {
+    lines.push("## Architecture Decisions");
+    lines.push("");
+    for (const adr of adrs) lines.push(`- ${adr.replace(".md", "")}`);
+    lines.push("");
+    lines.push(`See \`.forgehive/memory/adrs/\` for full decision records.`);
+    lines.push("");
+  }
+  if (commits.length > 0) {
+    lines.push("## Recent Activity");
+    lines.push("");
+    for (const c of commits.slice(0, 10)) lines.push(`- ${c}`);
+    lines.push("");
+  }
+  lines.push("## forgehive");
+  lines.push("");
+  lines.push("This project uses [forgehive](https://www.npmjs.com/package/forgehive) for AI-assisted development.");
+  lines.push("");
+  lines.push("```bash");
+  lines.push("npm install -g forgehive");
+  lines.push("fh status   # check project health");
+  lines.push("```");
+  return lines.join("\n");
+}
+
+// src/changelog.ts
+import { spawnSync as spawnSync8 } from "node:child_process";
+var TYPE_LABELS = {
+  feat: "Added",
+  fix: "Fixed",
+  perf: "Improved",
+  refactor: "Changed",
+  chore: "Maintenance",
+  docs: "Documentation",
+  test: "Tests",
+  ci: "CI",
+  other: "Other"
+};
+function parseGitLog(rawLog) {
+  return rawLog.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => {
+    const spaceIdx = line.indexOf(" ");
+    const hash = line.slice(0, spaceIdx);
+    const rest2 = line.slice(spaceIdx + 1);
+    const conventionalMatch = rest2.match(/^(\w+)(?:\(([^)]+)\))?\s*:\s*(.+)$/);
+    if (conventionalMatch) {
+      return {
+        hash,
+        type: conventionalMatch[1],
+        scope: conventionalMatch[2] ?? null,
+        message: conventionalMatch[3]
+      };
+    }
+    return { hash, type: "other", scope: null, message: rest2 };
+  });
+}
+function groupByType(commits) {
+  const groups = {};
+  for (const commit of commits) {
+    if (!groups[commit.type]) groups[commit.type] = [];
+    groups[commit.type].push(commit);
+  }
+  return groups;
+}
+function formatChangelog(commits, version) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const lines = [];
+  lines.push(`## [${version}] \u2014 ${date}`);
+  lines.push("");
+  if (commits.length === 0) {
+    lines.push("No changes.");
+    return lines.join("\n");
+  }
+  const groups = groupByType(commits);
+  const typeOrder = ["feat", "fix", "perf", "refactor", "docs", "chore", "test", "ci", "other"];
+  for (const type2 of typeOrder) {
+    if (!groups[type2] || groups[type2].length === 0) continue;
+    const label = TYPE_LABELS[type2] ?? type2;
+    lines.push(`### ${label}`);
+    lines.push("");
+    for (const c of groups[type2]) {
+      const scope = c.scope ? `**${c.scope}:** ` : "";
+      lines.push(`- ${scope}${c.message} (\`${c.hash}\`)`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+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" });
+  if (result.status !== 0) return "";
+  return result.stdout.trim();
+}
+function getLatestTag(projectRoot2) {
+  const result = spawnSync8("git", ["describe", "--tags", "--abbrev=0"], {
+    cwd: projectRoot2,
+    encoding: "utf8"
+  });
+  if (result.status !== 0) return null;
+  return result.stdout.trim() || null;
+}
+
+// src/metrics.ts
+import { spawnSync as spawnSync9 } from "node:child_process";
+function parseCommitStats(rawLog) {
+  const lines = rawLog.split("\n").map((l) => l.trim()).filter(Boolean);
+  const byAuthor = {};
+  const byType = {};
+  const dates = [];
+  for (const line of lines) {
+    const parts = line.split(" ");
+    if (parts.length < 3) continue;
+    const date = parts[0];
+    const author = parts[1];
+    const message = parts.slice(2).join(" ");
+    dates.push(date);
+    byAuthor[author] = (byAuthor[author] || 0) + 1;
+    const typeMatch = message.match(/^(\w+)(?:\([^)]+\))?:/);
+    const type2 = typeMatch ? typeMatch[1] : "other";
+    byType[type2] = (byType[type2] || 0) + 1;
+  }
+  const sortedDates = dates.sort();
+  return {
+    totalCommits: lines.length,
+    byAuthor,
+    byType,
+    dateRange: {
+      from: sortedDates[0] ?? "",
+      to: sortedDates[sortedDates.length - 1] ?? ""
+    }
+  };
+}
+function formatMetrics(stats, projectName) {
+  const lines = [];
+  lines.push(`# Developer Metrics: ${projectName}`);
+  lines.push(`Generated: ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`);
+  lines.push("");
+  lines.push(`**Total commits:** ${stats.totalCommits}`);
+  if (stats.dateRange.from)
+    lines.push(`**Date range:** ${stats.dateRange.from} \u2192 ${stats.dateRange.to}`);
+  lines.push("");
+  if (Object.keys(stats.byAuthor).length > 0) {
+    lines.push("## Commits by Author");
+    lines.push("");
+    for (const [author, count] of Object.entries(stats.byAuthor).sort((a, b) => b[1] - a[1]))
+      lines.push(`- **${author}:** ${count}`);
+    lines.push("");
+  }
+  if (Object.keys(stats.byType).length > 0) {
+    lines.push("## Commits by Type");
+    lines.push("");
+    for (const [type2, count] of Object.entries(stats.byType).sort((a, b) => b[1] - a[1]))
+      lines.push(`- **${type2}:** ${count}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+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" });
+  if (result.status !== 0) return "";
+  return result.stdout.trim();
+}
+
+// src/sync.ts
+import fs25 from "node:fs";
+import path26 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 configResult = spawnSync10(
+    "git",
+    ["config", "--get", "forgehive.sync-remote"],
+    { cwd: projectRoot2, encoding: "utf8" }
+  );
+  const remote = configResult.status === 0 ? configResult.stdout.trim() : null;
+  const branchResult = spawnSync10(
+    "git",
+    ["config", "--get", "forgehive.sync-branch"],
+    { cwd: projectRoot2, encoding: "utf8" }
+  );
+  const branch = branchResult.status === 0 ? branchResult.stdout.trim() : null;
+  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)) {
+    return { success: false, message: "Kein Memory-Verzeichnis gefunden.", filesCommitted: 0 };
+  }
+  const files = fs25.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")],
+    { cwd: projectRoot2, encoding: "utf8" }
+  );
+  if (addResult.status !== 0) {
+    return { success: false, message: `git add failed: ${addResult.stderr}`, filesCommitted: 0 };
+  }
+  const commitResult = spawnSync10(
+    "git",
+    ["commit", "-m", `chore: sync forgehive memory [${(/* @__PURE__ */ new Date()).toISOString()}]`],
+    { cwd: projectRoot2, encoding: "utf8" }
+  );
+  const commitOk = commitResult.status === 0 || (commitResult.stdout + commitResult.stderr).includes("nothing to commit");
+  if (!commitOk) {
+    return { success: false, message: `git commit failed: ${commitResult.stderr}`, filesCommitted: 0 };
+  }
+  const pushResult = spawnSync10(
+    "git",
+    ["push", remote, `HEAD:${branch}`],
+    { cwd: projectRoot2, encoding: "utf8" }
+  );
+  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 });
+  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 fetchResult = spawnSync10(
+    "git",
+    ["fetch", remote, branch],
+    { cwd: projectRoot2, encoding: "utf8" }
+  );
+  if (fetchResult.status !== 0) {
+    return { success: false, message: `git fetch failed: ${fetchResult.stderr}`, filesImported: [] };
+  }
+  const listResult = spawnSync10(
+    "git",
+    ["ls-tree", "--name-only", `${remote}/${branch}`, ".forgehive/memory/"],
+    { cwd: projectRoot2, encoding: "utf8" }
+  );
+  if (listResult.status !== 0) {
+    return { success: false, message: "Remote branch hat keine Memory-Dateien.", filesImported: [] };
+  }
+  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 contentResult = spawnSync10(
+        "git",
+        ["show", `${remote}/${branch}:${remotePath}`],
+        { cwd: projectRoot2, encoding: "utf8" }
+      );
+      if (contentResult.status === 0) {
+        fs25.writeFileSync(localPath, contentResult.stdout, "utf8");
+        imported.push(filename);
+      }
+    }
+  }
+  return {
+    success: true,
+    message: imported.length > 0 ? `${imported.length} neue Dateien importiert.` : "Keine neuen Dateien (bereits aktuell).",
+    filesImported: imported
+  };
+}
+
+// src/background.ts
+import fs26 from "node:fs";
+import path27 from "node:path";
+import { spawn } from "node:child_process";
+var AGENT_ROLES = {
+  kai: "Senior Engineer \u2014 implements features and fixes bugs",
+  sam: "QA & Test Architect \u2014 writes tests and checks quality",
+  viktor: "System Architect \u2014 designs architecture and reviews structure",
+  vera: "Security Analyst \u2014 reviews for OWASP, GDPR, auth issues",
+  nora: "Senior Research Analyst \u2014 researches options and summarizes findings",
+  eli: "Technical Writer \u2014 writes documentation and changelogs",
+  suki: "UX Designer \u2014 reviews UI/UX and user flows",
+  remy: "Creative Strategist \u2014 explores creative approaches"
+};
+var LABEL_TO_AGENT = {
+  security: "vera",
+  research: "nora",
+  docs: "eli",
+  documentation: "eli",
+  design: "suki",
+  ux: "suki",
+  architecture: "viktor",
+  arch: "viktor",
+  test: "sam",
+  qa: "sam"
+};
+function resolveAgent(label) {
+  if (!label) return "kai";
+  return LABEL_TO_AGENT[label.toLowerCase()] ?? "kai";
+}
+function buildAgentPrompt(issueUrl, agentId) {
+  const role = AGENT_ROLES[agentId] ?? "Senior Engineer";
+  return `You are ${agentId} \u2014 ${role}.
+
+Your task: Resolve the following issue autonomously.
+
+Issue URL: ${issueUrl}
+
+Instructions:
+1. Read the issue at the URL above (use web fetch or gh CLI if available)
+2. Understand what needs to be done
+3. Implement the solution following the project's conventions (read .forgehive/ for context)
+4. Write tests for any new code
+5. Commit your changes with a descriptive message
+6. Report what you did
+
+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 timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const logFile = path27.join(logsDir, `${agentId}-${timestamp2}.log`);
+  const prompt = buildAgentPrompt(issueUrl, agentId);
+  const logStream = fs26.openSync(logFile, "w");
+  const child = spawn(
+    "claude",
+    ["-p", prompt, "--output-format", "text"],
+    {
+      cwd: path27.dirname(forgehiveDir2),
+      detached: true,
+      stdio: ["ignore", logStream, logStream]
+    }
+  );
+  child.unref();
+  fs26.closeSync(logStream);
+  return {
+    pid: child.pid,
+    logFile,
+    message: `Agent ${agentId} gestartet (PID ${child.pid}). Log: ${logFile}`
+  };
+}
+
+// src/stories.ts
+init_js_yaml();
+import fs27 from "node:fs";
+import path28 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));
+  const max = existing.length > 0 ? Math.max(...existing) : 0;
+  return `US-${max + 1}`;
+}
+function storyToMarkdown(story) {
+  const frontmatter = jsYaml.dump({
+    id: story.id,
+    title: story.title,
+    asA: story.asA,
+    iWant: story.iWant,
+    soThat: story.soThat,
+    points: story.points,
+    epicId: story.epicId,
+    status: story.status
+  });
+  const acLines = story.acceptanceCriteria.map((c) => `- [ ] ${c}`).join("\n");
+  return `---
+${frontmatter}---
+
+# ${story.id}: ${story.title}
+
+## User Story
+
+Als **${story.asA}** m\xF6chte ich **${story.iWant}**, damit **${story.soThat}**.
+
+## Acceptance Criteria
+
+${acLines || "- [ ] (noch nicht definiert)"}
+`;
+}
+function parseStoryFile(filePath) {
+  try {
+    const content = fs27.readFileSync(filePath, "utf8");
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match) return null;
+    const data = jsYaml.load(match[1]);
+    return {
+      id: data.id ?? "",
+      title: data.title ?? "",
+      asA: data.asA ?? "",
+      iWant: data.iWant ?? "",
+      soThat: data.soThat ?? "",
+      acceptanceCriteria: data.acceptanceCriteria ?? [],
+      points: data.points ?? null,
+      epicId: data.epicId ?? null,
+      status: data.status ?? "backlog"
+    };
+  } catch {
+    return null;
+  }
+}
+function createStory(storiesDir, title, epicId) {
+  fs27.mkdirSync(storiesDir, { recursive: true });
+  const id = nextStoryId(storiesDir);
+  const story = {
+    id,
+    title,
+    asA: "",
+    iWant: title,
+    soThat: "",
+    acceptanceCriteria: [],
+    points: null,
+    epicId: epicId ?? null,
+    status: "backlog"
+  };
+  fs27.writeFileSync(path28.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) => {
+    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;
+  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");
+}
+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");
+}
+function formatStoryCard(story) {
+  const points = story.points !== null ? ` \xB7 ${story.points} Punkte` : "";
+  const epic = story.epicId ? ` \xB7 ${story.epicId}` : "";
+  const lines = [];
+  lines.push(`## ${story.id}: ${story.title}${points}${epic}`);
+  lines.push(`**Status:** ${story.status}`);
+  if (story.asA || story.iWant)
+    lines.push(`**Story:** Als ${story.asA || "Nutzer"} m\xF6chte ich ${story.iWant}${story.soThat ? `, damit ${story.soThat}` : ""}.`);
+  if (story.acceptanceCriteria.length > 0) {
+    lines.push("**Acceptance Criteria:**");
+    for (const ac of story.acceptanceCriteria) lines.push(`- ${ac}`);
+  }
+  return lines.join("\n");
+}
+
+// src/epics.ts
+init_js_yaml();
+import fs28 from "node:fs";
+import path29 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));
+  const max = existing.length > 0 ? Math.max(...existing) : 0;
+  return `EPC-${max + 1}`;
+}
+function epicToMarkdown(epic) {
+  const frontmatter = jsYaml.dump({
+    id: epic.id,
+    title: epic.title,
+    goal: epic.goal,
+    stories: epic.stories,
+    status: epic.status
+  });
+  const storyLines = epic.stories.map((s) => `- ${s}`).join("\n");
+  return `---
+${frontmatter}---
+
+# ${epic.id}: ${epic.title}
+
+**Ziel:** ${epic.goal || "(noch nicht definiert)"}
+
+## Stories
+
+${storyLines || "(noch keine Stories)"}
+`;
+}
+function parseEpicFile(filePath) {
+  try {
+    const content = fs28.readFileSync(filePath, "utf8");
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match) return null;
+    const data = jsYaml.load(match[1]);
+    return {
+      id: data.id ?? "",
+      title: data.title ?? "",
+      goal: data.goal ?? "",
+      stories: data.stories ?? [],
+      status: data.status ?? "active"
+    };
+  } catch {
+    return null;
+  }
+}
+function createEpic(epicsDir, title, goal) {
+  fs28.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");
+  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) => {
+    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;
+  return parseEpicFile(filePath);
+}
+function formatEpicCard(epic, stories) {
+  const lines = [];
+  lines.push(`## ${epic.id}: ${epic.title} [${epic.status}]`);
+  if (epic.goal) lines.push(`**Ziel:** ${epic.goal}`);
+  lines.push(`**Stories:** ${epic.stories.length}`);
+  if (stories && stories.length > 0) {
+    const total = stories.reduce((sum, s) => sum + (s.points ?? 0), 0);
+    lines.push(`**Punkte:** ${total}`);
+    lines.push("");
+    for (const s of stories) {
+      const pts = s.points !== null ? ` [${s.points}pt]` : " [?pt]";
+      lines.push(`  - ${s.id}${pts} \u2014 ${s.title} [${s.status}]`);
+    }
+  } else if (epic.stories.length > 0) {
+    for (const id of epic.stories) lines.push(`  - ${id}`);
+  }
+  return lines.join("\n");
+}
+
+// src/velocity.ts
+import fs29 from "node:fs";
+import path30 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");
+  } else {
+    fs29.appendFileSync(velocityFile, row, "utf8");
+  }
+}
+function getVelocityHistory(velocityFile) {
+  if (!fs29.existsSync(velocityFile)) return [];
+  const content = fs29.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);
+    const sprintMatch = cells[0]?.match(/Sprint (\d+)/);
+    return {
+      sprint: sprintMatch ? parseInt(sprintMatch[1], 10) : 0,
+      date: cells[1] ?? "",
+      committed: parseInt(cells[2] ?? "0", 10),
+      delivered: parseInt(cells[3] ?? "0", 10)
+    };
+  }).filter((r) => r.sprint > 0);
+}
+function getRollingAverage(history, window = 3) {
+  if (history.length === 0) return 0;
+  const recent = history.slice(-window);
+  const sum = recent.reduce((acc, s) => acc + s.delivered, 0);
+  return Math.round(sum / recent.length);
+}
+function formatVelocityReport(history) {
+  if (history.length === 0)
+    return "Noch keine Velocity-Daten vorhanden.\n\nStarte mit: `fh velocity record <sprint> --committed N --delivered N`";
+  const avg3 = getRollingAverage(history, 3);
+  const lines = [];
+  lines.push("# Sprint Velocity");
+  lines.push("");
+  lines.push(`**Rolling Average (letzte 3 Sprints):** ${avg3} Punkte`);
+  lines.push("");
+  lines.push("| Sprint | Datum | Committed | Delivered | Rate |");
+  lines.push("|---|---|---|---|---|");
+  for (const s of history) {
+    const rate = s.committed > 0 ? Math.round(s.delivered / s.committed * 100) : 0;
+    lines.push(`| Sprint ${s.sprint} | ${s.date} | ${s.committed} | ${s.delivered} | ${rate}% |`);
+  }
+  lines.push("");
+  lines.push(`**Empfehlung f\xFCr n\xE4chsten Sprint:** ~${avg3} Punkte einplanen`);
+  return lines.join("\n");
+}
+
 // src/cli.ts
 var [, , command, subcommand, ...rest] = process.argv;
 var projectRoot = process.cwd();
-var forgehiveDir = path23.join(projectRoot, ".forgehive");
+var forgehiveDir = path31.join(projectRoot, ".forgehive");
 if (command === "--version" || command === "-v") {
-  console.log("0.6.1");
+  console.log("0.7.1");
   process.exit(0);
 }
 function loadClaudeMdBlock() {
-  const templatePath = path23.join(
-    path23.dirname(new URL(import.meta.url).pathname),
+  const templatePath = path31.join(
+    path31.dirname(new URL(import.meta.url).pathname),
     "..",
     "forgehive",
     "templates",
     "claude-md.block.md"
   );
-  if (!fs23.existsSync(templatePath)) return "## forgehive\n\nSee .forgehive/ for configuration.";
-  return fs23.readFileSync(templatePath, "utf8");
+  if (!fs30.existsSync(templatePath)) return "## forgehive\n\nSee .forgehive/ for configuration.";
+  return fs30.readFileSync(templatePath, "utf8");
 }
 if (command === "init") {
   console.log("\u{1F50D} Analysiere Projekt...\n");
@@ -5612,9 +6485,9 @@ if (command === "init") {
   const block = loadClaudeMdBlock();
   writeForgehiveDir(projectRoot, scanResult, capMap, block);
   const hash = computeHash(projectRoot);
-  fs23.writeFileSync(path23.join(forgehiveDir, ".scan-hash"), hash, "utf8");
-  const runtimeDir = path23.join(
-    path23.dirname(new URL(import.meta.url).pathname),
+  fs30.writeFileSync(path31.join(forgehiveDir, ".scan-hash"), hash, "utf8");
+  const runtimeDir = path31.join(
+    path31.dirname(new URL(import.meta.url).pathname),
     "..",
     "forgehive"
   );
@@ -5646,7 +6519,7 @@ if (command === "init") {
     process.exit(1);
   }
 } else if (command === "memory") {
-  if (!fs23.existsSync(forgehiveDir)) {
+  if (!fs30.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -5655,7 +6528,7 @@ if (command === "init") {
   } else if (subcommand === "clean") {
     cleanMemory(forgehiveDir);
   } else if (subcommand === "export") {
-    const outputPath = rest[0] ?? path23.join(projectRoot, "forgehive-memory-export.md");
+    const outputPath = rest[0] ?? path31.join(projectRoot, "forgehive-memory-export.md");
     try {
       exportMemory(forgehiveDir, outputPath);
     } catch (err) {
@@ -5703,7 +6576,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] ?? path23.join(
+      const outPath = rest[1] ?? path31.join(
         projectRoot,
         `forgehive-snapshot-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.json`
       );
@@ -5743,11 +6616,11 @@ Ausf\xFChren mit --remove um zu l\xF6schen: fh memory prune ${days} --remove`);
     process.exit(1);
   }
 } else if (command === "scan" && subcommand === "--update") {
-  if (!fs23.existsSync(forgehiveDir)) {
+  if (!fs30.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
-  const savedHash = fs23.existsSync(path23.join(forgehiveDir, ".scan-hash")) ? fs23.readFileSync(path23.join(forgehiveDir, ".scan-hash"), "utf8").trim() : null;
+  const savedHash = fs30.existsSync(path31.join(forgehiveDir, ".scan-hash")) ? fs30.readFileSync(path31.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");
@@ -5755,7 +6628,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(
-    fs23.readFileSync(path23.join(forgehiveDir, "capabilities.yaml"), "utf8")
+    fs30.readFileSync(path31.join(forgehiveDir, "capabilities.yaml"), "utf8")
   );
   const oldMap = { confirmed: oldDoc.capabilities.confirmed ?? [], inferred: [] };
   const scanResult = scan(projectRoot);
@@ -5775,16 +6648,16 @@ Ausf\xFChren mit --remove um zu l\xF6schen: fh memory prune ${days} --remove`);
     console.log();
     const block = loadClaudeMdBlock();
     writeForgehiveDir(projectRoot, scanResult, newMap, block);
-    fs23.writeFileSync(path23.join(forgehiveDir, ".scan-hash"), currentHash, "utf8");
+    fs30.writeFileSync(path31.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 (!fs23.existsSync(path23.join(forgehiveDir, ".scan-hash"))) {
+  if (!fs30.existsSync(path31.join(forgehiveDir, ".scan-hash"))) {
     console.log("Warnung: Kein Scan-Hash gefunden. F\xFChre `fh init` aus.");
     process.exit(1);
   }
-  const saved = fs23.readFileSync(path23.join(forgehiveDir, ".scan-hash"), "utf8").trim();
+  const saved = fs30.readFileSync(path31.join(forgehiveDir, ".scan-hash"), "utf8").trim();
   const current = computeHash(projectRoot);
   if (saved !== current) {
     console.log("\u26A0 Codebase hat sich seit letztem Scan ge\xE4ndert.");
@@ -5793,7 +6666,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 (!fs23.existsSync(forgehiveDir)) {
+  if (!fs30.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -5829,7 +6702,7 @@ Ausf\xFChren mit --remove um zu l\xF6schen: fh memory prune ${days} --remove`);
     process.exit(1);
   }
 } else if (command === "party") {
-  if (!fs23.existsSync(forgehiveDir)) {
+  if (!fs30.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -5950,7 +6823,7 @@ Ausf\xFChren mit --remove um zu l\xF6schen: fh memory prune ${days} --remove`);
     }
   }
 } else if (command === "wire") {
-  if (!fs23.existsSync(forgehiveDir)) {
+  if (!fs30.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -5989,7 +6862,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 (!fs23.existsSync(forgehiveDir)) {
+    if (!fs30.existsSync(forgehiveDir)) {
       console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
       process.exit(1);
     }
@@ -6015,14 +6888,14 @@ N\xE4chster Schritt: Setze die erforderlichen Umgebungsvariablen und starte Clau
     }
     const sessions = parseCostSessions(projectRoot);
     console.log(formatCostReport(sessions, range));
-    if (fs23.existsSync(forgehiveDir)) {
+    if (fs30.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 (!fs23.existsSync(forgehiveDir)) {
+  if (!fs30.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -6038,7 +6911,7 @@ N\xE4chster Schritt: Setze die erforderlichen Umgebungsvariablen und starte Clau
     process.exit(0);
   });
 } else if (command === "mcp") {
-  if (!fs23.existsSync(forgehiveDir)) {
+  if (!fs30.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -6149,7 +7022,7 @@ Setze diese Umgebungsvariablen:`);
     process.exit(1);
   }
 } else if (command === "security") {
-  if (!fs23.existsSync(forgehiveDir)) {
+  if (!fs30.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -6235,8 +7108,8 @@ Setze diese Umgebungsvariablen:`);
 `);
     const report = generateSecurityReport(projectRoot, forgehiveDir, mode);
     const text = formatSecurityReport(report);
-    const reportPath = path23.join(forgehiveDir, "security-report.md");
-    fs23.writeFileSync(reportPath, text, "utf8");
+    const reportPath = path31.join(forgehiveDir, "security-report.md");
+    fs30.writeFileSync(reportPath, text, "utf8");
     console.log(text);
     console.log(`
 \u2713 Report gespeichert: ${reportPath}`);
@@ -6248,17 +7121,221 @@ Setze diese Umgebungsvariablen:`);
   } else if (subcommand === "permissions") {
     const { writePermissions: writePermissions2 } = await Promise.resolve().then(() => (init_harness(), harness_exports));
     writePermissions2(forgehiveDir);
-    const permPath = path23.join(forgehiveDir, "harness", "permissions.yaml");
-    console.log(fs23.readFileSync(permPath, "utf8"));
+    const permPath = path31.join(forgehiveDir, "harness", "permissions.yaml");
+    console.log(fs30.readFileSync(permPath, "utf8"));
   } else {
     console.error(`Unbekannter security-Subcommand: ${subcommand}`);
     console.error("Verf\xFCgbar: scan | deps | audit | report [gdpr|soc2|hipaa|none] | permissions");
     process.exit(1);
   }
+} else if (command === "ci") {
+  const allCiArgs = [subcommand, ...rest].filter((a) => Boolean(a));
+  const format = allCiArgs.includes("--format") ? allCiArgs[allCiArgs.indexOf("--format") + 1] : "markdown";
+  const failOnArg = allCiArgs.includes("--fail-on") ? allCiArgs[allCiArgs.indexOf("--fail-on") + 1] : "high";
+  const initFlag = allCiArgs.includes("--init");
+  if (initFlag) {
+    const ghDir = path31.join(projectRoot, ".github", "workflows");
+    fs30.mkdirSync(ghDir, { recursive: true });
+    const outPath = path31.join(ghDir, "forgehive.yml");
+    fs30.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") {
+      fs30.mkdirSync(forgehiveDir, { recursive: true });
+      fs30.writeFileSync(path31.join(forgehiveDir, "ci-report.json"), output, "utf8");
+    }
+    if (report.status === "fail") process.exit(1);
+  }
+} else if (command === "map") {
+  const map2 = generateMap(projectRoot);
+  const md = formatMap(map2);
+  const mapPath = path31.join(forgehiveDir, "map.md");
+  fs30.mkdirSync(forgehiveDir, { recursive: true });
+  fs30.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 ?? path31.join(projectRoot, "ONBOARDING.md");
+  const doc = generateOnboardingDoc(projectRoot, forgehiveDir);
+  fs30.writeFileSync(outputPath, doc, "utf8");
+  console.log(`\u2714 Onboarding-Dokument geschrieben: ${outputPath}`);
+} 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;
+  const since = sinceArg ?? getLatestTag(projectRoot) ?? void 0;
+  const rawLog = getGitLogSince(projectRoot, since);
+  const commits = parseGitLog(rawLog);
+  let version = "unreleased";
+  try {
+    const pkgPath = path31.join(projectRoot, "package.json");
+    if (fs30.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs30.readFileSync(pkgPath, "utf8").replace(/^\s*\/\/.*$/gm, ""));
+      version = pkg.version ?? "unreleased";
+    }
+  } catch {
+  }
+  const md = formatChangelog(commits, version);
+  const outputPath = outputArg ?? path31.join(projectRoot, "CHANGELOG.md");
+  let existing = "";
+  if (fs30.existsSync(outputPath)) existing = fs30.readFileSync(outputPath, "utf8");
+  fs30.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, path31.basename(projectRoot));
+  const metricsPath = path31.join(forgehiveDir, "metrics.md");
+  fs30.mkdirSync(forgehiveDir, { recursive: true });
+  fs30.writeFileSync(metricsPath, md, "utf8");
+  console.log(md);
+  console.log(`
+\u2714 Metrics gespeichert: ${metricsPath}`);
+} else if (command === "sync") {
+  const remoteArg = rest.includes("--remote") ? rest[rest.indexOf("--remote") + 1] : "origin";
+  const branchArg = rest.includes("--branch") ? rest[rest.indexOf("--branch") + 1] : "forgehive-memory";
+  if (subcommand === "push") {
+    const result = pushSync(forgehiveDir, remoteArg, branchArg);
+    console.log(result.success ? `\u2714 ${result.message}` : `\u2717 ${result.message}`);
+    if (!result.success) process.exit(1);
+  } else if (subcommand === "pull") {
+    const result = pullSync(forgehiveDir, remoteArg, branchArg);
+    console.log(result.success ? `\u2714 ${result.message}` : `\u2717 ${result.message}`);
+    if (result.filesImported.length > 0)
+      console.log("  Importiert:", result.filesImported.join(", "));
+    if (!result.success) process.exit(1);
+  } else {
+    const status = getSyncStatus(forgehiveDir);
+    console.log(`Memory: ${status.files} Dateien`);
+    console.log(status.hasRemote ? `Remote: ${status.remote}/${status.branch}` : "Kein Remote konfiguriert. Nutze: fh sync push [--remote origin --branch forgehive-memory]");
+  }
+} else if (command === "run") {
+  const issueUrl = subcommand;
+  if (!issueUrl) {
+    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`);
+} else if (command === "story") {
+  const storiesDir = path31.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;
+    const pointsArg = rest.includes("--points") ? parseInt(rest[rest.indexOf("--points") + 1], 10) : void 0;
+    if (!title) {
+      console.error("Usage: fh story create <titel> [--epic EPC-N] [--points N]");
+      process.exit(1);
+    }
+    const story = createStory(storiesDir, title, epicArg);
+    if (pointsArg) updateStoryPoints(storiesDir, story.id, pointsArg);
+    console.log(`\u2714 ${story.id} erstellt: ${path31.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;
+    let stories = listStories(storiesDir);
+    if (epicFilter) stories = stories.filter((s) => s.epicId === epicFilter);
+    if (stories.length === 0) {
+      console.log("Keine Stories gefunden.");
+    } else {
+      for (const s of stories) {
+        const pts = s.points !== null ? ` [${s.points}pt]` : " [?pt]";
+        const epic = s.epicId ? ` (${s.epicId})` : "";
+        console.log(`  ${s.id}${pts}${epic} \u2014 ${s.title} [${s.status}]`);
+      }
+    }
+  } else if (subcommand === "done") {
+    const id = rest[0];
+    const pointsArg = rest.includes("--points") ? parseInt(rest[rest.indexOf("--points") + 1], 10) : void 0;
+    if (!id) {
+      console.error("Usage: fh story done <US-N> [--points N]");
+      process.exit(1);
+    }
+    if (pointsArg) updateStoryPoints(storiesDir, id, pointsArg);
+    updateStoryStatus(storiesDir, id, "done");
+    console.log(`\u2714 ${id} als done markiert`);
+  } else if (subcommand === "show") {
+    const id = rest[0];
+    if (!id) {
+      console.error("Usage: fh story show <US-N>");
+      process.exit(1);
+    }
+    const story = getStory(storiesDir, id);
+    if (!story) {
+      console.error(`Story ${id} nicht gefunden`);
+      process.exit(1);
+    }
+    console.log(formatStoryCard(story));
+  } else {
+    console.error("Verf\xFCgbar: fh story create | list | show | done");
+  }
+} else if (command === "epic") {
+  const epicsDir = path31.join(forgehiveDir, "memory", "epics");
+  const storiesDir = path31.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;
+    if (!title) {
+      console.error("Usage: fh epic create <titel> [--goal <ziel>]");
+      process.exit(1);
+    }
+    const epic = createEpic(epicsDir, title, goalArg);
+    console.log(`\u2714 ${epic.id} erstellt: ${path31.join(epicsDir, epic.id + ".md")}`);
+  } else if (subcommand === "list") {
+    const epics = listEpics(epicsDir);
+    if (epics.length === 0) {
+      console.log("Keine Epics gefunden.");
+    } else {
+      for (const e of epics)
+        console.log(`  ${e.id} \u2014 ${e.title} [${e.status}] (${e.stories.length} Stories)`);
+    }
+  } else if (subcommand === "show") {
+    const id = rest[0];
+    if (!id) {
+      console.error("Usage: fh epic show <EPC-N>");
+      process.exit(1);
+    }
+    const epic = getEpic(epicsDir, id);
+    if (!epic) {
+      console.error(`Epic ${id} nicht gefunden`);
+      process.exit(1);
+    }
+    const stories = listStories(storiesDir).filter((s) => s.epicId === id);
+    console.log(formatEpicCard(epic, stories));
+  } else {
+    console.error("Verf\xFCgbar: fh epic create | list | show");
+  }
+} else if (command === "velocity") {
+  const velocityFile = path31.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;
+    const delivered = rest.includes("--delivered") ? parseInt(rest[rest.indexOf("--delivered") + 1], 10) : NaN;
+    if (!sprintNum || isNaN(committed) || isNaN(delivered)) {
+      console.error("Usage: fh velocity record <sprint-num> --committed N --delivered N");
+      process.exit(1);
+    }
+    recordVelocity(velocityFile, sprintNum, committed, delivered);
+    const avg = getRollingAverage(getVelocityHistory(velocityFile));
+    console.log(`\u2714 Sprint ${sprintNum} gespeichert. Rolling Average: ${avg} Punkte`);
+  } else {
+    const history = getVelocityHistory(velocityFile);
+    console.log(formatVelocityReport(history));
+  }
 } else {
   const cmd = [command, subcommand].filter(Boolean).join(" ") || "(kein)";
   console.error(`Unbekannter Befehl: ${cmd}`);
-  console.error("Verf\xFCgbar: init | confirm | rollback | scan --update | scan --check | status | cost [today|week|all] | cost --limit N --alert N | memory [show|clean|export|prune|snapshot] | memory adr [list|<titel>] | skills [list|regen|pull <url>] | party [--set <name>|run|status|cleanup] | wire <service> | mcp [auth|search|add] | security [scan|deps|report|audit|permissions]");
+  console.error("Verf\xFCgbar: init | confirm | rollback | scan --update | scan --check | status | ci [--format json|markdown] [--fail-on critical|high|any] [--init] | map | onboard [--output path] | changelog [--since tag] | metrics [--since date] | sync [push|pull] [--remote origin --branch forgehive-memory] | run <issue-url> [--agent <name>] | cost [today|week|all] | cost --limit N --alert N | memory [show|clean|export|prune|snapshot] | memory adr [list|<titel>] | skills [list|regen|pull <url>] | party [--set <name>|run|status|cleanup] | wire <service> | mcp [auth|search|add] | security [scan|deps|report|audit|permissions]");
   process.exit(1);
 }
 /*! Bundled license information: