forgehive 0.8.1 → 0.9.0

package/dist/cli.js

@@ -2753,7 +2753,7 @@ var init_harness = __esm({
 init_js_yaml();
 import fs35 from "node:fs";
 import path36 from "node:path";
-import { spawnSync as spawnSync12 } from "node:child_process";
+import { spawnSync as spawnSync13 } from "node:child_process";
 import { createInterface } from "node:readline";
 
 // src/scanner.ts
@@ -4860,6 +4860,109 @@ function countMdFiles(dir) {
   if (!fs15.existsSync(dir)) return 0;
   return fs15.readdirSync(dir).filter((f) => f.endsWith(".md")).length;
 }
+function readYamlFrontmatterFiles(dir) {
+  if (!fs15.existsSync(dir)) return [];
+  const results = [];
+  for (const filename of fs15.readdirSync(dir)) {
+    if (!filename.endsWith(".md")) continue;
+    try {
+      const content = fs15.readFileSync(path15.join(dir, filename), "utf8");
+      const match = content.match(/^---\n([\s\S]*?)\n---/);
+      if (!match) continue;
+      const parsed = jsYaml.load(match[1]);
+      if (parsed && typeof parsed === "object") results.push(parsed);
+    } catch {
+    }
+  }
+  return results;
+}
+function formatSprintSection(forgehiveDir2) {
+  const storiesDir = path15.join(forgehiveDir2, "memory", "stories");
+  if (!fs15.existsSync(storiesDir)) return "";
+  const stories = readYamlFrontmatterFiles(storiesDir);
+  const open = stories.filter((s) => s.status !== "done");
+  const inSprint = stories.filter((s) => s.status === "in-sprint");
+  const next = inSprint[0] ?? open[0] ?? null;
+  const epicsDir = path15.join(forgehiveDir2, "memory", "epics");
+  const activeEpics = readYamlFrontmatterFiles(epicsDir).filter((e) => e.status === "active" || e.status === "in-progress");
+  const lines = ["SPRINT"];
+  lines.push(`  \u25CF ${open.length} offen  \u25CF ${inSprint.length} in-sprint`);
+  if (activeEpics.length > 0) {
+    lines.push(`  Epic: ${activeEpics[0].id} ${activeEpics[0].title}`);
+  }
+  if (next) {
+    const pts = next.points ? `  [${next.points} pts]` : "";
+    lines.push(`  \u2192 n\xE4chstes: ${next.id} "${next.title}"${pts}`);
+  }
+  return lines.join("\n");
+}
+function formatCodeHealthSection(projectRoot2, forgehiveDir2) {
+  const lines = ["CODE HEALTH"];
+  const gitResult = spawnSync4("git", ["status", "--porcelain"], {
+    cwd: projectRoot2,
+    encoding: "utf8"
+  });
+  if (gitResult.status === 0) {
+    const changed = gitResult.stdout.trim().split("\n").filter(Boolean).length;
+    lines.push(
+      changed === 0 ? "  \u2713 Arbeitsbaum sauber" : `  \u26A0 ${changed} ge\xE4nderte Datei(en) \u2014 nicht committed`
+    );
+  }
+  const secPath = path15.join(forgehiveDir2, "security-last-scan.txt");
+  if (fs15.existsSync(secPath)) {
+    try {
+      const ts = fs15.readFileSync(secPath, "utf8").trim();
+      const days = Math.floor((Date.now() - new Date(ts).getTime()) / 864e5);
+      lines.push(
+        days > 7 ? `  \u26A0 Security-Scan: ${days} Tage alt \u2014 fh security scan` : `  \u2713 Security-Scan: ${days} Tage alt`
+      );
+    } catch {
+    }
+  }
+  const prCachePath = path15.join(forgehiveDir2, "github-pr-cache.json");
+  if (fs15.existsSync(prCachePath)) {
+    try {
+      const cache = JSON.parse(fs15.readFileSync(prCachePath, "utf8"));
+      if (cache.open.length > 0) {
+        lines.push(`  \u25CF ${cache.open.length} offene PR(s): #${cache.open.join(", #")}`);
+      }
+    } catch {
+    }
+  }
+  return lines.join("\n");
+}
+function formatWatchSection(forgehiveDir2) {
+  const logPath = path15.join(forgehiveDir2, "watch-events.jsonl");
+  if (!fs15.existsSync(logPath)) return "";
+  const events = fs15.readFileSync(logPath, "utf8").trim().split("\n").filter(Boolean).map((line) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return null;
+    }
+  }).filter((e) => e !== null).slice(-5).reverse();
+  if (events.length === 0) return "";
+  const lines = ["WATCH  (letzte Ereignisse)"];
+  for (const e of events) {
+    const time = new Date(e.ts).toLocaleTimeString("de", { hour: "2-digit", minute: "2-digit" });
+    if (e.type === "stack-update") {
+      lines.push(`  [${time}] \u2713 Stack-Update (${e.file ?? "?"}) \u2014 capabilities.yaml aktualisiert`);
+    } else {
+      const verdict = e.accepted === true ? "\u2192 gestartet" : e.accepted === false ? "\u2192 abgelehnt" : "\u2192 vorgeschlagen";
+      lines.push(`  [${time}] \u26A0 ${e.file ?? e.type}  ${verdict}: ${e.agent ?? "?"}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatDashboard(projectRoot2, forgehiveDir2) {
+  const sections = [
+    formatSprintSection(forgehiveDir2),
+    formatCodeHealthSection(projectRoot2, forgehiveDir2),
+    formatWatchSection(forgehiveDir2)
+  ].filter(Boolean);
+  if (sections.length === 0) return "";
+  return "\n" + sections.join("\n\n");
+}
 function checkDrift(projectRoot2, forgehiveDir2) {
   const scanPath = path15.join(forgehiveDir2, "scan-result.yaml");
   if (!fs15.existsSync(scanPath)) {
@@ -4974,6 +5077,7 @@ function projectStatus(projectRoot2, forgehiveDir2) {
 // src/watch.ts
 import fs16 from "node:fs";
 import path16 from "node:path";
+import { spawnSync as spawnSync5 } from "node:child_process";
 function checkProjectHash(projectRoot2, forgehiveDir2, claudeMdBlock) {
   const hashPath = path16.join(forgehiveDir2, ".scan-hash");
   const savedHash = fs16.existsSync(hashPath) ? fs16.readFileSync(hashPath, "utf8").trim() : null;
@@ -5031,6 +5135,91 @@ function defaultOnUpdate(changed) {
     console.log("[forgehive] \u2713 Codebase changed \u2014 capabilities.yaml aktualisiert");
   }
 }
+function appendWatchEvent(forgehiveDir2, event) {
+  const logPath = path16.join(forgehiveDir2, "watch-events.jsonl");
+  fs16.appendFileSync(logPath, JSON.stringify(event) + "\n", "utf8");
+  try {
+    const stat = fs16.statSync(logPath);
+    if (stat.size > 25e3) {
+      const lines = fs16.readFileSync(logPath, "utf8").trim().split("\n").filter(Boolean);
+      if (lines.length >= 500) {
+        fs16.writeFileSync(logPath, lines.slice(-500).join("\n") + "\n", "utf8");
+      }
+    }
+  } catch {
+  }
+}
+function detectErrorType(output) {
+  const lower = output.toLowerCase();
+  if (lower.includes("failing") || lower.includes("assertionerror") || lower.includes("not ok")) {
+    return { agent: "sam", reason: "Test-Fehler erkannt" };
+  }
+  if (lower.includes("error ts") || lower.includes("type error")) {
+    return { agent: "kai", reason: "TypeScript-Fehler erkannt" };
+  }
+  if (lower.includes("secret") || lower.includes("vulnerability") || lower.includes("cve")) {
+    return { agent: "vera", reason: "Sicherheitsproblem erkannt" };
+  }
+  if (lower.includes("error") || lower.includes("failed to compile")) {
+    return { agent: "kai", reason: "Build-Fehler erkannt" };
+  }
+  return null;
+}
+function smartWatch(projectRoot2, forgehiveDir2, testCmd, onSuggest) {
+  const srcDir = path16.join(projectRoot2, "src");
+  const testDir = path16.join(projectRoot2, "test");
+  const watchDirs = [srcDir, testDir].filter((d) => fs16.existsSync(d));
+  let debounce = null;
+  const watchers = [];
+  function runAndAnalyze(changedFile) {
+    const result = spawnSync5(testCmd, {
+      cwd: projectRoot2,
+      encoding: "utf8",
+      shell: true
+    });
+    if (result.status === 0) return;
+    const output = (result.stdout ?? "") + (result.stderr ?? "");
+    const detection = detectErrorType(output);
+    if (!detection) return;
+    const relFile = path16.relative(projectRoot2, changedFile);
+    console.log(`
+\u26A0 ${relFile} \u2014 ${detection.reason}`);
+    console.log(`  \u2192 ${detection.agent} ist der richtige Agent.`);
+    void onSuggest(detection.agent, detection.reason, relFile).then((accepted) => {
+      appendWatchEvent(forgehiveDir2, {
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "test-failure",
+        file: relFile,
+        agent: detection.agent,
+        accepted
+      });
+    });
+  }
+  function schedule(changedFile) {
+    if (debounce) clearTimeout(debounce);
+    debounce = setTimeout(() => runAndAnalyze(changedFile), 1500);
+  }
+  for (const dir of watchDirs) {
+    try {
+      const watcher = fs16.watch(dir, { recursive: true }, (_evt, filename) => {
+        if (filename && (filename.endsWith(".ts") || filename.endsWith(".js"))) {
+          schedule(path16.join(dir, filename));
+        }
+      });
+      watchers.push(watcher);
+    } catch {
+    }
+  }
+  return () => {
+    if (debounce) clearTimeout(debounce);
+    for (const w of watchers) {
+      try {
+        w.close();
+      } catch {
+      }
+    }
+  };
+}
 
 // src/cost.ts
 import fs17 from "node:fs";
@@ -5200,7 +5389,7 @@ function checkMcpTrust(packageName) {
 // src/mcp-registry.ts
 import fs19 from "node:fs";
 import path19 from "node:path";
-import { spawnSync as spawnSync5 } from "node:child_process";
+import { spawnSync as spawnSync6 } from "node:child_process";
 function parseRegistryResponse(raw) {
   if (!raw || typeof raw !== "object") return [];
   const data = raw;
@@ -5214,7 +5403,7 @@ function parseRegistryResponse(raw) {
 }
 function searchRegistry(query) {
   const url = `https://registry.smithery.ai/servers?q=${encodeURIComponent(query)}&pageSize=10`;
-  const result = spawnSync5("curl", [
+  const result = spawnSync6("curl", [
     "-s",
     "--max-time",
     "10",
@@ -5277,7 +5466,7 @@ function addMcpFromRegistry(projectRoot2, forgehiveDir2, packageName, envKeys) {
 // src/security-scan.ts
 import fs20 from "node:fs";
 import path20 from "node:path";
-import { spawnSync as spawnSync6 } from "node:child_process";
+import { spawnSync as spawnSync7 } from "node:child_process";
 var SECRET_PATTERNS = [
   { name: "Anthropic Key", pattern: /sk-ant-[a-zA-Z0-9-]{20,}/g },
   { name: "OpenAI Key", pattern: /sk-(?!ant-)[a-zA-Z0-9]{20,}/g },
@@ -5412,7 +5601,7 @@ function scanSast(projectRoot2) {
 function scanDeps(projectRoot2) {
   const pkgJsonPath = path20.join(projectRoot2, "package.json");
   if (!fs20.existsSync(pkgJsonPath)) return [];
-  const result = spawnSync6("npm", ["audit", "--json"], {
+  const result = spawnSync7("npm", ["audit", "--json"], {
     cwd: projectRoot2,
     encoding: "utf8",
     timeout: 3e4
@@ -5996,9 +6185,9 @@ function buildSemanticMap(projectRoot2) {
 init_js_yaml();
 import fs25 from "node:fs";
 import path26 from "node:path";
-import { spawnSync as spawnSync7 } from "node:child_process";
+import { spawnSync as spawnSync8 } from "node:child_process";
 function getRecentCommits(projectRoot2, n = 20) {
-  const result = spawnSync7("git", ["log", `--oneline`, `-${n}`], {
+  const result = spawnSync8("git", ["log", `--oneline`, `-${n}`], {
     cwd: projectRoot2,
     encoding: "utf8"
   });
@@ -6103,7 +6292,7 @@ function generateOnboardingDoc(projectRoot2, forgehiveDir2) {
 }
 
 // src/changelog.ts
-import { spawnSync as spawnSync8 } from "node:child_process";
+import { spawnSync as spawnSync9 } from "node:child_process";
 var TYPE_LABELS = {
   feat: "Added",
   fix: "Fixed",
@@ -6167,12 +6356,12 @@ function formatChangelog(commits, version2) {
 function getGitLogSince(projectRoot2, since) {
   const args = ["log", "--oneline", "--no-merges"];
   if (since) args.push(`${since}..HEAD`);
-  const result = spawnSync8("git", args, { cwd: projectRoot2, encoding: "utf8" });
+  const result = spawnSync9("git", args, { cwd: projectRoot2, encoding: "utf8" });
   if (result.status !== 0) return "";
   return result.stdout.trim();
 }
 function getLatestTag(projectRoot2) {
-  const result = spawnSync8("git", ["describe", "--tags", "--abbrev=0"], {
+  const result = spawnSync9("git", ["describe", "--tags", "--abbrev=0"], {
     cwd: projectRoot2,
     encoding: "utf8"
   });
@@ -6181,7 +6370,7 @@ function getLatestTag(projectRoot2) {
 }
 
 // src/metrics.ts
-import { spawnSync as spawnSync9 } from "node:child_process";
+import { spawnSync as spawnSync10 } from "node:child_process";
 function parseCommitStats(rawLog) {
   const lines = rawLog.split("\n").map((l) => l.trim()).filter(Boolean);
   const byAuthor = {};
@@ -6238,7 +6427,7 @@ function formatMetrics(stats, projectName) {
 function getMetricsGitLog(projectRoot2, since) {
   const args = ["log", "--no-merges", "--format=%as %an %s"];
   if (since) args.push(`--since=${since}`);
-  const result = spawnSync9("git", args, { cwd: projectRoot2, encoding: "utf8" });
+  const result = spawnSync10("git", args, { cwd: projectRoot2, encoding: "utf8" });
   if (result.status !== 0) return "";
   return result.stdout.trim();
 }
@@ -6246,18 +6435,18 @@ function getMetricsGitLog(projectRoot2, since) {
 // src/sync.ts
 import fs26 from "node:fs";
 import path27 from "node:path";
-import { spawnSync as spawnSync10 } from "node:child_process";
+import { spawnSync as spawnSync11 } from "node:child_process";
 function getSyncStatus(forgehiveDir2) {
   const memDir = path27.join(forgehiveDir2, "memory");
   const files = fs26.existsSync(memDir) ? fs26.readdirSync(memDir).filter((f) => f.endsWith(".md")).length : 0;
   const projectRoot2 = path27.dirname(forgehiveDir2);
-  const configResult = spawnSync10(
+  const configResult = spawnSync11(
     "git",
     ["config", "--get", "forgehive.sync-remote"],
     { cwd: projectRoot2, encoding: "utf8" }
   );
   const remote = configResult.status === 0 ? configResult.stdout.trim() : null;
-  const branchResult = spawnSync10(
+  const branchResult = spawnSync11(
     "git",
     ["config", "--get", "forgehive.sync-branch"],
     { cwd: projectRoot2, encoding: "utf8" }
@@ -6275,7 +6464,7 @@ function pushSync(forgehiveDir2, remote = "origin", branch = "forgehive-memory")
   if (files.length === 0) {
     return { success: false, message: "Keine Memory-Dateien gefunden.", filesCommitted: 0 };
   }
-  const addResult = spawnSync10(
+  const addResult = spawnSync11(
     "git",
     ["add", path27.join(".forgehive", "memory")],
     { cwd: projectRoot2, encoding: "utf8" }
@@ -6283,7 +6472,7 @@ function pushSync(forgehiveDir2, remote = "origin", branch = "forgehive-memory")
   if (addResult.status !== 0) {
     return { success: false, message: `git add failed: ${addResult.stderr}`, filesCommitted: 0 };
   }
-  const commitResult = spawnSync10(
+  const commitResult = spawnSync11(
     "git",
     ["commit", "-m", `chore: sync forgehive memory [${(/* @__PURE__ */ new Date()).toISOString()}]`],
     { cwd: projectRoot2, encoding: "utf8" }
@@ -6292,7 +6481,7 @@ function pushSync(forgehiveDir2, remote = "origin", branch = "forgehive-memory")
   if (!commitOk) {
     return { success: false, message: `git commit failed: ${commitResult.stderr}`, filesCommitted: 0 };
   }
-  const pushResult = spawnSync10(
+  const pushResult = spawnSync11(
     "git",
     ["push", remote, `HEAD:${branch}`],
     { cwd: projectRoot2, encoding: "utf8" }
@@ -6300,15 +6489,15 @@ function pushSync(forgehiveDir2, remote = "origin", branch = "forgehive-memory")
   if (pushResult.status !== 0) {
     return { success: false, message: `git push failed: ${pushResult.stderr}`, filesCommitted: 0 };
   }
-  spawnSync10("git", ["config", "forgehive.sync-remote", remote], { cwd: projectRoot2 });
-  spawnSync10("git", ["config", "forgehive.sync-branch", branch], { cwd: projectRoot2 });
+  spawnSync11("git", ["config", "forgehive.sync-remote", remote], { cwd: projectRoot2 });
+  spawnSync11("git", ["config", "forgehive.sync-branch", branch], { cwd: projectRoot2 });
   return { success: true, message: `Memory gepusht nach ${remote}/${branch}`, filesCommitted: files.length };
 }
 function pullSync(forgehiveDir2, remote = "origin", branch = "forgehive-memory") {
   const projectRoot2 = path27.dirname(forgehiveDir2);
   const memDir = path27.join(forgehiveDir2, "memory");
   fs26.mkdirSync(memDir, { recursive: true });
-  const fetchResult = spawnSync10(
+  const fetchResult = spawnSync11(
     "git",
     ["fetch", remote, branch],
     { cwd: projectRoot2, encoding: "utf8" }
@@ -6316,7 +6505,7 @@ function pullSync(forgehiveDir2, remote = "origin", branch = "forgehive-memory")
   if (fetchResult.status !== 0) {
     return { success: false, message: `git fetch failed: ${fetchResult.stderr}`, filesImported: [] };
   }
-  const listResult = spawnSync10(
+  const listResult = spawnSync11(
     "git",
     ["ls-tree", "--name-only", `${remote}/${branch}`, ".forgehive/memory/"],
     { cwd: projectRoot2, encoding: "utf8" }
@@ -6330,7 +6519,7 @@ function pullSync(forgehiveDir2, remote = "origin", branch = "forgehive-memory")
     const filename = path27.basename(remotePath);
     const localPath = path27.join(memDir, filename);
     if (!fs26.existsSync(localPath)) {
-      const contentResult = spawnSync10(
+      const contentResult = spawnSync11(
         "git",
         ["show", `${remote}/${branch}:${remotePath}`],
         { cwd: projectRoot2, encoding: "utf8" }
@@ -6848,7 +7037,7 @@ function formatVelocityReport(history) {
 init_js_yaml();
 import fs32 from "node:fs";
 import path33 from "node:path";
-import { spawnSync as spawnSync11 } from "node:child_process";
+import { spawnSync as spawnSync12 } from "node:child_process";
 var SOURCE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".py", ".go"];
 var IGNORE_DIRS4 = ["node_modules", ".git", "dist", ".forgehive", "coverage", ".next", "build", "test", "__tests__", "spec"];
 var EXPORT_PATTERNS2 = [
@@ -6897,7 +7086,7 @@ function readMemoryFiles2(forgehiveDir2) {
   return result;
 }
 function getRecentCommits2(projectRoot2, n = 10) {
-  const result = spawnSync11("git", ["log", "--oneline", `-${n}`], { cwd: projectRoot2, encoding: "utf8" });
+  const result = spawnSync12("git", ["log", "--oneline", `-${n}`], { cwd: projectRoot2, encoding: "utf8" });
   if (result.status !== 0) return [];
   return result.stdout.trim().split("\n").filter(Boolean);
 }
@@ -7339,6 +7528,21 @@ function formatPRContext(pr, files, repoFullName) {
     fileLines || "(keine Dateien)"
   ].join("\n");
 }
+async function fetchOpenPRs(owner, repo, token) {
+  const prs = [];
+  let page = 1;
+  while (true) {
+    const batch = await githubGet(
+      `/repos/${owner}/${repo}/pulls?state=open&per_page=100&page=${page}`,
+      token
+    );
+    if (batch.length === 0) break;
+    prs.push(...batch);
+    if (batch.length < 100) break;
+    page++;
+  }
+  return prs.map((pr) => pr.number);
+}
 
 // src/cli.ts
 import { createRequire } from "node:module";
@@ -7363,6 +7567,7 @@ SETUP
   fh confirm                       Activate capabilities (draft \u2192 confirmed)
   fh rollback                      Remove forgehive from the project
   fh status                        Show current project state
+  fh watch [--smart]               Observe project; --smart runs tests on change and suggests agents
   fh scan --update                 Re-scan project after changes
   fh scan --check                  Check if scan is still current
 
@@ -7450,7 +7655,7 @@ async function promptConfirm(question) {
     rl.question(question, (answer) => {
       rl.close();
       const a = answer.trim().toLowerCase();
-      resolve(a === "y" || a === "yes" || a === "");
+      resolve(a === "y" || a === "yes" || a === "j" || a === "ja" || a === "");
     });
   });
 }
@@ -7464,7 +7669,7 @@ function buildCapabilitySummary(ids) {
 }
 if (command === "init") {
   (async () => {
-    const gitCheck = spawnSync12("git", ["--version"], { stdio: "ignore" });
+    const gitCheck = spawnSync13("git", ["--version"], { stdio: "ignore" });
     if (gitCheck.error || gitCheck.status !== 0) {
       console.error("Fehler: git nicht gefunden.");
       console.error("  Installation: https://git-scm.com");
@@ -7870,6 +8075,8 @@ N\xE4chster Schritt: Setze die erforderlichen Umgebungsvariablen und starte Clau
   }
 } else if (command === "status") {
   console.log(projectStatus(projectRoot, forgehiveDir));
+  const dashboard = formatDashboard(projectRoot, forgehiveDir);
+  if (dashboard) console.log(dashboard);
 } else if (command === "cost") {
   const allArgs = [subcommand, ...rest].filter((a) => Boolean(a));
   const limitIdx = allArgs.indexOf("--limit");
@@ -7912,17 +8119,44 @@ N\xE4chster Schritt: Setze die erforderlichen Umgebungsvariablen und starte Clau
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
     process.exit(1);
   }
-  const block = loadClaudeMdBlock();
-  console.log("\u{1F441}  ForgeHive watch gestartet \u2014 beobachte Projekt-Dateien (Ctrl+C zum Beenden)\n");
-  const stop = watchProject(projectRoot, forgehiveDir, block);
-  process.on("SIGINT", () => {
-    stop();
-    process.exit(0);
-  });
-  process.on("SIGTERM", () => {
-    stop();
-    process.exit(0);
-  });
+  const isSmartMode = subcommand === "--smart" || rest.includes("--smart");
+  if (isSmartMode) {
+    let testCmd = "npm test";
+    const capsPath = path36.join(forgehiveDir, "capabilities.yaml");
+    if (fs35.existsSync(capsPath)) {
+      try {
+        const caps = jsYaml.load(fs35.readFileSync(capsPath, "utf8"));
+        if (caps?.test_command) testCmd = caps.test_command;
+      } catch {
+      }
+    }
+    console.log(`\u{1F441}  ForgeHive Smart Watch \u2014 Testbefehl: ${testCmd}`);
+    console.log("  \xDCberwache src/ und test/ auf \xC4nderungen (Ctrl+C zum Beenden)\n");
+    const stop = smartWatch(projectRoot, forgehiveDir, testCmd, async (agent, _reason, file) => {
+      console.log(`  Soll ich ${agent} starten f\xFCr ${file}?`);
+      return promptConfirm("  [j/n] ");
+    });
+    process.on("SIGINT", () => {
+      stop();
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      stop();
+      process.exit(0);
+    });
+  } else {
+    const block = loadClaudeMdBlock();
+    console.log("\u{1F441}  ForgeHive watch gestartet \u2014 beobachte Projekt-Dateien (Ctrl+C zum Beenden)\n");
+    const stop = watchProject(projectRoot, forgehiveDir, block);
+    process.on("SIGINT", () => {
+      stop();
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      stop();
+      process.exit(0);
+    });
+  }
 } else if (command === "mcp") {
   if (!fs35.existsSync(forgehiveDir)) {
     console.error("Fehler: .forgehive/ nicht gefunden \u2014 f\xFChre zuerst `fh init` aus");
@@ -8088,6 +8322,11 @@ Setze diese Umgebungsvariablen:`);
         high: high.length
       }
     });
+    fs35.writeFileSync(
+      path36.join(forgehiveDir, "security-last-scan.txt"),
+      (/* @__PURE__ */ new Date()).toISOString(),
+      "utf8"
+    );
     if (secrets.length > 0 || critical.length > 0 || high.length > 0) {
       process.exit(1);
     }
@@ -8654,6 +8893,16 @@ Task: "${taskDescription}"
     }
     console.log(`
   ${created} ${created === 1 ? "Story" : "Stories"} erstellt, ${skipped} \xFCbersprungen.`);
+    try {
+      const [syncOwner, syncRepo] = config.repo.split("/");
+      const openPrNumbers = await fetchOpenPRs(syncOwner, syncRepo, creds.GITHUB_TOKEN);
+      fs35.writeFileSync(
+        path36.join(forgehiveDir, "github-pr-cache.json"),
+        JSON.stringify({ open: openPrNumbers, ts: (/* @__PURE__ */ new Date()).toISOString() }),
+        "utf8"
+      );
+    } catch {
+    }
   } else if (subcommand === "pr") {
     const prNumberRaw = rest[0];
     if (!prNumberRaw || isNaN(parseInt(prNumberRaw, 10))) {

package/forgehive/templates/claude-md.block.md

@@ -9,6 +9,7 @@ This project uses **forgehive** for structured AI-assisted development.
    - If `status: confirmed` → load silently and apply throughout the session
 2. Read `.forgehive/memory/MEMORY.md` — follow the index links to load project context
 3. Run `fh scan --check` to verify the stack snapshot is current
+4. Run `fh status` for the daily overview (sprint, code health, watch events)
 
 ### During the Session
 

package/package.json

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