forgehive 0.7.7 → 0.7.8

package/docs/superpowers/plans/2026-05-11-v05-nextgen-gaps.md

@@ -1,2364 +0,0 @@
-# ForgeHive v0.5 — NextGen Gap Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Close all competitive gaps from the v0.5 analysis: AGENTS.md cross-tool output, harness constraints, memory aging + ADR system, context drift detection, session cost tracking, multi-model party routing, worktree-isolated party runs, MCP credential management, and Smithery registry integration.
-
-**Architecture:** Ten independent modules extending the existing TypeScript ESM CLI. Each is a focused export + CLI surface added to `src/cli.ts`. No new runtime npm dependencies — only Node.js built-ins (fs, os, crypto, child_process), js-yaml, and `curl` (available macOS/Linux) for the registry HTTP call. All modules use the same patterns as existing code: synchronous functions, node:test, tmpDir fixtures.
-
-**Tech Stack:** TypeScript 5.8 ESM, Node.js built-ins, js-yaml 4.1, node:test runner, esbuild bundler. Test command: `node --import tsx/esm --test test/*.test.ts`.
-
----
-
-## File Structure
-
-**New source files:**
-- `src/agents-md.ts` — `writeAgentsMd(projectRoot, scanResult, capMap): void`
-- `src/harness.ts` — `writeHarness(forgehiveDir, scanResult, capMap): void`
-- `src/adr.ts` — `createAdr(forgehiveDir, projectRoot, title): string`, `listAdrs(forgehiveDir): AdrEntry[]`
-- `src/cost.ts` — `parseCostSessions(projectRoot): SessionCost[]`, `formatCostReport(sessions, range): string`
-- `src/mcp-auth.ts` — `setCredentials`, `getCredentials`, `listCredentialServices`, `removeCredentials`
-- `src/mcp-registry.ts` — `searchRegistry(query): RegistryServer[]`, `addMcpFromRegistry(projectRoot, forgehiveDir, packageName, envKeys): void`
-
-**Modified source files:**
-- `src/memory.ts` — add `pruneMemory(forgehiveDir, days, remove?): PruneResult`, `getMemoryMeta(forgehiveDir): MemoryFileMeta[]`; update stubs with `last_updated` frontmatter
-- `src/party.ts` — extend `PartySet` with `model_map?`, add `setAgentModel`, `runParty`, `getPartyStatus`, `cleanupPartyWorktrees`
-- `src/status.ts` — add `checkDrift(projectRoot, forgehiveDir): DriftInfo`, extend `projectStatus()` with drift line
-- `src/writer.ts` — call `writeAgentsMd()` from `writeForgehiveDir()`, call `writeHarness()` from `initForgehiveRuntime()`
-- `src/cli.ts` — add handlers for all new subcommands (see each task)
-
-**New test files:** `test/agents-md.test.ts`, `test/harness.test.ts`, `test/adr.test.ts`, `test/cost.test.ts`, `test/mcp-auth.test.ts`, `test/mcp-registry.test.ts`
-
-**Modified test files:** `test/memory.test.ts`, `test/party.test.ts`, `test/status.test.ts`
-
----
-
-### Task 1: AGENTS.md Generation
-
-**Files:**
-- Create: `src/agents-md.ts`
-- Modify: `src/writer.ts` (lines 11–43)
-- Test: `test/agents-md.test.ts`
-
-- [ ] **Step 1: Write failing tests**
-
-```typescript
-// test/agents-md.test.ts
-import { describe, it, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import { writeAgentsMd } from "../src/agents-md.ts";
-
-const mockCapMap = {
-  confirmed: [
-    { id: "typescript", source: "tsconfig.json", confidence: "confirmed" as const },
-    { id: "nodejs", source: "package.json", confidence: "confirmed" as const },
-  ],
-  inferred: [],
-};
-const mockScan = { scanned_at: "2026-05-11", project_root: "", signals: [], packages: [] };
-
-describe("writeAgentsMd()", () => {
-  let tmpDir: string;
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "forgehive-agents-md-"));
-    mockScan.project_root = tmpDir;
-  });
-  afterEach(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-  it("creates AGENTS.md at project root", () => {
-    writeAgentsMd(tmpDir, mockScan, mockCapMap);
-    assert.ok(fs.existsSync(path.join(tmpDir, "AGENTS.md")));
-  });
-
-  it("includes confirmed capabilities", () => {
-    writeAgentsMd(tmpDir, mockScan, mockCapMap);
-    const content = fs.readFileSync(path.join(tmpDir, "AGENTS.md"), "utf8");
-    assert.ok(content.includes("typescript"));
-    assert.ok(content.includes("nodejs"));
-  });
-
-  it("uses project name from package.json", () => {
-    fs.writeFileSync(
-      path.join(tmpDir, "package.json"),
-      JSON.stringify({ name: "my-cool-project", scripts: { test: "jest", build: "tsc" } }),
-      "utf8"
-    );
-    writeAgentsMd(tmpDir, mockScan, mockCapMap);
-    const content = fs.readFileSync(path.join(tmpDir, "AGENTS.md"), "utf8");
-    assert.ok(content.includes("my-cool-project"));
-    assert.ok(content.includes("npm run build"));
-    assert.ok(content.includes("npm test"));
-  });
-
-  it("is idempotent — overwrites on re-run", () => {
-    writeAgentsMd(tmpDir, mockScan, mockCapMap);
-    writeAgentsMd(tmpDir, mockScan, mockCapMap);
-    const files = fs.readdirSync(tmpDir).filter(f => f === "AGENTS.md");
-    assert.equal(files.length, 1);
-  });
-
-  it("mentions .forgehive/memory and skills", () => {
-    writeAgentsMd(tmpDir, mockScan, mockCapMap);
-    const content = fs.readFileSync(path.join(tmpDir, "AGENTS.md"), "utf8");
-    assert.ok(content.includes(".forgehive/memory"));
-    assert.ok(content.includes(".forgehive/skills"));
-  });
-});
-```
-
-- [ ] **Step 2: Run test to confirm it fails**
-
-```bash
-cd /path/to/project && node --import tsx/esm --test test/agents-md.test.ts 2>&1 | head -10
-```
-
-Expected: `Error: Cannot find module '../src/agents-md.ts'`
-
-- [ ] **Step 3: Implement `src/agents-md.ts`**
-
-```typescript
-import fs from "node:fs";
-import path from "node:path";
-import type { ScanResult } from "./types.ts";
-import type { CapabilityMap } from "./lookup-table.ts";
-
-export function writeAgentsMd(
-  projectRoot: string,
-  scanResult: ScanResult,
-  capMap: CapabilityMap
-): void {
-  const pkgPath = path.join(projectRoot, "package.json");
-  let projectName = path.basename(projectRoot);
-  let buildLine = "";
-  let testLine = "";
-
-  if (fs.existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8")) as {
-        name?: string;
-        scripts?: Record<string, string>;
-      };
-      if (pkg.name) projectName = pkg.name;
-      if (pkg.scripts?.build) buildLine = "\nBuild: `npm run build`";
-      if (pkg.scripts?.test) testLine = "\nTest: `npm test`";
-    } catch { /* ignore */ }
-  }
-
-  const capLines = capMap.confirmed.length > 0
-    ? capMap.confirmed.slice(0, 10).map(c => `- **${c.id}** (via ${c.source})`).join("\n")
-    : "- (run `fh init` to populate)";
-
-  const content = [
-    `# ${projectName}`,
-    "",
-    "> AI context for Cursor, GitHub Copilot, Claude Code, Gemini CLI, Codex, Windsurf.",
-    "> Generated by ForgeHive. Regenerate with: `fh init`",
-    "",
-    "## Instructions",
-    "",
-    "Before making changes:",
-    "1. Read `.forgehive/capabilities.yaml` — confirmed project capabilities",
-    "2. Read `.forgehive/memory/MEMORY.md` — persistent project context",
-    "3. Load relevant skills from `.forgehive/skills/INDEX.yaml`",
-    "",
-    "## Build & Test",
-    buildLine,
-    testLine,
-    "",
-    "## Capabilities",
-    "",
-    capLines,
-    "",
-    "## Memory",
-    "",
-    "Persistent context in `.forgehive/memory/`. Read `MEMORY.md` for the index.",
-    "",
-    "## Skills",
-    "",
-    "Context-aware skills in `.forgehive/skills/`. Check `INDEX.yaml` for available skills.",
-  ].join("\n");
-
-  fs.writeFileSync(path.join(projectRoot, "AGENTS.md"), content + "\n", "utf8");
-}
-```
-
-- [ ] **Step 4: Wire into `src/writer.ts`**
-
-Add import at top of `src/writer.ts` (after existing imports):
-```typescript
-import { writeAgentsMd } from "./agents-md.ts";
-```
-
-Add call at end of `writeForgehiveDir()` body, after the `mergeClaudeMd(projectRoot, claudeMdBlock);` line:
-```typescript
-  writeAgentsMd(projectRoot, scanResult, capMap);
-```
-
-- [ ] **Step 5: Run all tests**
-
-```bash
-node --import tsx/esm --test test/*.test.ts 2>&1 | tail -8
-```
-
-Expected:
-```
-# pass 128
-# fail 0
-```
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add src/agents-md.ts src/writer.ts test/agents-md.test.ts
-git commit -m "feat: generate AGENTS.md on fh init — cross-tool AI context (Cursor, Copilot, Gemini)"
-```
-
----
-
-### Task 2: Harness File Generation
-
-**Files:**
-- Create: `src/harness.ts`
-- Modify: `src/writer.ts:51–125` (initForgehiveRuntime)
-- Test: `test/harness.test.ts`
-
-- [ ] **Step 1: Write failing tests**
-
-```typescript
-// test/harness.test.ts
-import { describe, it, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import { writeHarness } from "../src/harness.ts";
-
-const mockCapMap = {
-  confirmed: [
-    { id: "typescript", source: "tsconfig.json", confidence: "confirmed" as const },
-  ],
-  inferred: [],
-};
-const mockScan = { scanned_at: "2026-05-11", project_root: "", signals: [], packages: [] };
-
-describe("writeHarness()", () => {
-  let tmpDir: string;
-  let forgehiveDir: string;
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "forgehive-harness-"));
-    forgehiveDir = path.join(tmpDir, ".forgehive");
-    fs.mkdirSync(forgehiveDir, { recursive: true });
-    mockScan.project_root = tmpDir;
-  });
-  afterEach(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-  it("creates .forgehive/harness/ directory", () => {
-    writeHarness(forgehiveDir, mockScan, mockCapMap);
-    assert.ok(fs.existsSync(path.join(forgehiveDir, "harness")));
-  });
-
-  it("creates architecture.md with detected capabilities", () => {
-    writeHarness(forgehiveDir, mockScan, mockCapMap);
-    const content = fs.readFileSync(path.join(forgehiveDir, "harness", "architecture.md"), "utf8");
-    assert.ok(content.includes("typescript"));
-    assert.ok(content.includes("Architecture Constraints"));
-  });
-
-  it("creates constraints.yaml with defaults", () => {
-    writeHarness(forgehiveDir, mockScan, mockCapMap);
-    const content = fs.readFileSync(path.join(forgehiveDir, "harness", "constraints.yaml"), "utf8");
-    assert.ok(content.includes("max_lines"));
-    assert.ok(content.includes("require_tests"));
-  });
-
-  it("is idempotent — does not overwrite existing files", () => {
-    writeHarness(forgehiveDir, mockScan, mockCapMap);
-    const archPath = path.join(forgehiveDir, "harness", "architecture.md");
-    fs.writeFileSync(archPath, "# Custom content", "utf8");
-    writeHarness(forgehiveDir, mockScan, mockCapMap);
-    assert.equal(fs.readFileSync(archPath, "utf8"), "# Custom content");
-  });
-});
-```
-
-- [ ] **Step 2: Run test to confirm it fails**
-
-```bash
-node --import tsx/esm --test test/harness.test.ts 2>&1 | head -5
-```
-
-Expected: `Error: Cannot find module '../src/harness.ts'`
-
-- [ ] **Step 3: Implement `src/harness.ts`**
-
-```typescript
-import fs from "node:fs";
-import path from "node:path";
-import yaml from "js-yaml";
-import type { ScanResult } from "./types.ts";
-import type { CapabilityMap } from "./lookup-table.ts";
-
-export function writeHarness(
-  forgehiveDir: string,
-  scanResult: ScanResult,
-  capMap: CapabilityMap
-): void {
-  const harnessDir = path.join(forgehiveDir, "harness");
-  fs.mkdirSync(harnessDir, { recursive: true });
-
-  const archPath = path.join(harnessDir, "architecture.md");
-  if (!fs.existsSync(archPath)) {
-    const capLines = capMap.confirmed.length > 0
-      ? capMap.confirmed.map(c => `- **${c.id}**: detected via ${c.source}`).join("\n")
-      : "- (none detected)";
-
-    fs.writeFileSync(archPath, [
-      "# Architecture Constraints",
-      "",
-      "> Generated by ForgeHive. Edit to reflect actual project conventions.",
-      "> Referenced in CLAUDE.md and AGENTS.md.",
-      "",
-      "## Detected Stack",
-      "",
-      capLines,
-      "",
-      "## Rules",
-      "",
-      "- Do not add new dependencies without a brief justification in the PR",
-      "- Files should stay under 300 lines — split by responsibility when exceeded",
-      "- New exported functions require a corresponding test",
-      "- Never force-push to protected branches (main, master)",
-      "- Database migrations must be reviewed before running in production",
-      "",
-      "## Naming Conventions",
-      "",
-      "_Update based on actual codebase conventions found in .forgehive/skills/generated/_",
-    ].join("\n") + "\n", "utf8");
-  }
-
-  const constraintsPath = path.join(harnessDir, "constraints.yaml");
-  if (!fs.existsSync(constraintsPath)) {
-    fs.writeFileSync(
-      constraintsPath,
-      yaml.dump({
-        file_complexity: { max_lines: 300, max_functions_per_file: 15 },
-        require_tests_for_new_exports: true,
-        no_new_dependencies_without_review: true,
-        protected_branches: ["main", "master"],
-      }),
-      "utf8"
-    );
-  }
-}
-```
-
-- [ ] **Step 4: Wire into `src/writer.ts` — `initForgehiveRuntime`**
-
-Add import at top of `src/writer.ts`:
-```typescript
-import { writeHarness } from "./harness.ts";
-```
-
-Add call at the end of `initForgehiveRuntime()`, after `writeGuardrailHooks(projectRoot, forgehiveDir)`:
-```typescript
-  writeHarness(forgehiveDir, yaml.load(
-    fs.readFileSync(path.join(forgehiveDir, "scan-result.yaml"), "utf8")
-  ) as ScanResult, { confirmed: [], inferred: [] });
-```
-
-Wait — `initForgehiveRuntime` does not receive `scanResult` or `capMap`. It only receives `forgehiveDir` and `runtimeDir`. The scan-result.yaml has already been written by `writeForgehiveDir`. Read it back:
-
-Replace the last line of `initForgehiveRuntime` (the `writeGuardrailHooks` call) with:
-
-```typescript
-  writeGuardrailHooks(projectRoot, forgehiveDir);
-
-  // Generate harness from already-written scan-result
-  const scanPath = path.join(forgehiveDir, "scan-result.yaml");
-  if (fs.existsSync(scanPath)) {
-    try {
-      const scanResult = yaml.load(fs.readFileSync(scanPath, "utf8")) as ScanResult;
-      writeHarness(forgehiveDir, scanResult, { confirmed: [], inferred: [] });
-    } catch { /* ignore if scan-result is missing or malformed */ }
-  }
-```
-
-Note: capabilities are not available at this point without calling `mapSignalsToCapabilities` again. Use an empty capMap — the architecture.md will still be created with a note to update it.
-
-- [ ] **Step 5: Run all tests**
-
-```bash
-node --import tsx/esm --test test/*.test.ts 2>&1 | tail -8
-```
-
-Expected:
-```
-# pass 132
-# fail 0
-```
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add src/harness.ts src/writer.ts test/harness.test.ts
-git commit -m "feat: generate .forgehive/harness/ with architecture constraints on fh init"
-```
-
----
-
-### Task 3: Memory Aging + Prune
-
-**Files:**
-- Modify: `src/memory.ts`
-- Modify: `src/cli.ts` (memory command handler)
-- Test: `test/memory.test.ts` (add tests to existing file)
-
-- [ ] **Step 1: Write failing tests** (append to `test/memory.test.ts`)
-
-```typescript
-import { pruneMemory, getMemoryMeta } from "../src/memory.ts";
-
-describe("getMemoryMeta()", () => {
-  let tmpDir: string;
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "forgehive-mem-meta-"));
-  });
-  afterEach(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-  it("returns empty array when memory dir missing", () => {
-    const meta = getMemoryMeta(tmpDir);
-    assert.deepEqual(meta, []);
-  });
-
-  it("returns null lastUpdated when file has no frontmatter", () => {
-    fs.mkdirSync(path.join(tmpDir, "memory"), { recursive: true });
-    fs.writeFileSync(path.join(tmpDir, "memory", "project.md"), "# project\nno frontmatter", "utf8");
-    const meta = getMemoryMeta(tmpDir);
-    assert.equal(meta.length, 1);
-    assert.equal(meta[0].lastUpdated, null);
-  });
-
-  it("parses last_updated from frontmatter", () => {
-    fs.mkdirSync(path.join(tmpDir, "memory"), { recursive: true });
-    fs.writeFileSync(
-      path.join(tmpDir, "memory", "project.md"),
-      "---\ntype: project\nlast_updated: 2020-01-01\n---\n\n# old content",
-      "utf8"
-    );
-    const meta = getMemoryMeta(tmpDir);
-    assert.equal(meta.length, 1);
-    assert.ok(meta[0].lastUpdated instanceof Date);
-    assert.ok((meta[0].daysSinceUpdate ?? 0) > 365);
-  });
-});
-
-describe("pruneMemory()", () => {
-  let tmpDir: string;
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "forgehive-prune-"));
-    fs.mkdirSync(path.join(tmpDir, "memory"), { recursive: true });
-  });
-  afterEach(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-  it("returns empty array when nothing stale", () => {
-    const today = new Date().toISOString().slice(0, 10);
-    fs.writeFileSync(
-      path.join(tmpDir, "memory", "project.md"),
-      `---\ntype: project\nlast_updated: ${today}\n---\n\n# fresh`,
-      "utf8"
-    );
-    const result = pruneMemory(tmpDir, 30, false);
-    assert.deepEqual(result.stale, []);
-  });
-
-  it("identifies stale files without removing them (remove=false)", () => {
-    fs.writeFileSync(
-      path.join(tmpDir, "memory", "old.md"),
-      "---\ntype: project\nlast_updated: 2020-01-01\n---\n\n# old",
-      "utf8"
-    );
-    const result = pruneMemory(tmpDir, 30, false);
-    assert.ok(result.stale.includes("old.md"));
-    assert.ok(fs.existsSync(path.join(tmpDir, "memory", "old.md")));
-  });
-
-  it("removes stale files when remove=true", () => {
-    fs.writeFileSync(
-      path.join(tmpDir, "memory", "old.md"),
-      "---\ntype: project\nlast_updated: 2020-01-01\n---\n\n# old",
-      "utf8"
-    );
-    const result = pruneMemory(tmpDir, 30, true);
-    assert.ok(result.removed.includes("old.md"));
-    assert.ok(!fs.existsSync(path.join(tmpDir, "memory", "old.md")));
-  });
-
-  it("never removes MEMORY.md", () => {
-    fs.writeFileSync(
-      path.join(tmpDir, "memory", "MEMORY.md"),
-      "---\ntype: index\nlast_updated: 2020-01-01\n---\n\n# index",
-      "utf8"
-    );
-    pruneMemory(tmpDir, 30, true);
-    assert.ok(fs.existsSync(path.join(tmpDir, "memory", "MEMORY.md")));
-  });
-});
-```
-
-- [ ] **Step 2: Run test to confirm it fails**
-
-```bash
-node --import tsx/esm --test test/memory.test.ts 2>&1 | grep "fail\|Cannot find"
-```
-
-Expected: `SyntaxError: The requested module '../src/memory.ts' does not provide an export named 'pruneMemory'`
-
-- [ ] **Step 3: Add exports to `src/memory.ts`**
-
-Add at the bottom of `src/memory.ts` (before the closing, after `exportMemory`):
-
-```typescript
-export interface MemoryFileMeta {
-  file: string;
-  lastUpdated: Date | null;
-  daysSinceUpdate: number | null;
-}
-
-export interface PruneResult {
-  stale: string[];
-  removed: string[];
-}
-
-export function getMemoryMeta(forgehiveDir: string): MemoryFileMeta[] {
-  const memDir = path.join(forgehiveDir, "memory");
-  if (!fs.existsSync(memDir)) return [];
-  const now = new Date();
-  return fs.readdirSync(memDir)
-    .filter(f => f.endsWith(".md") && f !== "MEMORY.md")
-    .map(f => {
-      const content = fs.readFileSync(path.join(memDir, f), "utf8");
-      const match = content.match(/^---\n[\s\S]*?last_updated:\s*(\d{4}-\d{2}-\d{2})[\s\S]*?---/m);
-      const lastUpdated = match ? new Date(match[1]) : null;
-      const daysSinceUpdate = lastUpdated && !isNaN(lastUpdated.getTime())
-        ? Math.floor((now.getTime() - lastUpdated.getTime()) / (1000 * 60 * 60 * 24))
-        : null;
-      return { file: f, lastUpdated: lastUpdated && !isNaN(lastUpdated.getTime()) ? lastUpdated : null, daysSinceUpdate };
-    });
-}
-
-export function pruneMemory(forgehiveDir: string, days: number, remove: boolean): PruneResult {
-  const meta = getMemoryMeta(forgehiveDir);
-  const stale = meta
-    .filter(m => m.daysSinceUpdate !== null && m.daysSinceUpdate > days)
-    .map(m => m.file);
-  const removed: string[] = [];
-  if (remove) {
-    for (const f of stale) {
-      fs.unlinkSync(path.join(forgehiveDir, "memory", f));
-      removed.push(f);
-    }
-  }
-  return { stale, removed };
-}
-```
-
-Also update the memory file stubs in `src/memory.ts` to include frontmatter. Replace `PROJECT_STUB`, `FEEDBACK_STUB`, and `STACK_STUB` constants with functions that include today's date:
-
-Replace the three constants and the `write` calls in `initMemory` with:
-
-```typescript
-function makeProjectStub(date: string): string {
-  return `---
-type: project
-last_updated: ${date}
-confidence: high
----
-
-# Projektkontext
-
-Noch keine Einträge. Claude füllt diese Datei beim ersten Session-Ende.
-`;
-}
-
-function makeFeedbackStub(date: string): string {
-  return `---
-type: feedback
-last_updated: ${date}
-confidence: high
----
-
-# Feedback & Korrekturen
-
-Noch keine Einträge.
-`;
-}
-
-function makeStackStub(date: string): string {
-  return `---
-type: reference
-last_updated: ${date}
-confidence: high
----
-
-# Stack-Eigenheiten
-
-Eigenheiten die der Scanner nicht erkennt — spezifische Konventionen, Workarounds, bekannte Einschränkungen.
-`;
-}
-```
-
-Update `initMemory` to use these functions:
-
-```typescript
-export function initMemory(forgehiveDir: string): void {
-  const memDir = path.join(forgehiveDir, "memory");
-  fs.mkdirSync(memDir, { recursive: true });
-  fs.mkdirSync(path.join(forgehiveDir, "state"), { recursive: true });
-
-  const date = new Date().toISOString().slice(0, 10);
-  const write = (filename: string, content: string) => {
-    const p = path.join(memDir, filename);
-    if (!fs.existsSync(p)) fs.writeFileSync(p, content, "utf8");
-  };
-
-  write("MEMORY.md", MEMORY_INDEX);
-  write("project.md", makeProjectStub(date));
-  write("feedback.md", makeFeedbackStub(date));
-  write("stack.md", makeStackStub(date));
-}
-```
-
-Remove the old `PROJECT_STUB`, `FEEDBACK_STUB`, `STACK_STUB` constants.
-
-- [ ] **Step 4: Add `fh memory prune` to `src/cli.ts`**
-
-In `src/cli.ts`, find the `} else if (subcommand === "export") {` block inside the `memory` handler. Add a new `else if` branch before the final `else`:
-
-```typescript
-  } else if (subcommand === "prune") {
-    const daysArg = rest[0] ? parseInt(rest[0], 10) : 30;
-    const doRemove = rest.includes("--remove");
-    const days = isNaN(daysArg) ? 30 : daysArg;
-    const { pruneMemory } = await import("./memory.ts");
-    const result = pruneMemory(forgehiveDir, days, doRemove);
-    if (result.stale.length === 0) {
-      console.log(`✓ Kein veraltetes Memory (>${days} Tage) gefunden`);
-    } else if (!doRemove) {
-      console.log(`⚠ Veraltete Memory-Dateien (>${days} Tage):`);
-      for (const f of result.stale) console.log(`  ${f}`);
-      console.log(`\nAusführen mit --remove um zu löschen: fh memory prune ${days} --remove`);
-    } else {
-      console.log(`Gelöscht: ${result.removed.join(", ")}`);
-    }
-```
-
-Note: `src/cli.ts` does not use dynamic imports — use static import at top instead. Add to existing imports at top of cli.ts:
-
-```typescript
-import { showMemory, cleanMemory, exportMemory, pruneMemory } from "./memory.ts";
-```
-
-Then in the handler add the `prune` branch (no dynamic import needed).
-
-- [ ] **Step 5: Run all tests**
-
-```bash
-node --import tsx/esm --test test/*.test.ts 2>&1 | tail -8
-```
-
-Expected:
-```
-# pass 140
-# fail 0
-```
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add src/memory.ts test/memory.test.ts src/cli.ts
-git commit -m "feat: memory aging — frontmatter tracking + fh memory prune [days] [--remove]"
-```
-
----
-
-### Task 4: ADR Integration
-
-**Files:**
-- Create: `src/adr.ts`
-- Modify: `src/cli.ts` (memory adr subcommand)
-- Test: `test/adr.test.ts`
-
-- [ ] **Step 1: Write failing tests**
-
-```typescript
-// test/adr.test.ts
-import { describe, it, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import { createAdr, listAdrs } from "../src/adr.ts";
-
-describe("createAdr()", () => {
-  let tmpDir: string;
-  let forgehiveDir: string;
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "forgehive-adr-"));
-    forgehiveDir = path.join(tmpDir, ".forgehive");
-    fs.mkdirSync(path.join(forgehiveDir, "memory"), { recursive: true });
-  });
-  afterEach(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-  it("creates adrs/ directory", () => {
-    createAdr(forgehiveDir, tmpDir, "use typescript over javascript");
-    assert.ok(fs.existsSync(path.join(forgehiveDir, "memory", "adrs")));
-  });
-
-  it("creates a markdown file with date-slug name", () => {
-    const filepath = createAdr(forgehiveDir, tmpDir, "use typescript");
-    assert.ok(fs.existsSync(filepath));
-    assert.ok(path.basename(filepath).includes("use-typescript"));
-    assert.ok(path.basename(filepath).endsWith(".md"));
-  });
-
-  it("file contains the title and sections", () => {
-    const filepath = createAdr(forgehiveDir, tmpDir, "use postgres for storage");
-    const content = fs.readFileSync(filepath, "utf8");
-    assert.ok(content.includes("use postgres for storage"));
-    assert.ok(content.includes("## Context"));
-    assert.ok(content.includes("## Decision"));
-    assert.ok(content.includes("## Consequences"));
-  });
-
-  it("file contains current date", () => {
-    const filepath = createAdr(forgehiveDir, tmpDir, "some decision");
-    const content = fs.readFileSync(filepath, "utf8");
-    const today = new Date().toISOString().slice(0, 10);
-    assert.ok(content.includes(today));
-  });
-});
-
-describe("listAdrs()", () => {
-  let tmpDir: string;
-  let forgehiveDir: string;
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "forgehive-adr-list-"));
-    forgehiveDir = path.join(tmpDir, ".forgehive");
-    fs.mkdirSync(path.join(forgehiveDir, "memory"), { recursive: true });
-  });
-  afterEach(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-  it("returns empty array when no adrs exist", () => {
-    assert.deepEqual(listAdrs(forgehiveDir), []);
-  });
-
-  it("lists created ADRs with title and date", () => {
-    createAdr(forgehiveDir, tmpDir, "use redis for caching");
-    const adrs = listAdrs(forgehiveDir);
-    assert.equal(adrs.length, 1);
-    assert.ok(adrs[0].title.includes("use redis for caching"));
-    assert.ok(adrs[0].date.match(/^\d{4}-\d{2}-\d{2}$/));
-  });
-});
-```
-
-- [ ] **Step 2: Run test to confirm it fails**
-
-```bash
-node --import tsx/esm --test test/adr.test.ts 2>&1 | head -5
-```
-
-Expected: `Error: Cannot find module '../src/adr.ts'`
-
-- [ ] **Step 3: Implement `src/adr.ts`**
-
-```typescript
-import fs from "node:fs";
-import path from "node:path";
-import { spawnSync } from "node:child_process";
-
-export interface AdrEntry {
-  file: string;
-  title: string;
-  date: string;
-  gitSha: string | null;
-}
-
-function slugify(title: string): string {
-  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
-}
-
-export function createAdr(forgehiveDir: string, projectRoot: string, title: string): string {
-  const adrsDir = path.join(forgehiveDir, "memory", "adrs");
-  fs.mkdirSync(adrsDir, { recursive: true });
-
-  const date = new Date().toISOString().slice(0, 10);
-  const slug = slugify(title);
-  const filename = `${date}-${slug}.md`;
-  const filepath = path.join(adrsDir, filename);
-
-  const gitResult = spawnSync("git", ["rev-parse", "--short", "HEAD"], {
-    cwd: projectRoot,
-    encoding: "utf8",
-  });
-  const gitSha = gitResult.status === 0 ? gitResult.stdout.trim() : null;
-
-  const content = [
-    `# ADR: ${title}`,
-    "",
-    `**Date:** ${date}`,
-    `**Status:** Proposed`,
-    gitSha ? `**Git SHA:** ${gitSha}` : null,
-    "",
-    "## Context",
-    "",
-    "_Describe the situation and problem you are solving._",
-    "",
-    "## Decision",
-    "",
-    "_State the decision made._",
-    "",
-    "## Consequences",
-    "",
-    "_What are the positive, negative, and neutral outcomes of this decision?_",
-  ].filter(l => l !== null).join("\n");
-
-  fs.writeFileSync(filepath, content + "\n", "utf8");
-  return filepath;
-}
-
-export function listAdrs(forgehiveDir: string): AdrEntry[] {
-  const adrsDir = path.join(forgehiveDir, "memory", "adrs");
-  if (!fs.existsSync(adrsDir)) return [];
-
-  return fs.readdirSync(adrsDir)
-    .filter(f => f.endsWith(".md"))
-    .sort()
-    .map(f => {
-      const content = fs.readFileSync(path.join(adrsDir, f), "utf8");
-      const titleMatch = content.match(/^# ADR: (.+)$/m);
-      const dateMatch = content.match(/\*\*Date:\*\* (\d{4}-\d{2}-\d{2})/);
-      const shaMatch = content.match(/\*\*Git SHA:\*\* (\w+)/);
-      return {
-        file: f,
-        title: titleMatch?.[1] ?? f,
-        date: dateMatch?.[1] ?? "unknown",
-        gitSha: shaMatch?.[1] ?? null,
-      };
-    });
-}
-```
-
-- [ ] **Step 4: Add `fh memory adr` to `src/cli.ts`**
-
-Add import at top of `cli.ts`:
-```typescript
-import { createAdr, listAdrs } from "./adr.ts";
-```
-
-In the memory command handler, add a new `else if` branch before the final `else` error branch:
-
-```typescript
-  } else if (subcommand === "adr") {
-    const adrSub = rest[0];
-    if (!adrSub || adrSub === "list") {
-      const adrs = listAdrs(forgehiveDir);
-      if (adrs.length === 0) {
-        console.log("Keine ADRs vorhanden. Erstelle einen mit: fh memory adr \"<titel>\"");
-      } else {
-        console.log("Architecture Decision Records:\n");
-        for (const adr of adrs) {
-          console.log(`  ${adr.date}  ${adr.title}${adr.gitSha ? ` (${adr.gitSha})` : ""}`);
-        }
-      }
-    } else {
-      const title = [adrSub, ...rest.slice(1)].join(" ");
-      try {
-        const filepath = createAdr(forgehiveDir, projectRoot, title);
-        console.log(`✓ ADR erstellt: ${filepath}`);
-        console.log("  Öffne die Datei und fülle Context, Decision und Consequences aus.");
-      } catch (err) {
-        console.error(`Fehler: ${(err as Error).message}`);
-        process.exit(1);
-      }
-    }
-```
-
-Also update the help message at the bottom of `cli.ts` to add `adr` to memory subcommands:
-```
-memory [show|clean|export|prune|adr]
-```
-
-- [ ] **Step 5: Run all tests**
-
-```bash
-node --import tsx/esm --test test/*.test.ts 2>&1 | tail -8
-```
-
-Expected: `# pass 148` and `# fail 0`
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add src/adr.ts test/adr.test.ts src/cli.ts
-git commit -m "feat: ADR integration — fh memory adr \"<title>\" creates structured decision records"
-```
-
----
-
-### Task 5: Context Drift Detection
-
-**Files:**
-- Modify: `src/status.ts`
-- Test: `test/status.test.ts` (add tests to existing file)
-
-- [ ] **Step 1: Write failing tests** (append to `test/status.test.ts`)
-
-```typescript
-import { checkDrift } from "../src/status.ts";
-import { spawnSync } from "node:child_process";
-
-describe("checkDrift()", () => {
-  let tmpDir: string;
-  let forgehiveDir: string;
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "fh-drift-"));
-    forgehiveDir = path.join(tmpDir, ".forgehive");
-    fs.mkdirSync(forgehiveDir, { recursive: true });
-  });
-  afterEach(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-  it("returns isDrifted=false when no scan-result.yaml", () => {
-    const drift = checkDrift(tmpDir, forgehiveDir);
-    assert.equal(drift.isDrifted, false);
-    assert.equal(drift.daysSinceScan, null);
-  });
-
-  it("returns daysSinceScan > 0 for old scan date", () => {
-    fs.writeFileSync(
-      path.join(forgehiveDir, "scan-result.yaml"),
-      yaml.dump({ scanned_at: "2020-01-01", project_root: tmpDir, signals: [], packages: [] }),
-      "utf8"
-    );
-    const drift = checkDrift(tmpDir, forgehiveDir);
-    assert.ok((drift.daysSinceScan ?? 0) > 365);
-    assert.equal(drift.isDrifted, true);
-  });
-
-  it("returns isDrifted=false for scan today", () => {
-    const today = new Date().toISOString().slice(0, 10);
-    fs.writeFileSync(
-      path.join(forgehiveDir, "scan-result.yaml"),
-      yaml.dump({ scanned_at: today, project_root: tmpDir, signals: [], packages: [] }),
-      "utf8"
-    );
-    const drift = checkDrift(tmpDir, forgehiveDir);
-    assert.equal(drift.isDrifted, false);
-    assert.ok((drift.daysSinceScan ?? 99) < 2);
-  });
-});
-
-describe("projectStatus() with drift", () => {
-  let tmpDir: string;
-  let forgehiveDir: string;
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "fh-status-drift-"));
-    forgehiveDir = path.join(tmpDir, ".forgehive");
-    fs.mkdirSync(forgehiveDir, { recursive: true });
-  });
-  afterEach(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-  it("zeigt Drift-Warnung bei altem Scan", () => {
-    fs.writeFileSync(
-      path.join(forgehiveDir, "scan-result.yaml"),
-      yaml.dump({ scanned_at: "2020-01-01", project_root: tmpDir, signals: [], packages: [] }),
-      "utf8"
-    );
-    const out = projectStatus(tmpDir, forgehiveDir);
-    assert.ok(out.includes("Drift") || out.includes("veraltet") || out.includes("fh scan"));
-  });
-});
-```
-
-- [ ] **Step 2: Run test to confirm it fails**
-
-```bash
-node --import tsx/esm --test test/status.test.ts 2>&1 | grep "fail\|SyntaxError"
-```
-
-Expected: `SyntaxError: ... does not provide an export named 'checkDrift'`
-
-- [ ] **Step 3: Add `checkDrift` to `src/status.ts`**
-
-Add import at top of `src/status.ts` (after existing imports):
-```typescript
-import { spawnSync } from "node:child_process";
-```
-
-Add the `DriftInfo` interface and `checkDrift` function before `projectStatus`:
-
-```typescript
-export interface DriftInfo {
-  daysSinceScan: number | null;
-  recentCommits: number;
-  isDrifted: boolean;
-}
-
-export function checkDrift(projectRoot: string, forgehiveDir: string): DriftInfo {
-  const scanPath = path.join(forgehiveDir, "scan-result.yaml");
-  if (!fs.existsSync(scanPath)) {
-    return { daysSinceScan: null, recentCommits: 0, isDrifted: false };
-  }
-
-  let scannedAt: string | null = null;
-  try {
-    const raw = yaml.load(fs.readFileSync(scanPath, "utf8")) as { scanned_at?: string };
-    scannedAt = raw?.scanned_at ?? null;
-  } catch { /* ignore */ }
-
-  if (!scannedAt) return { daysSinceScan: null, recentCommits: 0, isDrifted: false };
-
-  const scanDate = new Date(scannedAt);
-  if (isNaN(scanDate.getTime())) return { daysSinceScan: null, recentCommits: 0, isDrifted: false };
-
-  const daysSinceScan = Math.floor(
-    (Date.now() - scanDate.getTime()) / (1000 * 60 * 60 * 24)
-  );
-
-  let recentCommits = 0;
-  const gitResult = spawnSync("git", ["log", "--oneline", `--since=${scannedAt}T00:00:00`], {
-    cwd: projectRoot,
-    encoding: "utf8",
-  });
-  if (gitResult.status === 0) {
-    recentCommits = gitResult.stdout.trim().split("\n").filter(Boolean).length;
-  }
-
-  const isDrifted = daysSinceScan > 7 || recentCommits > 20;
-  return { daysSinceScan, recentCommits, isDrifted };
-}
-```
-
-Add drift reporting to `projectStatus()`, after the last scan line:
-
-```typescript
-  // Context drift
-  const drift = checkDrift(projectRoot, forgehiveDir);
-  if (drift.isDrifted) {
-    const msg = drift.daysSinceScan !== null
-      ? `⚠ Kontext veraltet: ${drift.daysSinceScan} Tage seit letztem Scan, ${drift.recentCommits} neue Commits — führe \`fh scan --update\` aus`
-      : `⚠ Drift erkannt — führe \`fh scan --update\` aus`;
-    lines.push(msg);
-  } else if (drift.daysSinceScan !== null) {
-    lines.push(`✓ Kontext aktuell (${drift.daysSinceScan} Tage alt, ${drift.recentCommits} Commits seit Scan)`);
-  }
-```
-
-- [ ] **Step 4: Run all tests**
-
-```bash
-node --import tsx/esm --test test/*.test.ts 2>&1 | tail -8
-```
-
-Expected: `# pass 153` and `# fail 0`
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add src/status.ts test/status.test.ts
-git commit -m "feat: context drift detection in fh status — warns when scan is stale"
-```
-
----
-
-### Task 6: Session Cost Tracking
-
-**Files:**
-- Create: `src/cost.ts`
-- Modify: `src/cli.ts` (add `fh cost` command)
-- Test: `test/cost.test.ts`
-
-- [ ] **Step 1: Write failing tests**
-
-```typescript
-// test/cost.test.ts
-import { describe, it, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import { parseCostSessions, formatCostReport, type SessionCost } from "../src/cost.ts";
-
-describe("parseCostSessions()", () => {
-  let tmpDir: string;
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "forgehive-cost-"));
-  });
-  afterEach(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-  it("returns empty array when no Claude project dir exists", () => {
-    const sessions = parseCostSessions(tmpDir, path.join(tmpDir, "fake-claude-home"));
-    assert.deepEqual(sessions, []);
-  });
-
-  it("parses usage from JSONL file", () => {
-    const encoded = "-home-user-myproject";
-    const projectDir = path.join(tmpDir, "projects", encoded);
-    fs.mkdirSync(projectDir, { recursive: true });
-    const lines = [
-      JSON.stringify({ usage: { input_tokens: 1000, output_tokens: 500 } }),
-      JSON.stringify({ usage: { input_tokens: 2000, output_tokens: 1000, cache_read_input_tokens: 500 } }),
-      '{"no_usage": true}',
-    ].join("\n");
-    fs.writeFileSync(path.join(projectDir, "session-abc.jsonl"), lines, "utf8");
-
-    const sessions = parseCostSessions(tmpDir, tmpDir);
-    assert.equal(sessions.length, 1);
-    assert.equal(sessions[0].inputTokens, 3000);
-    assert.equal(sessions[0].outputTokens, 1500);
-    assert.ok(sessions[0].estimatedCostUsd > 0);
-  });
-
-  it("skips malformed JSONL lines", () => {
-    const encoded = "-home-user-myproject";
-    const projectDir = path.join(tmpDir, "projects", encoded);
-    fs.mkdirSync(projectDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(projectDir, "session.jsonl"),
-      'not json\n{"usage": {"input_tokens": 100, "output_tokens": 50}}\n{broken',
-      "utf8"
-    );
-    const sessions = parseCostSessions(tmpDir, tmpDir);
-    assert.equal(sessions.length, 1);
-    assert.equal(sessions[0].inputTokens, 100);
-  });
-});
-
-describe("formatCostReport()", () => {
-  it("shows 'Keine Sessions' when empty", () => {
-    const report = formatCostReport([], "all");
-    assert.ok(report.includes("Keine Sessions"));
-  });
-
-  it("shows total cost and session count", () => {
-    const sessions: SessionCost[] = [{
-      sessionFile: "abc.jsonl",
-      date: "2026-05-11",
-      inputTokens: 1_000_000,
-      outputTokens: 100_000,
-      cacheCreationTokens: 0,
-      cacheReadTokens: 0,
-      estimatedCostUsd: 4.50,
-    }];
-    const report = formatCostReport(sessions, "all");
-    assert.ok(report.includes("4.500") || report.includes("$4.5"));
-    assert.ok(report.includes("1 session"));
-  });
-});
-```
-
-- [ ] **Step 2: Run test to confirm it fails**
-
-```bash
-node --import tsx/esm --test test/cost.test.ts 2>&1 | head -5
-```
-
-Expected: `Error: Cannot find module '../src/cost.ts'`
-
-- [ ] **Step 3: Implement `src/cost.ts`**
-
-```typescript
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-
-export interface SessionCost {
-  sessionFile: string;
-  date: string;
-  inputTokens: number;
-  outputTokens: number;
-  cacheCreationTokens: number;
-  cacheReadTokens: number;
-  estimatedCostUsd: number;
-}
-
-// Claude Sonnet 4.6 pricing per million tokens (May 2026)
-const PRICING = {
-  input: 3.0,
-  output: 15.0,
-  cacheCreation: 3.75,
-  cacheRead: 0.30,
-};
-
-function calcCost(
-  inputTokens: number,
-  outputTokens: number,
-  cacheCreationTokens: number,
-  cacheReadTokens: number
-): number {
-  return (
-    (inputTokens / 1_000_000) * PRICING.input +
-    (outputTokens / 1_000_000) * PRICING.output +
-    (cacheCreationTokens / 1_000_000) * PRICING.cacheCreation +
-    (cacheReadTokens / 1_000_000) * PRICING.cacheRead
-  );
-}
-
-interface UsageLine {
-  usage?: {
-    input_tokens?: number;
-    output_tokens?: number;
-    cache_creation_input_tokens?: number;
-    cache_read_input_tokens?: number;
-  };
-}
-
-// claudeHome defaults to ~/.claude; override in tests
-export function parseCostSessions(
-  projectRoot: string,
-  claudeHome: string = path.join(os.homedir(), ".claude")
-): SessionCost[] {
-  const projectsDir = path.join(claudeHome, "projects");
-  if (!fs.existsSync(projectsDir)) return [];
-
-  // Find the directory matching this project's encoded path
-  const encodedPath = "-" + projectRoot.replace(/\//g, "-");
-  const allDirs = fs.readdirSync(projectsDir);
-  const matchDirs = allDirs.filter(
-    d => d === encodedPath || d.endsWith("-" + path.basename(projectRoot))
-  );
-
-  const sessions: SessionCost[] = [];
-
-  for (const dir of matchDirs) {
-    const dirPath = path.join(projectsDir, dir);
-    if (!fs.statSync(dirPath).isDirectory()) continue;
-
-    for (const jsonlFile of fs.readdirSync(dirPath).filter(f => f.endsWith(".jsonl"))) {
-      const filePath = path.join(dirPath, jsonlFile);
-      let inputTokens = 0, outputTokens = 0, cacheCreationTokens = 0, cacheReadTokens = 0;
-
-      try {
-        for (const line of fs.readFileSync(filePath, "utf8").split("\n").filter(Boolean)) {
-          try {
-            const entry = JSON.parse(line) as UsageLine;
-            if (entry.usage) {
-              inputTokens += entry.usage.input_tokens ?? 0;
-              outputTokens += entry.usage.output_tokens ?? 0;
-              cacheCreationTokens += entry.usage.cache_creation_input_tokens ?? 0;
-              cacheReadTokens += entry.usage.cache_read_input_tokens ?? 0;
-            }
-          } catch { /* skip malformed */ }
-        }
-
-        const mtime = fs.statSync(filePath).mtime;
-        sessions.push({
-          sessionFile: jsonlFile,
-          date: mtime.toISOString().slice(0, 10),
-          inputTokens,
-          outputTokens,
-          cacheCreationTokens,
-          cacheReadTokens,
-          estimatedCostUsd: calcCost(inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens),
-        });
-      } catch { /* skip unreadable */ }
-    }
-  }
-
-  return sessions.sort((a, b) => b.date.localeCompare(a.date));
-}
-
-export function formatCostReport(
-  sessions: SessionCost[],
-  range: "today" | "week" | "all"
-): string {
-  const now = new Date();
-  const today = now.toISOString().slice(0, 10);
-  const weekAgo = new Date(now);
-  weekAgo.setDate(weekAgo.getDate() - 7);
-
-  const filtered = sessions.filter(s => {
-    if (range === "today") return s.date === today;
-    if (range === "week") return new Date(s.date) >= weekAgo;
-    return true;
-  });
-
-  const lines = [`ForgeHive Cost Report (${range})`, ""];
-
-  if (filtered.length === 0) {
-    lines.push("Keine Sessions gefunden.");
-    return lines.join("\n");
-  }
-
-  const total = filtered.reduce((sum, s) => sum + s.estimatedCostUsd, 0);
-  const totalIn = filtered.reduce((sum, s) => sum + s.inputTokens, 0);
-  const totalOut = filtered.reduce((sum, s) => sum + s.outputTokens, 0);
-
-  lines.push(`Total: $${total.toFixed(3)} (${filtered.length} session${filtered.length === 1 ? "" : "s"})`);
-  lines.push(`Tokens: ${(totalIn / 1000).toFixed(0)}k in, ${(totalOut / 1000).toFixed(0)}k out`);
-  lines.push("");
-  lines.push("Sessions:");
-
-  for (const s of filtered.slice(0, 15)) {
-    lines.push(`  ${s.date}  $${s.estimatedCostUsd.toFixed(3).padStart(7)}  ${s.sessionFile.slice(0, 36)}`);
-  }
-
-  if (filtered.length > 15) {
-    lines.push(`  ... und ${filtered.length - 15} weitere`);
-  }
-
-  return lines.join("\n");
-}
-```
-
-- [ ] **Step 4: Add `fh cost` to `src/cli.ts`**
-
-Add import at top:
-```typescript
-import { parseCostSessions, formatCostReport } from "./cost.ts";
-```
-
-Add new command handler before the final `else` block:
-
-```typescript
-} else if (command === "cost") {
-  const range = (subcommand as "today" | "week" | "all") ?? "all";
-  if (!["today", "week", "all"].includes(range)) {
-    console.error(`Unbekannter Bereich: ${range}. Verfügbar: today | week | all`);
-    process.exit(1);
-  }
-  const sessions = parseCostSessions(projectRoot);
-  console.log(formatCostReport(sessions, range));
-
-```
-
-Update help message to add `cost [today|week|all]`.
-
-- [ ] **Step 5: Run all tests**
-
-```bash
-node --import tsx/esm --test test/*.test.ts 2>&1 | tail -8
-```
-
-Expected: `# pass 160` and `# fail 0`
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add src/cost.ts test/cost.test.ts src/cli.ts
-git commit -m "feat: session cost tracking — fh cost [today|week|all] parses Claude JSONL logs"
-```
-
----
-
-### Task 7: Multi-Model Routing for Party
-
-**Files:**
-- Modify: `src/party.ts`
-- Test: `test/party.test.ts` (add tests to existing file)
-
-- [ ] **Step 1: Write failing tests** (append to `test/party.test.ts`)
-
-```typescript
-import { setAgentModel, showParty } from "../src/party.ts";
-
-describe("setAgentModel()", () => {
-  let tmpDir: string;
-  let forgehiveDir: string;
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "forgehive-model-"));
-    forgehiveDir = path.join(tmpDir, ".forgehive");
-    fs.mkdirSync(path.join(forgehiveDir, "party"), { recursive: true });
-    fs.writeFileSync(
-      path.join(forgehiveDir, "party", "config.yaml"),
-      yaml.dump({
-        sets: {
-          build: { agents: ["viktor", "kai"], trigger: "/party", description: "build set" }
-        }
-      }),
-      "utf8"
-    );
-  });
-  afterEach(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-  it("sets model_map for an agent", () => {
-    setAgentModel(forgehiveDir, "build", "viktor", "claude-opus-4-7");
-    const config = yaml.load(
-      fs.readFileSync(path.join(forgehiveDir, "party", "config.yaml"), "utf8")
-    ) as { sets: { build: { model_map?: Record<string, string> } } };
-    assert.equal(config.sets.build.model_map?.["viktor"], "claude-opus-4-7");
-  });
-
-  it("throws for unknown set", () => {
-    assert.throws(
-      () => setAgentModel(forgehiveDir, "unknown-set", "agent", "model"),
-      /unknown-set/
-    );
-  });
-
-  it("showParty includes model_map when set", () => {
-    setAgentModel(forgehiveDir, "build", "viktor", "claude-opus-4-7");
-    const output = showParty(forgehiveDir);
-    assert.ok(output.includes("claude-opus-4-7") || output.includes("model"));
-  });
-});
-```
-
-- [ ] **Step 2: Run test to confirm it fails**
-
-```bash
-node --import tsx/esm --test test/party.test.ts 2>&1 | grep "fail\|SyntaxError"
-```
-
-Expected: `SyntaxError: ... does not provide an export named 'setAgentModel'`
-
-- [ ] **Step 3: Update `src/party.ts`**
-
-Update the `PartySet` interface to include `model_map`:
-
-```typescript
-interface PartySet {
-  agents: string[];
-  trigger: string;
-  description: string;
-  model_map?: Record<string, string>;
-}
-```
-
-Add `setAgentModel` export after `addPartySet`:
-
-```typescript
-export function setAgentModel(
-  forgehiveDir: string,
-  setName: string,
-  agentName: string,
-  modelId: string
-): void {
-  const config = loadConfig(forgehiveDir);
-  if (!config.sets[setName]) {
-    throw new Error(
-      `Unbekanntes Set: "${setName}". Verfügbar: ${Object.keys(config.sets).join(", ")}`
-    );
-  }
-  if (!config.sets[setName].model_map) config.sets[setName].model_map = {};
-  config.sets[setName].model_map![agentName] = modelId;
-  saveConfig(forgehiveDir, config);
-}
-```
-
-Update `showParty` to display model_map when present. Replace the loop body:
-
-```typescript
-  for (const [name, set] of Object.entries(config.sets)) {
-    const marker = name === config.default_set ? " ← default" : "";
-    lines.push(`  ${name.padEnd(12)} ${set.trigger.padEnd(20)} Agenten: ${set.agents.join(", ")}${marker}`);
-    if (set.model_map && Object.keys(set.model_map).length > 0) {
-      const mapStr = Object.entries(set.model_map).map(([a, m]) => `${a}:${m}`).join(", ");
-      lines.push(`  ${"".padEnd(12)} ${"".padEnd(20)} Modelle: ${mapStr}`);
-    }
-  }
-```
-
-- [ ] **Step 4: Add `fh party --model-map` to `src/cli.ts`**
-
-Add import at top:
-```typescript
-import { showParty, setPartyDefault, addPartySet, setAgentModel } from "./party.ts";
-```
-
-In the existing `party` command handler, add a `modelFlag` branch. Inside the party args parsing block (after the `agentsFlag` block), add:
-
-```typescript
-  const modelMapFlag = partyArgs.findIndex(a => a === "--model-map");
-
-  // ... existing setFlag and agentsFlag handling ...
-
-  } else if (modelMapFlag !== -1) {
-    const mapArg = partyArgs[modelMapFlag + 1];
-    if (!mapArg) {
-      console.error("Fehler: --model-map erwartet ein Mapping wie \"architect:opus,code:sonnet\"");
-      process.exit(1);
-    }
-    const setName = partyArgs[setFlag + 1] ?? (
-      yaml.load(fs.readFileSync(path.join(forgehiveDir, "party", "config.yaml"), "utf8")) as { default_set?: string }
-    )?.default_set ?? "default";
-    for (const pair of mapArg.split(",")) {
-      const [agent, model] = pair.split(":").map(s => s.trim());
-      if (!agent || !model) continue;
-      try {
-        setAgentModel(forgehiveDir, setName, agent, model);
-        console.log(`✓ ${agent} → ${model}`);
-      } catch (err) {
-        console.error(`Fehler: ${(err as Error).message}`);
-        process.exit(1);
-      }
-    }
-```
-
-- [ ] **Step 5: Run all tests**
-
-```bash
-node --import tsx/esm --test test/*.test.ts 2>&1 | tail -8
-```
-
-Expected: `# pass 164` and `# fail 0`
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add src/party.ts test/party.test.ts src/cli.ts
-git commit -m "feat: multi-model routing for party — fh party --model-map \"architect:opus,code:sonnet\""
-```
-
----
-
-### Task 8: Worktree-Isolated Party Runs
-
-**Files:**
-- Modify: `src/party.ts` (add runParty, getPartyStatus, cleanupPartyWorktrees)
-- Modify: `src/cli.ts` (add `fh party run/status/cleanup`)
-- Test: `test/party.test.ts` (add tests)
-
-- [ ] **Step 1: Write failing tests** (append to `test/party.test.ts`)
-
-```typescript
-import { runParty, getPartyStatus, cleanupPartyWorktrees } from "../src/party.ts";
-import { spawnSync as _spawnSync } from "node:child_process";
-
-describe("runParty()", () => {
-  let tmpDir: string;
-  let forgehiveDir: string;
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "forgehive-run-party-"));
-    forgehiveDir = path.join(tmpDir, ".forgehive");
-    fs.mkdirSync(path.join(forgehiveDir, "party"), { recursive: true });
-    fs.writeFileSync(
-      path.join(forgehiveDir, "party", "config.yaml"),
-      yaml.dump({
-        sets: {
-          build: { agents: ["viktor", "kai"], trigger: "/party", description: "build" }
-        }
-      }),
-      "utf8"
-    );
-    // Init git repo so worktree add works
-    _spawnSync("git", ["init"], { cwd: tmpDir });
-    _spawnSync("git", ["commit", "--allow-empty", "-m", "init"], { cwd: tmpDir });
-  });
-  afterEach(() => {
-    // Cleanup any worktrees before removing tmpDir
-    _spawnSync("git", ["worktree", "prune"], { cwd: tmpDir });
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("throws for unknown set", () => {
-    assert.throws(
-      () => runParty(forgehiveDir, tmpDir, "unknown"),
-      /unknown/
-    );
-  });
-
-  it("creates worktrees dir under .forgehive/", () => {
-    runParty(forgehiveDir, tmpDir, "build");
-    assert.ok(fs.existsSync(path.join(forgehiveDir, "worktrees")));
-  });
-
-  it("creates one worktree per agent", () => {
-    const state = runParty(forgehiveDir, tmpDir, "build");
-    assert.equal(state.worktrees.length, 2);
-    for (const wt of state.worktrees) {
-      assert.ok(fs.existsSync(wt.path));
-    }
-  });
-
-  it("writes dispatch file in each worktree", () => {
-    const state = runParty(forgehiveDir, tmpDir, "build");
-    for (const wt of state.worktrees) {
-      assert.ok(fs.existsSync(path.join(wt.path, ".forgehive-agent-dispatch.md")));
-    }
-  });
-
-  it("saves party-session.yaml state file", () => {
-    runParty(forgehiveDir, tmpDir, "build");
-    assert.ok(fs.existsSync(path.join(forgehiveDir, "party", "party-session.yaml")));
-  });
-});
-
-describe("getPartyStatus()", () => {
-  let tmpDir: string;
-  let forgehiveDir: string;
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "fh-party-status-"));
-    forgehiveDir = path.join(tmpDir, ".forgehive");
-    fs.mkdirSync(path.join(forgehiveDir, "party"), { recursive: true });
-  });
-  afterEach(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-  it("returns null when no session file", () => {
-    assert.equal(getPartyStatus(forgehiveDir), null);
-  });
-
-  it("reads state from session file", () => {
-    const state = { setName: "build", sessionId: "20260511T120000", worktrees: [] };
-    fs.writeFileSync(
-      path.join(forgehiveDir, "party", "party-session.yaml"),
-      yaml.dump(state),
-      "utf8"
-    );
-    const loaded = getPartyStatus(forgehiveDir);
-    assert.equal(loaded?.setName, "build");
-  });
-});
-```
-
-- [ ] **Step 2: Run test to confirm it fails**
-
-```bash
-node --import tsx/esm --test test/party.test.ts 2>&1 | grep "fail\|SyntaxError" | head -3
-```
-
-Expected: `SyntaxError: ... does not provide an export named 'runParty'`
-
-- [ ] **Step 3: Add worktree functions to `src/party.ts`**
-
-Add import at top of `src/party.ts`:
-```typescript
-import { spawnSync } from "node:child_process";
-```
-
-Add these exports after `addPartySet`:
-
-```typescript
-export interface WorktreeEntry {
-  agent: string;
-  branch: string;
-  path: string;
-  status: "pending" | "running" | "done";
-}
-
-export interface WorktreePartyState {
-  setName: string;
-  sessionId: string;
-  worktrees: WorktreeEntry[];
-}
-
-export function runParty(
-  forgehiveDir: string,
-  projectRoot: string,
-  setName: string
-): WorktreePartyState {
-  const config = loadConfig(forgehiveDir);
-  if (!config.sets[setName]) {
-    throw new Error(
-      `Unbekanntes Set: "${setName}". Verfügbar: ${Object.keys(config.sets).join(", ")}`
-    );
-  }
-
-  const sessionId = new Date().toISOString().slice(0, 19).replace(/[:-]/g, "");
-  const wtBaseDir = path.join(forgehiveDir, "worktrees");
-  fs.mkdirSync(wtBaseDir, { recursive: true });
-
-  const state: WorktreePartyState = { setName, sessionId, worktrees: [] };
-
-  for (const agent of config.sets[setName].agents) {
-    const branch = `forgehive/party/${sessionId}/${agent}`;
-    const wtPath = path.join(wtBaseDir, `${sessionId}-${agent}`);
-
-    const result = spawnSync("git", ["worktree", "add", "-b", branch, wtPath], {
-      cwd: projectRoot,
-      encoding: "utf8",
-    });
-
-    if (result.status !== 0) {
-      throw new Error(`Worktree für ${agent} fehlgeschlagen: ${result.stderr?.trim()}`);
-    }
-
-    fs.writeFileSync(
-      path.join(wtPath, ".forgehive-agent-dispatch.md"),
-      [
-        `# ${agent} — Party Session ${sessionId}`,
-        "",
-        `Dieser Worktree ist für Agent **${agent}** im Set **${setName}**.`,
-        "",
-        `Branch: \`${branch}\``,
-        "",
-        "## Aufgabe",
-        "",
-        "_Trage hier die spezifische Aufgabe für diesen Agenten ein._",
-        "",
-        "Führe \`claude\` in diesem Verzeichnis aus um die Arbeit zu starten.",
-      ].join("\n") + "\n",
-      "utf8"
-    );
-
-    state.worktrees.push({ agent, branch, path: wtPath, status: "pending" });
-  }
-
-  fs.writeFileSync(
-    path.join(forgehiveDir, "party", "party-session.yaml"),
-    yaml.dump(state),
-    "utf8"
-  );
-
-  return state;
-}
-
-export function getPartyStatus(forgehiveDir: string): WorktreePartyState | null {
-  const statePath = path.join(forgehiveDir, "party", "party-session.yaml");
-  if (!fs.existsSync(statePath)) return null;
-  try {
-    return yaml.load(fs.readFileSync(statePath, "utf8")) as WorktreePartyState;
-  } catch {
-    return null;
-  }
-}
-
-export function cleanupPartyWorktrees(
-  forgehiveDir: string,
-  projectRoot: string
-): string[] {
-  const state = getPartyStatus(forgehiveDir);
-  if (!state) throw new Error("Keine aktive Party-Session gefunden");
-
-  const removed: string[] = [];
-  for (const wt of state.worktrees) {
-    if (fs.existsSync(wt.path)) {
-      const result = spawnSync("git", ["worktree", "remove", "--force", wt.path], {
-        cwd: projectRoot,
-        encoding: "utf8",
-      });
-      if (result.status === 0) removed.push(wt.agent);
-    }
-  }
-
-  spawnSync("git", ["worktree", "prune"], { cwd: projectRoot, encoding: "utf8" });
-
-  const statePath = path.join(forgehiveDir, "party", "party-session.yaml");
-  if (fs.existsSync(statePath)) fs.unlinkSync(statePath);
-
-  return removed;
-}
-```
-
-- [ ] **Step 4: Add `fh party run/status/cleanup` to `src/cli.ts`**
-
-Update the `party` import:
-```typescript
-import { showParty, setPartyDefault, addPartySet, setAgentModel, runParty, getPartyStatus, cleanupPartyWorktrees } from "./party.ts";
-```
-
-In the party handler, add a `run` branch at the top of the args parsing, before `setFlag`:
-
-```typescript
-  if (subcommand === "run") {
-    const runSet = rest[0] ?? (() => {
-      try {
-        return (yaml.load(fs.readFileSync(
-          path.join(forgehiveDir, "party", "config.yaml"), "utf8"
-        )) as { default_set?: string })?.default_set ?? "default";
-      } catch { return "default"; }
-    })();
-    try {
-      const state = runParty(forgehiveDir, projectRoot, runSet);
-      console.log(`✓ Party gestartet — Set: ${state.setName}, Session: ${state.sessionId}\n`);
-      for (const wt of state.worktrees) {
-        console.log(`  ${wt.agent.padEnd(12)} Branch: ${wt.branch}`);
-        console.log(`  ${"".padEnd(12)} Pfad:   ${wt.path}`);
-        console.log(`  ${"".padEnd(12)} Starte: cd "${wt.path}" && claude\n`);
-      }
-    } catch (err) {
-      console.error(`Fehler: ${(err as Error).message}`);
-      process.exit(1);
-    }
-  } else if (subcommand === "status") {
-    const state = getPartyStatus(forgehiveDir);
-    if (!state) {
-      console.log("Keine aktive Party-Session. Starte mit: fh party run");
-    } else {
-      console.log(`Aktive Session: ${state.sessionId} (Set: ${state.setName})\n`);
-      for (const wt of state.worktrees) {
-        console.log(`  ${wt.agent.padEnd(12)} ${wt.branch}`);
-      }
-    }
-  } else if (subcommand === "cleanup") {
-    try {
-      const removed = cleanupPartyWorktrees(forgehiveDir, projectRoot);
-      console.log(removed.length > 0
-        ? `✓ Worktrees entfernt: ${removed.join(", ")}`
-        : "Keine Worktrees zu bereinigen"
-      );
-    } catch (err) {
-      console.error(`Fehler: ${(err as Error).message}`);
-      process.exit(1);
-    }
-  } else if (setFlag !== -1) {
-```
-
-(Note: restructure the `party` handler so `run`, `status`, and `cleanup` are checked first via `subcommand`, then the `partyArgs` flag-based handling follows for the `--set`, `--agents`, `--model-map` flags.)
-
-- [ ] **Step 5: Run all tests**
-
-```bash
-node --import tsx/esm --test test/*.test.ts 2>&1 | tail -8
-```
-
-Expected: `# pass 172` and `# fail 0`
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add src/party.ts test/party.test.ts src/cli.ts
-git commit -m "feat: worktree-isolated party runs — fh party run creates per-agent git worktrees"
-```
-
----
-
-### Task 9: MCP Credential Management
-
-**Files:**
-- Create: `src/mcp-auth.ts`
-- Modify: `src/cli.ts` (add `fh mcp auth` subcommands)
-- Test: `test/mcp-auth.test.ts`
-
-- [ ] **Step 1: Write failing tests**
-
-```typescript
-// test/mcp-auth.test.ts
-import { describe, it, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import {
-  setCredentials, getCredentials, listCredentialServices, removeCredentials
-} from "../src/mcp-auth.ts";
-
-describe("mcp-auth credential store", () => {
-  let tmpHome: string;
-  const origHome = process.env.HOME;
-
-  beforeEach(() => {
-    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "forgehive-mcp-auth-"));
-    process.env.HOME = tmpHome;
-  });
-  afterEach(() => {
-    process.env.HOME = origHome;
-    fs.rmSync(tmpHome, { recursive: true, force: true });
-  });
-
-  it("stores and retrieves credentials for a service", () => {
-    setCredentials("github", { GITHUB_TOKEN: "ghp_abc123" });
-    const creds = getCredentials("github");
-    assert.equal(creds?.["GITHUB_TOKEN"], "ghp_abc123");
-  });
-
-  it("returns null for unknown service", () => {
-    assert.equal(getCredentials("unknown-service"), null);
-  });
-
-  it("merges credentials for the same service", () => {
-    setCredentials("slack", { SLACK_BOT_TOKEN: "xoxb-123" });
-    setCredentials("slack", { SLACK_TEAM_ID: "T123" });
-    const creds = getCredentials("slack");
-    assert.equal(creds?.["SLACK_BOT_TOKEN"], "xoxb-123");
-    assert.equal(creds?.["SLACK_TEAM_ID"], "T123");
-  });
-
-  it("lists all services with stored credentials", () => {
-    setCredentials("linear", { LINEAR_API_KEY: "lin_abc" });
-    setCredentials("github", { GITHUB_TOKEN: "ghp_xyz" });
-    const services = listCredentialServices();
-    assert.ok(services.includes("linear"));
-    assert.ok(services.includes("github"));
-  });
-
-  it("removes credentials for a service", () => {
-    setCredentials("github", { GITHUB_TOKEN: "ghp_abc" });
-    removeCredentials("github");
-    assert.equal(getCredentials("github"), null);
-  });
-
-  it("credentials file has mode 600 (user-only)", () => {
-    setCredentials("test", { KEY: "value" });
-    const credsPath = path.join(tmpHome, ".forgehive", "credentials.json");
-    const mode = fs.statSync(credsPath).mode;
-    // On Linux: 0o100600 = regular file + 600 perms
-    assert.ok((mode & 0o777) === 0o600);
-  });
-});
-```
-
-- [ ] **Step 2: Run test to confirm it fails**
-
-```bash
-node --import tsx/esm --test test/mcp-auth.test.ts 2>&1 | head -5
-```
-
-Expected: `Error: Cannot find module '../src/mcp-auth.ts'`
-
-- [ ] **Step 3: Implement `src/mcp-auth.ts`**
-
-```typescript
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-
-interface CredentialStore {
-  [service: string]: Record<string, string>;
-}
-
-function getCredsPath(): string {
-  const dir = path.join(os.homedir(), ".forgehive");
-  fs.mkdirSync(dir, { recursive: true });
-  return path.join(dir, "credentials.json");
-}
-
-function loadStore(): CredentialStore {
-  const p = getCredsPath();
-  if (!fs.existsSync(p)) return {};
-  try {
-    return JSON.parse(fs.readFileSync(p, "utf8")) as CredentialStore;
-  } catch {
-    return {};
-  }
-}
-
-function saveStore(store: CredentialStore): void {
-  const p = getCredsPath();
-  fs.writeFileSync(p, JSON.stringify(store, null, 2), "utf8");
-  try { fs.chmodSync(p, 0o600); } catch { /* ignore on systems without chmod */ }
-}
-
-export function setCredentials(service: string, creds: Record<string, string>): void {
-  const store = loadStore();
-  store[service] = { ...(store[service] ?? {}), ...creds };
-  saveStore(store);
-}
-
-export function getCredentials(service: string): Record<string, string> | null {
-  return loadStore()[service] ?? null;
-}
-
-export function listCredentialServices(): string[] {
-  return Object.keys(loadStore());
-}
-
-export function removeCredentials(service: string): void {
-  const store = loadStore();
-  delete store[service];
-  saveStore(store);
-}
-```
-
-- [ ] **Step 4: Add `fh mcp auth` to `src/cli.ts`**
-
-Add import at top:
-```typescript
-import { setCredentials, getCredentials, listCredentialServices, removeCredentials } from "./mcp-auth.ts";
-```
-
-Add a new `mcp` command handler before the final `else` block:
-
-```typescript
-} else if (command === "mcp") {
-  if (!fs.existsSync(forgehiveDir)) {
-    console.error("Fehler: .forgehive/ nicht gefunden — führe zuerst `fh init` aus");
-    process.exit(1);
-  }
-
-  if (subcommand === "auth") {
-    const authSub = rest[0];
-
-    if (!authSub || authSub === "list") {
-      const services = listCredentialServices();
-      if (services.length === 0) {
-        console.log("Keine Credentials gespeichert. Verwende: fh mcp auth add <service> KEY=value");
-      } else {
-        console.log("Gespeicherte Credentials:\n");
-        for (const s of services) {
-          const creds = getCredentials(s);
-          const keys = Object.keys(creds ?? {}).join(", ");
-          console.log(`  ${s.padEnd(16)} ${keys}`);
-        }
-      }
-    } else if (authSub === "add") {
-      const service = rest[1];
-      if (!service) {
-        console.error("Fehler: fh mcp auth add <service> KEY=value [KEY2=value2 ...]");
-        process.exit(1);
-      }
-      const pairs = rest.slice(2);
-      if (pairs.length === 0) {
-        console.error("Fehler: mindestens ein KEY=value Paar erforderlich");
-        process.exit(1);
-      }
-      const creds: Record<string, string> = {};
-      for (const pair of pairs) {
-        const eqIdx = pair.indexOf("=");
-        if (eqIdx === -1) { console.error(`Ungültiges Format: ${pair} (erwartet KEY=value)`); process.exit(1); }
-        creds[pair.slice(0, eqIdx)] = pair.slice(eqIdx + 1);
-      }
-      setCredentials(service, creds);
-      console.log(`✓ Credentials für ${service} gespeichert (${Object.keys(creds).join(", ")})`);
-
-    } else if (authSub === "remove") {
-      const service = rest[1];
-      if (!service) { console.error("Fehler: fh mcp auth remove <service>"); process.exit(1); }
-      removeCredentials(service);
-      console.log(`✓ Credentials für ${service} entfernt`);
-
-    } else {
-      console.error(`Unbekannter auth-Subcommand: ${authSub}`);
-      console.error("Verfügbar: list | add <service> KEY=value | remove <service>");
-      process.exit(1);
-    }
-
-  } else {
-    console.error(`Unbekannter mcp-Subcommand: ${subcommand ?? "(kein)"}`);
-    console.error("Verfügbar: auth [list|add|remove]");
-    process.exit(1);
-  }
-
-```
-
-Update the help message to include `mcp auth [list|add|remove]`.
-
-- [ ] **Step 5: Run all tests**
-
-```bash
-node --import tsx/esm --test test/*.test.ts 2>&1 | tail -8
-```
-
-Expected: `# pass 179` and `# fail 0`
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add src/mcp-auth.ts test/mcp-auth.test.ts src/cli.ts
-git commit -m "feat: MCP credential management — fh mcp auth add/list/remove stores keys at ~/.forgehive/credentials.json"
-```
-
----
-
-### Task 10: Smithery Registry Integration
-
-**Files:**
-- Create: `src/mcp-registry.ts`
-- Modify: `src/cli.ts` (add `fh mcp search` and `fh mcp add`)
-- Test: `test/mcp-registry.test.ts`
-
-- [ ] **Step 1: Write failing tests**
-
-```typescript
-// test/mcp-registry.test.ts
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { parseRegistryResponse, addMcpFromRegistry } from "../src/mcp-registry.ts";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-
-describe("parseRegistryResponse()", () => {
-  it("returns empty array for null/undefined input", () => {
-    assert.deepEqual(parseRegistryResponse(null), []);
-    assert.deepEqual(parseRegistryResponse(undefined), []);
-  });
-
-  it("parses Smithery-style response", () => {
-    const raw = {
-      servers: [
-        { qualifiedName: "@org/github-mcp", displayName: "GitHub MCP", description: "GitHub integration" },
-        { qualifiedName: "@org/slack-mcp", displayName: "Slack MCP", description: "Slack integration" },
-      ]
-    };
-    const results = parseRegistryResponse(raw);
-    assert.equal(results.length, 2);
-    assert.equal(results[0].qualifiedName, "@org/github-mcp");
-    assert.equal(results[0].displayName, "GitHub MCP");
-  });
-
-  it("handles missing fields gracefully", () => {
-    const raw = { servers: [{ qualifiedName: "@org/server" }] };
-    const results = parseRegistryResponse(raw);
-    assert.equal(results.length, 1);
-    assert.equal(results[0].displayName, "@org/server");
-  });
-});
-
-describe("addMcpFromRegistry()", () => {
-  let tmpDir: string;
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "forgehive-mcp-registry-"));
-    fs.mkdirSync(path.join(tmpDir, ".forgehive", "skills", "workflows"), { recursive: true });
-  });
-  afterEach(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-  it("writes .mcp.json with the package config", () => {
-    addMcpFromRegistry(tmpDir, path.join(tmpDir, ".forgehive"), "@org/my-mcp-server", ["MY_API_KEY"]);
-    const mcp = JSON.parse(fs.readFileSync(path.join(tmpDir, ".mcp.json"), "utf8"));
-    assert.ok(mcp.mcpServers?.["my-mcp-server"]);
-    assert.equal(mcp.mcpServers["my-mcp-server"].command, "npx");
-    assert.ok(mcp.mcpServers["my-mcp-server"].args.includes("@org/my-mcp-server"));
-  });
-
-  it("adds env vars to the MCP config", () => {
-    addMcpFromRegistry(tmpDir, path.join(tmpDir, ".forgehive"), "@org/my-mcp", ["MY_KEY", "MY_SECRET"]);
-    const mcp = JSON.parse(fs.readFileSync(path.join(tmpDir, ".mcp.json"), "utf8"));
-    const server = mcp.mcpServers["my-mcp"];
-    assert.equal(server.env.MY_KEY, "${MY_KEY}");
-    assert.equal(server.env.MY_SECRET, "${MY_SECRET}");
-  });
-
-  it("merges with existing .mcp.json without overwriting other services", () => {
-    fs.writeFileSync(
-      path.join(tmpDir, ".mcp.json"),
-      JSON.stringify({ mcpServers: { linear: { command: "npx", args: ["-y", "linear-mcp"] } } }),
-      "utf8"
-    );
-    addMcpFromRegistry(tmpDir, path.join(tmpDir, ".forgehive"), "@org/new-server", []);
-    const mcp = JSON.parse(fs.readFileSync(path.join(tmpDir, ".mcp.json"), "utf8"));
-    assert.ok(mcp.mcpServers.linear);
-    assert.ok(mcp.mcpServers["new-server"]);
-  });
-});
-```
-
-- [ ] **Step 2: Run test to confirm it fails**
-
-```bash
-node --import tsx/esm --test test/mcp-registry.test.ts 2>&1 | head -5
-```
-
-Expected: `Error: Cannot find module '../src/mcp-registry.ts'`
-
-- [ ] **Step 3: Implement `src/mcp-registry.ts`**
-
-```typescript
-import fs from "node:fs";
-import path from "node:path";
-import { spawnSync } from "node:child_process";
-
-export interface RegistryServer {
-  qualifiedName: string;
-  displayName: string;
-  description: string;
-  homepage?: string;
-}
-
-interface SmitheryResponse {
-  servers?: Array<{
-    qualifiedName?: string;
-    displayName?: string;
-    description?: string;
-    homepage?: string;
-  }>;
-}
-
-export function parseRegistryResponse(raw: unknown): RegistryServer[] {
-  if (!raw || typeof raw !== "object") return [];
-  const data = raw as SmitheryResponse;
-  if (!Array.isArray(data.servers)) return [];
-  return data.servers.map(s => ({
-    qualifiedName: s.qualifiedName ?? "",
-    displayName: s.displayName ?? s.qualifiedName ?? "",
-    description: s.description ?? "",
-    homepage: s.homepage,
-  })).filter(s => s.qualifiedName !== "");
-}
-
-export function searchRegistry(query: string): RegistryServer[] {
-  const url = `https://registry.smithery.ai/servers?q=${encodeURIComponent(query)}&pageSize=10`;
-
-  const result = spawnSync("curl", [
-    "-s",
-    "--max-time", "10",
-    "-H", "Accept: application/json",
-    url,
-  ], { encoding: "utf8", timeout: 15000 });
-
-  if (result.error) {
-    throw new Error(`curl nicht verfügbar: ${result.error.message}`);
-  }
-  if (result.status !== 0) {
-    throw new Error(`Registry-Abfrage fehlgeschlagen (HTTP ${result.status ?? "?"})`);
-  }
-
-  try {
-    return parseRegistryResponse(JSON.parse(result.stdout));
-  } catch {
-    throw new Error("Registry-Antwort konnte nicht geparst werden");
-  }
-}
-
-export function addMcpFromRegistry(
-  projectRoot: string,
-  forgehiveDir: string,
-  packageName: string,
-  envKeys: string[]
-): void {
-  // Derive a short server ID from the package name
-  const serverId = packageName.replace(/^@[^/]+\//, "").replace(/(-mcp|-server|mcp-)$/, "") || packageName;
-
-  const mcpPath = path.join(projectRoot, ".mcp.json");
-  let mcpConfig: { mcpServers: Record<string, unknown> } = { mcpServers: {} };
-  if (fs.existsSync(mcpPath)) {
-    try {
-      mcpConfig = JSON.parse(fs.readFileSync(mcpPath, "utf8")) as typeof mcpConfig;
-      if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
-    } catch { mcpConfig = { mcpServers: {} }; }
-  }
-
-  const envObj: Record<string, string> = {};
-  for (const key of envKeys) {
-    envObj[key] = `\${${key}}`;
-  }
-
-  mcpConfig.mcpServers[serverId] = {
-    command: "npx",
-    args: ["-y", packageName],
-    ...(envKeys.length > 0 ? { env: envObj } : {}),
-  };
-
-  fs.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf8");
-
-  // Write a stub workflow skill
-  const skillDir = path.join(forgehiveDir, "skills", "workflows");
-  fs.mkdirSync(skillDir, { recursive: true });
-  const skillPath = path.join(skillDir, `${serverId}.md`);
-  if (!fs.existsSync(skillPath)) {
-    fs.writeFileSync(skillPath, [
-      `# ${serverId} Workflow Skill`,
-      "",
-      `## Setup`,
-      `MCP server: \`${packageName}\``,
-      envKeys.length > 0 ? `Required env: ${envKeys.map(k => `\`${k}\``).join(", ")}` : "",
-      "",
-      `## Capabilities`,
-      "",
-      `_Fill in after installing and exploring the server tools._`,
-    ].filter(l => l !== null).join("\n") + "\n", "utf8");
-  }
-}
-```
-
-- [ ] **Step 4: Add `fh mcp search` and `fh mcp add` to `src/cli.ts`**
-
-Add import at top:
-```typescript
-import { searchRegistry, addMcpFromRegistry } from "./mcp-registry.ts";
-```
-
-Inside the existing `mcp` command handler (after `auth`), add two more `else if` branches:
-
-```typescript
-  } else if (subcommand === "search") {
-    const query = rest[0];
-    if (!query) {
-      console.error("Fehler: fh mcp search <suchbegriff>");
-      process.exit(1);
-    }
-    try {
-      console.log(`Suche in Smithery Registry nach "${query}"...\n`);
-      const results = searchRegistry(query);
-      if (results.length === 0) {
-        console.log("Keine Ergebnisse gefunden.");
-      } else {
-        for (const r of results) {
-          console.log(`  ${r.qualifiedName}`);
-          console.log(`  ${r.displayName} — ${r.description.slice(0, 80)}`);
-          console.log(`  Installieren: fh mcp add ${r.qualifiedName}\n`);
-        }
-      }
-    } catch (err) {
-      console.error(`Fehler: ${(err as Error).message}`);
-      process.exit(1);
-    }
-
-  } else if (subcommand === "add") {
-    const packageName = rest[0];
-    if (!packageName) {
-      console.error("Fehler: fh mcp add <npm-paketname> [--env KEY1 KEY2 ...]");
-      process.exit(1);
-    }
-    const envIdx = rest.indexOf("--env");
-    const envKeys = envIdx !== -1 ? rest.slice(envIdx + 1) : [];
-    try {
-      addMcpFromRegistry(projectRoot, forgehiveDir, packageName, envKeys);
-      console.log(`✓ ${packageName} zu .mcp.json hinzugefügt`);
-      if (envKeys.length > 0) {
-        console.log(`\nSetze diese Umgebungsvariablen:`);
-        for (const k of envKeys) console.log(`  export ${k}="<your-key>"`);
-      }
-      console.log("\nStarte Claude Code neu um den MCP-Server zu aktivieren.");
-    } catch (err) {
-      console.error(`Fehler: ${(err as Error).message}`);
-      process.exit(1);
-    }
-```
-
-Update help message: `mcp [auth|search|add]`.
-
-- [ ] **Step 5: Build and run all tests**
-
-```bash
-node --import tsx/esm --test test/*.test.ts 2>&1 | tail -8
-```
-
-Expected: `# pass 187` and `# fail 0`
-
-```bash
-node_modules/.bin/esbuild src/cli.ts --bundle --platform=node --format=esm --outfile=dist/cli.js && chmod +x dist/cli.js
-```
-
-Expected: `dist/cli.js 150-180 kb, 0 errors`
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add src/mcp-registry.ts test/mcp-registry.test.ts src/cli.ts
-git commit -m "feat: Smithery registry integration — fh mcp search <query> + fh mcp add <package>"
-```
-
----
-
-## Final: Bump version + integration check
-
-- [ ] **Step 1: Update version in `package.json`**
-
-```json
-"version": "0.5.0"
-```
-
-- [ ] **Step 2: Run full test suite**
-
-```bash
-node --import tsx/esm --test test/*.test.ts 2>&1 | tail -8
-```
-
-Expected: `# fail 0`
-
-- [ ] **Step 3: TypeScript typecheck**
-
-```bash
-node_modules/.bin/tsc --noEmit 2>&1
-```
-
-Expected: zero errors
-
-- [ ] **Step 4: Final build**
-
-```bash
-node_modules/.bin/esbuild src/cli.ts --bundle --platform=node --format=esm --outfile=dist/cli.js && chmod +x dist/cli.js && ls -lh dist/cli.js
-```
-
-Expected: single output file, no errors
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add package.json dist/cli.js
-git commit -m "chore: bump to v0.5.0 — NextGen v0.5 complete"
-```