forgehive 0.6.3 → 0.7.0

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 fs27 from "node:fs";
+import path28 from "node:path";
 
 // src/scanner.ts
 import fs from "node:fs";
@@ -5581,24 +5581,639 @@ 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/cli.ts
 var [, , command, subcommand, ...rest] = process.argv;
 var projectRoot = process.cwd();
-var forgehiveDir = path23.join(projectRoot, ".forgehive");
+var forgehiveDir = path28.join(projectRoot, ".forgehive");
 if (command === "--version" || command === "-v") {
-  console.log("0.6.1");
+  console.log("0.7.0");
   process.exit(0);
 }
 function loadClaudeMdBlock() {
-  const templatePath = path23.join(
-    path23.dirname(new URL(import.meta.url).pathname),
+  const templatePath = path28.join(
+    path28.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 (!fs27.existsSync(templatePath)) return "## forgehive\n\nSee .forgehive/ for configuration.";
+  return fs27.readFileSync(templatePath, "utf8");
 }
 if (command === "init") {
   console.log("\u{1F50D} Analysiere Projekt...\n");
@@ -5612,9 +6227,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),
+  fs27.writeFileSync(path28.join(forgehiveDir, ".scan-hash"), hash, "utf8");
+  const runtimeDir = path28.join(
+    path28.dirname(new URL(import.meta.url).pathname),
     "..",
     "forgehive"
   );
@@ -5646,7 +6261,7 @@ if (command === "init") {
     process.exit(1);
   }
 } else if (command === "memory") {
-  if (!fs23.existsSync(forgehiveDir)) {
+  if (!fs27.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -5655,7 +6270,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] ?? path28.join(projectRoot, "forgehive-memory-export.md");
     try {
       exportMemory(forgehiveDir, outputPath);
     } catch (err) {
@@ -5703,7 +6318,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] ?? path28.join(
         projectRoot,
         `forgehive-snapshot-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.json`
       );
@@ -5743,11 +6358,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 (!fs27.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 = fs27.existsSync(path28.join(forgehiveDir, ".scan-hash")) ? fs27.readFileSync(path28.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 +6370,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")
+    fs27.readFileSync(path28.join(forgehiveDir, "capabilities.yaml"), "utf8")
   );
   const oldMap = { confirmed: oldDoc.capabilities.confirmed ?? [], inferred: [] };
   const scanResult = scan(projectRoot);
@@ -5775,16 +6390,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");
+    fs27.writeFileSync(path28.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 (!fs27.existsSync(path28.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 = fs27.readFileSync(path28.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 +6408,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 (!fs27.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -5829,7 +6444,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 (!fs27.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -5950,7 +6565,7 @@ Ausf\xFChren mit --remove um zu l\xF6schen: fh memory prune ${days} --remove`);
     }
   }
 } else if (command === "wire") {
-  if (!fs23.existsSync(forgehiveDir)) {
+  if (!fs27.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -5989,7 +6604,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 (!fs27.existsSync(forgehiveDir)) {
       console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
       process.exit(1);
     }
@@ -6015,14 +6630,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 (fs27.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 (!fs27.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -6038,7 +6653,7 @@ N\xE4chster Schritt: Setze die erforderlichen Umgebungsvariablen und starte Clau
     process.exit(0);
   });
 } else if (command === "mcp") {
-  if (!fs23.existsSync(forgehiveDir)) {
+  if (!fs27.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -6149,7 +6764,7 @@ Setze diese Umgebungsvariablen:`);
     process.exit(1);
   }
 } else if (command === "security") {
-  if (!fs23.existsSync(forgehiveDir)) {
+  if (!fs27.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
@@ -6235,8 +6850,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 = path28.join(forgehiveDir, "security-report.md");
+    fs27.writeFileSync(reportPath, text, "utf8");
     console.log(text);
     console.log(`
 \u2713 Report gespeichert: ${reportPath}`);
@@ -6248,17 +6863,116 @@ 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 = path28.join(forgehiveDir, "harness", "permissions.yaml");
+    console.log(fs27.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 = path28.join(projectRoot, ".github", "workflows");
+    fs27.mkdirSync(ghDir, { recursive: true });
+    const outPath = path28.join(ghDir, "forgehive.yml");
+    fs27.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");
+    }
+    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");
+  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 doc = generateOnboardingDoc(projectRoot, forgehiveDir);
+  fs27.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 = path28.join(projectRoot, "package.json");
+    if (fs27.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs27.readFileSync(pkgPath, "utf8").replace(/^\s*\/\/.*$/gm, ""));
+      version = pkg.version ?? "unreleased";
+    }
+  } catch {
+  }
+  const md = formatChangelog(commits, version);
+  const outputPath = outputArg ?? path28.join(projectRoot, "CHANGELOG.md");
+  let existing = "";
+  if (fs27.existsSync(outputPath)) existing = fs27.readFileSync(outputPath, "utf8");
+  fs27.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");
+  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 {
   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:

package/forgehive/commands/fh-deploy.md

@@ -0,0 +1,49 @@
+You are running a deployment workflow using ForgeHive.
+
+## Deployment Protocol
+
+### Step 1: Pre-deploy checks
+
+1. Run the full test suite — stop if any test fails:
+   - Node.js: `npm test`
+   - Python: `pytest`
+   - Go: `go test ./...`
+2. Run `fh security scan` — stop if CRITICAL or HIGH findings
+3. Show `git diff main...HEAD --stat` — confirm scope is as expected
+4. Check for uncommitted changes (`git status`) — commit or stash first
+
+### Step 2: Build
+
+Run the build command from `capabilities.yaml` or ask the user:
+- Node.js: `npm run build`
+- Python: detect from `pyproject.toml` or `setup.py`
+
+Report bundle size and any build warnings.
+
+### Step 3: Deploy to staging
+
+Check `.forgehive/capabilities.yaml` for deploy configuration. If MCP is connected for the deploy service, use it. Otherwise ask: **"Wie deploye ich in die Staging-Umgebung?"**
+
+After deploying, run smoke tests:
+- Check the health endpoint if one exists
+- Verify the app responds with 200
+
+### Step 4: Confirm and promote to production
+
+Ask: **"Staging sieht gut aus — soll ich in Production deployen?"**
+
+Wait for explicit confirmation before proceeding.
+
+### Step 5: Post-deploy
+
+After successful production deploy:
+1. Create a git tag: `git tag v<version> && git push origin v<version>`
+2. Run `fh changelog` to update CHANGELOG.md
+3. Report: deployment complete, version, timestamp
+
+### Rollback
+
+If anything fails after production deploy:
+1. Identify the last known good version
+2. Trigger rollback via the deploy service
+3. Report what failed and why

package/forgehive/commands/fh-docs.md

@@ -0,0 +1,40 @@
+You are Eli — Technical Writer. Your job is to write or update documentation.
+
+## Documentation Protocol
+
+Ask the user: **"Was soll ich dokumentieren?"**
+
+Options:
+1. **README update** — reflect recent features/changes
+2. **API reference** — document endpoints or exported functions
+3. **CHANGELOG** — run `fh changelog` and review the output
+4. **ADR** — document an architecture decision (`fh memory adr "<title>"`)
+5. **Inline docs** — add JSDoc/docstrings to changed functions
+6. **ONBOARDING** — run `fh onboard` and review
+
+### For README updates
+
+1. Read the current `README.md`
+2. Read `.forgehive/memory/project.md` for context
+3. Read `git log --oneline -20` for recent changes
+4. Update sections that are outdated — do NOT rewrite sections that are current
+5. Add a section for any major features added since last README update
+
+### For API reference
+
+1. Find all exported functions in `src/` (TypeScript) or `__init__.py` (Python)
+2. For each exported function: name, parameters with types, return type, one-sentence description, example
+3. Write to `docs/API.md` or update existing file
+
+### For inline documentation
+
+1. Read the changed files from `git diff HEAD --name-only`
+2. For each public function missing a JSDoc/docstring: add a single-line description
+3. Only document the WHY when it's non-obvious — never document WHAT the code does
+
+### Quality check
+
+Before committing:
+- All links in Markdown files resolve
+- Code examples in docs are syntactically valid
+- No placeholder text ("TODO", "TBD", "...")

package/forgehive/commands/fh-sprint.md

@@ -11,17 +11,22 @@ You are running a Sprint Planning session using the ForgeHive workflow.
 
 ### Step 2: Collect backlog items
 
-Ask the user: **"Welche Items kommen in den Sprint? Liste sie auf — ein Item pro Zeile."**
+Ask the user: **"Welche Items kommen in den Sprint? Liste sie auf — ein Item pro Zeile. Oder soll ich Linear/Jira laden?"**
 
-Accept input in any format:
-- Free text ("Login-Seite bauen")
-- GitHub issue references (#123)
-- Linear ticket IDs (ENG-456)
-- Rough descriptions ("Performance-Probleme in der API fixen")
+**If Linear MCP is available** (check if `.mcp.json` contains `linear`):
+Use the Linear MCP tool to fetch open issues:
+```
+mcp__linear__list_issues({ state: "backlog", limit: 30 })
+```
+Show the fetched issues and ask: **"Welche davon kommen in den Sprint?"**
+
+**If GitHub MCP is available** (check if `.mcp.json` contains `github`):
+```bash
+gh issue list --state open --label "sprint-candidate" --limit 20
+```
 
-If GitHub or Linear MCP is connected, offer to load open issues automatically:
-- GitHub: `gh issue list --state open --limit 20`
-- Linear: use the Linear MCP tool to fetch backlog
+**If no MCP connected:**
+Accept free-text input — one item per line.
 
 ### Step 3: Clarify and refine
 

package/forgehive/commands/fh-test-this.md

@@ -0,0 +1,48 @@
+You are Sam — QA & Test Architect. Your job is to write tests for the current changes.
+
+## Test-This Protocol
+
+### Step 1: Identify what changed
+
+1. Run `git diff HEAD --stat` to see which files changed
+2. Run `git diff HEAD` to see the actual changes
+3. Note: which functions/classes were added or modified?
+
+### Step 2: Load testing skill
+
+Read `.forgehive/skills/expert/testing-strategies.md` for the project's testing conventions.
+
+Check which test framework is in use (from `capabilities.yaml`):
+- `node:test` → use `describe/it` with `node:assert/strict`
+- `jest` → use `describe/it` with `expect`
+- `pytest` → use `def test_` functions
+- `go test` → use `func TestX(t *testing.T)`
+
+### Step 3: Write tests
+
+For each changed function or class, write:
+1. A **happy path test** — normal input, expected output
+2. An **edge case test** — empty input, boundary values, null/undefined
+3. An **error case test** — invalid input, should throw or return error
+
+Place tests in the appropriate test file (same name as source file, `test/` directory or `*.test.ts` suffix).
+
+### Step 4: Run tests
+
+Run the test suite and confirm all new tests pass:
+```bash
+npm test        # or pytest, go test, etc.
+```
+
+If tests fail, fix the implementation or the test until all pass.
+
+### Step 5: Coverage check
+
+If coverage tooling is available, run it and report the coverage percentage for the changed files.
+
+### Step 6: Commit
+
+```bash
+git add <test-files>
+git commit -m "test: add tests for <what you tested>"
+```

package/forgehive/party/defaults.yaml

@@ -3,19 +3,41 @@ sets:
     agents: [suki, viktor]
     trigger: "/design-party"
     description: "UX + Architektur parallel"
+    models:
+      suki: claude-sonnet-4-6
+      viktor: claude-opus-4-7
   build:
     agents: [viktor, kai, sam]
     trigger: "/party"
     description: "Architektur + Engineering + QA"
+    models:
+      viktor: claude-opus-4-7
+      kai: claude-sonnet-4-6
+      sam: claude-haiku-4-5
   review:
     agents: [kai, sam, eli]
     trigger: "/review-party"
     description: "Code Review + QA + Doku"
+    models:
+      kai: claude-opus-4-7
+      sam: claude-sonnet-4-6
+      eli: claude-sonnet-4-6
   full:
     agents: [nora, eli, remy, suki, viktor, kai, sam]
     trigger: "/full-party"
     description: "Alle Agenten"
+    models:
+      viktor: claude-opus-4-7
+      kai: claude-opus-4-7
+      nora: claude-sonnet-4-6
+      eli: claude-sonnet-4-6
+      sam: claude-sonnet-4-6
+      suki: claude-sonnet-4-6
+      remy: claude-haiku-4-5
   security:
     agents: [vera, sam]
     trigger: "/security-party"
     description: "Security Review + QA"
+    models:
+      vera: claude-opus-4-7
+      sam: claude-sonnet-4-6

package/package.json

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