forgehive 0.7.6 → 0.7.8

package/README.md

@@ -45,9 +45,9 @@ Claude loses all project knowledge between sessions. forgehive solves this by wr
 
 ---
 
-## Status: v0.7.5 — Stable
+## Status: v0.7.7 — Stable
 
-273 passing tests back the commands listed below. The v0.7 feature set has been validated end-to-end.
+297 passing tests back the commands listed below. The v0.7 feature set has been validated end-to-end.
 
 **Stable — use with confidence:**
 
@@ -93,6 +93,15 @@ If you run into issues, please open an issue on GitHub. The most valuable feedba
 
 ---
 
+## Documentation
+
+| Document | Description |
+|---|---|
+| [User Guide](docs/user-guide.md) | Installation, quick start, all commands with examples, troubleshooting |
+| [TUTORIAL.md](TUTORIAL.md) | Step-by-step walkthrough of a real session |
+
+---
+
 ## Installation
 
 ### From npm (recommended)
@@ -116,7 +125,7 @@ npm link           # makes 'fh' available globally
 Verify the installation:
 
 ```bash
-fh --version       # should print 0.7.5
+fh --version       # should print 0.7.7
 fh --help          # lists all available commands
 ```
 
@@ -881,6 +890,8 @@ npm test            # node --import tsx/esm --test test/*.test.ts
 
 | Version | What's new |
 |---|---|
+| **0.7.7** | User Guide (`docs/user-guide.md`) included in npm package; Documentation table in README |
+| **0.7.6** | YAML shape fix in `fh docs user`; frontmatter regex fix; 8 new tests for HIGH RISK paths |
 | **0.7.5** | `fh --version` reads from `package.json` (no longer hardcoded) |
 | **0.7.4** | Party slash commands installed by `fh init` (`/party`, `/review-party`, `/design-party`, `/full-party`, `/security-party`) |
 | **0.7.3** | User Docs generation (`fh docs user`, `fh docs api`, `fh docs list`) |

package/dist/cli.js

@@ -6550,7 +6550,7 @@ function generateUserGuide(projectRoot2, forgehiveDir2) {
   lines.push("## Overview");
   lines.push("");
   if (memFiles["project.md"]) {
-    const content = memFiles["project.md"].replace(/^---[\s\S]*?---\n/, "").trim();
+    const content = memFiles["project.md"].replace(/^---[\s\S]*?---\n?/, "").trim();
     lines.push(content);
   } else {
     lines.push(`${projectName} is a ${lang ?? "software"} application.`);
@@ -6585,7 +6585,7 @@ function generateUserGuide(projectRoot2, forgehiveDir2) {
   }
   lines.push("```");
   lines.push("");
-  if (Array.isArray(entryPoints) && entryPoints.length > 0) {
+  if ((lang === "typescript" || lang === "javascript") && Array.isArray(entryPoints) && entryPoints.length > 0) {
     lines.push("## Getting Started");
     lines.push("");
     lines.push("```bash");
@@ -6596,7 +6596,7 @@ function generateUserGuide(projectRoot2, forgehiveDir2) {
   if (memFiles["stack.md"]) {
     lines.push("## Configuration");
     lines.push("");
-    const content = memFiles["stack.md"].replace(/^---[\s\S]*?---\n/, "").trim();
+    const content = memFiles["stack.md"].replace(/^---[\s\S]*?---\n?/, "").trim();
     lines.push(content);
     lines.push("");
   }
@@ -7671,6 +7671,7 @@ Setze diese Umgebungsvariablen:`);
   } else if (subcommand === "onboard") {
     const outputArg = rest.includes("--output") ? rest[rest.indexOf("--output") + 1] : null;
     const outputPath = outputArg ?? path32.join(projectRoot, "ONBOARDING.md");
+    fs31.mkdirSync(path32.dirname(outputPath), { recursive: true });
     const doc = generateOnboardingDoc(projectRoot, forgehiveDir);
     fs31.writeFileSync(outputPath, doc, "utf8");
     console.log(`\u2714 Onboarding-Dokument geschrieben: ${outputPath}`);
@@ -7680,12 +7681,11 @@ Setze diese Umgebungsvariablen:`);
     const since = sinceArg ?? getLatestTag(projectRoot) ?? void 0;
     const rawLog = getGitLogSince(projectRoot, since);
     const commits = parseGitLog(rawLog);
-    let pkg = {};
+    let pkgVersion = "unreleased";
     try {
-      pkg = JSON.parse(fs31.readFileSync(path32.join(projectRoot, "package.json"), "utf8"));
+      pkgVersion = JSON.parse(fs31.readFileSync(path32.join(projectRoot, "package.json"), "utf8")).version ?? "unreleased";
     } catch {
     }
-    const pkgVersion = pkg.version ?? "unreleased";
     const md = formatChangelog(commits, pkgVersion);
     const outputPath = outputArg ?? path32.join(projectRoot, "CHANGELOG.md");
     let existing = "";
@@ -7698,31 +7698,9 @@ Setze diese Umgebungsvariablen:`);
       console.error("Usage: fh docs adr <titel>");
       process.exit(1);
     }
-    const adrsDir = path32.join(forgehiveDir, "memory", "adrs");
-    fs31.mkdirSync(adrsDir, { recursive: true });
-    const existing = fs31.readdirSync(adrsDir).filter((f) => f.endsWith(".md")).length;
-    const adrId = String(existing + 1).padStart(4, "0");
-    const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-    const filename = `${adrId}-${slug}.md`;
-    const content = `# ADR-${adrId}: ${title}
-
-**Datum:** ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}
-**Status:** proposed
-
-## Kontext
-
-(Beschreibe das Problem oder die Situation.)
-
-## Entscheidung
-
-(Beschreibe die getroffene Entscheidung.)
-
-## Konsequenzen
-
-(Beschreibe die Auswirkungen dieser Entscheidung.)
-`;
-    fs31.writeFileSync(path32.join(adrsDir, filename), content, "utf8");
-    console.log(`\u2714 ADR erstellt: .forgehive/memory/adrs/${filename}`);
+    const adrPath = createAdr(forgehiveDir, projectRoot, title);
+    const adrFilename = path32.relative(projectRoot, adrPath);
+    console.log(`\u2714 ADR erstellt: ${adrFilename}`);
   } else {
     console.error("Verf\xFCgbar: fh docs [list|user|api|onboard|changelog|adr <titel>]");
   }

package/docs/user-guide.md

@@ -0,0 +1,342 @@
+# forgehive — User Guide
+
+> Version 0.7.7 · [npm](https://www.npmjs.com/package/forgehive) · `npm install -g forgehive`
+
+forgehive (`fh`) gives Claude Code persistent memory about your project. Without it, Claude forgets everything between sessions — your stack, your conventions, your decisions. With it, Claude opens every session already knowing your codebase.
+
+---
+
+## Installation
+
+```bash
+npm install -g forgehive
+```
+
+Requires **Node.js ≥ 18** and **Claude Code** (`claude` CLI). Installs two aliases: `fh` and `forgehive`.
+
+Verify:
+
+```bash
+fh --version   # prints 0.7.7
+fh --help      # full command reference
+```
+
+---
+
+## Quick Start
+
+Three commands to get Claude up to speed on any project:
+
+```bash
+cd my-project
+fh init       # scan the project, write .forgehive/
+fh confirm    # activate the context for Claude
+```
+
+Then open a new Claude Code session in the same directory. Claude reads `.forgehive/` automatically at session start and knows your stack, constraints, and memory.
+
+---
+
+## What `fh init` Does
+
+Running `fh init` in a project:
+
+1. Scans your project — language, framework, dependencies, directory structure
+2. Creates `.forgehive/` with capabilities, memory files, 16 expert skills, agent permissions
+3. Merges a context block into `CLAUDE.md` (creates it if it doesn't exist, never overwrites existing content)
+4. Writes `AGENTS.md` to the project root (works with Cursor, Copilot, Gemini CLI, Codex, Windsurf)
+
+The result looks like this:
+
+```
+my-project/
+  .forgehive/
+    capabilities.yaml     ← detected stack (status: draft → confirmed)
+    harness/
+      constraints.yaml    ← max_lines, require_tests, style rules
+      permissions.yaml    ← per-agent file access control
+    memory/
+      MEMORY.md           ← index of all memory files
+      project.md          ← project context and open decisions
+      feedback.md         ← corrections + confirmed approaches
+      stack.md            ← details the scanner can't detect
+      adrs/               ← Architecture Decision Records
+      stories/            ← story cards (US-N.md)
+      epics/              ← epic cards (EPC-N.md)
+      velocity.md         ← sprint velocity history
+    skills/expert/        ← 16 preinstalled expert skills
+  AGENTS.md
+  CLAUDE.md               ← forgehive block appended, nothing overwritten
+```
+
+**Already have a `.forgehive/`?** `fh init` prints a warning and stops. Use `fh init --force` to re-initialize, or `fh scan --update` to update only the scan.
+
+---
+
+## The Two Statuses: Draft and Confirmed
+
+After `fh init`, `capabilities.yaml` is in `status: draft`. Claude won't treat the context as authoritative until you run:
+
+```bash
+fh confirm
+```
+
+This is intentional — review what the scanner detected before committing to it. Open `capabilities.yaml`, check that the language, framework, and dependencies look right, then confirm.
+
+To check the current status at any time:
+
+```bash
+fh status
+```
+
+---
+
+## Memory — Teaching Claude About Your Project
+
+The memory files in `.forgehive/memory/` are the most important part of forgehive. Claude reads them at every session start. Write to them directly in your editor, or let Claude append to them at session end.
+
+| File | What to put here |
+|---|---|
+| `project.md` | Architecture decisions, goals, open questions |
+| `feedback.md` | Things Claude got wrong, things that worked well |
+| `stack.md` | Auth patterns, deploy targets, things the scanner missed |
+| `adrs/` | Architecture Decision Records |
+
+**Create an ADR:**
+
+```bash
+fh docs adr "Use Postgres over MongoDB"
+```
+
+**List all ADRs:**
+
+```bash
+fh memory adr list
+```
+
+**View all memory:**
+
+```bash
+fh memory show
+```
+
+**Export for sharing:**
+
+```bash
+fh memory snapshot export ./team-memory.json
+fh memory snapshot import ./team-memory.json   # on another machine (skips existing files)
+```
+
+**Share with your team via git:**
+
+```bash
+fh sync push    # push .forgehive/memory/ to a dedicated git branch
+fh sync pull    # pull on another machine
+```
+
+---
+
+## Keeping Context Fresh
+
+Claude's context drifts when the codebase changes significantly. Run:
+
+```bash
+fh scan --check    # is the snapshot still current? (exits 1 if outdated)
+fh scan --update   # re-scan and update capabilities.yaml
+```
+
+Put `fh scan --check` in your CI pipeline to alert when the context needs refreshing.
+
+---
+
+## Documentation
+
+Generate documentation from your project's stack, memory, and git history:
+
+```bash
+fh docs                          # list existing documentation
+fh docs user                     # user guide → docs/user-guide.md
+fh docs api                      # API reference from exports → docs/api.md
+fh docs onboard                  # onboarding doc → ONBOARDING.md
+fh docs changelog                # semantic changelog → CHANGELOG.md
+fh docs changelog --since v1.0   # only changes since a tag
+fh docs adr "<title>"            # Architecture Decision Record
+```
+
+Custom output paths:
+
+```bash
+fh docs user --output ./guides/getting-started.md
+fh docs api  --output ./docs/reference.md
+```
+
+---
+
+## Security
+
+```bash
+fh security scan              # scan for secrets + SAST vulnerabilities
+fh security deps              # check npm dependencies for CVEs
+fh security report            # CISO-ready Markdown report
+fh security report gdpr       # GDPR-specific checks
+fh security report soc2       # SOC 2 relevant controls
+fh security report hipaa      # HIPAA technical safeguards
+fh security audit             # view the JSONL audit trail
+fh security permissions       # show per-agent file access rules
+```
+
+`fh security scan` exits with code 1 if CRITICAL or HIGH findings exist — safe to use as a CI gate. Secrets are never stored verbatim: only the first 6 characters appear in output, followed by `***`.
+
+---
+
+## Story Cards and Sprint Planning
+
+Lightweight agile tracking inside `.forgehive/memory/`:
+
+```bash
+# Epics
+fh epic create "User Authentication" --goal "Users can log in securely"
+fh epic list
+fh epic show EPC-1
+
+# Stories
+fh story create "As a user I want to log in" --epic EPC-1 --points 3
+fh story list
+fh story show US-1
+fh story sprint US-1    # pull into current sprint
+fh story done US-1      # mark done
+fh story done US-1 --points 5   # mark done and record actual points
+
+# Velocity
+fh velocity record sprint-3 --committed 21 --delivered 18
+fh velocity show        # history + rolling average + capacity recommendation
+```
+
+In a Claude Code session, run `/fh-sprint` to let Claude read the backlog and velocity data and suggest a realistic sprint scope.
+
+---
+
+## Party Mode — Parallel Agent Sessions
+
+Party Mode runs specialized agent sets in parallel, each in an isolated git worktree. Use this for reviews, design sessions, or full-release audits.
+
+```bash
+fh party run              # start the default (build) party
+fh party status           # check active sessions
+fh party cleanup          # remove finished worktrees
+```
+
+**Available party sets — trigger in Claude Code with the slash command:**
+
+| Slash Command | Agents | Use for |
+|---|---|---|
+| `/party` | Viktor + Kai + Sam | Feature development |
+| `/design-party` | Suki + Viktor | UI/UX and architecture |
+| `/review-party` | Kai + Sam + Eli | Code review, tests, docs |
+| `/security-party` | Vera + Sam | Security audit |
+| `/full-party` | All 8 agents | Major releases |
+
+Each agent works in its own worktree branch. After the party completes, review each agent's findings and merge selectively.
+
+---
+
+## Slash Commands in Claude Code
+
+These commands are available inside any Claude Code session in a forgehive-initialized project:
+
+| Command | What it does |
+|---|---|
+| `/fh-sprint` | Sprint planning from backlog + velocity data |
+| `/fh-ship` | Pre-ship checklist: tests, diff, PR draft |
+| `/fh-review` | Structured code review |
+| `/fh-hotfix` | Minimal hotfix protocol (< 50 lines rule) |
+| `/fh-test-this` | Generate tests for the current file |
+| `/fh-docs` | Interactive documentation generation |
+| `/fh-start-task` | Start a new feature branch with full context |
+| `/fh-deploy` | Pre-deploy checklist |
+| `/party` | Start build party (Viktor + Kai + Sam) |
+| `/design-party` | Start design party (Suki + Viktor) |
+| `/review-party` | Start review party (Kai + Sam + Eli) |
+| `/security-party` | Start security party (Vera + Sam) |
+| `/full-party` | Start all 8 agents |
+
+---
+
+## MCP — Connecting External Services
+
+Wire Claude Code to external services in one command:
+
+```bash
+fh wire linear     # Linear issue tracker
+fh wire github     # GitHub
+fh wire slack      # Slack
+fh wire notion     # Notion
+fh wire postgres   # PostgreSQL
+```
+
+Also supported: `sentry`, `jira`, `pagerduty`, `datadog`, `figma`.
+
+Store API keys securely (encrypted at `~/.forgehive/credentials.json`, chmod 600):
+
+```bash
+fh mcp auth add github GITHUB_TOKEN=ghp_yourtoken
+fh mcp auth add linear LINEAR_API_KEY=lin_api_key
+fh mcp auth list           # see which services have credentials
+fh mcp auth remove github  # delete credentials for a service
+```
+
+---
+
+## Cost Tracking
+
+```bash
+fh cost               # all-time Claude session costs
+fh cost today         # today's costs
+fh cost week          # this week
+fh cost --limit 20    # set a hard spend limit of $20
+fh cost --alert 15    # set an alert threshold at $15
+```
+
+Spend limits are enforced every time `fh cost` runs. At the alert threshold: warning printed. At the hard limit: non-zero exit — usable as a CI gate.
+
+---
+
+## CI Integration
+
+```bash
+fh ci                          # CI health report
+fh ci --format markdown        # Markdown output
+fh ci --fail-on high           # exit 1 on HIGH or CRITICAL findings
+fh ci --init                   # scaffold .github/workflows/forgehive.yml
+```
+
+`fh ci` aggregates security scan, dependency audit, and test results. The `--fail-on` flag controls which severity level blocks the pipeline.
+
+---
+
+## Removing forgehive
+
+```bash
+fh rollback
+```
+
+Removes `.forgehive/` and the forgehive block from `CLAUDE.md`. Everything else in `CLAUDE.md` is preserved. `AGENTS.md` is left in place (it's a standard file other tools use too — delete it manually if you don't want it).
+
+---
+
+## Troubleshooting
+
+**`fh init` says forgehive is already initialized**
+Use `fh init --force` to re-initialize, or `fh scan --update` to refresh only the scan.
+
+**Claude doesn't seem to pick up the context**
+Make sure `fh confirm` was run — check `fh status`. The context is inactive while `status: draft`.
+
+**`fh scan --check` exits with an error**
+Your codebase has changed significantly since the last scan. Run `fh scan --update` to refresh.
+
+**Party Mode: worktrees left over after a session**
+Run `fh party cleanup` to remove all finished worktrees.
+
+**`fh cost` shows no data**
+Cost tracking reads `~/.claude/` — requires Claude Code to be installed and to have run at least one session.

package/forgehive/commands/fh-refactor.md

@@ -0,0 +1,116 @@
+You are running the ForgeHive refactor workflow.
+
+## Refactor Workflow
+
+**Agenten:** Kai (Plan) → Viktor + Sam + Eli (parallel)
+
+**Mission:** Strukturierter Code-Umbau — erst verstehen und planen, dann parallel implementieren, testen und dokumentieren.
+
+## Protocol
+
+### Step 0: Scope klären
+
+Frage den User:
+
+---
+
+**Was soll refactored werden?**
+
+Gib eine der folgenden Angaben:
+- **Freie Beschreibung** — z.B. „die Docs-Generierung soll sauberer modularisiert werden"
+- **Dateipfade** — z.B. `src/docs.ts`, `src/cli.ts`
+- **Ziel-Statement** — z.B. „extrahiere generateUserGuide in ein eigenes Modul"
+
+---
+
+Wenn der Scope unklar ist: frage nach, bis das Ziel eindeutig ist.
+
+Dann führt **Kai** (Principal Engineer) die Ist-Analyse durch:
+1. Lese alle betroffenen Dateien
+2. Führe `git diff HEAD` aus (aktuelle uncommitted Änderungen)
+3. Liste alle Exports der Scope-Dateien und wo sie importiert werden
+4. Identifiziere Abhängigkeiten (wer importiert was aus den Scope-Dateien)
+
+### Step 1: Refactor-Plan erstellen (Kai)
+
+Erstelle folgenden Plan:
+
+```
+## Refactor-Plan: <Ziel>
+
+**Ziel:** <Ein Satz>
+
+**Betroffene Dateien:**
+- src/foo.ts → src/foo/index.ts + src/foo/helpers.ts
+
+**Bewegte Exports:**
+- `helperFn` aus foo.ts → foo/helpers.ts (re-exportiert aus foo/index.ts)
+
+**Breaking Changes:** keine / [Liste]
+
+**Risiken:** [z.B. zirkuläre Imports möglich bei X]
+
+**Nicht geändert:** [öffentliche API, bestehende Tests für Y, ...]
+```
+
+⚠️ **USER-APPROVAL GATE** — kein Code ohne explizites OK. Warte auf Bestätigung.
+
+### Step 2: Parallel Party starten
+
+Nach Approval:
+
+```bash
+fh party run refactor
+```
+
+Alle drei Agenten erhalten Kai's genehmigten Refactor-Plan als Kontext.
+
+**Viktor** (Systems Architect):
+- Implementiert die Änderungen Datei für Datei nach Plan
+- Darf nicht ohne User-Freigabe vom Plan abweichen
+- Meldet unvorhergesehene Abhängigkeiten explizit
+
+**Sam** (Quality Architect):
+- Liest bestehende Tests für betroffene Dateien
+- Schreibt neue Tests für umbenannte/verschobene Exports
+- Fixiert Tests die durch den Refactor brechen
+- Führt Testsuit am Ende aus — alle grün?
+
+**Eli** (Documentation Architect):
+- Aktualisiert Inline-Kommentare in geänderten Dateien
+- Aktualisiert Referenzen in README und docs/
+- Schreibt CHANGELOG-Eintrag für den Refactor
+
+### Step 3: Verifikation
+
+```bash
+fh party status
+```
+
+Synthesebericht erstellen:
+
+```
+## Refactor-Abschlussbericht
+
+### Viktor — Implementierung
+[Was wurde umgebaut]
+
+### Sam — Tests
+[Welche Tests angepasst/neu — Teststatus: ✅ alle grün / ⚠️ N fehlgeschlagen]
+
+### Eli — Dokumentation
+[Was wurde aktualisiert]
+
+### Offene Punkte
+[Was blieb unerledigt oder braucht Follow-up]
+
+### Verdict: ✅ Fertig / ⚠️ Offen
+```
+
+Abschlussfrage: **„Soll ich direkt einen Commit erstellen?"**
+
+### Step 4: Cleanup
+
+```bash
+fh party cleanup
+```

package/forgehive/commands/review-party.md

@@ -8,55 +8,74 @@ You are running a Review Party using ForgeHive.
 
 ## Protocol
 
-### Step 1: Launch the party
+### Step 0: Scope selection
+
+**Before doing anything else**, ask the user what to review:
+
+---
+
+**Was soll reviewed werden?**
+
+1. **Aktuelle Änderungen** — uncommitted working tree (`git diff HEAD`)
+2. **Letzter Commit** — `git diff HEAD~1..HEAD`
+3. **Branch vs main** — alles seit dem Abzweigen (`git diff main...HEAD`)
+4. **Letzte N Commits** — Anzahl angeben
+5. **Commit-Range** — z.B. `abc123..def456`
+6. **Spezifische Dateien** — Dateipfade angeben
+7. **PR** — PR-Nummer oder Branch-Name angeben
+
+---
+
+Wait for the user's answer. Then resolve the scope to a concrete `git diff` command and show the `--stat` output to confirm:
 
-Run:
 ```bash
-fh party run --set review
+# Example for option 3:
+git diff main...HEAD --stat
 ```
 
-This spins up isolated git worktrees for Kai, Sam, and Eli. Each agent reviews the current diff in parallel.
-
-### Step 2: Set the scope
+If the diff is empty or the result looks wrong, say so and ask the user to clarify before proceeding.
 
-Before the party starts, specify what is being reviewed — a branch name, a PR, or a commit range:
+### Step 1: Launch the party
 
+Once the scope is confirmed, run:
 ```bash
-git diff main...HEAD --stat   # show what changed
+fh party run review
 ```
 
-Share this with the party so all three agents review the same surface area.
+This spins up isolated git worktrees for Kai, Sam, and Eli.
+
+### Step 2: Dispatch agents in parallel
 
-### Step 3: Parallel review
+Pass each agent the confirmed scope and diff summary. Each agent works independently:
 
-**Kai** (Principal Engineer) — in his worktree:
-- Reviews code quality and correctness
+**Kai** (Principal Engineer):
+- Reviews code quality and correctness within the scoped diff
 - Flags bugs, logic errors, and anti-patterns
 - Checks for ambiguous naming, hidden coupling, and missing error handling
 - Labels findings: `[BUG]`, `[DESIGN]`, `[NIT]`, `[Q]`, `[+]`
 
-**Sam** (Quality Architect) — in his worktree:
+**Sam** (Quality Architect):
 - Checks test coverage for the changed code
 - Identifies missing edge cases, error states, and boundary conditions
-- Flags paths that are high-risk but untested
-- Proposes specific tests for any gaps found
+- Flags high-risk untested paths
+- Proposes specific tests for gaps
 
-**Eli** (Documentation Architect) — in his worktree:
-- Checks if README and docs reflect the changes
+**Eli** (Documentation Architect):
+- Checks if README and docs reflect the changes in scope
 - Flags missing or outdated inline documentation
-- Reviews any CHANGELOG entries for accuracy
+- Reviews CHANGELOG entries for accuracy
 - Checks that public API changes are documented
 
-### Step 4: Check status
+### Step 3: Check status
 
-After each agent completes their review:
+After each agent completes:
 ```bash
 fh party status
 ```
 
-### Step 5: Synthesize findings
+### Step 4: Synthesize findings
 
-Collect the three reports and merge them into a unified review:
+Merge the three reports into a unified review:
 
 1. **Blocking issues** — anything from Kai or Sam that must be fixed before merge
 2. **Test gaps** — Sam's missing coverage items
@@ -65,7 +84,7 @@ Collect the three reports and merge them into a unified review:
 
 Present the synthesized report to the user and ask: **"Soll ich die Blocking Issues direkt fixen?"**
 
-### Step 6: Cleanup
+### Step 5: Cleanup
 
 ```bash
 fh party cleanup

package/forgehive/party/defaults.yaml

@@ -41,3 +41,11 @@ sets:
     models:
       vera: claude-opus-4-7
       sam: claude-sonnet-4-6
+  refactor:
+    agents: [viktor, sam, eli]
+    trigger: "/fh-refactor"
+    description: "Refactor — Implementierung + Tests + Doku parallel"
+    models:
+      viktor: claude-opus-4-7
+      sam: claude-sonnet-4-6
+      eli: claude-sonnet-4-6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forgehive",
-  "version": "0.7.6",
+  "version": "0.7.8",
   "description": "Context-aware AI development environment — one binary, your stack.",
   "type": "module",
   "bin": {
@@ -9,6 +9,7 @@
   },
   "files": [
     "dist/",
+    "docs/user-guide.md",
     "forgehive/"
   ],
   "keywords": [