forgehive 0.7.0 → 0.7.1

package/dist/cli.js

@@ -2751,8 +2751,8 @@ var init_harness = __esm({
 
 // src/cli.ts
 init_js_yaml();
-import fs27 from "node:fs";
-import path28 from "node:path";
+import fs30 from "node:fs";
+import path31 from "node:path";
 
 // src/scanner.ts
 import fs from "node:fs";
@@ -6196,24 +6196,282 @@ function runBackgroundAgent(forgehiveDir2, issueUrl, agentId) {
   };
 }
 
+// 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 = path28.join(projectRoot, ".forgehive");
+var forgehiveDir = path31.join(projectRoot, ".forgehive");
 if (command === "--version" || command === "-v") {
-  console.log("0.7.0");
+  console.log("0.7.1");
   process.exit(0);
 }
 function loadClaudeMdBlock() {
-  const templatePath = path28.join(
-    path28.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 (!fs27.existsSync(templatePath)) return "## forgehive\n\nSee .forgehive/ for configuration.";
-  return fs27.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");
@@ -6227,9 +6485,9 @@ if (command === "init") {
   const block = loadClaudeMdBlock();
   writeForgehiveDir(projectRoot, scanResult, capMap, block);
   const hash = computeHash(projectRoot);
-  fs27.writeFileSync(path28.join(forgehiveDir, ".scan-hash"), hash, "utf8");
-  const runtimeDir = path28.join(
-    path28.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"
   );
@@ -6261,7 +6519,7 @@ if (command === "init") {
     process.exit(1);
   }
 } else if (command === "memory") {
-  if (!fs27.existsSync(forgehiveDir)) {
+  if (!fs30.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -6270,7 +6528,7 @@ if (command === "init") {
   } else if (subcommand === "clean") {
     cleanMemory(forgehiveDir);
   } else if (subcommand === "export") {
-    const outputPath = rest[0] ?? path28.join(projectRoot, "forgehive-memory-export.md");
+    const outputPath = rest[0] ?? path31.join(projectRoot, "forgehive-memory-export.md");
     try {
       exportMemory(forgehiveDir, outputPath);
     } catch (err) {
@@ -6318,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] ?? path28.join(
+      const outPath = rest[1] ?? path31.join(
         projectRoot,
         `forgehive-snapshot-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.json`
       );
@@ -6358,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 (!fs27.existsSync(forgehiveDir)) {
+  if (!fs30.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
-  const savedHash = fs27.existsSync(path28.join(forgehiveDir, ".scan-hash")) ? fs27.readFileSync(path28.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");
@@ -6370,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(
-    fs27.readFileSync(path28.join(forgehiveDir, "capabilities.yaml"), "utf8")
+    fs30.readFileSync(path31.join(forgehiveDir, "capabilities.yaml"), "utf8")
   );
   const oldMap = { confirmed: oldDoc.capabilities.confirmed ?? [], inferred: [] };
   const scanResult = scan(projectRoot);
@@ -6390,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);
-    fs27.writeFileSync(path28.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 (!fs27.existsSync(path28.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 = fs27.readFileSync(path28.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.");
@@ -6408,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 (!fs27.existsSync(forgehiveDir)) {
+  if (!fs30.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -6444,7 +6702,7 @@ Ausf\xFChren mit --remove um zu l\xF6schen: fh memory prune ${days} --remove`);
     process.exit(1);
   }
 } else if (command === "party") {
-  if (!fs27.existsSync(forgehiveDir)) {
+  if (!fs30.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -6565,7 +6823,7 @@ Ausf\xFChren mit --remove um zu l\xF6schen: fh memory prune ${days} --remove`);
     }
   }
 } else if (command === "wire") {
-  if (!fs27.existsSync(forgehiveDir)) {
+  if (!fs30.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -6604,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 (!fs27.existsSync(forgehiveDir)) {
+    if (!fs30.existsSync(forgehiveDir)) {
       console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
       process.exit(1);
     }
@@ -6630,14 +6888,14 @@ N\xE4chster Schritt: Setze die erforderlichen Umgebungsvariablen und starte Clau
     }
     const sessions = parseCostSessions(projectRoot);
     console.log(formatCostReport(sessions, range));
-    if (fs27.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 (!fs27.existsSync(forgehiveDir)) {
+  if (!fs30.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -6653,7 +6911,7 @@ N\xE4chster Schritt: Setze die erforderlichen Umgebungsvariablen und starte Clau
     process.exit(0);
   });
 } else if (command === "mcp") {
-  if (!fs27.existsSync(forgehiveDir)) {
+  if (!fs30.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -6764,7 +7022,7 @@ Setze diese Umgebungsvariablen:`);
     process.exit(1);
   }
 } else if (command === "security") {
-  if (!fs27.existsSync(forgehiveDir)) {
+  if (!fs30.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -6850,8 +7108,8 @@ Setze diese Umgebungsvariablen:`);
 `);
     const report = generateSecurityReport(projectRoot, forgehiveDir, mode);
     const text = formatSecurityReport(report);
-    const reportPath = path28.join(forgehiveDir, "security-report.md");
-    fs27.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}`);
@@ -6863,8 +7121,8 @@ Setze diese Umgebungsvariablen:`);
   } else if (subcommand === "permissions") {
     const { writePermissions: writePermissions2 } = await Promise.resolve().then(() => (init_harness(), harness_exports));
     writePermissions2(forgehiveDir);
-    const permPath = path28.join(forgehiveDir, "harness", "permissions.yaml");
-    console.log(fs27.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");
@@ -6876,35 +7134,35 @@ 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 = path28.join(projectRoot, ".github", "workflows");
-    fs27.mkdirSync(ghDir, { recursive: true });
-    const outPath = path28.join(ghDir, "forgehive.yml");
-    fs27.writeFileSync(outPath, getGithubActionsTemplate(), "utf8");
+    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") {
-      fs27.mkdirSync(forgehiveDir, { recursive: true });
-      fs27.writeFileSync(path28.join(forgehiveDir, "ci-report.json"), output, "utf8");
+      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 = path28.join(forgehiveDir, "map.md");
-  fs27.mkdirSync(forgehiveDir, { recursive: true });
-  fs27.writeFileSync(mapPath, md, "utf8");
+  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 ?? path28.join(projectRoot, "ONBOARDING.md");
+  const outputPath = outputArg ?? path31.join(projectRoot, "ONBOARDING.md");
   const doc = generateOnboardingDoc(projectRoot, forgehiveDir);
-  fs27.writeFileSync(outputPath, doc, "utf8");
+  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;
@@ -6914,28 +7172,28 @@ Setze diese Umgebungsvariablen:`);
   const commits = parseGitLog(rawLog);
   let version = "unreleased";
   try {
-    const pkgPath = path28.join(projectRoot, "package.json");
-    if (fs27.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs27.readFileSync(pkgPath, "utf8").replace(/^\s*\/\/.*$/gm, ""));
+    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 ?? path28.join(projectRoot, "CHANGELOG.md");
+  const outputPath = outputArg ?? path31.join(projectRoot, "CHANGELOG.md");
   let existing = "";
-  if (fs27.existsSync(outputPath)) existing = fs27.readFileSync(outputPath, "utf8");
-  fs27.writeFileSync(outputPath, md + "\n\n" + existing, "utf8");
+  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, path28.basename(projectRoot));
-  const metricsPath = path28.join(forgehiveDir, "metrics.md");
-  fs27.mkdirSync(forgehiveDir, { recursive: true });
-  fs27.writeFileSync(metricsPath, md, "utf8");
+  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}`);
@@ -6969,6 +7227,111 @@ Setze diese Umgebungsvariablen:`);
   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}`);

package/forgehive/commands/fh-sprint.md

@@ -7,11 +7,15 @@ You are running a Sprint Planning session using the ForgeHive workflow.
 1. Read `.forgehive/capabilities.yaml` — understand the tech stack and constraints
 2. Read `.forgehive/memory/MEMORY.md` and all linked memory files — load project context
 3. Check if `.forgehive/memory/sprint.md` exists — if so, show the last sprint summary first
-4. Run `fh scan --check` to verify the codebase snapshot is current
+4. Check if `.forgehive/memory/velocity.md` exists — if so, show rolling average as capacity hint
+5. Run `fh scan --check` to verify the codebase snapshot is current
 
 ### Step 2: Collect backlog items
 
-Ask the user: **"Welche Items kommen in den Sprint? Liste sie auf — ein Item pro Zeile. Oder soll ich Linear/Jira laden?"**
+Ask the user: **"Welche Items kommen in den Sprint? Liste sie auf — oder soll ich Backlog-Stories laden?"**
+
+**If stories exist** in `.forgehive/memory/stories/` with status `backlog`:
+Run `fh story list` to show available stories. Ask: **"Welche dieser Stories kommen in den Sprint?"**
 
 **If Linear MCP is available** (check if `.mcp.json` contains `linear`):
 Use the Linear MCP tool to fetch open issues:
@@ -25,7 +29,7 @@ Show the fetched issues and ask: **"Welche davon kommen in den Sprint?"**
 gh issue list --state open --label "sprint-candidate" --limit 20
 ```
 
-**If no MCP connected:**
+**If no stories/MCP:**
 Accept free-text input — one item per line.
 
 ### Step 3: Clarify and refine
@@ -37,44 +41,59 @@ For each item, ask one clarifying question if needed:
 
 Do NOT ask more than one question per item. If the item is clear, skip this step.
 
-### Step 4: Estimate effort
+### Step 4: Estimate with Fibonacci Points
 
-Estimate each item using T-shirt sizes:
+Estimate each item using Fibonacci story points:
 
-| Size | Meaning | Typical scope |
+| Points | Meaning | Typical scope |
 |---|---|---|
-| XS | < 2h | Config change, copy fix, small bug |
-| S | half day | Simple feature, isolated fix |
-| M | 1–2 days | Feature with tests, moderate complexity |
-| L | 3–5 days | Complex feature, multiple files, integration work |
-| XL | > 5 days | Should be broken down further |
+| 1 | Trivial | Config change, copy fix, 1-line fix |
+| 2 | Small | Simple isolated change |
+| 3 | Medium-small | Small feature, isolated fix |
+| 5 | Medium | Feature with tests, moderate complexity |
+| 8 | Large | Complex feature, multiple files |
+| 13 | Extra-large | Should be broken down |
+
+**T-Shirt aliases:** XS=1, S=2, M=5, L=8, XL=13
 
-Flag any XL items: **"Dieses Item ist zu groß für einen Sprint — soll ich es aufteilen?"**
+Flag any 13-point items: **"Dieses Item ist zu groß für einen Sprint — soll ich es aufteilen?"**
+
+If items were loaded from `.forgehive/memory/stories/`, update their points:
+```bash
+fh story <US-N> --points <N>
+```
 
 ### Step 5: Prioritize
 
 Sort items into three buckets:
 
-**Must (Sprint-Ziel)** — delivers the sprint goal, blocks other work, or is overdue  
-**Should (Best Effort)** — important but not blocking  
-**Could (Nice to Have)** — do if capacity allows  
+**Must (Sprint-Ziel)** — delivers the sprint goal, blocks other work, or is overdue
+**Should (Best Effort)** — important but not blocking
+**Could (Nice to Have)** — do if capacity allows
 
 Suggest a sprint goal in one sentence based on the Must items.
 
 ### Step 6: Check capacity
 
-Ask: **"Wie viele Entwickler-Tage habt ihr im Sprint?"** (default: 10 days for a 2-week sprint with one developer)
+Show velocity hint if available:
+```bash
+fh velocity show
+```
+
+Ask: **"Wie viele Punkte habt ihr im Sprint?"**
 
-Calculate if the Must + Should items fit. If they don't, move the lowest-priority Should items to Could.
+Default: rolling average from velocity history, or 20 points for a 2-week sprint with one developer.
+
+Calculate if Must + Should items fit. If they don't, move the lowest-priority Should items to Could.
 
 Show a capacity summary:
 ```
-Sprint-Kapazität: 10 Tage
-Must:   [sum] Tage
-Should: [sum] Tage  
-Could:  [sum] Tage
-─────────────────
-Geplant: [must+should] / 10 Tage
+Sprint-Kapazität: 20 Punkte
+Must:   [sum] Punkte
+Should: [sum] Punkte
+Could:  [sum] Punkte
+─────────────────────
+Geplant: [must+should] / 20 Punkte
 ```
 
 ### Step 7: Output the sprint plan
@@ -86,16 +105,16 @@ Write the sprint plan to `.forgehive/memory/sprint.md` in this format:
 
 **Ziel:** [one sentence sprint goal]
 
-**Kapazität:** [X] Entwickler-Tage
+**Kapazität:** [X] Punkte
 
 ## Must
-- [ ] [Item] ([size]) — [one-line description]
+- [ ] [ID] [Item] ([points]pt) — [one-line description]
 
-## Should  
-- [ ] [Item] ([size]) — [one-line description]
+## Should
+- [ ] [ID] [Item] ([points]pt) — [one-line description]
 
 ## Could
-- [ ] [Item] ([size]) — [one-line description]
+- [ ] [ID] [Item] ([points]pt) — [one-line description]
 
 ## Offen / Blocked
 - [any blocked items with reason]
@@ -104,10 +123,25 @@ Write the sprint plan to `.forgehive/memory/sprint.md` in this format:
 *Erstellt mit fh sprint — [timestamp]*
 ```
 
-Confirm with the user: **"Sprint Plan gespeichert in `.forgehive/memory/sprint.md`. Soll ich für jedes Must-Item direkt einen Branch anlegen?"**
+Confirm with the user: **"Sprint Plan gespeichert. Soll ich für jedes Must-Item direkt einen Branch anlegen?"**
 
-If yes: create branches for each Must item following the `git-conventions` skill (`feat/<slug>`, `fix/<slug>`, `chore/<slug>`).
+If yes: create branches following `feat/<slug>`, `fix/<slug>`, `chore/<slug>`.
 
 ### Step 8: Update project memory
 
-Append the sprint goal to `.forgehive/memory/project.md` under a `## Aktueller Sprint` section so Claude knows the current focus in every future session.
+Append the sprint goal to `.forgehive/memory/project.md` under a `## Aktueller Sprint` section.
+
+### Step 9: Record velocity (at sprint end)
+
+When the user runs `/fh-sprint` and mentions "Sprint ist fertig" or "Sprint abgeschlossen":
+
+1. Ask: **"Wie viele Punkte habt ihr tatsächlich geliefert?"**
+2. Read the committed points from `sprint.md`
+3. Record velocity:
+```bash
+fh velocity record <N> --committed <committed> --delivered <delivered>
+```
+4. Show updated velocity report:
+```bash
+fh velocity show
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forgehive",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Context-aware AI development environment — one binary, your stack.",
   "type": "module",
   "bin": {