diff --git a/README.md b/README.md
index ed3336c..4d4c3fe 100644
--- a/README.md
+++ b/README.md
@@ -70,6 +70,12 @@ Projects that need worker orchestration can import `createDifferentialTestingWor
 
 See the [Differential Testing data contract](skills/burnlist/references/differential-testing-data.md) and [adapter SDK reference](skills/burnlist/references/differential-testing-adapter-sdk.md) for scenario bundles, exact sessions, telemetry, and worker interfaces.
 
+## Streaming Diff hooks
+
+`burnlist hooks install --agent codex,claude` merges local Streaming Diff commands into `.codex/hooks.json` and `.claude/settings.json`; it preserves existing hook entries. The agent remains responsible for any first-run hook trust/consent prompt—Burnlist only writes configuration and never bypasses that review. `burnlist hooks status` reports whether each config is tracked (and therefore shared) or local; an already tracked config cannot be hidden with `.git/info/exclude`.
+
+Hooks use the portable `burnlist` command from `PATH`; the host resolves the platform-specific launcher.
+
 ## Command Line
 
 - `burnlist --plan <burnlist.md> --check` validates the active queue and completed ledger.
diff --git a/bin/burnlist.mjs b/bin/burnlist.mjs
index 1cbfc88..6aba10c 100755
--- a/bin/burnlist.mjs
+++ b/bin/burnlist.mjs
@@ -9,6 +9,8 @@ const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const knownSubcommands = new Set([
   "uninstall",
   "differential-testing",
+  "streaming-diff",
+  "hooks",
   "oven",
   "new",
   "show",
@@ -42,6 +44,7 @@ function runNodeScript(path, scriptArgs) {
   });
 }
 
+async function main() {
 if (args[0] === "uninstall") {
   let prefix;
   try {
@@ -64,17 +67,18 @@ if (args[0] === "uninstall") {
     console.error("Burnlist: npm uninstall failed; restoring agent skill registrations.");
     runNodeScript(resolve(packageRoot, "scripts", "register-skills.mjs"), ["--force-global"]);
   }
-  process.exit(removal.status || 0);
+  process.exitCode = removal.status || 0;
+  return;
 }
 
 if (args[0] === "differential-testing" && args[1] === "schema") {
   console.log(resolve(packageRoot, "ovens", "differential-testing", "schema", "differential-testing-data.schema.json"));
-  process.exit(0);
+  return;
 }
 
 if (args[0] === "differential-testing" && args[1] === "sdk") {
   console.log(resolve(packageRoot, "ovens", "differential-testing", "engine", "differential-testing-adapter-sdk.mjs"));
-  process.exit(0);
+  return;
 }
 
 if (args[0] === "differential-testing" && ["validate", "validate-bundle"].includes(args[1])) {
@@ -95,7 +99,7 @@ if (args[0] === "differential-testing" && ["validate", "validate-bundle"].includ
       const sampleCount = document.fields.reduce((total, field) => total + field.sampleCount, 0);
       console.log(`Valid Differential Testing data: ${document.fields.length} fields, ${sampleCount} samples, ${document.summary.frames.uniqueTicks} aligned ticks.`);
     }
-    process.exit(0);
+    return;
   } catch (error) {
     console.error(error.message);
     process.exit(1);
@@ -120,6 +124,8 @@ Usage:
   burnlist differential-testing validate-bundle <bundle/current.json>
   burnlist differential-testing schema
   burnlist differential-testing sdk
+  burnlist streaming-diff <ensure-feed|capture|url|hook> ...
+  burnlist hooks <install|uninstall|status> [--agent codex,claude] [--untracked]
   burnlist oven <list|view|bind|unbind|bindings|create|update> ...
   burnlist new [--repo <path>]
   burnlist show <id>[#<item>] [--repo <path>]
@@ -142,17 +148,21 @@ Options:
   --oven-data <id=path> Bind one Oven to a read-only normalized JSON payload.
   --version, -v         Print the installed Burnlist version.
   --help, -h            Show this help.`);
-  process.exit(0);
+  return;
 }
 
 if (args[0] !== "oven" && (args.includes("--version") || args.includes("-v"))) {
   const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
   console.log(packageJson.version);
-  process.exit(0);
+  return;
 }
 
 if (args[0] === "oven") {
   await import("../src/cli/oven-cli.mjs");
+} else if (args[0] === "streaming-diff") {
+  await import("../src/cli/streaming-diff-cli.mjs");
+} else if (args[0] === "hooks") {
+  await import("../src/cli/hooks-cli.mjs");
 } else if (["new", "show", "ready", "start", "close", "burn"].includes(args[0])) {
   await import("../src/cli/lifecycle-cli.mjs");
 } else if (["register", "unregister", "roots", "init"].includes(args[0])) {
@@ -160,3 +170,6 @@ if (args[0] === "oven") {
 } else {
   await import("../src/server/burnlist-dashboard-server.mjs");
 }
+}
+
+await main();
diff --git a/dashboard/src/App.tsx b/dashboard/src/App.tsx
index a068380..e751ab7 100644
--- a/dashboard/src/App.tsx
+++ b/dashboard/src/App.tsx
@@ -1,6 +1,6 @@
 import { useMemo, useState } from "react";
 import { Clock3, ListChecks } from "lucide-react";
-import { AppHeader, ChecklistDashboard, DashboardError, DifferentialTestingPage, EmptyState, FILTERS, Filters, NewOvenPage, ProjectGroup, RunBurnPage } from "@components";
+import { AppHeader, ChecklistDashboard, DashboardError, DifferentialTestingPage, EmptyState, FILTERS, Filters, NewOvenPage, ProjectGroup, RunBurnPage, StreamingDiff } from "@components";
 import { useDashboardData } from "@hooks";
 import { currentSection, filterFromUrl, listHref, selectedBurnlist } from "@lib";
 import type { Filter } from "@lib";
@@ -9,7 +9,8 @@ export function App() {
   const section = currentSection();
   const selected = useMemo(selectedBurnlist, [window.location.pathname, window.location.search]);
   const [filter, setFilter] = useState(() => filterFromUrl(FILTERS));
-  const { projects, progress, error, loading } = useDashboardData({ section, selected });
+  const dashboardSection = section === "streaming-diff" ? "burnlists" : section;
+  const { projects, progress, error, loading } = useDashboardData({ section: dashboardSection, selected });
 
   const updateFilter = (nextFilter: Filter) => {
     const url = new URL(window.location.href);
@@ -23,8 +24,8 @@ export function App() {
   return (
     <div className="dashboard-app">
       <AppHeader section={section} />
-      <main className="dashboard-main" data-layout={section === "differential-testing" || selected ? "full" : "index"} data-section={section}>
-        {section === "differential-testing" ? <DifferentialTestingPage /> : section === "new-oven" ? <NewOvenPage /> : section === "run-burn" ? <RunBurnPage /> : selected ? (
+      <main className="dashboard-main" data-layout={section === "differential-testing" || section === "streaming-diff" || selected ? "full" : "index"} data-section={section}>
+        {section === "differential-testing" ? <DifferentialTestingPage /> : section === "streaming-diff" ? <StreamingDiff projects={projects} projectsLoading={loading} /> : section === "new-oven" ? <NewOvenPage /> : section === "run-burn" ? <RunBurnPage /> : selected ? (
           error ? <DashboardError message={error} /> : loading && !progress ? <EmptyState title="Loading progress" detail="Reading the selected Burnlist." /> : progress ? (
             <ChecklistDashboard backHref={listHref(filter)} data={progress} />
           ) : <EmptyState title="Choose a Burnlist" detail="Select an item from the list to inspect its progress." icon={ListChecks} />
diff --git a/dashboard/src/components/AppHeader/AppHeader.tsx b/dashboard/src/components/AppHeader/AppHeader.tsx
index b0ee491..5a978fc 100644
--- a/dashboard/src/components/AppHeader/AppHeader.tsx
+++ b/dashboard/src/components/AppHeader/AppHeader.tsx
@@ -13,8 +13,9 @@ export function AppHeader({ section }: { section: string }) {
           <span className="dashboard-brand-name">Burnlist</span>
         </a>
         {section === "differential-testing" && <div className="dashboard-oven-title">Differential Testing</div>}
+        {section === "streaming-diff" && <div className="dashboard-oven-title">Streaming Diff</div>}
         <nav aria-label="Primary navigation" className="dashboard-primary-nav">
-          {section !== "differential-testing" && HEADER_LINKS.map((link, index) => (
+          {section !== "differential-testing" && section !== "streaming-diff" && HEADER_LINKS.map((link, index) => (
             <span className="dashboard-primary-nav-item" key={link.href}>
               {index > 0 && <span aria-hidden="true" className="dashboard-primary-nav-separator">·</span>}
               <a aria-label={link.label} aria-current={section === link.section ? "page" : undefined} className="dashboard-primary-nav-link" href={link.href} title={link.label}>
diff --git a/dashboard/src/components/StreamingDiff/StreamingDiff.tsx b/dashboard/src/components/StreamingDiff/StreamingDiff.tsx
new file mode 100644
index 0000000..5fb7f5f
--- /dev/null
+++ b/dashboard/src/components/StreamingDiff/StreamingDiff.tsx
@@ -0,0 +1,94 @@
+import { useEffect, useMemo } from "react";
+import { Badge, Card, CardContent, CardDescription, CardHeader, CardTitle } from "@layout";
+import { useStreamingDiffCards, useStreamingDiffFeeds } from "@hooks";
+import { ovenRepoKey, streamingDiffAutoOpenHref, streamingDiffFeedKey, streamingDiffRepositories, streamingDiffSelection } from "@lib";
+import { fileKindChip, isTextFileKind } from "@lib";
+import type { Project, StreamingDiffCard, StreamingDiffFeed, StreamingDiffFile } from "@lib";
+import "../../../../ovens/streaming-diff/renderer/streaming-diff.css";
+
+function timestamp(value: string | null) {
+  const parsed = value ? Date.parse(value) : Number.NaN;
+  return Number.isFinite(parsed) ? new Date(parsed).toLocaleString() : value ?? "Unknown activity time";
+}
+
+function FeedList({ feeds, error, loading, showRepository }: { feeds: StreamingDiffFeed[]; error: string; loading: boolean; showRepository: boolean }) {
+  return (
+    <section className="streaming-diff-view">
+      <header className="streaming-diff-heading">
+        <h1>Streaming Diff</h1>
+        <p>Recent feeds are ordered by published activity time, not process liveness.</p>
+      </header>
+      {error ? <p className="streaming-diff-message is-error">{error}</p> : loading ? <p className="streaming-diff-message">Loading recent feeds.</p> : !feeds.length ? <p className="streaming-diff-message">No recent feeds.</p> : (
+        <div className="streaming-diff-feed-list">
+          {feeds.map((feed) => (
+            <a className="streaming-diff-feed" href={feed.href} key={streamingDiffFeedKey(feed)}>
+              <span className="streaming-diff-feed-session">{feed.identity.session}</span>
+              {showRepository && <span className="streaming-diff-feed-worktree">repository {feed.repoLabel}</span>}
+              <span className="streaming-diff-feed-worktree">worktree {feed.identity.worktreeKey}</span>
+              <time className="streaming-diff-feed-time" dateTime={feed.updatedAt ?? undefined}>{timestamp(feed.updatedAt)}</time>
+            </a>
+          ))}
+        </div>
+      )}
+    </section>
+  );
+}
+
+function FileDiff({ file }: { file: StreamingDiffFile }) {
+  const chip = fileKindChip(file.kind, file.meta);
+  if (chip) {
+    return <section className="streaming-diff-file">
+      <div className="streaming-diff-file-head"><code>{file.path}</code><Badge variant="outline">{chip}</Badge></div>
+      {(file.meta?.reason || file.meta?.bytes !== undefined) && <p className="streaming-diff-file-meta">{file.meta?.reason}{file.meta?.reason && file.meta?.bytes !== undefined ? " · " : ""}{file.meta?.bytes !== undefined ? `${file.meta.bytes} bytes` : ""}</p>}
+    </section>;
+  }
+  return <section className="streaming-diff-file">
+    <div className="streaming-diff-file-head"><code>{file.path}</code><Badge variant="secondary">{file.kind}</Badge></div>
+    {isTextFileKind(file.kind) && file.diff !== undefined ? <pre className="streaming-diff-unified">{file.diff}</pre> : <p className="streaming-diff-file-meta">Diff content is unavailable.</p>}
+  </section>;
+}
+
+function DiffCard({ card }: { card: StreamingDiffCard }) {
+  const partial = card.status === "partial";
+  return <Card className="streaming-diff-card">
+    <CardHeader className="streaming-diff-card-header">
+      <div>
+        <CardTitle>{card.toolUseId}</CardTitle>
+        <CardDescription><time dateTime={card.ts}>{timestamp(card.ts)}</time> · {card.revId}</CardDescription>
+      </div>
+      <Badge variant={partial ? "destructive" : "default"}>{card.status}</Badge>
+    </CardHeader>
+    <CardContent className="streaming-diff-card-content">
+      {partial && <p className="streaming-diff-partial">{card.partialReason ?? "This revision is partial."}</p>}
+      {card.files.length ? card.files.map((file) => <FileDiff file={file} key={file.path} />) : <p className="streaming-diff-file-meta">No file content was captured.</p>}
+    </CardContent>
+  </Card>;
+}
+
+function SelectedFeed({ cards, error, session }: { cards: StreamingDiffCard[]; error: string; session: string }) {
+  return <section className="streaming-diff-view">
+    <header className="streaming-diff-heading">
+      <a className="streaming-diff-back" href={`/ovens/streaming-diff/view?repoKey=${encodeURIComponent(ovenRepoKey() ?? "")}`}>Recent feeds</a>
+      <h1>Streaming Diff</h1>
+      <p>Session {session}</p>
+    </header>
+    {error && <p className="streaming-diff-message is-error">{error}</p>}
+    <div className="streaming-diff-cards">{cards.map((card) => <DiffCard card={card} key={card.revId} />)}</div>
+    {!cards.length && <p className="streaming-diff-message">Waiting for diff cards.</p>}
+  </section>;
+}
+
+export function StreamingDiff({ projects, projectsLoading }: { projects: Project[]; projectsLoading: boolean }) {
+  const selection = streamingDiffSelection();
+  const repoKey = ovenRepoKey();
+  const repositories = useMemo(() => repoKey ? [{ repoKey, label: repoKey }] : streamingDiffRepositories(projects), [projects, repoKey]);
+  const feeds = useStreamingDiffFeeds(repositories, projectsLoading, Boolean(selection));
+  const cards = useStreamingDiffCards(selection);
+  const autoOpenHref = streamingDiffAutoOpenHref(feeds.feeds);
+
+  useEffect(() => {
+    if (autoOpenHref) window.location.replace(autoOpenHref);
+  }, [autoOpenHref]);
+
+  return selection ? <SelectedFeed cards={cards.cards} error={cards.error} session={selection.session} /> : <FeedList {...feeds} showRepository={!repoKey && repositories.length > 1} />;
+}
diff --git a/dashboard/src/components/StreamingDiff/index.ts b/dashboard/src/components/StreamingDiff/index.ts
new file mode 100644
index 0000000..5b1f0a6
--- /dev/null
+++ b/dashboard/src/components/StreamingDiff/index.ts
@@ -0,0 +1 @@
+export { StreamingDiff } from "./StreamingDiff";
diff --git a/dashboard/src/components/index.ts b/dashboard/src/components/index.ts
index 81bc2c4..340766d 100644
--- a/dashboard/src/components/index.ts
+++ b/dashboard/src/components/index.ts
@@ -6,3 +6,4 @@ export { DifferentialTestingPage } from "./DifferentialTesting";
 export { EmptyState } from "./EmptyState";
 export { FILTERS, Filters } from "./Filters";
 export { ProjectGroup } from "./ProjectGroup";
+export { StreamingDiff } from "./StreamingDiff";
diff --git a/dashboard/src/hooks/index.ts b/dashboard/src/hooks/index.ts
index 3546153..8a513a7 100644
--- a/dashboard/src/hooks/index.ts
+++ b/dashboard/src/hooks/index.ts
@@ -1 +1,2 @@
 export { useDashboardData } from "./useDashboardData";
+export { useStreamingDiffCards, useStreamingDiffFeeds } from "./useStreamingDiff";
diff --git a/dashboard/src/hooks/useStreamingDiff.ts b/dashboard/src/hooks/useStreamingDiff.ts
new file mode 100644
index 0000000..6ab86ec
--- /dev/null
+++ b/dashboard/src/hooks/useStreamingDiff.ts
@@ -0,0 +1,78 @@
+import { useEffect, useState } from "react";
+import { applyStreamingDiffUpdate, mapStreamingDiffLandingFeeds, parseStreamingDiffCard } from "@lib";
+import type { StreamingDiffCard, StreamingDiffFeed } from "@lib";
+
+type FeedState = { feeds: StreamingDiffFeed[]; error: string; loading: boolean };
+type CardState = { cards: StreamingDiffCard[]; error: string };
+type Selection = { repoKey: string; worktreeKey: string; session: string } | null;
+type Repository = { repoKey: string; label: string };
+
+export function useStreamingDiffFeeds(repositories: Repository[], discoveryLoading: boolean, selected: boolean): FeedState {
+  const [state, setState] = useState<FeedState>({ feeds: [], error: "", loading: !selected });
+
+  useEffect(() => {
+    if (selected) return;
+    if (discoveryLoading) {
+      setState({ feeds: [], error: "", loading: true });
+      return;
+    }
+    if (!repositories.length) {
+      setState({ feeds: [], error: "", loading: false });
+      return;
+    }
+    let cancelled = false;
+    setState({ feeds: [], error: "", loading: true });
+    void Promise.allSettled(repositories.map(async (repository) => {
+      const params = new URLSearchParams({ list: "", repoKey: repository.repoKey });
+      const response = await fetch(`/api/oven-data/streaming-diff?${params}`, { cache: "no-store" });
+      const payload = await response.json();
+      if (!response.ok) throw new Error(payload.error ?? "Could not load recent feeds.");
+      return { repository, payload };
+    })).then((results) => {
+      const successful = results.filter((result): result is PromiseFulfilledResult<{ repository: Repository; payload: unknown }> => result.status === "fulfilled").map((result) => result.value);
+      if (!successful.length) {
+        const failure = results.find((result): result is PromiseRejectedResult => result.status === "rejected");
+        throw failure?.reason ?? new Error("Could not load recent feeds.");
+      }
+      if (!cancelled) setState({ feeds: mapStreamingDiffLandingFeeds(successful), error: "", loading: false });
+    }).catch((cause) => {
+      if (!cancelled) setState({ feeds: [], error: cause instanceof Error ? cause.message : "Could not load recent feeds.", loading: false });
+    });
+    return () => { cancelled = true; };
+  }, [discoveryLoading, repositories, selected]);
+
+  return state;
+}
+
+export function useStreamingDiffCards(selection: Selection): CardState {
+  const [state, setState] = useState<CardState>({ cards: [], error: "" });
+
+  useEffect(() => {
+    if (!selection) {
+      setState({ cards: [], error: "" });
+      return;
+    }
+    const params = new URLSearchParams(selection);
+    const stream = new EventSource(`/api/oven-data/streaming-diff?${params}`);
+    setState({ cards: [], error: "" });
+    const reset = () => setState((current) => ({ ...current, cards: applyStreamingDiffUpdate(current.cards, { type: "reset" }) }));
+    stream.addEventListener("reset", reset);
+    stream.onopen = () => setState((current) => ({ ...current, error: "" }));
+    stream.onmessage = (event) => {
+      try {
+        const card = parseStreamingDiffCard(JSON.parse(event.data));
+        if (!card) throw new Error("invalid card");
+        setState((current) => ({ ...current, cards: applyStreamingDiffUpdate(current.cards, { type: "card", card }) }));
+      } catch {
+        setState((current) => ({ ...current, error: "Received an invalid Streaming Diff card." }));
+      }
+    };
+    stream.onerror = () => setState((current) => ({ ...current, error: "The stream disconnected; reconnecting." }));
+    return () => {
+      stream.removeEventListener("reset", reset);
+      stream.close();
+    };
+  }, [selection?.repoKey, selection?.session, selection?.worktreeKey]);
+
+  return state;
+}
diff --git a/dashboard/src/lib/hrefs.ts b/dashboard/src/lib/hrefs.ts
index 02cbc36..ac76856 100644
--- a/dashboard/src/lib/hrefs.ts
+++ b/dashboard/src/lib/hrefs.ts
@@ -3,16 +3,26 @@ import type { Burnlist, Filter, SelectedBurnlist } from "./types";
 export function currentSection() {
   if (window.location.pathname === "/ovens/new") return "new-oven";
   if (window.location.pathname === "/ovens/differential-testing/view") return "differential-testing";
+  if (window.location.pathname === "/ovens/streaming-diff/view") return "streaming-diff";
   if (window.location.pathname === "/runs/new") return "run-burn";
   return "burnlists";
 }
 
 export function ovenRepoKey() {
-  return currentSection() === "differential-testing"
+  return ["differential-testing", "streaming-diff"].includes(currentSection())
     ? new URLSearchParams(window.location.search).get("repoKey")
     : null;
 }
 
+export function streamingDiffSelection() {
+  if (currentSection() !== "streaming-diff") return null;
+  const params = new URLSearchParams(window.location.search);
+  const repoKey = params.get("repoKey");
+  const worktreeKey = params.get("worktreeKey");
+  const session = params.get("session");
+  return repoKey && worktreeKey && session ? { repoKey, worktreeKey, session } : null;
+}
+
 export function selectedBurnlist(): SelectedBurnlist | null {
   if (currentSection() !== "burnlists") return null;
   const plan = new URLSearchParams(window.location.search).get("plan");
diff --git a/dashboard/src/lib/index.ts b/dashboard/src/lib/index.ts
index 94d9d5b..432a15a 100644
--- a/dashboard/src/lib/index.ts
+++ b/dashboard/src/lib/index.ts
@@ -1,5 +1,6 @@
 export { formatTime } from "./format";
-export { burnlistHref, currentSection, filterFromUrl, listHref, ovenRepoKey, selectedBurnlist } from "./hrefs";
-export type { Burnlist, ChecklistProgressData, ChecklistItem, CompletedItem, Filter, HistoryPoint, ProgressData, Project, SelectedBurnlist, Warning } from "./types";
+export { burnlistHref, currentSection, filterFromUrl, listHref, ovenRepoKey, selectedBurnlist, streamingDiffSelection } from "./hrefs";
+export { applyStreamingDiffUpdate, fileKindChip, groupStreamingDiffCard, isTextFileKind, mapStreamingDiffFeeds, mapStreamingDiffLandingFeeds, parseStreamingDiffCard, streamingDiffAutoOpenHref, streamingDiffFeedHref, streamingDiffFeedKey, streamingDiffRepositories } from "./streaming-diff.mjs";
+export type { Burnlist, ChecklistProgressData, ChecklistItem, CompletedItem, Filter, HistoryPoint, ProgressData, Project, SelectedBurnlist, StreamingDiffCard, StreamingDiffFeed, StreamingDiffFile, StreamingDiffFileKind, StreamingDiffIdentity, Warning } from "./types";
 export { cn, joinClasses } from "./utils";
 export type { ClassValue } from "./utils";
diff --git a/dashboard/src/lib/streaming-diff.mjs b/dashboard/src/lib/streaming-diff.mjs
new file mode 100644
index 0000000..0057492
--- /dev/null
+++ b/dashboard/src/lib/streaming-diff.mjs
@@ -0,0 +1,139 @@
+const textFileKinds = new Set(["modified", "added", "deleted"]);
+const withheldFileKinds = new Set(["denied", "redacted", "truncated", "unavailable"]);
+
+const metadataKindLabels = Object.freeze({
+  binary: "binary",
+  denied: "denied",
+  redacted: "redacted",
+  truncated: "truncated",
+  unavailable: "unavailable",
+});
+
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function string(value) {
+  return typeof value === "string" ? value : null;
+}
+
+function identity(value) {
+  if (!object(value)) return null;
+  const logicalRepoKey = string(value.logicalRepoKey);
+  const worktreeKey = string(value.worktreeKey);
+  const session = string(value.session);
+  return logicalRepoKey && worktreeKey && session ? { logicalRepoKey, worktreeKey, session } : null;
+}
+
+function parseFile(value) {
+  if (!object(value)) return null;
+  const path = string(value.path);
+  const kind = string(value.kind);
+  if (!path || !kind) return null;
+  const meta = object(value.meta) ? {
+    ...(Number.isSafeInteger(value.meta.bytes) && value.meta.bytes >= 0 ? { bytes: value.meta.bytes } : {}),
+    ...(string(value.meta.reason) ? { reason: value.meta.reason } : {}),
+    ...(value.meta.redacted === true ? { redacted: true } : {}),
+  } : undefined;
+  const withheld = meta?.redacted === true || withheldFileKinds.has(kind);
+  return {
+    path,
+    kind,
+    ...(!withheld && typeof value.diff === "string" ? { diff: value.diff } : {}),
+    ...(meta ? { meta } : {}),
+  };
+}
+
+export function streamingDiffFeedHref({ logicalRepoKey, worktreeKey, session }) {
+  const params = new URLSearchParams({ repoKey: logicalRepoKey, worktreeKey, session });
+  return `/ovens/streaming-diff/view?${params}`;
+}
+
+export function mapStreamingDiffFeeds(value) {
+  if (!object(value) || !Array.isArray(value.feeds)) return [];
+  return value.feeds.map((feed) => {
+    if (!object(feed)) return null;
+    const feedIdentity = identity(feed.identity);
+    if (!feedIdentity) return null;
+    const updatedAt = string(feed.updatedAt);
+    return { identity: feedIdentity, updatedAt, href: streamingDiffFeedHref(feedIdentity) };
+  }).filter(Boolean).sort((left, right) => (Date.parse(right.updatedAt ?? "") || 0) - (Date.parse(left.updatedAt ?? "") || 0));
+}
+
+export function streamingDiffRepositories(projects) {
+  const repositories = new Map();
+  for (const project of projects) {
+    if (typeof project?.repoKey === "string" && project.repoKey && !repositories.has(project.repoKey)) {
+      repositories.set(project.repoKey, { repoKey: project.repoKey, label: project.displayName || project.repoKey });
+    }
+  }
+  return [...repositories.values()];
+}
+
+export function mapStreamingDiffLandingFeeds(results) {
+  return results.flatMap(({ repository, payload }) => mapStreamingDiffFeeds(payload)
+    .filter((feed) => feed.identity.logicalRepoKey === repository.repoKey)
+    .map((feed) => ({ ...feed, repoLabel: repository.label })))
+    .sort((left, right) => (Date.parse(right.updatedAt ?? "") || 0) - (Date.parse(left.updatedAt ?? "") || 0));
+}
+
+export function streamingDiffFeedKey(feed) {
+  const { logicalRepoKey, worktreeKey, session } = feed.identity;
+  return `${logicalRepoKey}/${worktreeKey}/${session}`;
+}
+
+export function streamingDiffAutoOpenHref(feeds) {
+  return feeds.length === 1 ? feeds[0].href : null;
+}
+
+export function parseStreamingDiffCard(value) {
+  if (!object(value) || !Array.isArray(value.files)) return null;
+  const revId = string(value.revId);
+  const toolUseId = string(value.toolUseId);
+  const ts = string(value.ts);
+  const status = value.status === "captured" || value.status === "partial" ? value.status : null;
+  if (!revId || !toolUseId || !ts || !status) return null;
+  const files = value.files.map(parseFile).filter(Boolean);
+  if (files.length !== value.files.length) return null;
+  const withheld = files.some((file) => file.meta?.redacted === true || withheldFileKinds.has(file.kind));
+  const partialReason = string(value.partialReason);
+  return {
+    revId,
+    toolUseId,
+    ts,
+    status: status === "partial" || withheld ? "partial" : "captured",
+    ...(partialReason ? { partialReason } : withheld ? { partialReason: "One or more file diffs were withheld." } : {}),
+    files,
+  };
+}
+
+// Revisions are emitted in the manifest's ordered sequence. A pre-hook attempt
+// is superseded by its terminal card using the common tool use id; a reconnect
+// replay can still replace a card by its revision id without moving it.
+export function groupStreamingDiffCard(cards, card) {
+  const index = cards.findIndex((entry) => entry.toolUseId === card.toolUseId || entry.revId === card.revId);
+  if (index < 0) return [...cards, card];
+  const matches = (entry) => entry.toolUseId === card.toolUseId || entry.revId === card.revId;
+  const existingTerminal = cards.find((entry) => entry.toolUseId === card.toolUseId && !isAttemptCard(entry));
+  const replacement = isAttemptCard(card) && existingTerminal ? existingTerminal : card;
+  const next = cards.filter((entry) => !matches(entry));
+  return [...next.slice(0, index), replacement, ...next.slice(index)];
+}
+
+function isAttemptCard(card) {
+  return card.status === "partial" && card.files.length === 0 && card.partialReason?.startsWith("attempt in progress") === true;
+}
+
+export function applyStreamingDiffUpdate(cards, update) {
+  return update?.type === "reset" ? [] : update?.type === "card" && update.card
+    ? groupStreamingDiffCard(cards, update.card)
+    : cards;
+}
+
+export function fileKindChip(kind, meta) {
+  return meta?.redacted === true ? "redacted" : metadataKindLabels[kind] ?? null;
+}
+
+export function isTextFileKind(kind) {
+  return textFileKinds.has(kind);
+}
diff --git a/dashboard/src/lib/streaming-diff.test.mjs b/dashboard/src/lib/streaming-diff.test.mjs
new file mode 100644
index 0000000..2393fc4
--- /dev/null
+++ b/dashboard/src/lib/streaming-diff.test.mjs
@@ -0,0 +1,114 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { applyStreamingDiffUpdate, fileKindChip, groupStreamingDiffCard, mapStreamingDiffFeeds, mapStreamingDiffLandingFeeds, parseStreamingDiffCard, streamingDiffAutoOpenHref, streamingDiffFeedKey, streamingDiffRepositories } from "./streaming-diff.mjs";
+
+const first = { revId: "r-first", toolUseId: "tool-first", ts: "2026-07-15T10:00:00.000Z", status: "captured", files: [] };
+const second = { revId: "r-second", toolUseId: "tool-second", ts: "2026-07-15T10:01:00.000Z", status: "partial", partialReason: "bounded", files: [] };
+
+test("recent feed mapping sorts published activity and creates session deep links", () => {
+  const feeds = mapStreamingDiffFeeds({
+    feeds: [
+      { identity: { logicalRepoKey: "aaaaaaaaaaaa", worktreeKey: "111111111111", session: "older session" }, updatedAt: "2026-07-15T10:00:00.000Z" },
+      { identity: { logicalRepoKey: "aaaaaaaaaaaa", worktreeKey: "222222222222", session: "newer" }, updatedAt: "2026-07-15T10:01:00.000Z" },
+    ],
+  });
+
+  assert.deepEqual(feeds.map((feed) => feed.identity.session), ["newer", "older session"]);
+  assert.equal(feeds[1].href, "/ovens/streaming-diff/view?repoKey=aaaaaaaaaaaa&worktreeKey=111111111111&session=older+session");
+});
+
+test("landing derives repositories and aggregates their feeds by recent activity", () => {
+  const repositories = streamingDiffRepositories([
+    { repoKey: "aaaaaaaaaaaa", displayName: "alpha" },
+    { repoKey: "bbbbbbbbbbbb", displayName: "beta" },
+    { repoKey: "aaaaaaaaaaaa", displayName: "duplicate" },
+    { repoKey: null, displayName: "Ungrouped" },
+  ]);
+  const feeds = mapStreamingDiffLandingFeeds([
+    { repository: repositories[0], payload: { feeds: [{ identity: { logicalRepoKey: "aaaaaaaaaaaa", worktreeKey: "111111111111", session: "alpha-feed" }, updatedAt: "2026-07-15T10:00:00.000Z" }] } },
+    { repository: repositories[1], payload: { feeds: [{ identity: { logicalRepoKey: "bbbbbbbbbbbb", worktreeKey: "222222222222", session: "beta-feed" }, updatedAt: "2026-07-15T10:01:00.000Z" }] } },
+  ]);
+
+  assert.deepEqual(repositories, [{ repoKey: "aaaaaaaaaaaa", label: "alpha" }, { repoKey: "bbbbbbbbbbbb", label: "beta" }]);
+  assert.deepEqual(feeds.map((feed) => [feed.repoLabel, feed.identity.session]), [["beta", "beta-feed"], ["alpha", "alpha-feed"]]);
+  assert.equal(streamingDiffAutoOpenHref(feeds), null);
+  assert.equal(streamingDiffAutoOpenHref([feeds[0]]), feeds[0].href);
+});
+
+test("landing drops feeds whose repository identity does not match the request", () => {
+  const feeds = mapStreamingDiffLandingFeeds([{
+    repository: { repoKey: "aaaaaaaaaaaa", label: "alpha" },
+    payload: { feeds: [
+      { identity: { logicalRepoKey: "aaaaaaaaaaaa", worktreeKey: "111111111111", session: "matching" }, updatedAt: "2026-07-15T10:00:00.000Z" },
+      { identity: { logicalRepoKey: "bbbbbbbbbbbb", worktreeKey: "111111111111", session: "mismatched" }, updatedAt: "2026-07-15T10:01:00.000Z" },
+    ] },
+  }]);
+
+  assert.deepEqual(feeds.map((feed) => feed.identity.session), ["matching"]);
+});
+
+test("landing feed keys remain unique for matching worktrees and sessions in different repositories", () => {
+  const feeds = mapStreamingDiffLandingFeeds([
+    { repository: { repoKey: "aaaaaaaaaaaa", label: "alpha" }, payload: { feeds: [{ identity: { logicalRepoKey: "aaaaaaaaaaaa", worktreeKey: "same-worktree", session: "same-session" }, updatedAt: "2026-07-15T10:00:00.000Z" }] } },
+    { repository: { repoKey: "bbbbbbbbbbbb", label: "beta" }, payload: { feeds: [{ identity: { logicalRepoKey: "bbbbbbbbbbbb", worktreeKey: "same-worktree", session: "same-session" }, updatedAt: "2026-07-15T10:01:00.000Z" }] } },
+  ]);
+
+  assert.equal(new Set(feeds.map(streamingDiffFeedKey)).size, 2);
+});
+
+test("revision grouping replaces a repeated revision without changing manifest order", () => {
+  const replacement = { ...first, status: "partial", partialReason: "replayed" };
+  const cards = groupStreamingDiffCard(groupStreamingDiffCard([], first), second);
+  assert.deepEqual(groupStreamingDiffCard(cards, replacement), [replacement, second]);
+});
+
+test("terminal cards supersede attempts regardless of their arrival order", () => {
+  const attempt = { ...first, status: "partial", partialReason: "attempt in progress", files: [] };
+  const terminal = { ...first, revId: "r-terminal", status: "captured", files: [{ path: "done.txt", kind: "modified", diff: "" }] };
+  const cards = groupStreamingDiffCard(groupStreamingDiffCard([], attempt), second);
+
+  assert.deepEqual(groupStreamingDiffCard(cards, terminal), [terminal, second]);
+  assert.equal(groupStreamingDiffCard(cards, terminal).filter((card) => card.toolUseId === first.toolUseId).length, 1);
+  assert.deepEqual(groupStreamingDiffCard(groupStreamingDiffCard([], terminal), attempt), [terminal]);
+});
+
+test("redacted and withheld files force a partial card and never retain diff text", () => {
+  const card = parseStreamingDiffCard({
+    ...first,
+    files: [
+      { path: "secret.txt", kind: "modified", diff: "sensitive", meta: { redacted: true } },
+      { path: "denied.txt", kind: "denied", diff: "also sensitive" },
+    ],
+  });
+
+  assert.deepEqual(card, {
+    ...first,
+    status: "partial",
+    partialReason: "One or more file diffs were withheld.",
+    files: [
+      { path: "secret.txt", kind: "modified", meta: { redacted: true } },
+      { path: "denied.txt", kind: "denied" },
+    ],
+  });
+});
+
+test("binary metadata cards remain captured", () => {
+  const card = parseStreamingDiffCard({
+    ...first,
+    files: [{ path: "image.png", kind: "binary", meta: { bytes: 12 } }],
+  });
+
+  assert.deepEqual(card, { ...first, files: [{ path: "image.png", kind: "binary", meta: { bytes: 12 } }] });
+});
+
+test("a reset clears retained cards before the server replays them", () => {
+  assert.deepEqual(applyStreamingDiffUpdate([first, second], { type: "reset" }), []);
+  assert.deepEqual(applyStreamingDiffUpdate([], { type: "card", card: first }), [first]);
+});
+
+test("only metadata-only file kinds get compact chips", () => {
+  assert.equal(fileKindChip("modified"), null);
+  assert.equal(fileKindChip("binary"), "binary");
+  assert.equal(fileKindChip("redacted"), "redacted");
+  assert.equal(fileKindChip("unavailable"), "unavailable");
+});
diff --git a/dashboard/src/lib/types.ts b/dashboard/src/lib/types.ts
index b9902ee..ab4bcca 100644
--- a/dashboard/src/lib/types.ts
+++ b/dashboard/src/lib/types.ts
@@ -70,5 +70,11 @@ export type OvenSummary = {
 
 export type RepoSummary = { name: string; root: string; repoKey: string };
 
+export type StreamingDiffIdentity = { logicalRepoKey: string; worktreeKey: string; session: string };
+export type StreamingDiffFileKind = "modified" | "added" | "deleted" | "binary" | "denied" | "redacted" | "truncated" | "unavailable";
+export type StreamingDiffFile = { path: string; kind: StreamingDiffFileKind; diff?: string; meta?: { bytes?: number; reason?: string; redacted?: true } };
+export type StreamingDiffCard = { revId: string; toolUseId: string; ts: string; status: "captured" | "partial"; partialReason?: string; files: StreamingDiffFile[] };
+export type StreamingDiffFeed = { identity: StreamingDiffIdentity; updatedAt: string | null; href: string; repoLabel?: string };
+
 export type SelectedBurnlist = { repo?: string; repoKey?: string; id?: string; plan?: string };
 export type ProgressData = ChecklistProgressData;
diff --git a/ovens/streaming-diff/detail.json b/ovens/streaming-diff/detail.json
new file mode 100644
index 0000000..f9b2a2a
--- /dev/null
+++ b/ovens/streaming-diff/detail.json
@@ -0,0 +1,32 @@
+{
+  "version": 1,
+  "columns": 2,
+  "rows": 3,
+  "rowHeight": 56,
+  "cells": [
+    {
+      "id": "recent-feeds",
+      "title": "Recent feeds",
+      "description": "Recent session feeds by published activity time.",
+      "widget": "list",
+      "source": "/api/oven-data/streaming-diff?list&repoKey={repoKey}",
+      "format": "plain",
+      "column": 1,
+      "row": 1,
+      "columnSpan": 2,
+      "rowSpan": 1
+    },
+    {
+      "id": "stream-cards",
+      "title": "Stream cards",
+      "description": "A selected feed publishes immutable pre-to-post diff cards.",
+      "widget": "timeline",
+      "source": "/api/oven-data/streaming-diff",
+      "format": "plain",
+      "column": 1,
+      "row": 2,
+      "columnSpan": 2,
+      "rowSpan": 2
+    }
+  ]
+}
diff --git a/ovens/streaming-diff/e2e/synthetic-hook-events.test.mjs b/ovens/streaming-diff/e2e/synthetic-hook-events.test.mjs
new file mode 100644
index 0000000..1ff72c7
--- /dev/null
+++ b/ovens/streaming-diff/e2e/synthetic-hook-events.test.mjs
@@ -0,0 +1,151 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { createServer, get } from "node:http";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { withServer } from "../../../src/server/dashboard-routes-fixtures.mjs";
+import { captureStreamingDiff } from "../engine/streaming-diff-feed-capture.mjs";
+import { resolveStreamingDiffIdentity } from "../engine/streaming-diff-feed.mjs";
+import { streamingDiffHandler } from "../engine/streaming-diff-handler.mjs";
+
+function parseCards(text) {
+  return text.split("\n\n").filter(Boolean).map((block) => ({
+    id: block.match(/^id: (.+)$/mu)?.[1] ?? null,
+    type: block.match(/^event: (.+)$/mu)?.[1] ?? "message",
+    card: JSON.parse(block.match(/^data: (.+)$/mu)?.[1] ?? "null"),
+  })).filter((entry) => entry.id);
+}
+
+function assertStreamedRevisionOrder(cards) {
+  assert.deepEqual(
+    cards.map((entry) => entry.id.match(/:(r-.+)$/u)?.[1] ?? null),
+    cards.map((entry) => entry.card.revId),
+  );
+}
+
+class MockResponse extends EventEmitter {
+  constructor() { super(); this.headers = null; this.writes = []; }
+  writeHead(status, headers) { this.headers = { status, headers }; }
+  write(text) { this.writes.push(text); return true; }
+  end() { this.emit("finish"); }
+}
+
+function fixture() {
+  const root = mkdtempSync(join(tmpdir(), "burnlist-streaming-synthetic-"));
+  execFileSync("git", ["init", "--quiet"], { cwd: root, stdio: "ignore" });
+  mkdirSync(join(root, "notes", "burnlists", "inprogress"), { recursive: true });
+  writeFileSync(join(root, "note.txt"), "before\n");
+  return { root, cleanup: () => rmSync(root, { recursive: true, force: true }) };
+}
+
+function capturePair(root) {
+  captureStreamingDiff({ cwd: root, session: "synthetic", toolUseId: "tool-synthetic", phase: "pre", hintedPaths: ["note.txt"] });
+  writeFileSync(join(root, "note.txt"), "after\n");
+  captureStreamingDiff({ cwd: root, session: "synthetic", toolUseId: "tool-synthetic", phase: "post", hintedPaths: ["note.txt"] });
+  return resolveStreamingDiffIdentity({ cwd: root, session: "synthetic" });
+}
+
+async function canBindLoopback() {
+  const server = createServer();
+  try {
+    await new Promise((resolve, reject) => { server.once("error", reject); server.listen(0, "127.0.0.1", resolve); });
+    return true;
+  } catch (error) {
+    if (error?.code === "EPERM" || error?.code === "EACCES") return false;
+    throw error;
+  } finally {
+    await new Promise((resolve) => server.close(() => resolve()));
+  }
+}
+
+async function readCards(baseUrl, path, expected) {
+  return new Promise((resolve, reject) => {
+    const cards = [];
+    let buffer = "";
+    let settled = false;
+    const fail = (error) => { if (!settled) { settled = true; reject(error); } };
+    const request = get(new URL(path, baseUrl), { headers: { accept: "text/event-stream" } }, (response) => {
+      if (response.statusCode !== 200) {
+        response.resume();
+        fail(new Error(`SSE response status was ${response.statusCode}, expected 200`));
+        return;
+      }
+      response.setEncoding("utf8");
+      response.on("data", (chunk) => {
+        buffer += chunk;
+        for (;;) {
+          const boundary = buffer.indexOf("\n\n");
+          if (boundary < 0) return;
+          const block = buffer.slice(0, boundary);
+          buffer = buffer.slice(boundary + 2);
+          const id = block.match(/^id: (.+)$/mu)?.[1];
+          const data = block.match(/^data: (.+)$/mu)?.[1];
+          if (id && data) cards.push({ id, card: JSON.parse(data) });
+          if (cards.length === expected && !settled) {
+            settled = true;
+            response.destroy();
+            resolve(cards);
+            return;
+          }
+        }
+      });
+      response.once("error", fail);
+      response.once("end", () => fail(new Error("SSE stream ended before the expected cards arrived")));
+    });
+    request.once("error", fail);
+  });
+}
+
+test("socketless synthetic hook capture streams the exact card sequence", () => {
+  const { root, cleanup } = fixture();
+  try {
+    const identity = capturePair(root);
+    const res = new MockResponse();
+    const result = streamingDiffHandler.serveData({
+      binding: { repoRoot: identity.logicalRepoRoot }, bindingPath: identity.feedRoot,
+      req: { headers: { accept: "text/event-stream" } }, res,
+      url: new URL(`http://localhost/?repoKey=${identity.logicalRepoKey}&worktreeKey=${identity.worktreeKey}&session=synthetic`),
+      maxOvenDataBytes: 1024 * 1024,
+      timers: { setInterval: () => null, clearInterval: () => {} },
+    });
+    assert.equal(result, undefined);
+    assert.equal(res.headers.status, 200);
+    const cards = parseCards(res.writes.join(""));
+    assert.equal(cards.length, 2);
+    assertStreamedRevisionOrder(cards);
+    assert.deepEqual(cards.map((entry) => entry.card.status), ["partial", "captured"]);
+    assert.equal(cards[1].card.files[0].path, "note.txt");
+    assert.match(cards[1].card.files[0].diff, /-before\n\+after/u);
+    res.emit("close");
+  } finally { cleanup(); }
+});
+
+test("synthetic hook capture reaches the real HTTP SSE reader", { timeout: 20_000 }, async (t) => {
+  if (!await canBindLoopback()) return t.skip("requires loopback sockets (runs on host/CI)");
+  await withServer({
+    scanRoots: ["fixture-repo"],
+    setup: async ({ fixtureRoot }) => {
+      const repo = join(fixtureRoot, "fixture-repo");
+      mkdirSync(join(repo, "notes", "burnlists", "inprogress"), { recursive: true });
+      execFileSync("git", ["init", "--quiet"], { cwd: repo, stdio: "ignore" });
+      writeFileSync(join(repo, "note.txt"), "before\n");
+    },
+  }, async ({ baseUrl, repoRoot }) => {
+    const cli = join(process.cwd(), "bin", "burnlist.mjs");
+    const runCapture = (phase) => execFileSync(process.execPath, [cli, "streaming-diff", "capture", "--session", "synthetic", "--tool-use-id", "tool-synthetic", "--phase", phase, "--path", "note.txt"], { cwd: repoRoot, stdio: "pipe" });
+    runCapture("pre");
+    writeFileSync(join(repoRoot, "note.txt"), "after\n");
+    runCapture("post");
+    const identity = resolveStreamingDiffIdentity({ cwd: repoRoot, session: "synthetic" });
+    const query = `repoKey=${identity.logicalRepoKey}&worktreeKey=${identity.worktreeKey}&session=synthetic`;
+    const cards = await readCards(baseUrl, `/api/oven-data/streaming-diff?${query}`, 2);
+    assertStreamedRevisionOrder(cards);
+    assert.deepEqual(cards.map((entry) => entry.card.status), ["partial", "captured"]);
+    assert.equal(cards[1].card.files[0].path, "note.txt");
+    assert.match(cards[1].card.files[0].diff, /-before\n\+after/u);
+  });
+});
diff --git a/ovens/streaming-diff/engine/streaming-diff-capture-git.mjs b/ovens/streaming-diff/engine/streaming-diff-capture-git.mjs
new file mode 100644
index 0000000..6802710
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-capture-git.mjs
@@ -0,0 +1,133 @@
+import { spawnSync } from "node:child_process";
+import { closeSync, constants, fstatSync, lstatSync, openSync, readSync, realpathSync } from "node:fs";
+import { relative, resolve, sep } from "node:path";
+
+import { captureCard, captureLimits, STREAMING_DIFF_ABSENT, STREAMING_DIFF_CAPTURE_LIMITS, STREAMING_DIFF_MISSING } from "./streaming-diff-capture.mjs";
+
+export const STREAMING_DIFF_GIT_LIMITS = Object.freeze({ timeout: 2_000, maxBuffer: 8 * 1024 * 1024 });
+
+export function gitCaptureLimits(policy = {}) {
+  const result = {};
+  for (const [key, maximum] of Object.entries(STREAMING_DIFF_GIT_LIMITS)) {
+    const value = policy[key];
+    if (value === undefined) result[key] = maximum;
+    else {
+      if (!Number.isSafeInteger(value)) throw new Error(`git ${key} must be a finite integer`);
+      result[key] = Math.max(1, Math.min(maximum, value));
+    }
+  }
+  return result;
+}
+
+function within(root, target) {
+  const path = relative(root, target);
+  return path === "" || (path !== ".." && !path.startsWith(`..${sep}`));
+}
+
+function git(worktreeRoot, args, limits) {
+  const result = spawnSync("git", args, { cwd: worktreeRoot, encoding: "buffer", shell: false, ...limits });
+  if (result.error || result.status !== 0) throw result.error ?? new Error(result.stderr.toString("utf8").trim() || `git ${args[0]} failed`);
+  return result.stdout;
+}
+
+export function readContainedFile(root, file, maxFileBytes, {
+  close = closeSync,
+  fstat = fstatSync,
+  lstat = lstatSync,
+  open = openSync,
+  read = readSync,
+  realpath = realpathSync,
+} = {}) {
+  let fd;
+  try {
+    const initial = lstat(file);
+    if (!initial.isFile() || initial.isSymbolicLink() || !within(root, realpath(file))) return STREAMING_DIFF_ABSENT;
+    fd = open(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    const opened = fstat(fd);
+    if (!opened.isFile() || opened.dev !== initial.dev || opened.ino !== initial.ino || !within(root, realpath(file))) return STREAMING_DIFF_ABSENT;
+    const buffer = Buffer.allocUnsafe(maxFileBytes + 1);
+    let bytes = 0;
+    while (bytes < buffer.length) {
+      const readNow = read(fd, buffer, bytes, buffer.length - bytes, null);
+      if (readNow === 0) break;
+      bytes += readNow;
+    }
+    const finished = fstat(fd);
+    if (finished.dev !== opened.dev || finished.ino !== opened.ino || finished.size !== opened.size || finished.mtimeMs !== opened.mtimeMs) return STREAMING_DIFF_MISSING;
+    if (bytes > maxFileBytes) return { truncated: true, bytes: finished.size };
+    return buffer.subarray(0, bytes);
+  } catch (error) {
+    if (["ENOENT", "ELOOP", "ENOTDIR"].includes(error?.code)) return STREAMING_DIFF_ABSENT;
+    throw error;
+  } finally {
+    if (fd !== undefined) close(fd);
+  }
+}
+
+// captureCard creates its own bounded pre-to-post unified diff. It never calls
+// `git diff`, so Git external diff drivers and text conversions cannot run.
+export function createGitCaptureIo(worktreeRoot, limits = {}) {
+  const root = realpathSync(worktreeRoot);
+  const bounded = gitCaptureLimits(limits);
+  const maxFileBytes = captureLimits(limits).maxFileBytes;
+  const target = (path) => resolve(root, path);
+  return {
+    inspect(path) {
+      const file = target(path);
+      if (!within(root, file)) return { contained: false };
+      try {
+        const stat = lstatSync(file);
+        if (!stat.isFile()) return { type: stat.isSymbolicLink() ? "symlink" : "other", contained: false };
+        return { type: "file", contained: within(root, realpathSync(file)) };
+      } catch (error) {
+        if (error?.code === "ENOENT") return { type: "file", contained: true };
+        throw error;
+      }
+    },
+    readPost(path) {
+      const file = target(path);
+      if (!within(root, file)) return STREAMING_DIFF_ABSENT;
+      return readContainedFile(root, file, maxFileBytes);
+    },
+    isIgnored(path) {
+      const result = spawnSync("git", ["check-ignore", "--quiet", "--", path], { cwd: root, shell: false, ...bounded });
+      if (result.error) throw result.error;
+      if (result.status === 0) return true;
+      if (result.status === 1) return false;
+      throw new Error(result.stderr?.toString("utf8").trim() || `git check-ignore failed (${result.status ?? result.signal ?? "unknown"})`);
+    },
+    listUntracked(paths) {
+      if (paths.length === 0) return [];
+      return git(root, ["ls-files", "--others", "--exclude-standard", "-z", "--", ...paths], bounded)
+        .toString("utf8").split("\0").filter(Boolean);
+    },
+    listTracked(paths) {
+      if (paths.length === 0) return [];
+      return git(root, ["ls-files", "-z", "--", ...paths], bounded)
+        .toString("utf8").split("\0").filter(Boolean);
+    },
+    isTracked(path) {
+      return this.listTracked([path]).includes(path);
+    },
+  };
+}
+
+// The caller persists this exact map at pre-hook time. Entries that could not be
+// read are MISSING, while an observed non-existent file is explicitly ABSENT.
+export function snapshotGitPaths({ worktreeRoot, hintedPaths = [], policy = {} }) {
+  const io = createGitCaptureIo(worktreeRoot, policy);
+  const snapshot = new Map();
+  for (const path of hintedPaths) {
+    try {
+      snapshot.set(path, io.readPost(path));
+    } catch {
+      snapshot.set(path, STREAMING_DIFF_MISSING);
+    }
+  }
+  return snapshot;
+}
+
+export function captureGitCard({ worktreeRoot, policy, ...options }) {
+  const io = createGitCaptureIo(worktreeRoot, policy);
+  return captureCard({ ...options, policy, ...io });
+}
diff --git a/ovens/streaming-diff/engine/streaming-diff-capture-git.test.mjs b/ovens/streaming-diff/engine/streaming-diff-capture-git.test.mjs
new file mode 100644
index 0000000..72c2483
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-capture-git.test.mjs
@@ -0,0 +1,129 @@
+import assert from "node:assert/strict";
+import { fstatSync, mkdtempSync, readSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import test from "node:test";
+
+import { captureCard, STREAMING_DIFF_ABSENT, STREAMING_DIFF_MISSING } from "./streaming-diff-capture.mjs";
+import { createGitCaptureIo, readContainedFile, snapshotGitPaths } from "./streaming-diff-capture-git.mjs";
+
+function git(root, args) {
+  const result = spawnSync("git", args, { cwd: root, encoding: "utf8", shell: false });
+  assert.equal(result.status, 0, result.stderr);
+}
+
+function fixture() {
+  const root = mkdtempSync(join(tmpdir(), "burnlist-streaming-diff-"));
+  git(root, ["init", "--quiet"]);
+  git(root, ["config", "user.email", "test@example.invalid"]);
+  git(root, ["config", "user.name", "Test"]);
+  return { root, cleanup: () => rmSync(root, { recursive: true, force: true }) };
+}
+
+test("git captures tracked ignored paths but denies ignored untracked paths", () => {
+  const context = fixture();
+  try {
+    writeFileSync(join(context.root, ".gitignore"), "ignored.txt\n");
+    writeFileSync(join(context.root, "ignored.txt"), "tracked ignored\n");
+    writeFileSync(join(context.root, "untracked-ignored.txt"), "inside\n");
+    writeFileSync(join(context.root, ".gitignore"), "ignored.txt\nuntracked-ignored.txt\n");
+    writeFileSync(join(context.root, "outside.txt"), "outside\n");
+    git(context.root, ["add", ".gitignore"]);
+    git(context.root, ["add", "-f", "ignored.txt"]);
+    git(context.root, ["commit", "--quiet", "-m", "fixture"]);
+    const io = createGitCaptureIo(context.root);
+    assert.equal(io.isTracked("ignored.txt"), true);
+    assert.equal(io.isIgnored("ignored.txt"), false, "Git does not ignore a tracked path for capture");
+    assert.equal(io.isTracked("untracked-ignored.txt"), false);
+    assert.equal(io.isIgnored("untracked-ignored.txt"), true);
+    assert.deepEqual(io.listUntracked(["untracked-ignored.txt"]), []);
+    const notGit = mkdtempSync(join(tmpdir(), "not-a-git-"));
+    try {
+      assert.throws(() => createGitCaptureIo(notGit).isIgnored("x"), /not a git repository/u);
+    } finally {
+      rmSync(notGit, { recursive: true, force: true });
+    }
+  } finally {
+    context.cleanup();
+  }
+});
+
+test("descriptor reader rejects a symlink swap and reports oversized files without returning content", () => {
+  const context = fixture();
+  const outside = mkdtempSync(join(tmpdir(), "burnlist-streaming-diff-outside-"));
+  try {
+    writeFileSync(join(context.root, "post.txt"), "inside content");
+    writeFileSync(join(outside, "secret.txt"), "outside content");
+    const io = createGitCaptureIo(context.root, { maxFileBytes: 16 });
+    assert.equal(io.inspect("post.txt").contained, true);
+    rmSync(join(context.root, "post.txt"));
+    symlinkSync(join(outside, "secret.txt"), join(context.root, "post.txt"));
+    assert.equal(io.readPost("post.txt"), STREAMING_DIFF_ABSENT);
+    rmSync(join(context.root, "post.txt"));
+    writeFileSync(join(context.root, "large.txt"), "x".repeat(128));
+    assert.deepEqual(io.readPost("large.txt"), { truncated: true, bytes: 128 });
+  } finally {
+    context.cleanup();
+    rmSync(outside, { recursive: true, force: true });
+  }
+});
+
+test("descriptor reader bounds reads and rejects a file that grows after fstat", () => {
+  const context = fixture();
+  try {
+    const large = join(context.root, "large.txt");
+    writeFileSync(large, "x".repeat(1_024));
+    const requested = [];
+    const truncated = readContainedFile(realpathSync(context.root), large, 16, {
+      read(fd, buffer, offset, length, position) {
+        requested.push(length);
+        return readSync(fd, buffer, offset, length, position);
+      },
+    });
+    assert.deepEqual(truncated, { truncated: true, bytes: 1_024 });
+    assert.deepEqual(requested, [17]);
+
+    const growing = join(context.root, "growing.txt");
+    writeFileSync(growing, "before\n");
+    let fstats = 0;
+    const result = readContainedFile(realpathSync(context.root), growing, 64, {
+      fstat(fd) {
+        const stat = fstatSync(fd);
+        if (++fstats === 1) writeFileSync(growing, "before\nafter growth\n");
+        return stat;
+      },
+    });
+    assert.equal(result, STREAMING_DIFF_MISSING);
+    const card = captureCard({
+      hintedPaths: ["growing.txt"],
+      preSnapshot: new Map([["growing.txt", "before\n"]]),
+      readPost: () => result,
+      toolUseId: "tool-fixture",
+      revId: "r-0123456789abcdef01234567",
+      now: () => "2026-07-15T09:00:00.000Z",
+    });
+    assert.deepEqual(card, {
+      revId: "r-0123456789abcdef01234567",
+      toolUseId: "tool-fixture",
+      ts: "2026-07-15T09:00:00.000Z",
+      status: "partial",
+      partialReason: "post-capture unavailable; content withheld/incomplete",
+      files: [{ path: "growing.txt", kind: "unavailable", meta: { reason: "post-capture unavailable" } }],
+    });
+  } finally {
+    context.cleanup();
+  }
+});
+
+test("pre-snapshot builder distinguishes observed absence from a failed snapshot", () => {
+  const context = fixture();
+  try {
+    writeFileSync(join(context.root, "present.txt"), "present\n");
+    const snapshot = snapshotGitPaths({ worktreeRoot: context.root, hintedPaths: ["gone.txt", "present.txt"] });
+    assert.equal(snapshot.get("gone.txt"), STREAMING_DIFF_ABSENT);
+    assert.equal(Buffer.from(snapshot.get("present.txt")).toString("utf8"), "present\n");
+  } finally {
+    context.cleanup();
+  }
+});
diff --git a/ovens/streaming-diff/engine/streaming-diff-capture.mjs b/ovens/streaming-diff/engine/streaming-diff-capture.mjs
new file mode 100644
index 0000000..be04dc7
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-capture.mjs
@@ -0,0 +1,271 @@
+import { randomBytes } from "node:crypto";
+
+import { assertCard } from "./streaming-diff-data-contract.mjs";
+import { unifiedLineDiff } from "./streaming-diff-linediff.mjs";
+
+export const STREAMING_DIFF_ABSENT = Symbol("streaming-diff-absent");
+// Missing means the pre-hook did not obtain a snapshot; it is deliberately not
+// interchangeable with an observed absent file.
+export const STREAMING_DIFF_MISSING = Symbol("streaming-diff-missing");
+export const STREAMING_DIFF_CAPTURE_LIMITS = Object.freeze({
+  maxPaths: 64,
+  maxPathLength: 512,
+  maxFileBytes: 256 * 1024,
+  maxHunkBytes: 96 * 1024,
+  maxCardBytes: 512 * 1024,
+});
+const incompleteFileKinds = new Set(["denied", "redacted", "truncated", "unavailable"]);
+const terminalReasons = new Set(["tool failed", "path hints truncated", "hook adapter mapping was incomplete", "hook payload exceeded byte limit", "hook payload read timed out"]);
+
+export function captureLimits(policy = {}) {
+  const limits = {};
+  for (const [key, maximum] of Object.entries(STREAMING_DIFF_CAPTURE_LIMITS)) {
+    const value = policy[key];
+    if (value === undefined) limits[key] = maximum;
+    else {
+      if (!Number.isSafeInteger(value)) throw new Error(`capture ${key} must be a finite integer`);
+      limits[key] = Math.max(1, Math.min(maximum, value));
+    }
+  }
+  return limits;
+}
+
+function pathIsSafe(path, maxPathLength) {
+  return typeof path === "string" && path.length > 0 && path.length <= maxPathLength
+    && !path.startsWith("/") && !path.includes("\\")
+    && !path.split("/").some((part) => !part || part === "." || part === "..");
+}
+
+function hardDenied(path) {
+  return path.split("/").some((part) => {
+    const name = part.toLowerCase();
+    return name === ".git" || name.startsWith(".env")
+      || /(?:^|[._-])(?:key|keys|cert|certificate|credential|credentials|secret|secrets|password|token)(?:[._-]|$)/u.test(name)
+      || /^(?:id_rsa|id_dsa|id_ecdsa|id_ed25519)$/u.test(name)
+      || /\.(?:pem|p12|pfx|key|crt)$/u.test(name);
+  });
+}
+
+function contentOf(value) {
+  if (value === STREAMING_DIFF_MISSING) return { missing: true };
+  if (value === null || value === undefined || value === STREAMING_DIFF_ABSENT) return { absent: true };
+  if (typeof value === "string" || Buffer.isBuffer(value)) return { content: value };
+  if (typeof value === "object" && value !== null) {
+    if (value.truncated === true) return { truncated: true, bytes: value.bytes };
+    if (value.binary === true && Number.isSafeInteger(value.bytes) && value.bytes >= 0) return { binary: true, bytes: value.bytes };
+    if (value.content === STREAMING_DIFF_ABSENT) return { absent: true };
+    if (typeof value.content === "string" || Buffer.isBuffer(value.content)) return value;
+  }
+  throw new Error("content reader returned an unsupported value");
+}
+
+function bytesOf(value) {
+  return Buffer.isBuffer(value) ? value.length : Buffer.byteLength(value, "utf8");
+}
+
+export function isBinaryContent(value) {
+  if (!Buffer.isBuffer(value)) return false;
+  if (value.includes(0)) return true;
+  try {
+    new TextDecoder("utf-8", { fatal: true }).decode(value);
+    return false;
+  } catch {
+    return true;
+  }
+}
+
+export function redact(value) {
+  const text = String(value);
+  if (/-----BEGIN\s+(?:[A-Z ]+\s+)?PRIVATE\s+KEY-----/u.test(text)) return { marker: "private-key content", redacted: true };
+  let redacted = false;
+  // Redact the whole value portion to end-of-line. Never try to preserve quoted
+  // structure — a value-shaped sub-match leaves fragments (e.g. an escaped quote)
+  // exposed. Over-redaction of a trailing benign token is an accepted trade-off.
+  let result = text.replace(/\b((?:proxy-)?authorization)\b(\s*[:=]\s*)((?:bearer|token)\s+)?[^\n]*/giu, (match, header, separator, scheme) => {
+    redacted = true;
+    return `${header}${separator}${scheme ?? ""}[REDACTED]`;
+  });
+  result = result.replace(/\b(api[_-]?key|key|secret|token|password|passwd)\b(\s*[:=]\s*)[^\n]*/giu, (match, keyword, separator) => {
+    redacted = true;
+    return `${keyword}${separator}[REDACTED]`;
+  });
+  result = result.replace(/\bBearer\s+[^\n]*/giu, () => {
+    redacted = true;
+    return "Bearer [REDACTED]";
+  });
+  result = result.replace(/[A-Za-z0-9+/_=-]{32,}/gu, (candidate) => {
+    const classes = new Set(candidate.replaceAll(/[^A-Za-z0-9]/gu, "").split("")).size;
+    if (classes < 12) return candidate;
+    redacted = true;
+    return "[REDACTED]";
+  });
+  return { text: result, redacted };
+}
+
+function partialReason(reasons) {
+  return [...new Set(reasons)].join("; ").slice(0, 500) || "capture was incomplete";
+}
+
+function snapshotValue(snapshot, path) {
+  if (snapshot instanceof Map) return snapshot.has(path) ? snapshot.get(path) : STREAMING_DIFF_MISSING;
+  return Object.hasOwn(snapshot ?? {}, path) ? snapshot[path] : STREAMING_DIFF_MISSING;
+}
+
+function revisionId() {
+  return `r-${randomBytes(12).toString("hex")}`;
+}
+
+function metadata(path, kind, reason, bytes) {
+  return { path, kind, meta: { ...(bytes === undefined ? {} : { bytes }), ...(reason === undefined ? {} : { reason }) } };
+}
+
+// This synchronous core deliberately has no filesystem writes. IO is injected as
+// inspect(path), readPost(path), listTracked(paths), isIgnored(path), and
+// listUntracked(hintedPaths). Ignore rules apply only after tracked status.
+export function captureCard({
+  hintedPaths,
+  preSnapshot = new Map(),
+  readPost,
+  listTracked = () => [],
+  listUntracked = () => [],
+  inspect = () => ({ type: "file", contained: true }),
+  isIgnored = () => false,
+  policy = {},
+  toolUseId,
+  now = () => new Date().toISOString(),
+  revId = revisionId(),
+  opaqueReason = null,
+} = {}) {
+  const limits = captureLimits(policy);
+  const reasons = [];
+  const files = [];
+  if (typeof readPost !== "function") throw new Error("capture requires a post-content reader");
+  if (typeof toolUseId !== "string" || !toolUseId.trim()) throw new Error("capture requires a toolUseId");
+  if (!Array.isArray(hintedPaths) || hintedPaths.length === 0) reasons.push("missing path hints");
+  const safeHints = [...new Set(Array.isArray(hintedPaths) ? hintedPaths : [])];
+  if (safeHints.length > limits.maxPaths) reasons.push("path hint limit exceeded");
+  const eligible = [];
+  for (const path of safeHints.slice(0, limits.maxPaths)) {
+    if (!pathIsSafe(path, limits.maxPathLength)) {
+      reasons.push("unsafe path hint");
+      continue;
+    }
+    if (hardDenied(path)) {
+      files.push({ path, kind: "denied" });
+      continue;
+    }
+    let info;
+    try {
+      info = inspect(path) ?? {};
+    } catch {
+      reasons.push(`could not inspect ${path}`);
+      continue;
+    }
+    if (info.type && info.type !== "file") {
+      files.push(metadata(path, "denied", "not a regular contained file"));
+    } else if (info.contained === false || info.symlinkEscape === true) {
+      files.push(metadata(path, "denied", "path escapes the worktree"));
+    } else {
+      eligible.push(path);
+    }
+  }
+  const readable = [];
+  let tracked = new Set();
+  try {
+    tracked = new Set([...new Set(listTracked(eligible))].filter((path) => eligible.includes(path)));
+  } catch {
+    reasons.push("tracked eligibility was unavailable");
+  }
+  for (const path of eligible) {
+    try {
+      if (tracked.has(path)) readable.push(path);
+      else if (isIgnored(path)) files.push({ path, kind: "denied" });
+      else readable.push(path);
+    } catch {
+      reasons.push(`could not determine whether ${path} is ignored`);
+    }
+  }
+  let untracked = new Set();
+  try {
+    const allowed = new Set(readable);
+    untracked = new Set([...new Set(listUntracked(readable))].filter((path) => allowed.has(path)));
+  } catch {
+    reasons.push("untracked eligibility was unavailable");
+  }
+  for (const path of readable) {
+    let before;
+    let after;
+    try {
+      before = contentOf(snapshotValue(preSnapshot, path));
+      after = contentOf(readPost(path));
+    } catch {
+      reasons.push(`could not read ${path}`);
+      continue;
+    }
+    if (before.missing) {
+      files.push(metadata(path, "unavailable", "snapshot unavailable"));
+      reasons.push("snapshot unavailable");
+      continue;
+    }
+    if (after.missing) {
+      files.push(metadata(path, "unavailable", "post-capture unavailable"));
+      reasons.push("post-capture unavailable");
+      continue;
+    }
+    if (before.absent && after.absent) continue;
+    if (before.absent && !tracked.has(path) && !untracked.has(path)) {
+      reasons.push(`new path ${path} was not eligible untracked content`);
+      continue;
+    }
+    const known = [before, after].filter((entry) => !entry.absent && !entry.truncated && !entry.binary);
+    const largest = Math.max(0, ...known.map((entry) => bytesOf(entry.content)), before.bytes ?? 0, after.bytes ?? 0);
+    if (before.truncated || after.truncated || largest > limits.maxFileBytes) {
+      files.push(metadata(path, "truncated", "file byte limit exceeded", largest));
+      reasons.push("file byte limit exceeded");
+      continue;
+    }
+    if (before.binary || after.binary || known.some((entry) => isBinaryContent(entry.content))) {
+      files.push(metadata(path, "binary", undefined, largest));
+      continue;
+    }
+    const rawBefore = before.absent ? "" : String(before.content);
+    const rawAfter = after.absent ? "" : String(after.content);
+    if (rawBefore === rawAfter) continue;
+    const safeBefore = before.absent ? { text: "", redacted: false } : redact(before.content);
+    const safeAfter = after.absent ? { text: "", redacted: false } : redact(after.content);
+    if (safeBefore.marker || safeAfter.marker || (rawBefore !== rawAfter && (safeBefore.redacted || safeAfter.redacted))) {
+      files.push({ path, kind: "redacted", meta: { redacted: true, reason: safeBefore.marker ?? safeAfter.marker ?? "secret-looking value" } });
+      continue;
+    }
+    if (safeBefore.text === safeAfter.text) continue;
+    let diff;
+    try {
+      diff = unifiedLineDiff(path, safeBefore.text, safeAfter.text);
+    } catch (error) {
+      if (error instanceof RangeError) {
+        files.push(metadata(path, "truncated", "line diff limit exceeded", largest));
+        reasons.push("line diff limit exceeded");
+        continue;
+      }
+      throw error;
+    }
+    const diffBytes = Buffer.byteLength(diff, "utf8");
+    if (diffBytes > limits.maxHunkBytes) {
+      files.push(metadata(path, "truncated", "hunk byte limit exceeded", diffBytes));
+      reasons.push("hunk byte limit exceeded");
+      continue;
+    }
+    files.push({ path, kind: before.absent ? "added" : after.absent ? "deleted" : "modified", diff });
+  }
+  for (const reason of typeof opaqueReason === "string" ? opaqueReason.split("; ") : []) {
+    if (terminalReasons.has(reason)) reasons.push(reason);
+  }
+  if (files.some((file) => incompleteFileKinds.has(file.kind))) reasons.push("content withheld/incomplete");
+  const card = { revId, toolUseId, ts: now(), status: reasons.length ? "partial" : "captured", ...(reasons.length ? { partialReason: partialReason(reasons) } : {}), files };
+  if (Buffer.byteLength(JSON.stringify(card), "utf8") > limits.maxCardBytes) {
+    card.status = "partial";
+    card.partialReason = "card byte limit exceeded";
+    card.files = files.map((file) => metadata(file.path, "truncated", "card byte limit exceeded"));
+  }
+  return assertCard(card);
+}
diff --git a/ovens/streaming-diff/engine/streaming-diff-capture.test.mjs b/ovens/streaming-diff/engine/streaming-diff-capture.test.mjs
new file mode 100644
index 0000000..076484d
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-capture.test.mjs
@@ -0,0 +1,238 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import test from "node:test";
+
+import { appendCard } from "./streaming-diff-journal.mjs";
+import { captureCard, captureLimits, redact, STREAMING_DIFF_ABSENT, STREAMING_DIFF_CAPTURE_LIMITS, STREAMING_DIFF_MISSING } from "./streaming-diff-capture.mjs";
+import { captureGitCard, createGitCaptureIo, gitCaptureLimits, STREAMING_DIFF_GIT_LIMITS } from "./streaming-diff-capture-git.mjs";
+
+const identity = { logicalRepoKey: "logical", worktreeKey: "worktree", session: "session" };
+const fixed = { toolUseId: "tool-fixture", revId: "r-0123456789abcdef01234567", now: () => "2026-07-15T09:00:00.000Z" };
+
+function git(root, args) {
+  const result = spawnSync("git", args, { cwd: root, encoding: "utf8", shell: false });
+  assert.equal(result.status, 0, result.stderr);
+}
+
+function repository() {
+  const root = mkdtempSync(join(tmpdir(), "burnlist-streaming-capture-"));
+  git(root, ["init", "--quiet"]);
+  git(root, ["config", "user.email", "test@example.invalid"]);
+  git(root, ["config", "user.name", "Test"]);
+  return { root, cleanup: () => rmSync(root, { recursive: true, force: true }) };
+}
+
+function capture(options = {}) {
+  return captureCard({
+    hintedPaths: ["foo.ts"],
+    preSnapshot: new Map([["foo.ts", "export const foo = 1;\n"]]),
+    readPost: () => "export const foo = 2;\n",
+    ...fixed,
+    ...options,
+  });
+}
+
+test("the actual git capture path diffs a pre-existing dirty hinted-file snapshot", () => {
+  const context = repository();
+  try {
+    writeFileSync(join(context.root, "foo.ts"), "export const foo = 1;\n");
+    git(context.root, ["add", "foo.ts"]);
+    git(context.root, ["commit", "--quiet", "-m", "baseline"]);
+    writeFileSync(join(context.root, "foo.ts"), "export const foo = 1; // predate\n");
+    const preSnapshot = new Map([["foo.ts", readFileSync(join(context.root, "foo.ts"))]]);
+    writeFileSync(join(context.root, "foo.ts"), "export const foo = 2; // predate\n");
+    const card = captureGitCard({ worktreeRoot: context.root, hintedPaths: ["foo.ts"], preSnapshot, ...fixed });
+    assert.deepEqual(card, {
+      revId: fixed.revId,
+      toolUseId: fixed.toolUseId,
+      ts: fixed.now(),
+      status: "captured",
+      files: [{ path: "foo.ts", kind: "modified", diff: "--- a/foo.ts\n+++ b/foo.ts\n@@ -1 +1 @@\n-export const foo = 1; // predate\n+export const foo = 2; // predate" }],
+    });
+    assert.equal(card.files[0].diff.includes("-export const foo = 1;\n"), false);
+  } finally {
+    context.cleanup();
+  }
+});
+
+test("only explicit absence may produce an addition; an omitted pre-snapshot is unavailable", () => {
+  const missing = capture({ hintedPaths: ["created.txt"], preSnapshot: new Map(), readPost: () => "existing untracked\n", listUntracked: () => ["created.txt"] });
+  assert.equal(missing.status, "partial");
+  assert.deepEqual(missing.files, [{ path: "created.txt", kind: "unavailable", meta: { reason: "snapshot unavailable" } }]);
+  const created = capture({ hintedPaths: ["created.txt"], preSnapshot: new Map([["created.txt", STREAMING_DIFF_ABSENT]]), readPost: () => "created now\n", listUntracked: () => ["created.txt"] });
+  const deleted = capture({ hintedPaths: ["gone.txt"], preSnapshot: new Map([["gone.txt", "gone\n"]]), readPost: () => STREAMING_DIFF_ABSENT });
+  assert.equal(created.files[0].kind, "added");
+  assert.equal(deleted.files[0].kind, "deleted");
+  assert.equal(STREAMING_DIFF_MISSING === STREAMING_DIFF_ABSENT, false);
+});
+
+test("one small edit has an exact bounded minimal unified hunk", () => {
+  const before = Array.from({ length: 50 }, (_, index) => `line ${index + 1}`);
+  const after = [...before];
+  after[20] = "changed line 21";
+  const card = capture({ preSnapshot: new Map([["foo.ts", `${before.join("\n")}\n`]]), readPost: () => `${after.join("\n")}\n` });
+  assert.equal(card.files[0].diff, "--- a/foo.ts\n+++ b/foo.ts\n@@ -18,7 +18,7 @@\n line 18\n line 19\n line 20\n-line 21\n+changed line 21\n line 22\n line 23\n line 24");
+});
+
+test("deny/redaction happens before every journal write and cannot disclose protected bytes", () => {
+  const feed = mkdtempSync(join(tmpdir(), "burnlist-streaming-feed-"));
+  const worktree = mkdtempSync(join(tmpdir(), "burnlist-streaming-worktree-"));
+  const outside = mkdtempSync(join(tmpdir(), "burnlist-streaming-outside-"));
+  try {
+    const keyMarker = ["-----BEGIN", " PRIVATE", " KEY-----"].join("");
+    const raw = { ".env": "env-value", "document.txt": `${keyMarker}\nmaterial`, "values.txt": "password = hunter2\napi_key: short-value\nAuthorization: Bearer bearer-value\ntoken=token-value\n" };
+    const reads = [];
+    const card = capture({
+      hintedPaths: Object.keys(raw),
+      preSnapshot: new Map([[".env", raw[".env"]], ["document.txt", "old\n"], ["values.txt", "old\n"]]),
+      readPost(path) { reads.push(path); return raw[path]; },
+    });
+    appendCard(feed, card, { identity });
+    for (const forbidden of [raw[".env"], "hunter2", "short-value", "bearer-value", "token-value", "material"]) {
+      assert.equal(JSON.stringify(card).includes(forbidden), false);
+    }
+    assert.equal(reads.includes(".env"), false);
+    assert.equal(card.files.find((file) => file.path === "document.txt").kind, "redacted");
+
+    writeFileSync(join(worktree, "swap.txt"), "inside\n");
+    writeFileSync(join(outside, "secret.txt"), "outside bytes");
+    const io = createGitCaptureIo(worktree);
+    const swapped = captureCard({
+      hintedPaths: ["swap.txt"],
+      preSnapshot: new Map([["swap.txt", "inside\n"]]),
+      inspect(path) {
+        const inspected = io.inspect(path);
+        rmSync(join(worktree, "swap.txt"));
+        symlinkSync(join(outside, "secret.txt"), join(worktree, "swap.txt"));
+        return inspected;
+      },
+      readPost: io.readPost,
+      ...fixed,
+      revId: "r-0123456789abcdef01234568",
+    });
+    appendCard(feed, swapped, { identity });
+    assert.equal(JSON.stringify(swapped).includes("outside bytes"), false);
+
+    const context = repository();
+    try {
+      writeFileSync(join(context.root, ".gitignore"), "ignored.txt\n");
+      writeFileSync(join(context.root, "ignored.txt"), "do not publish\n");
+      git(context.root, ["add", ".gitignore"]);
+      git(context.root, ["add", "-f", "ignored.txt"]);
+      git(context.root, ["commit", "--quiet", "-m", "tracked ignored fixture"]);
+      writeFileSync(join(context.root, "ignored.txt"), "tracked change\n");
+      const ignored = captureGitCard({
+        worktreeRoot: context.root,
+        hintedPaths: ["ignored.txt"],
+        preSnapshot: new Map([["ignored.txt", "do not publish\n"]]),
+        ...fixed,
+        revId: "r-0123456789abcdef01234569",
+      });
+      assert.equal(ignored.files[0].path, "ignored.txt");
+      assert.equal(ignored.files[0].kind, "modified");
+      appendCard(feed, ignored, { identity });
+
+      writeFileSync(join(context.root, "untracked-ignored.txt"), "ignored\n");
+      writeFileSync(join(context.root, ".gitignore"), "ignored.txt\nuntracked-ignored.txt\n");
+      const untrackedIgnored = captureGitCard({
+        worktreeRoot: context.root,
+        hintedPaths: ["untracked-ignored.txt"],
+        preSnapshot: new Map([["untracked-ignored.txt", STREAMING_DIFF_ABSENT]]),
+        ...fixed,
+        revId: "r-0123456789abcdef01234570",
+      });
+      assert.deepEqual(untrackedIgnored.files, [{ path: "untracked-ignored.txt", kind: "denied" }]);
+    } finally {
+      context.cleanup();
+    }
+
+    const persisted = readdirSync(feed)
+      .filter((name) => name.startsWith("rev-") && name.endsWith(".json"))
+      .map((name) => readFileSync(join(feed, name), "utf8"));
+    assert.equal(persisted.length, 3);
+    for (const forbidden of [raw[".env"], "material", "hunter2", "short-value", "bearer-value", "token-value", "outside bytes"]) {
+      assert.equal(persisted.some((contents) => contents.includes(forbidden)), false, forbidden);
+    }
+  } finally {
+    rmSync(feed, { recursive: true, force: true });
+    rmSync(worktree, { recursive: true, force: true });
+    rmSync(outside, { recursive: true, force: true });
+  }
+});
+
+test("containment and deny gates run before bounded untracked discovery", () => {
+  const card = capture({
+    hintedPaths: ["secrets/config.txt", "inside.txt", "../outside.txt"],
+    preSnapshot: new Map([["inside.txt", STREAMING_DIFF_ABSENT]]),
+    readPost: () => "inside\n",
+    inspect: (path) => path === "inside.txt" ? { type: "file", contained: true } : { type: "symlink", contained: false },
+    listUntracked(paths) { assert.deepEqual(paths, ["inside.txt"]); return ["inside.txt", "outside.txt"]; },
+  });
+  assert.equal(card.files.find((file) => file.path === "secrets/config.txt").kind, "denied");
+  assert.equal(card.files.find((file) => file.path === "inside.txt").kind, "added");
+  assert.equal(card.status, "partial");
+});
+
+test("withheld file entries always make the capture partial", () => {
+  const denied = capture({ hintedPaths: [".env"], preSnapshot: new Map([[".env", "before"]]), readPost: () => "after" });
+  const redacted = capture({ readPost: () => "Authorization: Bearer secret" });
+
+  for (const card of [denied, redacted]) {
+    assert.equal(card.status, "partial");
+    assert.match(card.partialReason, /content withheld\/incomplete/u);
+  }
+  assert.equal(denied.files[0].kind, "denied");
+  assert.equal(redacted.files[0].kind, "redacted");
+});
+
+test("denied .git hints are partial while binary changes are captured metadata", () => {
+  let read = false;
+  let inspected = false;
+  const denied = capture({
+    hintedPaths: [".git/config"], preSnapshot: new Map([[".git/config", "before"]]),
+    readPost() { read = true; return "after"; },
+    inspect() { inspected = true; return { type: "file", contained: true }; },
+  });
+  const invalid = Buffer.from([0xc3, 0x28]);
+  const binary = capture({ preSnapshot: new Map([["foo.ts", invalid]]), readPost: () => Buffer.from([0xc3, 0x29]) });
+
+  assert.equal(read, false);
+  assert.equal(inspected, false);
+  assert.deepEqual(denied.files, [{ path: ".git/config", kind: "denied" }]);
+  assert.equal(denied.status, "partial");
+  assert.deepEqual(binary.files, [{ path: "foo.ts", kind: "binary", meta: { bytes: 2 } }]);
+  assert.equal(binary.status, "captured");
+  assert.equal(binary.files[0].diff, undefined);
+});
+
+test("capture policy overrides can narrow but never enlarge hard ceilings", () => {
+  const capture = captureLimits({ maxPaths: 9_999, maxFileBytes: 9_999_999, maxHunkBytes: 0 });
+  const git = gitCaptureLimits({ timeout: 0, maxBuffer: 99_999_999 });
+  assert.equal(capture.maxPaths, STREAMING_DIFF_CAPTURE_LIMITS.maxPaths);
+  assert.equal(capture.maxFileBytes, STREAMING_DIFF_CAPTURE_LIMITS.maxFileBytes);
+  assert.equal(capture.maxHunkBytes, 1);
+  assert.equal(git.timeout, 1);
+  assert.equal(git.maxBuffer, STREAMING_DIFF_GIT_LIMITS.maxBuffer);
+});
+
+test("authorization credentials always produce a redacted card entry", () => {
+  for (const [header, expected] of [
+    ["Authorization: Bearer bearer-secret-value", "Authorization: Bearer [REDACTED]"],
+    ["Authorization: Token abc", "Authorization: Token [REDACTED]"],
+    ["Proxy-Authorization: Bearer x", "Proxy-Authorization: Bearer [REDACTED]"],
+    ["Authorization: Bearer \"abc\\\"def\"", "Authorization: Bearer [REDACTED]"],
+    ["api_key = 's3cr3t-fragment'; keep", "api_key = [REDACTED]"],
+  ]) {
+    const transformed = redact(header);
+    assert.equal(transformed.text, expected, header);
+    assert.equal(transformed.redacted, true, header);
+    for (const secret of ["def", "s3cr3t-fragment", "bearer-secret-value"]) {
+      if (header.includes(secret)) assert.equal(transformed.text.includes(secret), false, `${secret} survived in ${header}`);
+    }
+    const card = capture({ readPost: () => `${header}\n` });
+    assert.deepEqual(card.files, [{ path: "foo.ts", kind: "redacted", meta: { redacted: true, reason: "secret-looking value" } }]);
+  }
+});
diff --git a/ovens/streaming-diff/engine/streaming-diff-claude-hook.mjs b/ovens/streaming-diff/engine/streaming-diff-claude-hook.mjs
new file mode 100644
index 0000000..783e4df
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-claude-hook.mjs
@@ -0,0 +1,62 @@
+import { hookCapture, hookNoop, hookText } from "./streaming-diff-hook-contract.mjs";
+import { execFileSync } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
+
+const MUTATING_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+const EVENTS = { SessionStart: "ensure", PreToolUse: "pre", PostToolUse: "post", PostToolUseFailure: "failure" };
+const CLAUDE_GIT_TIMEOUT_MS = 500;
+
+function within(root, path) {
+  const value = relative(root, path);
+  return value === "" || (value !== ".." && !value.startsWith(`..${sep}`));
+}
+
+function realpathWithMissingTail(path) {
+  const tail = [];
+  let probe = path;
+  while (true) {
+    try { return resolve(realpathSync(probe), ...tail.reverse()); } catch (error) {
+      if (error?.code !== "ENOENT" || dirname(probe) === probe) throw error;
+      tail.push(basename(probe));
+      probe = dirname(probe);
+    }
+  }
+}
+
+function worktreeRoot(cwd) {
+  return realpathSync(execFileSync("git", ["-C", cwd, "rev-parse", "--show-toplevel"], {
+    encoding: "utf8", shell: false, timeout: CLAUDE_GIT_TIMEOUT_MS, maxBuffer: 64 * 1024,
+  }).trim());
+}
+
+export function claudeRepoRelativePath(path, { cwd = process.cwd(), root = worktreeRoot(cwd) } = {}) {
+  if (!isAbsolute(path)) return null;
+  const candidate = realpathWithMissingTail(resolve(path));
+  return within(root, candidate) ? relative(root, candidate).split(sep).join("/") : null;
+}
+
+export function mapClaudeHook(payload = {}, event, env = process.env, options) {
+  try {
+    event ??= EVENTS[payload.hook_event_name];
+    if (event === "ensure") return hookCapture({ event, session: payload.session_id ?? env.CLAUDE_SESSION_ID });
+    const tool = hookText(payload.tool_name);
+    if (!tool) return hookCapture({ event, session: payload.session_id ?? env.CLAUDE_SESSION_ID });
+    if (!MUTATING_TOOLS.has(tool)) return hookNoop();
+    const input = payload.tool_input && typeof payload.tool_input === "object" ? payload.tool_input : {};
+    const absolutePath = hookText(input.file_path) ?? hookText(input.notebook_path);
+    const path = absolutePath ? claudeRepoRelativePath(absolutePath, options) : null;
+    return hookCapture({
+      event,
+      session: payload.session_id ?? env.CLAUDE_SESSION_ID,
+      toolUseId: payload.tool_use_id,
+      hintedPaths: path ? [path] : [],
+    });
+  } catch {
+    return hookCapture({
+      event,
+      session: payload?.session_id ?? env.CLAUDE_SESSION_ID,
+      toolUseId: payload?.tool_use_id,
+    });
+  }
+}
diff --git a/ovens/streaming-diff/engine/streaming-diff-codex-hook.mjs b/ovens/streaming-diff/engine/streaming-diff-codex-hook.mjs
new file mode 100644
index 0000000..438319b
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-codex-hook.mjs
@@ -0,0 +1,49 @@
+import { hookCapture, hookNoop, hookText } from "./streaming-diff-hook-contract.mjs";
+
+const MUTATING_TOOLS = new Set(["apply_patch", "write_file", "edit_file", "create_file", "delete_file", "rename_file", "move_file"]);
+const PATH_KEYS = ["file_path", "filepath", "path", "target_path", "source_path", "destination_path"];
+const EVENTS = { SessionStart: "ensure", PreToolUse: "pre", PostToolUse: "post", PostToolUseFailure: "failure" };
+
+function object(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) return value;
+  if (typeof value === "string") {
+    try { return object(JSON.parse(value)); } catch { return {}; }
+  }
+  return {};
+}
+
+function patchPaths(value) {
+  if (typeof value !== "string") return [];
+  const result = [];
+  for (const match of value.matchAll(/^\*\*\* (?:Add|Update|Delete) File:\s*(.+?)\s*$/gmu)) result.push(match[1]);
+  for (const match of value.matchAll(/^\*\*\* Move to:\s*(.+?)\s*$/gmu)) result.push(match[1]);
+  return [...new Set(result.map(hookText).filter(Boolean))];
+}
+
+function paths(input) {
+  const result = PATH_KEYS.map((key) => hookText(input[key])).filter(Boolean);
+  if (Array.isArray(input.files)) result.push(...input.files.flatMap((entry) => paths(object(entry))));
+  // Codex supplies apply_patch's complete envelope in tool_input.command.
+  // `input.patch` was an invented shape and silently yielded no hints.
+  result.push(...patchPaths(input.command));
+  return [...new Set(result)];
+}
+
+export function mapCodexHook(payload = {}, event, env = process.env) {
+  try {
+    event ??= EVENTS[payload.hook_event_name ?? payload.hookEventName ?? payload.event];
+    if (event === "ensure") return hookCapture({ event, session: payload.session_id ?? payload.sessionId ?? env.CODEX_SESSION_ID });
+    const tool = hookText(payload.tool_name) ?? hookText(payload.toolName) ?? hookText(payload.name);
+    if (!tool) return hookCapture({ event, session: payload.session_id ?? payload.sessionId ?? env.CODEX_SESSION_ID });
+    if (!tool || !MUTATING_TOOLS.has(tool.replace(/^functions\./u, ""))) return hookNoop();
+    const input = object(payload.tool_input ?? payload.toolInput ?? payload.input ?? payload.arguments);
+    return hookCapture({
+      event,
+      session: payload.session_id ?? payload.sessionId ?? env.CODEX_SESSION_ID,
+      toolUseId: payload.tool_use_id ?? payload.toolUseId ?? payload.call_id ?? payload.id,
+      hintedPaths: paths(input),
+    });
+  } catch {
+    return hookCapture({ event });
+  }
+}
diff --git a/ovens/streaming-diff/engine/streaming-diff-data-contract.mjs b/ovens/streaming-diff/engine/streaming-diff-data-contract.mjs
new file mode 100644
index 0000000..de37a28
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-data-contract.mjs
@@ -0,0 +1,137 @@
+export const STREAMING_DIFF_DATA_CONTRACT = "burnlist-streaming-diff-data@2";
+export const STREAMING_DIFF_CONTRACT_LIMITS = Object.freeze({ maxRevs: 128, maxFiles: 64, maxCardBytes: 512 * 1024 });
+
+const cardStatuses = new Set(["captured", "partial"]);
+const fileKinds = new Set(["modified", "added", "deleted", "binary", "denied", "redacted", "truncated", "unavailable"]);
+const textKinds = new Set(["modified", "added", "deleted"]);
+const incompleteFileKinds = new Set(["denied", "redacted", "truncated", "unavailable"]);
+const opaqueRevision = /^r-[a-f0-9]{16,64}$/u;
+const opaqueGeneration = /^g-[a-f0-9]{16,64}$/u;
+
+export class StreamingDiffDataValidationError extends Error {
+  constructor(issues) {
+    super(`Streaming Diff data is invalid: ${issues.map((issue) => `${issue.path}: ${issue.message}`).join("; ")}`);
+    this.name = "StreamingDiffDataValidationError";
+    this.issues = issues;
+    this.status = 422;
+  }
+}
+
+function plainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function timestamp(value) {
+  return typeof value === "string" && value.length > 0 && Number.isFinite(Date.parse(value));
+}
+
+function repositoryPath(value) {
+  return typeof value === "string"
+    && value.length > 0
+    && value.length <= 512
+    && !value.startsWith("/")
+    && !value.includes("\\")
+    && !value.split("/").some((part) => !part || part === "." || part === "..");
+}
+
+function validate(value, kind) {
+  const issues = [];
+  const issue = (path, message) => issues.push({ path, message });
+  const keys = (object, path, allowed) => {
+    if (!plainObject(object)) return;
+    for (const key of Object.keys(object)) if (!allowed.has(key)) issue(`${path}.${key}`, "is not supported by the @2 contract");
+  };
+  const text = (value, path, max = 2_000) => {
+    if (typeof value !== "string" || !value.trim()) issue(path, "must be a non-empty string");
+    else if (value.length > max) issue(path, `must be at most ${max} characters`);
+  };
+
+  if (!plainObject(value)) {
+    issue("$", "must be an object");
+    return { ok: false, issues };
+  }
+  if (kind === "card") {
+    keys(value, "$", new Set(["revId", "toolUseId", "ts", "status", "partialReason", "files"]));
+    if (typeof value.revId !== "string" || !opaqueRevision.test(value.revId) || /^r-0+$/u.test(value.revId)) issue("$.revId", "must be a random opaque r- hexadecimal id");
+    text(value.toolUseId, "$.toolUseId", 256);
+    if (!timestamp(value.ts)) issue("$.ts", "must be a parseable timestamp");
+    if (!cardStatuses.has(value.status)) issue("$.status", "must be captured or partial");
+    if (value.status === "partial") text(value.partialReason, "$.partialReason", 500);
+    else if (Object.hasOwn(value, "partialReason")) issue("$.partialReason", "is only allowed when status is partial");
+    if (Buffer.byteLength(JSON.stringify(value), "utf8") > STREAMING_DIFF_CONTRACT_LIMITS.maxCardBytes) issue("$", `must serialize to at most ${STREAMING_DIFF_CONTRACT_LIMITS.maxCardBytes} bytes`);
+    if (!Array.isArray(value.files)) issue("$.files", "must be an array");
+    else {
+      if (value.files.length > STREAMING_DIFF_CONTRACT_LIMITS.maxFiles) issue("$.files", `must contain at most ${STREAMING_DIFF_CONTRACT_LIMITS.maxFiles} entries`);
+      value.files.forEach((file, index) => {
+        const path = `$.files[${index}]`;
+        if (!plainObject(file)) {
+          issue(path, "must be an object");
+          return;
+        }
+        keys(file, path, new Set(["path", "kind", "diff", "meta"]));
+        if (!repositoryPath(file.path)) issue(`${path}.path`, "must be a relative contained repository path");
+        if (!fileKinds.has(file.kind)) issue(`${path}.kind`, "is not a supported file kind");
+        if (textKinds.has(file.kind) && typeof file.diff !== "string") issue(`${path}.diff`, "is required for a text change");
+        if (!textKinds.has(file.kind) && Object.hasOwn(file, "diff")) issue(`${path}.diff`, "is not allowed for a metadata-only file kind");
+        if (typeof file.diff === "string" && file.diff.length > 262_144) issue(`${path}.diff`, "must be at most 262144 characters");
+        if (Object.hasOwn(file, "meta")) {
+          if (!plainObject(file.meta)) issue(`${path}.meta`, "must be an object");
+          else {
+            keys(file.meta, `${path}.meta`, new Set(["bytes", "reason", "redacted"]));
+            if (Object.hasOwn(file.meta, "bytes") && (!Number.isSafeInteger(file.meta.bytes) || file.meta.bytes < 0)) issue(`${path}.meta.bytes`, "must be a non-negative safe integer");
+            if (Object.hasOwn(file.meta, "reason")) text(file.meta.reason, `${path}.meta.reason`, 500);
+            if (Object.hasOwn(file.meta, "redacted") && file.meta.redacted !== true) issue(`${path}.meta.redacted`, "must be true when present");
+          }
+        }
+        if (file.kind === "redacted") {
+          if (!plainObject(file.meta) || file.meta.redacted !== true) issue(`${path}.meta.redacted`, "must be true for a redacted file");
+          if (!plainObject(file.meta) || !Object.hasOwn(file.meta, "reason")) issue(`${path}.meta.reason`, "is required for a redacted file");
+        }
+      });
+      if (value.status === "captured" && value.files.some((file) => incompleteFileKinds.has(file?.kind))) {
+        issue("$.status", "must be partial when file content is withheld or incomplete");
+      }
+    }
+  } else {
+    keys(value, "$", new Set(["contract", "identity", "generation", "updatedAt", "revs"]));
+    if (value.contract !== STREAMING_DIFF_DATA_CONTRACT) issue("$.contract", `must equal ${STREAMING_DIFF_DATA_CONTRACT}; upgrade or restart this feed`);
+    if (!plainObject(value.identity)) issue("$.identity", "must be an object");
+    else {
+      keys(value.identity, "$.identity", new Set(["logicalRepoKey", "worktreeKey", "session"]));
+      for (const key of ["logicalRepoKey", "worktreeKey", "session"]) text(value.identity[key], `$.identity.${key}`, 256);
+    }
+    if (!timestamp(value.updatedAt)) issue("$.updatedAt", "must be a parseable activity timestamp");
+    if (typeof value.generation !== "string" || !opaqueGeneration.test(value.generation)) issue("$.generation", "must be an opaque g- hexadecimal feed generation");
+    if (!Array.isArray(value.revs)) issue("$.revs", "must be an ordered array");
+    else {
+      if (value.revs.length > STREAMING_DIFF_CONTRACT_LIMITS.maxRevs) issue("$.revs", `must contain at most ${STREAMING_DIFF_CONTRACT_LIMITS.maxRevs} revisions`);
+      const seen = new Set();
+      value.revs.forEach((rev, index) => {
+        if (typeof rev !== "string" || !opaqueRevision.test(rev) || /^r-0+$/u.test(rev)) issue(`$.revs[${index}]`, "must be a random opaque r- hexadecimal id");
+        else if (seen.has(rev)) issue(`$.revs[${index}]`, "must not repeat a revision id");
+        else seen.add(rev);
+      });
+    }
+  }
+  return { ok: issues.length === 0, issues };
+}
+
+export function validateCard(value) {
+  return validate(value, "card");
+}
+
+export function validateManifest(value) {
+  return validate(value, "manifest");
+}
+
+export function assertCard(value) {
+  const result = validateCard(value);
+  if (!result.ok) throw new StreamingDiffDataValidationError(result.issues);
+  return value;
+}
+
+export function assertManifest(value) {
+  const result = validateManifest(value);
+  if (!result.ok) throw new StreamingDiffDataValidationError(result.issues);
+  return value;
+}
diff --git a/ovens/streaming-diff/engine/streaming-diff-data-contract.test.mjs b/ovens/streaming-diff/engine/streaming-diff-data-contract.test.mjs
new file mode 100644
index 0000000..0b66a05
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-data-contract.test.mjs
@@ -0,0 +1,69 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { assertCard, assertManifest, STREAMING_DIFF_CONTRACT_LIMITS, STREAMING_DIFF_DATA_CONTRACT, StreamingDiffDataValidationError, validateCard, validateManifest } from "./streaming-diff-data-contract.mjs";
+
+const card = Object.freeze({
+  revId: "r-0123456789abcdef01234567",
+  toolUseId: "tool-fixture",
+  ts: "2026-07-15T09:00:00.000Z",
+  status: "captured",
+  files: [{ path: "src/example.mjs", kind: "modified", diff: "--- a/src/example.mjs\n+++ b/src/example.mjs\n@@ -1,1 +1,1 @@\n-before\n+after" }],
+});
+
+const manifest = Object.freeze({
+  contract: STREAMING_DIFF_DATA_CONTRACT,
+  identity: { logicalRepoKey: "logical-fixture", worktreeKey: "worktree-fixture", session: "session-fixture" },
+  generation: "g-0123456789abcdef01234567",
+  updatedAt: "2026-07-15T09:01:00.000Z",
+  revs: [card.revId],
+});
+
+test("the @2 golden card and manifest survive a JSON round trip", () => {
+  const roundTrippedCard = JSON.parse(JSON.stringify(card));
+  const roundTrippedManifest = JSON.parse(JSON.stringify(manifest));
+  assert.equal(validateCard(roundTrippedCard).ok, true);
+  assert.equal(validateManifest(roundTrippedManifest).ok, true);
+  assert.equal(assertCard(roundTrippedCard), roundTrippedCard);
+  assert.equal(assertManifest(roundTrippedManifest), roundTrippedManifest);
+});
+
+test("the @2 contract rejects version negotiation, unknown fields, and oversized collections", () => {
+  const wrongVersion = { ...manifest, contract: "burnlist-streaming-diff-data@1" };
+  const unknownField = { ...card, sequence: 1 };
+  assert.match(validateManifest(wrongVersion).issues[0].message, /upgrade or restart/u);
+  assert.ok(validateCard(unknownField).issues.some((issue) => issue.path === "$.sequence"));
+  assert.throws(() => assertManifest(wrongVersion), StreamingDiffDataValidationError);
+  assert.ok(validateCard({ ...card, files: Array.from({ length: STREAMING_DIFF_CONTRACT_LIMITS.maxFiles + 1 }, () => card.files[0]) }).issues.some((issue) => issue.path === "$.files"));
+  assert.ok(validateCard({ ...card, files: Array.from({ length: STREAMING_DIFF_CONTRACT_LIMITS.maxFiles }, (_, index) => ({ path: `src/${index}.mjs`, kind: "modified", diff: "x".repeat(9_000) })) }).issues.some((issue) => issue.path === "$"));
+  assert.ok(validateManifest({ ...manifest, revs: Array.from({ length: STREAMING_DIFF_CONTRACT_LIMITS.maxRevs + 1 }, (_, index) => `r-${index.toString(16).padStart(24, "0")}`) }).issues.some((issue) => issue.path === "$.revs"));
+});
+
+test("redacted metadata entries require both redacted truth and a reason", () => {
+  const redacted = { path: "safe.txt", kind: "redacted", meta: { redacted: true, reason: "secret-looking value" } };
+  const partial = { ...card, status: "partial", partialReason: "content withheld/incomplete", files: [redacted] };
+  assert.equal(validateCard(partial).ok, true);
+  assert.ok(validateCard({ ...card, files: [{ ...redacted, meta: { reason: "secret-looking value" } }] }).issues.some((issue) => issue.path.endsWith(".redacted")));
+  assert.ok(validateCard({ ...card, files: [{ ...redacted, meta: { redacted: true } }] }).issues.some((issue) => issue.path.endsWith(".reason")));
+  assert.ok(validateCard({ ...card, files: [{ path: "src\\escape.mjs", kind: "modified", diff: "x" }] }).issues.some((issue) => issue.path.endsWith(".path")));
+});
+
+test("captured cards cannot contain denied or otherwise incomplete file entries", () => {
+  const denied = { ...card, files: [{ path: "private.env", kind: "denied" }] };
+  const result = validateCard(denied);
+
+  assert.equal(result.ok, false);
+  assert.ok(result.issues.some((issue) => issue.path === "$.status" && /partial/u.test(issue.message)));
+  assert.throws(() => assertCard(denied), StreamingDiffDataValidationError);
+});
+
+test("a captured binary metadata entry is complete", () => {
+  const binary = { ...card, files: [{ path: "image.png", kind: "binary", meta: { bytes: 12 } }] };
+
+  assert.equal(validateCard(binary).ok, true);
+});
+
+test("a pre-hook attempt marker is a valid empty partial card", () => {
+  const attempt = { ...card, status: "partial", partialReason: "attempt in progress / unterminated", files: [] };
+  assert.equal(validateCard(attempt).ok, true);
+});
diff --git a/ovens/streaming-diff/engine/streaming-diff-durable-write.mjs b/ovens/streaming-diff/engine/streaming-diff-durable-write.mjs
new file mode 100644
index 0000000..f089e64
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-durable-write.mjs
@@ -0,0 +1,55 @@
+import { randomBytes } from "node:crypto";
+import { closeSync, constants, fsyncSync, linkSync, openSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+export function fsyncDirectory(path) {
+  const fd = openSync(path, constants.O_RDONLY);
+  try { fsyncSync(fd); } finally { closeSync(fd); }
+}
+
+// The replacement is the commit point. Once it succeeds, the new content has
+// already been synced and a later parent-directory sync is only best effort.
+export function writeDurableAtomic(path, value, { fsyncTemporary = fsyncSync, fsyncParent = fsyncDirectory } = {}) {
+  const temporary = `${path}.${randomBytes(8).toString("hex")}.tmp`;
+  let fd;
+  let renamed = false;
+  try {
+    fd = openSync(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 0o600);
+    writeFileSync(fd, value);
+    fsyncTemporary(fd);
+    closeSync(fd);
+    fd = undefined;
+    renameSync(temporary, path);
+    renamed = true;
+    try { fsyncParent(dirname(path)); } catch { /* the replacement is committed */ }
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+    try { rmSync(temporary, { force: true }); } catch (error) { if (!renamed) throw error; }
+  }
+}
+
+// Linking a synced temporary file is an atomic, no-replacement commit. It is
+// suitable for immutable records and monotonic marker files: EEXIST means a
+// concurrent writer already made the same state visible.
+export function writeDurableExclusive(path, value, { fsyncTemporary = fsyncSync, fsyncParent = fsyncDirectory } = {}) {
+  const temporary = `${path}.${randomBytes(8).toString("hex")}.tmp`;
+  let fd;
+  let linked = false;
+  try {
+    fd = openSync(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 0o600);
+    writeFileSync(fd, value);
+    fsyncTemporary(fd);
+    closeSync(fd);
+    fd = undefined;
+    try { linkSync(temporary, path); } catch (error) {
+      if (error?.code === "EEXIST") return false;
+      throw error;
+    }
+    linked = true;
+    try { fsyncParent(dirname(path)); } catch { /* the link is committed */ }
+    return true;
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+    try { rmSync(temporary, { force: true }); } catch (error) { if (!linked) throw error; }
+  }
+}
diff --git a/ovens/streaming-diff/engine/streaming-diff-ensure-feed.mjs b/ovens/streaming-diff/engine/streaming-diff-ensure-feed.mjs
new file mode 100644
index 0000000..a7cdb7f
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-ensure-feed.mjs
@@ -0,0 +1,19 @@
+import { writeBindingIfAbsent } from "../../../src/server/oven-bindings.mjs";
+import {
+  STREAMING_DIFF_OVEN_ID,
+  ensureFeedDirectory,
+  resolveStreamingDiffIdentity,
+  streamingDiffBindingPath,
+} from "./streaming-diff-feed.mjs";
+
+export function ensureStreamingDiffFeed({ cwd = process.cwd(), session, now = () => new Date().toISOString() } = {}) {
+  const identity = resolveStreamingDiffIdentity({ cwd, session });
+  ensureFeedDirectory(identity);
+  const binding = writeBindingIfAbsent(
+    identity.logicalRepoRoot,
+    STREAMING_DIFF_OVEN_ID,
+    streamingDiffBindingPath(identity),
+    now(),
+  );
+  return { identity, binding };
+}
diff --git a/ovens/streaming-diff/engine/streaming-diff-ensure-feed.test.mjs b/ovens/streaming-diff/engine/streaming-diff-ensure-feed.test.mjs
new file mode 100644
index 0000000..b02fb6e
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-ensure-feed.test.mjs
@@ -0,0 +1,37 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { readBindingStore } from "../../../src/server/oven-bindings.mjs";
+import { ensureStreamingDiffFeed } from "./streaming-diff-ensure-feed.mjs";
+
+function git(cwd, ...args) {
+  execFileSync("git", ["-C", cwd, ...args], { stdio: "ignore" });
+}
+
+function fixture() {
+  const root = mkdtempSync(join(tmpdir(), "burnlist-streaming-ensure-"));
+  git(root, "init", "--quiet");
+  git(root, "config", "user.email", "test@example.invalid");
+  git(root, "config", "user.name", "Test");
+  return { root, cleanup: () => rmSync(root, { recursive: true, force: true }) };
+}
+
+test("ensure-feed creates a session directory and binds the oven only once", () => {
+  const context = fixture();
+  try {
+    const first = ensureStreamingDiffFeed({ cwd: context.root, session: "first", now: () => "2026-07-15T09:00:00.000Z" });
+    const second = ensureStreamingDiffFeed({ cwd: context.root, session: "second", now: () => "2026-07-15T09:01:00.000Z" });
+    assert.equal(existsSync(first.identity.feedDir), true);
+    assert.equal(existsSync(second.identity.feedDir), true);
+    assert.equal(first.binding.created, true);
+    assert.equal(second.binding.created, false);
+    assert.deepEqual(readBindingStore(context.root).bindings["streaming-diff"], {
+      path: ".local/burnlist/streaming-diff/v2",
+      boundAt: "2026-07-15T09:00:00.000Z",
+    });
+  } finally { context.cleanup(); }
+});
diff --git a/ovens/streaming-diff/engine/streaming-diff-feed-capture.mjs b/ovens/streaming-diff/engine/streaming-diff-feed-capture.mjs
new file mode 100644
index 0000000..13fe0c6
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-feed-capture.mjs
@@ -0,0 +1,153 @@
+import { randomBytes } from "node:crypto";
+
+import { captureGitCard } from "./streaming-diff-capture-git.mjs";
+import { appendCard } from "./streaming-diff-journal.mjs";
+import { ensureStreamingDiffFeed } from "./streaming-diff-ensure-feed.mjs";
+import { feedIdentity, resolveStreamingDiffIdentity } from "./streaming-diff-feed.mjs";
+import { closeActiveWindows, inspectActiveWindowOverlap, markPreSnapshotAttributionUnavailable, markPreSnapshotOverlapped, markPreSnapshotRegistered, registerActiveWindows, removePreSnapshot, streamingDiffToolUseId, takePreSnapshot, writePreSnapshot } from "./streaming-diff-snapshot-store.mjs";
+
+const TERMINAL_REASONS = Object.freeze({
+  "adapter-incomplete": "hook adapter mapping was incomplete",
+  "path-hints-truncated": "path hints truncated",
+  "tool-failed": "tool failed",
+  "payload-too-large": "hook payload exceeded byte limit",
+  "payload-read-timed-out": "hook payload read timed out",
+});
+
+function terminalReason(code) {
+  return typeof code === "string" ? TERMINAL_REASONS[code] ?? null : null;
+}
+
+function attemptCard(toolUseId, terminalReasonCode) {
+  const reason = terminalReason(terminalReasonCode);
+  return {
+    revId: `r-${randomBytes(12).toString("hex")}`,
+    toolUseId,
+    ts: new Date().toISOString(),
+    status: "partial",
+    partialReason: ["attempt in progress / unterminated", reason].filter(Boolean).join("; "),
+    files: [],
+  };
+}
+
+function appendWithRetry(append, feedDir, card, options) {
+  for (let attempt = 0; attempt < 8; attempt += 1) {
+    try {
+      return append(feedDir, card, options);
+    } catch (error) {
+      if (error?.code !== "ELOCKED" || attempt === 7) throw error;
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, Math.min(5 * (attempt + 1), 25));
+    }
+  }
+  throw new Error("streaming diff journal retry unexpectedly exhausted");
+}
+
+const ACTIVE_WINDOW_LOCK_REASON = "attribution unavailable: active-window lock timed out";
+
+function activeWindowOperation(operation) {
+  try {
+    return operation();
+  } catch (error) {
+    if (error?.code !== "ELOCKED") throw error;
+    return { paths: [], attributionUnavailable: true, attributionUnavailableReason: ACTIVE_WINDOW_LOCK_REASON };
+  }
+}
+
+function markUnattributedOverlap(card, paths, attributionUnavailable, overlapDetected, attributionUnavailableReason) {
+  if (!paths.length && !attributionUnavailable && !overlapDetected) return card;
+  const reason = attributionUnavailable ? attributionUnavailableReason ?? "attribution unavailable: too many concurrent windows" : "overlapping concurrent edit (unattributed)";
+  const overlapped = new Set(attributionUnavailable ? card.files.map((file) => file.path) : paths);
+  return {
+    ...card,
+    status: "partial",
+    partialReason: [card.partialReason, reason].filter(Boolean).join("; "),
+    files: card.files.map((file) => overlapped.has(file.path)
+      ? { path: file.path, kind: "unavailable", meta: { reason } }
+      : file),
+  };
+}
+
+export function captureStreamingDiff({ cwd = process.cwd(), session, toolUseId: rawToolUseId, phase, hintedPaths = [], terminalReason: terminalReasonCode, policy, append = appendCard, activeWindows } = {}) {
+  if (phase !== "pre" && phase !== "post") throw new Error("streaming diff capture phase must be pre or post");
+  const identity = resolveStreamingDiffIdentity({ cwd, session });
+  const safeToolUseId = streamingDiffToolUseId(rawToolUseId);
+  // The hook fallback is shared by unrelated degraded events, so it cannot
+  // distinguish a retry from a later event.
+  const hasStableToolUseId = safeToolUseId !== "unknown-tool-use";
+  const journalOptions = { identity: feedIdentity(identity) };
+  const windows = activeWindows ?? { closeActiveWindows, inspectActiveWindowOverlap, registerActiveWindows };
+  if (phase === "pre") {
+    ensureStreamingDiffFeed({ cwd, session });
+    const marker = appendWithRetry(append, identity.feedDir, attemptCard(safeToolUseId, terminalReasonCode), { ...journalOptions, dedupeToolUseId: true });
+    const snapshot = writePreSnapshot({ identity, toolUseId: safeToolUseId, hintedPaths, terminalReason: terminalReason(terminalReasonCode), policy });
+    const activeWindow = activeWindowOperation(() => {
+      const registered = windows.registerActiveWindows({ identity, toolUseId: safeToolUseId, hintedPaths: snapshot.hintedPaths });
+      if (registered.attributionUnavailable) return registered;
+      const inspected = windows.inspectActiveWindowOverlap({ identity, toolUseId: safeToolUseId });
+      return {
+        ...registered,
+        paths: inspected.paths ?? [],
+        attributionUnavailable: inspected.attributionUnavailable,
+        attributionUnavailableReason: inspected.attributionUnavailableReason,
+      };
+    });
+    if (activeWindow.attributionUnavailable) {
+      markPreSnapshotAttributionUnavailable({ identity, toolUseId: safeToolUseId, reason: activeWindow.attributionUnavailableReason });
+    } else if (activeWindow.paths.length) {
+      markPreSnapshotOverlapped({ identity, toolUseId: safeToolUseId });
+    } else {
+      markPreSnapshotRegistered({ identity, toolUseId: safeToolUseId });
+    }
+    return { phase, identity, marker, snapshot, activeWindow };
+  }
+  const snapshot = takePreSnapshot({ identity, toolUseId: safeToolUseId });
+  const paths = snapshot.found ? snapshot.hintedPaths : hintedPaths;
+  let card = captureGitCard({
+    worktreeRoot: identity.worktreeRoot,
+    hintedPaths: paths,
+    preSnapshot: snapshot.preSnapshot,
+    toolUseId: safeToolUseId,
+    policy,
+    opaqueReason: [snapshot.terminalReason, terminalReason(terminalReasonCode)].find(Boolean),
+  });
+  const inspected = activeWindowOperation(() => windows.inspectActiveWindowOverlap({ identity, toolUseId: safeToolUseId }));
+  const closed = activeWindowOperation(() => windows.closeActiveWindows({ identity, toolUseId: safeToolUseId }));
+  const overlap = {
+    paths: [...new Set([...(inspected.paths ?? []), ...(closed.paths ?? [])])],
+    attributionUnavailable: inspected.attributionUnavailable || closed.attributionUnavailable,
+    attributionUnavailableReason: inspected.attributionUnavailableReason ?? (closed.attributionUnavailable ? closed.attributionUnavailableReason : undefined),
+  };
+  const ownWindowMissing = closed.closed === false;
+  const liveOverlap = overlap.paths.length > 0 || overlap.attributionUnavailable;
+  if (overlap.paths.length) markPreSnapshotOverlapped({ identity, toolUseId: safeToolUseId });
+  if (overlap.attributionUnavailable) {
+    activeWindowOperation(() => markPreSnapshotAttributionUnavailable({ identity, toolUseId: safeToolUseId, reason: overlap.attributionUnavailableReason }));
+  }
+  const attribution = takePreSnapshot({ identity, toolUseId: safeToolUseId });
+  const durableOverlap = attribution.overlapped || liveOverlap;
+  const attributionUnavailable = attribution.found === false || (attribution.registered === false && !durableOverlap)
+    || attribution.attributionUnavailable || overlap.attributionUnavailable || (ownWindowMissing && !durableOverlap);
+  card = markUnattributedOverlap(
+    card,
+    overlap.paths.length ? overlap.paths : durableOverlap ? card.files.map((file) => file.path) : [],
+    attributionUnavailable,
+    durableOverlap,
+    overlap.attributionUnavailableReason ?? attribution.attributionUnavailableReason
+      ?? (attribution.registered === false && !overlap.attributionUnavailable ? ACTIVE_WINDOW_LOCK_REASON : undefined)
+      ?? (ownWindowMissing && !durableOverlap ? closed.attributionUnavailableReason : undefined),
+  );
+  // A direct post invocation remains safe and useful: it establishes the
+  // immutable binding/feed before the journal's first manifest append.
+  ensureStreamingDiffFeed({ cwd, session });
+  try {
+    const appended = appendWithRetry(append, identity.feedDir, card, { ...journalOptions, dedupeTerminalToolUseId: hasStableToolUseId });
+    try {
+      removePreSnapshot({ identity, toolUseId: safeToolUseId });
+      return { phase, identity, snapshot, ...appended };
+    } catch (cleanupError) {
+      return { phase, identity, snapshot, ...appended, cleanupError };
+    }
+  } catch (error) {
+    return { phase, identity, snapshot, card, error };
+  }
+}
diff --git a/ovens/streaming-diff/engine/streaming-diff-feed-capture.test.mjs b/ovens/streaming-diff/engine/streaming-diff-feed-capture.test.mjs
new file mode 100644
index 0000000..85f8d84
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-feed-capture.test.mjs
@@ -0,0 +1,368 @@
+import assert from "node:assert/strict";
+import { execFileSync, spawn } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { captureStreamingDiff } from "./streaming-diff-feed-capture.mjs";
+import { resolveStreamingDiffIdentity } from "./streaming-diff-feed.mjs";
+import { markPreSnapshotOverlapped, markPreSnapshotRegistered, registerActiveWindows, STREAMING_DIFF_ACTIVE_WINDOW_MAX_ENTRIES, takePreSnapshot, writePreSnapshot } from "./streaming-diff-snapshot-store.mjs";
+import { readJournal } from "./streaming-diff-journal.mjs";
+
+function git(cwd, ...args) {
+  execFileSync("git", ["-C", cwd, ...args], { stdio: "ignore" });
+}
+
+function fixture() {
+  const root = mkdtempSync(join(tmpdir(), "burnlist-streaming-capture-"));
+  git(root, "init", "--quiet");
+  git(root, "config", "user.email", "test@example.invalid");
+  git(root, "config", "user.name", "Test");
+  writeFileSync(join(root, "target.txt"), "before\n");
+  git(root, "add", "target.txt");
+  git(root, "commit", "--quiet", "-m", "initial");
+  return { root, cleanup: () => rmSync(root, { recursive: true, force: true }) };
+}
+
+test("pre/post capture appends a Wave 1-readable self-contained journal card", () => {
+  const context = fixture();
+  try {
+    const pre = captureStreamingDiff({ cwd: context.root, session: "session-a", toolUseId: "tool-a", phase: "pre", hintedPaths: ["target.txt"] });
+    assert.deepEqual(readJournal(pre.identity.feedDir).cards.map((card) => ({ toolUseId: card.toolUseId, status: card.status, files: card.files })), [{ toolUseId: "tool-a", status: "partial", files: [] }]);
+    captureStreamingDiff({ cwd: context.root, session: "session-a", toolUseId: "tool-a", phase: "pre", hintedPaths: ["target.txt"] });
+    assert.equal(readJournal(pre.identity.feedDir).cards.length, 1);
+    writeFileSync(join(context.root, "target.txt"), "after\n");
+    const result = captureStreamingDiff({ cwd: context.root, session: "session-a", toolUseId: "tool-a", phase: "post", hintedPaths: ["target.txt"] });
+    const journal = readJournal(result.identity.feedDir);
+    assert.equal(result.card.status, "captured");
+    assert.equal(journal.manifest.identity.session, "session-a");
+    assert.equal(journal.cards.length, 2);
+    assert.equal(journal.cards[1].toolUseId, "tool-a");
+    assert.match(journal.cards[1].files[0].diff, /-before\n\+after/u);
+  } finally { context.cleanup(); }
+});
+
+test("overlapping sessions on one worktree are unattributed, while isolated worktrees are captured", () => {
+  const context = fixture();
+  const otherWorktree = mkdtempSync(join(tmpdir(), "burnlist-streaming-worktree-"));
+  rmSync(otherWorktree, { recursive: true, force: true });
+  try {
+    captureStreamingDiff({ cwd: context.root, session: "session-one", toolUseId: "tool-one", phase: "pre", hintedPaths: ["target.txt"] });
+    captureStreamingDiff({ cwd: context.root, session: "session-two", toolUseId: "tool-two", phase: "pre", hintedPaths: ["target.txt"] });
+    writeFileSync(join(context.root, "target.txt"), "after\n");
+    const first = captureStreamingDiff({ cwd: context.root, session: "session-one", toolUseId: "tool-one", phase: "post", hintedPaths: ["target.txt"] });
+    const second = captureStreamingDiff({ cwd: context.root, session: "session-two", toolUseId: "tool-two", phase: "post", hintedPaths: ["target.txt"] });
+    for (const result of [first, second]) {
+      assert.equal(result.card.status, "partial");
+      assert.match(result.card.partialReason, /overlapping concurrent edit \(unattributed\)/u);
+      assert.deepEqual(result.card.files, [{ path: "target.txt", kind: "unavailable", meta: { reason: "overlapping concurrent edit (unattributed)" } }]);
+    }
+
+    git(context.root, "worktree", "add", "--detach", otherWorktree, "HEAD");
+    captureStreamingDiff({ cwd: context.root, session: "session-root", toolUseId: "tool-root", phase: "pre", hintedPaths: ["target.txt"] });
+    captureStreamingDiff({ cwd: otherWorktree, session: "session-other", toolUseId: "tool-other", phase: "pre", hintedPaths: ["target.txt"] });
+    writeFileSync(join(context.root, "target.txt"), "root-after\n");
+    writeFileSync(join(otherWorktree, "target.txt"), "other-after\n");
+    const rootResult = captureStreamingDiff({ cwd: context.root, session: "session-root", toolUseId: "tool-root", phase: "post", hintedPaths: ["target.txt"] });
+    const otherResult = captureStreamingDiff({ cwd: otherWorktree, session: "session-other", toolUseId: "tool-other", phase: "post", hintedPaths: ["target.txt"] });
+    assert.equal(rootResult.card.status, "captured");
+    assert.equal(otherResult.card.status, "captured");
+  } finally {
+    try { git(context.root, "worktree", "remove", "--force", otherWorktree); } catch {}
+    rmSync(otherWorktree, { recursive: true, force: true });
+    context.cleanup();
+  }
+});
+
+test("a failed overlapping post stays unattributed when its publication is retried", () => {
+  const context = fixture();
+  try {
+    captureStreamingDiff({ cwd: context.root, session: "retry-one", toolUseId: "retry-tool-one", phase: "pre", hintedPaths: ["target.txt"] });
+    captureStreamingDiff({ cwd: context.root, session: "retry-two", toolUseId: "retry-tool-two", phase: "pre", hintedPaths: ["target.txt"] });
+    writeFileSync(join(context.root, "target.txt"), "after\n");
+    const failed = captureStreamingDiff({
+      cwd: context.root, session: "retry-one", toolUseId: "retry-tool-one", phase: "post", hintedPaths: ["target.txt"],
+      append: () => { throw new Error("simulated append failure"); },
+    });
+    const retried = captureStreamingDiff({ cwd: context.root, session: "retry-one", toolUseId: "retry-tool-one", phase: "post", hintedPaths: ["target.txt"] });
+
+    assert.match(failed.error.message, /simulated append failure/u);
+    for (const card of [failed.card, retried.card]) {
+      assert.equal(card.status, "partial");
+      assert.match(card.partialReason, /overlapping concurrent edit \(unattributed\)/u);
+      assert.deepEqual(card.files, [{ path: "target.txt", kind: "unavailable", meta: { reason: "overlapping concurrent edit (unattributed)" } }]);
+    }
+  } finally { context.cleanup(); }
+});
+
+test("a failed overlapping post remains unattributed after its live windows expire", () => {
+  const context = fixture();
+  try {
+    const pre = captureStreamingDiff({ cwd: context.root, session: "expired-one", toolUseId: "expired-tool-one", phase: "pre", hintedPaths: ["target.txt"] });
+    captureStreamingDiff({ cwd: context.root, session: "expired-two", toolUseId: "expired-tool-two", phase: "pre", hintedPaths: ["target.txt"] });
+    writeFileSync(join(context.root, "target.txt"), "after\n");
+    const failed = captureStreamingDiff({
+      cwd: context.root, session: "expired-one", toolUseId: "expired-tool-one", phase: "post", hintedPaths: ["target.txt"],
+      append: () => { throw new Error("simulated append failure"); },
+    });
+    assert.match(failed.error.message, /simulated append failure/u);
+    assert.equal(existsSync(pre.snapshot.path.replace(/\.json$/u, ".overlapped")), true);
+    rmSync(join(context.root, ".local", "burnlist", "streaming-diff-active-windows.json"));
+
+    const retried = captureStreamingDiff({ cwd: context.root, session: "expired-one", toolUseId: "expired-tool-one", phase: "post", hintedPaths: ["target.txt"] });
+
+    assert.equal(retried.card.status, "partial");
+    assert.match(retried.card.partialReason, /overlapping concurrent edit \(unattributed\)/u);
+    assert.deepEqual(retried.card.files, [{ path: "target.txt", kind: "unavailable", meta: { reason: "overlapping concurrent edit (unattributed)" } }]);
+  } finally { context.cleanup(); }
+});
+
+test("the later peer remains unattributed after its active window expires", () => {
+  const context = fixture();
+  try {
+    captureStreamingDiff({ cwd: context.root, session: "first-peer", toolUseId: "first-tool", phase: "pre", hintedPaths: ["target.txt"] });
+    captureStreamingDiff({ cwd: context.root, session: "second-peer", toolUseId: "second-tool", phase: "pre", hintedPaths: ["target.txt"] });
+    writeFileSync(join(context.root, "target.txt"), "after\n");
+    captureStreamingDiff({ cwd: context.root, session: "first-peer", toolUseId: "first-tool", phase: "post", hintedPaths: ["target.txt"] });
+    rmSync(join(context.root, ".local", "burnlist", "streaming-diff-active-windows.json"));
+    const second = captureStreamingDiff({ cwd: context.root, session: "second-peer", toolUseId: "second-tool", phase: "post", hintedPaths: ["target.txt"] });
+    assert.equal(second.card.status, "partial");
+    assert.match(second.card.partialReason, /overlapping concurrent edit \(unattributed\)/u);
+  } finally { context.cleanup(); }
+});
+
+test("overlapping calls in one session are unattributed by tool-use id", () => {
+  const context = fixture();
+  try {
+    captureStreamingDiff({ cwd: context.root, session: "shared-session", toolUseId: "first-call", phase: "pre", hintedPaths: ["target.txt"] });
+    captureStreamingDiff({ cwd: context.root, session: "shared-session", toolUseId: "second-call", phase: "pre", hintedPaths: ["target.txt"] });
+    writeFileSync(join(context.root, "target.txt"), "after\n");
+    const first = captureStreamingDiff({ cwd: context.root, session: "shared-session", toolUseId: "first-call", phase: "post", hintedPaths: ["target.txt"] });
+    const second = captureStreamingDiff({ cwd: context.root, session: "shared-session", toolUseId: "second-call", phase: "post", hintedPaths: ["target.txt"] });
+
+    for (const result of [first, second]) {
+      assert.equal(result.card.status, "partial");
+      assert.match(result.card.partialReason, /overlapping concurrent edit \(unattributed\)/u);
+      assert.deepEqual(result.card.files, [{ path: "target.txt", kind: "unavailable", meta: { reason: "overlapping concurrent edit (unattributed)" } }]);
+    }
+  } finally { context.cleanup(); }
+});
+
+test("an active-window registry overflow makes the current capture unattributed", () => {
+  const context = fixture();
+  try {
+    const openedAt = Date.now();
+    for (let index = 0; index < STREAMING_DIFF_ACTIVE_WINDOW_MAX_ENTRIES; index += 1) {
+      registerActiveWindows({
+        identity: resolveStreamingDiffIdentity({ cwd: context.root, session: `live-${index}` }),
+        toolUseId: `live-tool-${index}`,
+        hintedPaths: [`live-${index}.txt`],
+        openedAt,
+      });
+    }
+    const target = join(context.root, "target.txt");
+    writeFileSync(target, "before\n");
+    const pre = captureStreamingDiff({ cwd: context.root, session: "overflow", toolUseId: "overflow-tool", phase: "pre", hintedPaths: ["target.txt"] });
+    assert.equal(pre.activeWindow.attributionUnavailable, true);
+    writeFileSync(target, "after\n");
+    const result = captureStreamingDiff({ cwd: context.root, session: "overflow", toolUseId: "overflow-tool", phase: "post", hintedPaths: ["target.txt"] });
+
+    assert.equal(result.card.status, "partial");
+    assert.match(result.card.partialReason, /attribution unavailable: too many concurrent windows/u);
+    assert.deepEqual(result.card.files, [{ path: "target.txt", kind: "unavailable", meta: { reason: "attribution unavailable: too many concurrent windows" } }]);
+  } finally { context.cleanup(); }
+});
+
+test("a registration lock timeout leaves the pre-snapshot unregistered", () => {
+  const context = fixture();
+  try {
+    let persistedMarker;
+    const locked = () => {
+      persistedMarker = takePreSnapshot({
+        identity: resolveStreamingDiffIdentity({ cwd: context.root, session: "locked" }), toolUseId: "locked-tool",
+      });
+      const error = new Error("busy");
+      error.code = "ELOCKED";
+      throw error;
+    };
+    const pre = captureStreamingDiff({
+      cwd: context.root, session: "locked", toolUseId: "locked-tool", phase: "pre", hintedPaths: ["target.txt"],
+      activeWindows: { registerActiveWindows: locked },
+    });
+    assert.equal(pre.activeWindow.attributionUnavailable, true);
+    assert.equal(persistedMarker.found, true);
+    assert.equal(persistedMarker.registered, false);
+    assert.equal(persistedMarker.attributionUnavailable, false);
+    assert.equal(takePreSnapshot({ identity: resolveStreamingDiffIdentity({ cwd: context.root, session: "locked" }), toolUseId: "locked-tool" }).attributionUnavailable, true);
+    writeFileSync(join(context.root, "target.txt"), "after\n");
+    const post = captureStreamingDiff({ cwd: context.root, session: "locked", toolUseId: "locked-tool", phase: "post", hintedPaths: ["target.txt"] });
+    assert.equal(post.card.status, "partial");
+    assert.match(post.card.partialReason, /active-window lock timed out/u);
+    assert.notEqual(post.card.status, "captured");
+  } finally { context.cleanup(); }
+});
+
+test("a corrupt active-window registry makes the terminal capture partial", () => {
+  const context = fixture();
+  try {
+    captureStreamingDiff({ cwd: context.root, session: "corrupt", toolUseId: "corrupt-tool", phase: "pre", hintedPaths: ["target.txt"] });
+    writeFileSync(join(context.root, ".local", "burnlist", "streaming-diff-active-windows.json"), "{ broken");
+    writeFileSync(join(context.root, "target.txt"), "after\n");
+    const result = captureStreamingDiff({ cwd: context.root, session: "corrupt", toolUseId: "corrupt-tool", phase: "post", hintedPaths: ["target.txt"] });
+    assert.equal(result.card.status, "partial");
+    assert.match(result.card.partialReason, /active-window registry unreadable/u);
+  } finally { context.cleanup(); }
+});
+
+test("a failed post publication preserves its pre-snapshot for a retry", () => {
+  const context = fixture();
+  try {
+    const pre = captureStreamingDiff({ cwd: context.root, session: "session-c", toolUseId: "tool-c", phase: "pre", hintedPaths: ["target.txt"] });
+    writeFileSync(join(context.root, "target.txt"), "after\n");
+    const result = captureStreamingDiff({
+      cwd: context.root,
+      session: "session-c",
+      toolUseId: "tool-c",
+      phase: "post",
+      hintedPaths: ["target.txt"],
+      append: () => { throw new Error("simulated append failure"); },
+    });
+    assert.match(result.error.message, /simulated append failure/u);
+    assert.equal(existsSync(pre.snapshot.path), true);
+  } finally { context.cleanup(); }
+});
+
+test("concurrent posts retry the journal lock and publish both terminal cards", async () => {
+  const context = fixture();
+  const session = "session-race";
+  const ready = join(context.root, "ready");
+  const go = join(context.root, "go");
+  const captureUrl = new URL("./streaming-diff-feed-capture.mjs", import.meta.url).href;
+  const post = (toolUseId) => new Promise((resolvePost, reject) => {
+    const source = `import { existsSync, writeFileSync } from "node:fs"; import { captureStreamingDiff } from ${JSON.stringify(captureUrl)}; const [ready, go, session, toolUseId] = process.argv.slice(1); writeFileSync(ready + "-" + process.pid, ""); while (!existsSync(go)) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5); const result = captureStreamingDiff({ session, toolUseId, phase: "post", hintedPaths: ["target.txt"] }); if (result.error) throw result.error;`;
+    const child = spawn(process.execPath, ["--input-type=module", "--eval", source, ready, go, session, toolUseId], { cwd: context.root, stdio: "ignore" });
+    child.on("error", reject);
+    child.on("exit", (status) => status === 0 ? resolvePost() : reject(new Error(`post exited ${status}`)));
+  });
+  try {
+    const first = captureStreamingDiff({ cwd: context.root, session, toolUseId: "tool-one", phase: "pre", hintedPaths: ["target.txt"] });
+    captureStreamingDiff({ cwd: context.root, session, toolUseId: "tool-two", phase: "pre", hintedPaths: ["target.txt"] });
+    writeFileSync(join(context.root, "target.txt"), "after\n");
+    writeFileSync(join(first.identity.feedDir, ".lock"), JSON.stringify({ pid: process.pid, token: "test-lock" }));
+    const one = post("tool-one");
+    const two = post("tool-two");
+    for (let attempt = 0; attempt < 100 && readdirSync(context.root).filter((name) => name.startsWith("ready-")).length < 2; attempt += 1) await new Promise((resolveWait) => setTimeout(resolveWait, 5));
+    assert.equal(readdirSync(context.root).filter((name) => name.startsWith("ready-")).length, 2);
+    writeFileSync(go, "go");
+    await new Promise((resolveWait) => setTimeout(resolveWait, 20));
+    rmSync(join(first.identity.feedDir, ".lock"), { force: true });
+    await Promise.all([one, two]);
+    const terminal = readJournal(first.identity.feedDir).cards.filter((card) => card.status !== "partial" || card.files.length > 0);
+    assert.deepEqual(terminal.map((card) => card.toolUseId).sort(), ["tool-one", "tool-two"]);
+  } finally { context.cleanup(); }
+});
+
+test("missing pre-state is an honest partial card rather than a fabricated baseline", () => {
+  const context = fixture();
+  try {
+    const result = captureStreamingDiff({ cwd: context.root, session: "session-b", toolUseId: "tool-b", phase: "post", hintedPaths: ["target.txt"] });
+    assert.equal(result.card.status, "partial");
+    assert.match(result.card.partialReason, /snapshot unavailable/u);
+    assert.equal(result.card.files[0].kind, "unavailable");
+  } finally { context.cleanup(); }
+});
+
+test("missing or corrupt pre-snapshots make the terminal card partial", () => {
+  const context = fixture();
+  try {
+    for (const [session, corrupt] of [["missing-snapshot", false], ["corrupt-snapshot", true]]) {
+      const pre = captureStreamingDiff({ cwd: context.root, session, toolUseId: "snapshot-tool", phase: "pre", hintedPaths: ["target.txt"] });
+      if (corrupt) writeFileSync(pre.snapshot.path, "{ broken");
+      else rmSync(pre.snapshot.path);
+      writeFileSync(join(context.root, "target.txt"), `${session}\n`);
+      const result = captureStreamingDiff({ cwd: context.root, session, toolUseId: "snapshot-tool", phase: "post", hintedPaths: ["target.txt"] });
+      assert.equal(result.card.status, "partial");
+      assert.match(result.card.partialReason, /pre-snapshot unreadable/u);
+      assert.notEqual(result.card.status, "captured");
+    }
+  } finally { context.cleanup(); }
+});
+
+test("an immutable snapshot permits captured attribution only after its registered marker exists", () => {
+  const context = fixture();
+  try {
+    const identity = resolveStreamingDiffIdentity({ cwd: context.root, session: "clear-atomic" });
+    writePreSnapshot({ identity, toolUseId: "clear-tool", hintedPaths: ["target.txt"] });
+    assert.equal(takePreSnapshot({ identity, toolUseId: "clear-tool" }).registered, false);
+    writeFileSync(join(context.root, "target.txt"), "after\n");
+    const failed = captureStreamingDiff({ cwd: context.root, session: "clear-atomic", toolUseId: "clear-tool", phase: "post", hintedPaths: ["target.txt"] });
+    assert.equal(failed.card.status, "partial");
+
+    writePreSnapshot({ identity, toolUseId: "directory-fsync", hintedPaths: ["target.txt"] });
+    assert.doesNotThrow(() => markPreSnapshotRegistered({ identity, toolUseId: "directory-fsync" }));
+    assert.equal(takePreSnapshot({ identity, toolUseId: "directory-fsync" }).registered, true);
+    registerActiveWindows({ identity, toolUseId: "directory-fsync", hintedPaths: ["target.txt"] });
+    const committed = captureStreamingDiff({ cwd: context.root, session: "clear-atomic", toolUseId: "directory-fsync", phase: "post", hintedPaths: ["target.txt"] });
+    assert.equal(committed.card.status, "captured");
+  } finally { context.cleanup(); }
+});
+
+test("a late registered marker cannot overwrite a peer overlap marker", () => {
+  const context = fixture();
+  try {
+    const identity = resolveStreamingDiffIdentity({ cwd: context.root, session: "marker-race" });
+    const activeWindows = {
+      registerActiveWindows: () => ({ attributionUnavailable: false }),
+      inspectActiveWindowOverlap: () => {
+        // Registration has observed no overlap. Before it creates its marker,
+        // a peer determines that this attempt overlaps and marks it.
+        markPreSnapshotOverlapped({ identity, toolUseId: "marker-tool" });
+        return { paths: [], attributionUnavailable: false };
+      },
+    };
+    const pre = captureStreamingDiff({
+      cwd: context.root, session: "marker-race", toolUseId: "marker-tool", phase: "pre", hintedPaths: ["target.txt"], activeWindows,
+    });
+    assert.equal(takePreSnapshot({ identity, toolUseId: "marker-tool" }).registered, true);
+    assert.equal(takePreSnapshot({ identity, toolUseId: "marker-tool" }).overlapped, true);
+    assert.equal(JSON.parse(readFileSync(pre.snapshot.path, "utf8")).overlapped, undefined);
+
+    writeFileSync(join(context.root, "target.txt"), "after\n");
+    const post = captureStreamingDiff({ cwd: context.root, session: "marker-race", toolUseId: "marker-tool", phase: "post", hintedPaths: ["target.txt"] });
+    assert.equal(post.card.status, "partial");
+    assert.match(post.card.partialReason, /overlapping concurrent edit \(unattributed\)/u);
+    assert.deepEqual(post.card.files, [{ path: "target.txt", kind: "unavailable", meta: { reason: "overlapping concurrent edit (unattributed)" } }]);
+  } finally { context.cleanup(); }
+});
+
+test("a degraded pre-hook reason survives to force its terminal card partial", () => {
+  const context = fixture();
+  try {
+    captureStreamingDiff({
+      cwd: context.root, session: "session-degraded", toolUseId: "tool-degraded", phase: "pre",
+      hintedPaths: ["target.txt"], terminalReason: "path-hints-truncated",
+    });
+    writeFileSync(join(context.root, "target.txt"), "after\n");
+    const result = captureStreamingDiff({
+      cwd: context.root, session: "session-degraded", toolUseId: "tool-degraded", phase: "post", hintedPaths: ["target.txt"],
+    });
+    assert.equal(result.card.status, "partial");
+    assert.match(result.card.partialReason, /path hints truncated/u);
+  } finally { context.cleanup(); }
+});
+
+test("a denied-only snapshot stays visible and adapter text never reaches feed bytes", () => {
+  const context = fixture();
+  try {
+    const secret = "token=not-for-the-feed";
+    captureStreamingDiff({ cwd: context.root, session: "session-denied", toolUseId: "tool-denied", phase: "pre", hintedPaths: [".env"], terminalReason: secret });
+    writeFileSync(join(context.root, ".env"), "after\n");
+    const result = captureStreamingDiff({ cwd: context.root, session: "session-denied", toolUseId: "tool-denied", phase: "post", hintedPaths: [".env"], terminalReason: secret });
+    const bytes = readFileSync(join(result.identity.feedDir, `rev-${result.card.revId}.json`), "utf8");
+    assert.equal(result.card.status, "partial");
+    assert.deepEqual(result.card.files, [{ path: ".env", kind: "denied" }]);
+    assert.equal(bytes.includes(secret), false);
+    assert.equal(result.card.partialReason.includes(secret), false);
+  } finally { context.cleanup(); }
+});
diff --git a/ovens/streaming-diff/engine/streaming-diff-feed.mjs b/ovens/streaming-diff/engine/streaming-diff-feed.mjs
new file mode 100644
index 0000000..fcf225b
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-feed.mjs
@@ -0,0 +1,97 @@
+import { createHash } from "node:crypto";
+import { mkdirSync, realpathSync } from "node:fs";
+import { relative } from "node:path";
+
+import { gitProbe, resolveUmbrella } from "../../../src/cli/umbrella.mjs";
+import { repoKey } from "../../../src/server/registry.mjs";
+import { containedJoin, repoStateDir, withRepoStateLock } from "../../../src/server/repo-state.mjs";
+
+export const STREAMING_DIFF_OVEN_ID = "streaming-diff";
+export const STREAMING_DIFF_FEED_VERSION = "v2";
+const MAX_IDENTIFIER_BYTES = 200;
+
+function loneSurrogate(value) {
+  return /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u.test(value);
+}
+
+export function streamingDiffIdentifier(value, label) {
+  if (typeof value !== "string" || !value.trim() || Buffer.byteLength(value, "utf8") > MAX_IDENTIFIER_BYTES
+    || /[\u0000-\u001F\u007F-\u009F]/u.test(value) || loneSurrogate(value)) {
+    throw new Error(`streaming diff ${label} must be a non-empty, well-formed identifier of at most ${MAX_IDENTIFIER_BYTES} UTF-8 bytes without control characters`);
+  }
+  return value;
+}
+
+export function identifierPathComponent(value) {
+  return createHash("sha256").update(value, "utf8").digest("hex").slice(0, 32);
+}
+
+export function sessionId(value) {
+  return streamingDiffIdentifier(value, "session");
+}
+
+function worktreeRoot(cwd) {
+  const topLevel = gitProbe(cwd, ["rev-parse", "--show-toplevel"]);
+  if (!topLevel) throw new Error(`streaming diff requires a Git worktree: ${cwd}`);
+  return realpathSync(topLevel);
+}
+
+export function resolveStreamingDiffIdentity({ cwd = process.cwd(), session } = {}) {
+  const logicalRepoRoot = realpathSync(resolveUmbrella(cwd));
+  const root = worktreeRoot(cwd);
+  const safeSession = sessionId(session);
+  const logicalRepoKey = repoKey(logicalRepoRoot);
+  const worktreeKey = repoKey(root);
+  const feedRoot = containedJoin(logicalRepoRoot, "streaming-diff", STREAMING_DIFF_FEED_VERSION);
+  const sessionPath = identifierPathComponent(safeSession);
+  const feedDir = containedJoin(logicalRepoRoot, "streaming-diff", STREAMING_DIFF_FEED_VERSION, logicalRepoKey, worktreeKey, sessionPath);
+  return {
+    logicalRepoRoot,
+    logicalRepoKey,
+    worktreeRoot: root,
+    worktreeKey,
+    session: safeSession,
+    sessionPath,
+    feedRoot,
+    feedDir,
+  };
+}
+
+export function feedIdentity(identity) {
+  return {
+    logicalRepoKey: identity.logicalRepoKey,
+    worktreeKey: identity.worktreeKey,
+    session: identity.session,
+  };
+}
+
+export function streamingDiffBindingPath(identity) {
+  const path = relative(identity.logicalRepoRoot, identity.feedRoot);
+  if (!path || path.startsWith("..")) throw new Error("streaming diff feed root is not contained in the logical repository");
+  return path;
+}
+
+export function ensureFeedDirectory(identity) {
+  return withRepoStateLock(identity.logicalRepoRoot, () => {
+    // containedJoin has already checked every path component and nearest real
+    // parent. Directory creation is safe to repeat and never exposes a file.
+    mkdirSync(identity.feedDir, { recursive: true });
+    return identity.feedDir;
+  });
+}
+
+export function snapshotDirectory(identity) {
+  return containedJoin(
+    identity.logicalRepoRoot,
+    "streaming-diff",
+    STREAMING_DIFF_FEED_VERSION,
+    identity.logicalRepoKey,
+    identity.worktreeKey,
+    identity.sessionPath ?? identifierPathComponent(identity.session),
+    "snapshots",
+  );
+}
+
+export function streamingDiffStateDir(identity) {
+  return repoStateDir(identity.logicalRepoRoot);
+}
diff --git a/ovens/streaming-diff/engine/streaming-diff-feed.test.mjs b/ovens/streaming-diff/engine/streaming-diff-feed.test.mjs
new file mode 100644
index 0000000..a32565c
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-feed.test.mjs
@@ -0,0 +1,81 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, realpathSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { resolveStreamingDiffIdentity, sessionId, snapshotDirectory, streamingDiffBindingPath } from "./streaming-diff-feed.mjs";
+import { captureStreamingDiff } from "./streaming-diff-feed-capture.mjs";
+import { readJournal } from "./streaming-diff-journal.mjs";
+import { writePreSnapshot } from "./streaming-diff-snapshot-store.mjs";
+
+function git(cwd, ...args) {
+  execFileSync("git", ["-C", cwd, ...args], { stdio: "ignore" });
+}
+
+function fixture() {
+  const root = mkdtempSync(join(tmpdir(), "burnlist-streaming-feed-"));
+  git(root, "init", "--quiet");
+  git(root, "config", "user.email", "test@example.invalid");
+  git(root, "config", "user.name", "Test");
+  git(root, "commit", "--allow-empty", "--quiet", "-m", "initial");
+  const linked = join(tmpdir(), `burnlist-streaming-feed-worktree-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+  git(root, "worktree", "add", "--detach", linked);
+  return { root, linked, cleanup: () => { rmSync(root, { recursive: true, force: true }); rmSync(linked, { recursive: true, force: true }); } };
+}
+
+test("feed identity partitions linked worktrees under the primary repository state", () => {
+  const context = fixture();
+  try {
+    const primary = resolveStreamingDiffIdentity({ cwd: context.root, session: "agent-a" });
+    const linked = resolveStreamingDiffIdentity({ cwd: context.linked, session: "agent-a" });
+    assert.equal(primary.logicalRepoRoot, realpathSync(context.root));
+    assert.equal(linked.logicalRepoRoot, realpathSync(context.root));
+    assert.notEqual(primary.worktreeRoot, linked.worktreeRoot);
+    assert.notEqual(primary.worktreeKey, linked.worktreeKey);
+    assert.notEqual(primary.feedDir, linked.feedDir);
+    assert.match(linked.feedDir, new RegExp(`${linked.logicalRepoKey}/${linked.worktreeKey}/[a-f0-9]{32}$`));
+    assert.equal(streamingDiffBindingPath(linked), ".local/burnlist/streaming-diff/v2");
+    assert.match(snapshotDirectory(linked), new RegExp(`${linked.worktreeKey}/[a-f0-9]{32}/snapshots$`));
+  } finally { context.cleanup(); }
+});
+
+test("session and tool identifiers reject hostile input while hashed names preserve exact identities", () => {
+  const context = fixture();
+  try {
+    const oversize = "x".repeat(201);
+    for (const value of ["", " \t", "has\u0000nul", "has\nnewline", "has\u001fcontrol", oversize, "lone-\ud800"]) {
+      assert.throws(() => sessionId(value), /identifier/u);
+      assert.throws(() => writePreSnapshot({ identity: resolveStreamingDiffIdentity({ cwd: context.root, session: "valid" }), toolUseId: value }), /tool use id/u);
+    }
+    const unusual = "café-😀";
+    assert.equal(sessionId(unusual), unusual);
+    assert.equal(writePreSnapshot({ identity: resolveStreamingDiffIdentity({ cwd: context.root, session: "valid" }), toolUseId: unusual }).hintedPaths.length, 0);
+    const upper = resolveStreamingDiffIdentity({ cwd: context.root, session: "Agent-A" });
+    const lower = resolveStreamingDiffIdentity({ cwd: context.root, session: "agent-a" });
+    assert.notEqual(upper.feedDir, lower.feedDir);
+    captureStreamingDiff({ cwd: context.root, session: "Agent-A", toolUseId: "tool-upper", phase: "pre" });
+    captureStreamingDiff({ cwd: context.root, session: "agent-a", toolUseId: "tool-lower", phase: "pre" });
+    assert.equal(existsSync(upper.feedDir), true);
+    assert.equal(existsSync(lower.feedDir), true);
+    assert.equal(readJournal(upper.feedDir).manifest.identity.session, "Agent-A");
+    assert.equal(readJournal(lower.feedDir).manifest.identity.session, "agent-a");
+    const toolUpper = writePreSnapshot({ identity: upper, toolUseId: "Tool-A" });
+    const toolLower = writePreSnapshot({ identity: upper, toolUseId: "tool-a" });
+    assert.notEqual(toolUpper.path, toolLower.path);
+  } finally { context.cleanup(); }
+});
+
+test("path-looking session text is stored as identity data, never as a path component", () => {
+  const context = fixture();
+  try {
+    for (const value of ["../other", "nested/session", ".", "..", "x\\y"]) {
+      const identity = resolveStreamingDiffIdentity({ cwd: context.root, session: value });
+      assert.equal(identity.session, value);
+      assert.match(identity.sessionPath, /^[a-f0-9]{32}$/u);
+    }
+    assert.throws(() => sessionId(""), /identifier/u);
+    mkdirSync(join(context.root, "nested"));
+  } finally { context.cleanup(); }
+});
diff --git a/ovens/streaming-diff/engine/streaming-diff-handler.mjs b/ovens/streaming-diff/engine/streaming-diff-handler.mjs
new file mode 100644
index 0000000..d93fb63
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-handler.mjs
@@ -0,0 +1,326 @@
+import { opendirSync, realpathSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+
+import { registerOvenHandler } from "../../../src/ovens/oven-registry.mjs";
+import { containedJoin } from "../../../src/server/repo-state.mjs";
+import { STREAMING_DIFF_FEED_VERSION, STREAMING_DIFF_OVEN_ID, identifierPathComponent, streamingDiffIdentifier } from "./streaming-diff-feed.mjs";
+import { readJournal, readManifestPure, resolveReconnect } from "./streaming-diff-journal.mjs";
+
+export const STREAMING_DIFF_SSE_DEFAULTS = Object.freeze({
+  pollMs: 300, heartbeatMs: 15_000, maxGlobalSubscribers: 128, maxSubscribersPerFeed: 32,
+});
+// Listing reads at most this many session directories and manifest bytes; cards
+// are deliberately never read until a specific feed is selected.
+export const STREAMING_DIFF_LIST_LIMITS = Object.freeze({ maxFeedDirs: 128, maxBytes: 256 * 1024 });
+const KEY_PATTERN = /^[a-f0-9]{12}$/u;
+const SESSION_PATH_PATTERN = /^[a-f0-9]{32}$/u;
+const SSE_WIRE_PREFIX = `${STREAMING_DIFF_FEED_VERSION}:`;
+const subscribers = new Map();
+let subscriberTotal = 0;
+
+function httpError(message, status = 400) {
+  return Object.assign(new Error(message), { status, streamingDiffPublic: true });
+}
+
+function isWithin(parent, child) {
+  const path = relative(parent, child);
+  return path === "" || (path !== ".." && !path.startsWith(`..${sep}`));
+}
+
+function queryValue(url, name) {
+  const values = url.searchParams.getAll(name);
+  if (values.length > 1) throw httpError(`${name} must be supplied at most once`);
+  return values[0] ?? null;
+}
+
+function listRepoKey(ctx) {
+  const repoKey = queryValue(ctx.url, "repoKey");
+  if (!KEY_PATTERN.test(repoKey ?? "")) {
+    throw httpError("Streaming Diff list requires a lowercase 12-character hexadecimal repoKey");
+  }
+  return repoKey;
+}
+
+function feedRoot(ctx) {
+  if (!ctx.binding?.repoRoot || !ctx.bindingPath) throw httpError("Streaming Diff requires a repository-scoped feed binding", 404);
+  const expected = containedJoin(ctx.binding.repoRoot, "streaming-diff", STREAMING_DIFF_FEED_VERSION);
+  let root;
+  try {
+    root = realpathSync(ctx.bindingPath);
+  } catch (error) {
+    if (error?.code === "ENOENT") throw httpError("configured Streaming Diff feed root is missing", 404);
+    throw error;
+  }
+  const canonicalExpected = realpathSync(expected);
+  if (root !== canonicalExpected) {
+    throw httpError("configured Streaming Diff feed root escapes its repository");
+  }
+  return { root, repoRoot: ctx.binding.repoRoot };
+}
+
+function verifyFeed(ctx, rootInfo, feed) {
+  if (realpathSync(ctx.bindingPath) !== rootInfo.root) throw httpError("configured Streaming Diff feed root changed during read");
+  let resolved;
+  try {
+    resolved = realpathSync(feed.path);
+  } catch (error) {
+    if (error?.code === "ENOENT") throw httpError("Streaming Diff session feed is not available", 404);
+    throw error;
+  }
+  if (!isWithin(rootInfo.root, resolved)) throw httpError("Streaming Diff session feed escapes its feed root");
+  const journal = (ctx.readJournal ?? readJournal)(resolved);
+  if (!journal.manifest) throw httpError("Streaming Diff session feed has no published manifest", 404);
+  const identity = journal.manifest.identity;
+  if (identity.logicalRepoKey !== feed.repoKey || identity.worktreeKey !== feed.worktreeKey || identity.session !== feed.session) {
+    throw httpError("Streaming Diff session identity does not match its feed path");
+  }
+  return { ...feed, path: resolved, identity, journal };
+}
+
+function selectedFeed(ctx, rootInfo) {
+  if (ctx.url.searchParams.has("list")) return null;
+  const repoKey = queryValue(ctx.url, "repoKey");
+  const worktreeKey = queryValue(ctx.url, "worktreeKey");
+  const session = queryValue(ctx.url, "session");
+  if (!session) return null;
+  if (!KEY_PATTERN.test(repoKey ?? "") || !KEY_PATTERN.test(worktreeKey ?? "")) {
+    throw httpError("repoKey and worktreeKey must be lowercase 12-character hexadecimal keys");
+  }
+  const safeSession = streamingDiffIdentifier(session, "session");
+  const path = containedJoin(rootInfo.repoRoot, "streaming-diff", STREAMING_DIFF_FEED_VERSION, repoKey, worktreeKey, identifierPathComponent(safeSession));
+  return verifyFeed(ctx, rootInfo, { path, repoKey, worktreeKey, session: safeSession });
+}
+
+function safeUpdatedAt(value, now = Date.now()) {
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) && timestamp <= now + 5 * 60_000 ? value : null;
+}
+
+function directoryEntries(path, limit, visit) {
+  let directory;
+  try {
+    directory = opendirSync(path);
+    for (let count = 0; count < limit; count += 1) {
+      const entry = directory.readSync();
+      if (!entry) return false;
+      if (visit(entry) === false) return true;
+    }
+    return directory.readSync() !== null;
+  } catch (error) {
+    if (error?.code === "ENOENT" || error?.code === "ENOTDIR") return false;
+    throw error;
+  } finally {
+    directory?.closeSync();
+  }
+}
+
+function recentFeeds(root, repoKey, maxBytes, manifestReader = readManifestPure) {
+  const feeds = [];
+  let bytes = 0;
+  let remaining = STREAMING_DIFF_LIST_LIMITS.maxFeedDirs;
+  let truncated = false;
+  const repoPath = join(root, repoKey);
+  const keep = (entry) => {
+    const entryBytes = Buffer.byteLength(JSON.stringify(entry), "utf8");
+    if (bytes + entryBytes > maxBytes) {
+      truncated = true;
+      return false;
+    }
+    bytes += entryBytes;
+    feeds.push(entry);
+    return true;
+  };
+  try {
+    truncated ||= directoryEntries(repoPath, STREAMING_DIFF_LIST_LIMITS.maxFeedDirs, (worktree) => {
+      if (!worktree.isDirectory() || !KEY_PATTERN.test(worktree.name) || remaining <= 0) return remaining > 0;
+      const worktreePath = join(repoPath, worktree.name);
+      const more = directoryEntries(worktreePath, remaining, (session) => {
+        if (!session.isDirectory() || !SESSION_PATH_PATTERN.test(session.name)) return true;
+        remaining -= 1;
+        try {
+          const resolved = realpathSync(join(worktreePath, session.name));
+          if (!isWithin(root, resolved)) return true;
+          const manifest = manifestReader(resolved);
+          if (!manifest || manifest.identity.logicalRepoKey !== repoKey || manifest.identity.worktreeKey !== worktree.name
+            || identifierPathComponent(manifest.identity.session) !== session.name) return true;
+          return keep({ identity: manifest.identity, updatedAt: safeUpdatedAt(manifest.updatedAt) });
+        } catch {
+          return true;
+        }
+      });
+      if (more || remaining === 0) truncated = true;
+      return !truncated;
+    });
+  } catch {
+    // Incomplete, stale, or adversarial directories are not feeds.
+  }
+  return {
+    feeds: feeds.sort((left, right) => (Date.parse(right.updatedAt ?? "") || 0) - (Date.parse(left.updatedAt ?? "") || 0)),
+    truncated,
+  };
+}
+
+function bounded(value, maxBytes) {
+  if (Buffer.byteLength(JSON.stringify(value), "utf8") > maxBytes) throw httpError(`Streaming Diff response exceeds its ${maxBytes}-byte limit`, 413);
+  return value;
+}
+
+function boundedList(value, maxBytes) {
+  while (Buffer.byteLength(JSON.stringify(value), "utf8") > maxBytes && value.feeds.length) {
+    value.feeds.pop();
+    value.truncated = true;
+  }
+  return bounded(value, maxBytes);
+}
+
+function wantsSse(req) {
+  return String(req.headers.accept ?? "").split(",").some((value) => value.trim().startsWith("text/event-stream"));
+}
+
+function cursor(feed, revId) {
+  return `${SSE_WIRE_PREFIX}${feed.identity.logicalRepoKey}:${feed.identity.worktreeKey}:${identifierPathComponent(feed.identity.session)}:${feed.journal.manifest.generation}:${revId}`;
+}
+
+function reconnectSince(ctx, feed) {
+  const since = queryValue(ctx.url, "since");
+  const header = ctx.req.headers["last-event-id"];
+  const lastEventId = Array.isArray(header) ? header[0] : header;
+  if (since && lastEventId && since !== lastEventId) throw httpError("since and Last-Event-ID must match when both are supplied");
+  const value = since ?? lastEventId ?? null;
+  if (value === null) return null;
+  const prefix = cursor(feed, "");
+  return value.startsWith(prefix) ? value.slice(prefix.length) : "";
+}
+
+function reserveSubscriber(path, options) {
+  if (subscriberTotal >= options.maxGlobalSubscribers || (subscribers.get(path) ?? 0) >= options.maxSubscribersPerFeed) return false;
+  subscriberTotal += 1;
+  subscribers.set(path, (subscribers.get(path) ?? 0) + 1);
+  return true;
+}
+
+function releaseSubscriber(path) {
+  const count = subscribers.get(path) ?? 0;
+  if (count > 1) subscribers.set(path, count - 1);
+  else subscribers.delete(path);
+  subscriberTotal = Math.max(0, subscriberTotal - 1);
+}
+
+function sseWrite(res, state, text) {
+  if (state.pending) return false;
+  const accepted = res.write(text);
+  if (!accepted) {
+    state.pending = true;
+    state.drain = () => { state.pending = false; state.drain = null; };
+    res.once("drain", state.drain);
+  }
+  return true;
+}
+
+function startSse(ctx, feed) {
+  const options = { ...STREAMING_DIFF_SSE_DEFAULTS, ...(ctx.sseOptions ?? {}) };
+  const timers = ctx.timers ?? { setInterval, clearInterval };
+  const since = reconnectSince(ctx, feed);
+  const reconnect = (lastId) => {
+    if (ctx.reconnectFeed) return { result: ctx.reconnectFeed(feed.path, lastId), feed };
+    const current = verifyFeed(ctx, ctx.rootInfo, feed);
+    const reconnectId = current.journal.manifest.generation === feed.journal.manifest.generation ? lastId : "";
+    const result = !current.journal.manifest || current.journal.race
+      ? { type: "reset", cards: current.journal.cards }
+      : resolveReconnect(current.journal.manifest, current.journal.cards, reconnectId);
+    return { result, feed: current };
+  };
+  // The only fallible initial read happens before writeHead, allowing the
+  // route to return a normal JSON error rather than double-sending headers.
+  const initial = reconnect(since);
+  if (!reserveSubscriber(feed.path, options)) throw httpError("Streaming Diff subscriber limit reached", 503);
+  const res = ctx.res;
+  const state = { closed: false, pending: false, drain: null, poll: null, heartbeat: null, lastId: since, feed: initial.feed };
+  const cleanup = () => {
+    if (state.closed) return;
+    state.closed = true;
+    if (state.poll !== null) timers.clearInterval(state.poll);
+    if (state.heartbeat !== null) timers.clearInterval(state.heartbeat);
+    if (state.drain) res.removeListener("drain", state.drain);
+    res.removeListener("close", cleanup);
+    res.removeListener("error", cleanup);
+    res.removeListener("finish", cleanup);
+    releaseSubscriber(feed.path);
+  };
+  const endStream = () => {
+    cleanup();
+    if (!res.writableEnded) res.end?.();
+  };
+  const closeSlow = () => {
+    cleanup();
+    res.destroy?.();
+  };
+  const event = (card) => {
+    const payload = JSON.stringify(card);
+    if (Buffer.byteLength(payload, "utf8") > ctx.maxOvenDataBytes) return closeSlow();
+    if (!sseWrite(res, state, `id: ${cursor(state.feed, card.revId)}\ndata: ${payload}\n\n`)) closeSlow();
+    else state.lastId = card.revId;
+  };
+  const publish = ({ result, feed: current }) => {
+    if (state.closed) return;
+    state.feed = current;
+    if (result.type === "reset" && !sseWrite(res, state, "event: reset\ndata: {\"type\":\"reset\"}\n\n")) return closeSlow();
+    for (const card of result.cards) {
+      if (state.closed) return;
+      event(card);
+    }
+  };
+  const poll = () => {
+    try {
+      publish(reconnect(state.lastId));
+    } catch {
+      endStream();
+    }
+  };
+  try {
+    res.writeHead(200, { "content-type": "text/event-stream; charset=utf-8", "cache-control": "no-cache, no-transform", connection: "keep-alive" });
+    res.flushHeaders?.();
+    res.on("close", cleanup);
+    res.on("error", cleanup);
+    res.on("finish", cleanup);
+    publish(initial);
+    if (!state.closed) {
+      state.poll = timers.setInterval(poll, options.pollMs);
+      state.heartbeat = timers.setInterval(() => {
+        try {
+          if (!sseWrite(res, state, ": heartbeat\n\n")) closeSlow();
+        } catch {
+          endStream();
+        }
+      }, options.heartbeatMs);
+    }
+  } catch {
+    // Once writeHead succeeds, never rethrow into the JSON route catch.
+    endStream();
+  }
+}
+
+export const streamingDiffHandler = Object.freeze({
+  id: STREAMING_DIFF_OVEN_ID,
+
+  serveData(ctx) {
+    try {
+      const root = feedRoot(ctx);
+      if (ctx.url.searchParams.has("list")) {
+        const repoKey = listRepoKey(ctx);
+        const limit = Math.min(ctx.maxOvenDataBytes, STREAMING_DIFF_LIST_LIMITS.maxBytes);
+        return boundedList({ ovenId: STREAMING_DIFF_OVEN_ID, ...recentFeeds(root.root, repoKey, limit, ctx.readManifest) }, ctx.maxOvenDataBytes);
+      }
+      const feed = selectedFeed(ctx, root);
+      if (!feed) return bounded({ ovenId: STREAMING_DIFF_OVEN_ID, feeds: [] }, ctx.maxOvenDataBytes);
+      if (!wantsSse(ctx.req)) return bounded({ ovenId: STREAMING_DIFF_OVEN_ID, identity: feed.identity, updatedAt: feed.journal.manifest.updatedAt, cards: feed.journal.cards, reset: feed.journal.race }, ctx.maxOvenDataBytes);
+      startSse({ ...ctx, rootInfo: root }, feed);
+      return undefined;
+    } catch (error) {
+      if (error?.streamingDiffPublic) throw error;
+      throw httpError("Streaming Diff feed is unavailable", Number.isInteger(error?.status) ? error.status : 422);
+    }
+  },
+});
+
+registerOvenHandler(STREAMING_DIFF_OVEN_ID, streamingDiffHandler);
diff --git a/ovens/streaming-diff/engine/streaming-diff-handler.test.mjs b/ovens/streaming-diff/engine/streaming-diff-handler.test.mjs
new file mode 100644
index 0000000..edb6f81
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-handler.test.mjs
@@ -0,0 +1,310 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { createServer, get } from "node:http";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { withServer } from "../../../src/server/dashboard-routes-fixtures.mjs";
+import { appendCard, readJournal } from "./streaming-diff-journal.mjs";
+import { ensureStreamingDiffFeed } from "./streaming-diff-ensure-feed.mjs";
+import { feedIdentity } from "./streaming-diff-feed.mjs";
+import { STREAMING_DIFF_LIST_LIMITS, streamingDiffHandler } from "./streaming-diff-handler.mjs";
+
+function card(index) {
+  return { revId: `r-${index.toString(16).padStart(24, "a")}`, toolUseId: `tool-${index}`, ts: `2026-07-15T12:00:0${index}.000Z`, status: "captured", files: [{ path: `file-${index}.txt`, kind: "modified", diff: "--- a/file\n+++ b/file\n@@ -1 +1 @@\n-before\n+after" }] };
+}
+
+function largeCard(index) {
+  return { ...card(index), files: [{ path: `large-${index}.txt`, kind: "modified", diff: "x".repeat(250_000) }] };
+}
+
+function fixture() {
+  const root = mkdtempSync(join(tmpdir(), "burnlist-streaming-handler-"));
+  execFileSync("git", ["init", "--quiet"], { cwd: root, stdio: "ignore" });
+  const context = ensureStreamingDiffFeed({ cwd: root, session: "handler-direct" });
+  return { root, context, cleanup: () => rmSync(root, { recursive: true, force: true }) };
+}
+
+function handlerContext(context, overrides = {}) {
+  const query = `repoKey=${context.identity.logicalRepoKey}&worktreeKey=${context.identity.worktreeKey}&session=handler-direct`;
+  return {
+    binding: { repoRoot: context.identity.logicalRepoRoot }, bindingPath: context.identity.feedRoot,
+    req: { headers: {} }, url: new URL(`http://localhost/?${query}`), maxOvenDataBytes: 1024 * 1024,
+    ...overrides,
+  };
+}
+
+function timerHarness() {
+  const active = new Set();
+  const cleared = [];
+  return {
+    timers: {
+      setInterval(fn, delay) { const handle = { fn, delay }; active.add(handle); return handle; },
+      clearInterval(handle) { cleared.push(handle); active.delete(handle); },
+    },
+    active,
+    cleared,
+  };
+}
+
+class FakeResponse extends EventEmitter {
+  constructor({ slow = false } = {}) {
+    super();
+    this.slow = slow;
+    this.headers = null;
+    this.writes = [];
+    this.destroyed = false;
+    this.ended = false;
+  }
+
+  writeHead(status, headers) { this.headers = { status, headers }; }
+  write(value) { this.writes.push(value); return !this.slow; }
+  end() { this.ended = true; this.emit("finish"); }
+  destroy() { this.destroyed = true; this.emit("close"); }
+}
+
+async function requestSse(baseUrl, path, headers = {}) {
+  let stream;
+  await new Promise((resolve, reject) => {
+    const request = get(new URL(path, baseUrl), { headers: { accept: "text/event-stream", ...headers } }, (response) => {
+      if (response.statusCode !== 200) {
+        response.resume();
+        reject(new Error(`SSE response status was ${response.statusCode}, expected 200`));
+        return;
+      }
+      let buffer = "";
+      stream = { events: [], closed: false, error: null, response };
+      response.setEncoding("utf8");
+      response.on("data", (chunk) => {
+        buffer += chunk;
+        for (;;) {
+          const boundary = buffer.indexOf("\n\n");
+          if (boundary < 0) break;
+          const block = buffer.slice(0, boundary);
+          buffer = buffer.slice(boundary + 2);
+          if (block.startsWith(":")) stream.events.push({ comment: block });
+          else stream.events.push({ id: block.match(/^id: (.+)$/mu)?.[1] ?? null, type: block.match(/^event: (.+)$/mu)?.[1] ?? "message", data: JSON.parse(block.match(/^data: (.+)$/mu)?.[1] ?? "null") });
+        }
+      });
+      response.once("error", (error) => { if (!stream.closed) stream.error = error; });
+      response.once("end", () => { if (!stream.closed) stream.error = new Error("SSE stream ended before the expected cards arrived"); });
+      resolve();
+    });
+    request.once("error", reject);
+  });
+  stream.close = () => { stream.closed = true; stream.response.destroy(); };
+  return stream;
+}
+
+async function waitFor(predicate, label) {
+  const deadline = Date.now() + 4_000;
+  while (Date.now() < deadline) {
+    if (predicate()) return;
+    await new Promise((resolve) => setTimeout(resolve, 20));
+  }
+  throw new Error(`Timed out waiting for ${label}`);
+}
+
+async function canBindLoopback() {
+  const server = createServer();
+  try {
+    await new Promise((resolve, reject) => { server.once("error", reject); server.listen(0, "127.0.0.1", resolve); });
+    return true;
+  } catch (error) {
+    if (error?.code === "EPERM" || error?.code === "EACCES") return false;
+    throw error;
+  } finally {
+    await new Promise((resolve) => server.close(() => resolve()));
+  }
+}
+
+test("dashboard pure read leaves a raced feed untouched and reports reset", () => {
+  const { context, cleanup } = fixture();
+  try {
+    appendCard(context.identity.feedDir, card(1), { identity: feedIdentity(context.identity) });
+    const manifest = join(context.identity.feedDir, "manifest.json");
+    const revision = join(context.identity.feedDir, `rev-${card(1).revId}.json`);
+    unlinkSync(revision);
+    const before = { manifest: readFileSync(manifest, "utf8"), mtime: statSync(manifest).mtimeMs };
+    const response = streamingDiffHandler.serveData(handlerContext(context));
+    assert.equal(response.reset, true);
+    assert.deepEqual(response.cards, []);
+    const res = new FakeResponse();
+    streamingDiffHandler.serveData(handlerContext(context, {
+      req: { headers: { accept: "text/event-stream" } }, res,
+      timers: { setInterval: () => null, clearInterval: () => {} },
+    }));
+    assert.match(res.writes.join(""), /event: reset\ndata: \{"type":"reset"\}/u);
+    res.emit("close");
+    assert.equal(readFileSync(manifest, "utf8"), before.manifest);
+    assert.equal(statSync(manifest).mtimeMs, before.mtime);
+  } finally { cleanup(); }
+});
+
+test("recent feeds reads only bounded manifests and never card payloads", () => {
+  const { root, context, cleanup } = fixture();
+  try {
+    const base = join(context.identity.feedRoot, context.identity.logicalRepoKey, context.identity.worktreeKey);
+    for (let index = 0; index < STREAMING_DIFF_LIST_LIMITS.maxFeedDirs + 8; index += 1) mkdirSync(join(base, index.toString(16).padStart(32, "0")), { recursive: true });
+    let manifestReads = 0;
+    const response = streamingDiffHandler.serveData(handlerContext(context, {
+      url: new URL(`http://localhost/?list&repoKey=${context.identity.logicalRepoKey}`),
+      readManifest(path) { manifestReads += 1; assert.equal(path.startsWith(root), true); return null; },
+    }));
+    assert.equal(response.feeds.length, 0);
+    assert.equal(response.truncated, true);
+    assert.equal(manifestReads > 0 && manifestReads <= STREAMING_DIFF_LIST_LIMITS.maxFeedDirs, true);
+  } finally { cleanup(); }
+});
+
+test("recent feed listings budget their response envelope and truncate instead of returning 413", () => {
+  const { context, cleanup } = fixture();
+  try {
+    appendCard(context.identity.feedDir, card(1), { identity: feedIdentity(context.identity) });
+    const url = new URL(`http://localhost/?list&repoKey=${context.identity.logicalRepoKey}`);
+    const full = streamingDiffHandler.serveData(handlerContext(context, { url }));
+    const entryBytes = Buffer.byteLength(JSON.stringify(full.feeds[0]), "utf8");
+    const fullBytes = Buffer.byteLength(JSON.stringify(full), "utf8");
+    const maxOvenDataBytes = Math.floor((entryBytes + fullBytes) / 2);
+
+    assert.ok(entryBytes < maxOvenDataBytes && maxOvenDataBytes < fullBytes);
+    const response = streamingDiffHandler.serveData(handlerContext(context, { url, maxOvenDataBytes }));
+    assert.equal(response.truncated, true);
+    assert.deepEqual(response.feeds, []);
+    assert.ok(Buffer.byteLength(JSON.stringify(response), "utf8") <= maxOvenDataBytes);
+  } finally { cleanup(); }
+});
+
+test("SSE contains post-header errors and clears both timers on every completion path", () => {
+  const { context, cleanup } = fixture();
+  try {
+    appendCard(context.identity.feedDir, card(1), { identity: feedIdentity(context.identity) });
+    const before = new FakeResponse();
+    assert.throws(() => streamingDiffHandler.serveData(handlerContext(context, { res: before, req: { headers: { accept: "text/event-stream" } }, reconnectFeed: () => { throw new Error("before headers"); } })), /Streaming Diff feed is unavailable/u);
+    assert.equal(before.headers, null);
+
+    for (const completion of ["close", "error", "finish"]) {
+      const timers = timerHarness();
+      const res = new FakeResponse();
+      streamingDiffHandler.serveData(handlerContext(context, { res, req: { headers: { accept: "text/event-stream" } }, timers: timers.timers }));
+      assert.equal(timers.active.size, 2);
+      res.emit(completion);
+      assert.equal(timers.active.size, 0, `${completion} clears all intervals`);
+      assert.equal(timers.cleared.length, 2, `${completion} clears poll and heartbeat`);
+    }
+
+    const timers = timerHarness();
+    const res = new FakeResponse();
+    let calls = 0;
+    streamingDiffHandler.serveData(handlerContext(context, { res, req: { headers: { accept: "text/event-stream" } }, timers: timers.timers, reconnectFeed: () => {
+      calls += 1;
+      if (calls > 1) throw new Error("after headers");
+      return { type: "reset", cards: [card(1)] };
+    } }));
+    [...timers.active].find((handle) => handle.delay === 300).fn();
+    assert.equal(res.headers.status, 200);
+    assert.equal(res.ended, true);
+  } finally { cleanup(); }
+});
+
+test("SSE subscriber caps reject before headers while an allowed stream works", () => {
+  const { context, cleanup } = fixture();
+  try {
+    appendCard(context.identity.feedDir, card(1), { identity: feedIdentity(context.identity) });
+    const first = new FakeResponse();
+    streamingDiffHandler.serveData(handlerContext(context, { res: first, req: { headers: { accept: "text/event-stream" } }, sseOptions: { maxGlobalSubscribers: 1, maxSubscribersPerFeed: 1 } }));
+    const rejected = new FakeResponse();
+    assert.throws(() => streamingDiffHandler.serveData(handlerContext(context, { res: rejected, req: { headers: { accept: "text/event-stream" } }, sseOptions: { maxGlobalSubscribers: 1, maxSubscribersPerFeed: 1 } })), (error) => error.status === 503);
+    assert.equal(rejected.headers, null);
+    assert.match(first.writes.join(""), /id: v2:[a-f0-9]{12}:[a-f0-9]{12}:[a-f0-9]{32}:g-[a-f0-9]+:r-/u);
+    first.emit("close");
+  } finally { cleanup(); }
+});
+
+test("foreign cursors reset and malformed feed errors are sanitized", () => {
+  const { context, cleanup } = fixture();
+  try {
+    appendCard(context.identity.feedDir, card(1), { identity: feedIdentity(context.identity) });
+    const res = new FakeResponse();
+    streamingDiffHandler.serveData(handlerContext(context, {
+      res, req: { headers: { accept: "text/event-stream", "last-event-id": "v2:foreign-feed:r-aaaaaaaaaaaaaaaaaaaaaaaa" } },
+      timers: { setInterval: () => null, clearInterval: () => {} },
+    }));
+    assert.match(res.writes.join(""), /event: reset/u);
+    res.emit("close");
+    const raw = "/private/feed/secret-content";
+    assert.throws(
+      () => streamingDiffHandler.serveData(handlerContext(context, { readJournal: () => { throw new Error(raw); } })),
+      (error) => error.message === "Streaming Diff feed is unavailable" && !error.message.includes(raw),
+    );
+  } finally { cleanup(); }
+});
+
+test("SSE rechecks feed containment and identity before every poll", () => {
+  const { context, cleanup } = fixture();
+  try {
+    appendCard(context.identity.feedDir, card(1), { identity: feedIdentity(context.identity) });
+    const timers = timerHarness();
+    let reads = 0;
+    const res = new FakeResponse();
+    streamingDiffHandler.serveData(handlerContext(context, {
+      res, timers: timers.timers, req: { headers: { accept: "text/event-stream" } },
+      readJournal(path) {
+        const journal = readJournal(path);
+        reads += 1;
+        return reads < 3 ? journal : { ...journal, manifest: { ...journal.manifest, identity: { ...journal.manifest.identity, session: "other" } } };
+      },
+    }));
+    [...timers.active].find((handle) => handle.delay === 300).fn();
+    assert.equal(res.ended, true);
+  } finally { cleanup(); }
+});
+
+test("server lists only its repo binding and streams retained replay/reset cards", { timeout: 20_000 }, async (t) => {
+  if (!await canBindLoopback()) return t.skip("requires loopback sockets (runs on host/CI)");
+  const state = {};
+  await withServer({
+    scanRoots: ["fixture-repo"],
+    setup: async ({ fixtureRoot }) => {
+      const repo = join(fixtureRoot, "fixture-repo");
+      mkdirSync(join(repo, "notes", "burnlists", "inprogress"), { recursive: true });
+      execFileSync("git", ["init", "--quiet"], { cwd: repo, stdio: "ignore" });
+      writeFileSync(join(repo, "one.txt"), "before\n");
+      state.first = ensureStreamingDiffFeed({ cwd: repo, session: "session-one" }).identity;
+      appendCard(state.first.feedDir, card(1), { identity: feedIdentity(state.first) });
+      appendCard(state.first.feedDir, card(2), { identity: feedIdentity(state.first) });
+      state.second = ensureStreamingDiffFeed({ cwd: repo, session: "session-two" }).identity;
+      appendCard(state.second.feedDir, card(3), { identity: feedIdentity(state.second) });
+    },
+  }, async ({ baseUrl }) => {
+    const query = `repoKey=${state.first.logicalRepoKey}&worktreeKey=${state.first.worktreeKey}&session=session-one`;
+    assert.equal((await fetch(`${baseUrl}api/oven-data/streaming-diff?list`)).status, 400);
+    const recent = await (await fetch(`${baseUrl}api/oven-data/streaming-diff?list&repoKey=${state.first.logicalRepoKey}`)).json();
+    assert.equal(recent.feeds.length, 2);
+    assert.deepEqual(new Set(recent.feeds.map((entry) => entry.identity.session)), new Set(["session-one", "session-two"]));
+
+    const stream = await requestSse(baseUrl, `/api/oven-data/streaming-diff?${query}`);
+    await waitFor(() => { if (stream.error) throw stream.error; return stream.events.filter((entry) => entry.id).length === 2; }, "initial cards");
+    const initialIds = stream.events.filter((entry) => entry.id).map((entry) => entry.id);
+    assert.equal(initialIds[0].endsWith(`:${card(1).revId}`), true);
+    assert.equal(initialIds[1].endsWith(`:${card(2).revId}`), true);
+    stream.close();
+
+    const replay = await requestSse(baseUrl, `/api/oven-data/streaming-diff?${query}`, { "last-event-id": initialIds[0] });
+    await waitFor(() => { if (replay.error) throw replay.error; return replay.events.some((entry) => entry.id?.endsWith(`:${card(2).revId}`)); }, "replay suffix");
+    replay.close();
+
+    appendCard(state.first.feedDir, card(4), { identity: feedIdentity(state.first), limits: { maxRevs: 1, maxBytes: 1024 } });
+    const reset = await requestSse(baseUrl, `/api/oven-data/streaming-diff?${query}`, { "last-event-id": initialIds[0] });
+    await waitFor(() => { if (reset.error) throw reset.error; return reset.events.some((entry) => entry.id?.endsWith(`:${card(4).revId}`)); }, "pruned reset");
+    assert.equal(reset.events.some((entry) => entry.type === "reset"), true);
+    reset.close();
+
+    const slow = new FakeResponse({ slow: true });
+    streamingDiffHandler.serveData(handlerContext({ identity: state.first }, { url: new URL(`http://localhost/?${query}`), binding: { repoRoot: state.first.logicalRepoRoot }, bindingPath: state.first.feedRoot, res: slow, req: { headers: { accept: "text/event-stream" } } }));
+    assert.equal(slow.destroyed, true);
+  });
+});
diff --git a/ovens/streaming-diff/engine/streaming-diff-hook-adapters.mjs b/ovens/streaming-diff/engine/streaming-diff-hook-adapters.mjs
new file mode 100644
index 0000000..68429ef
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-hook-adapters.mjs
@@ -0,0 +1,8 @@
+import { mapClaudeHook } from "./streaming-diff-claude-hook.mjs";
+import { mapCodexHook } from "./streaming-diff-codex-hook.mjs";
+
+export function mapStreamingDiffHook({ agent, event, payload, env, cwd } = {}) {
+  if (agent === "claude") return mapClaudeHook(payload, event, env, { cwd });
+  if (agent === "codex") return mapCodexHook(payload, event, env);
+  return { action: "noop", args: [], degraded: true };
+}
diff --git a/ovens/streaming-diff/engine/streaming-diff-hook-adapters.test.mjs b/ovens/streaming-diff/engine/streaming-diff-hook-adapters.test.mjs
new file mode 100644
index 0000000..747e352
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-hook-adapters.test.mjs
@@ -0,0 +1,113 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { delimiter, join } from "node:path";
+import test from "node:test";
+
+import { mapStreamingDiffHook } from "./streaming-diff-hook-adapters.mjs";
+import { managedHookEntry } from "../../../src/cli/hooks-config.mjs";
+
+function worktree() {
+  const root = mkdtempSync(join(tmpdir(), "burnlist-hook-adapter-"));
+  execFileSync("git", ["init", "--quiet", root]);
+  return { root, cleanup: () => rmSync(root, { recursive: true, force: true }) };
+}
+
+test("real Claude absolute Write and Edit payloads become contained repo-relative capture hints", () => {
+  const context = worktree();
+  try {
+    const payload = {
+      session_id: "claude-session", tool_name: "Write", tool_use_id: "tool-1",
+      tool_input: { file_path: `${context.root}/src/new-file.mjs`, content: "export const value = 1;" },
+    };
+    assert.deepEqual(mapStreamingDiffHook({ agent: "claude", event: "pre", payload, cwd: context.root }), {
+      action: "capture", args: ["capture", "--session", "claude-session", "--tool-use-id", "tool-1", "--phase", "pre", "--path", "src/new-file.mjs"], degraded: false,
+    });
+    const edit = { ...payload, tool_name: "Edit", tool_input: { file_path: `${context.root}/src/new-file.mjs`, old_string: "1", new_string: "2" } };
+    assert.equal(mapStreamingDiffHook({ agent: "claude", event: "failure", payload: edit, cwd: context.root }).args.at(-1), "src/new-file.mjs");
+    const escaped = { ...payload, tool_input: { file_path: "/tmp/outside.mjs" } };
+    assert.equal(mapStreamingDiffHook({ agent: "claude", event: "post", payload: escaped, cwd: context.root }).degraded, true);
+  } finally { context.cleanup(); }
+});
+
+test("Claude worktree lookup has a finite subprocess timeout", { timeout: 3_000 }, () => {
+  const context = worktree();
+  const originalPath = process.env.PATH;
+  try {
+    const bin = join(context.root, "slow-bin");
+    mkdirSync(bin);
+    const git = join(bin, "git");
+    writeFileSync(git, "#!/bin/sh\nsleep 2\n");
+    chmodSync(git, 0o755);
+    process.env.PATH = `${bin}${delimiter}${originalPath}`;
+    const started = Date.now();
+    const mapped = mapStreamingDiffHook({
+      agent: "claude", event: "pre", cwd: context.root,
+      payload: { session_id: "claude-session", tool_name: "Write", tool_use_id: "call-timeout", tool_input: { file_path: join(context.root, "new-file.mjs") } },
+    });
+    assert.equal(mapped.action, "capture");
+    assert.equal(mapped.degraded, true);
+    assert.match(mapped.degradedReason, /missing path hints/u);
+    assert.ok(Date.now() - started < 1_200);
+  } finally {
+    process.env.PATH = originalPath;
+    context.cleanup();
+  }
+});
+
+test("real Codex apply_patch command envelope maps every changed path exactly", () => {
+  const payload = {
+    hook_event_name: "PreToolUse", session_id: "codex-session", tool_name: "apply_patch", tool_use_id: "call-1",
+    tool_input: { command: "*** Begin Patch\n*** Update File: lib/a.mjs\n@@\n*** Add File: lib/b.mjs\n+export {};\n*** Delete File: lib/c.mjs\n*** Update File: lib/old.mjs\n*** Move to: lib/new.mjs\n*** End Patch" },
+  };
+  assert.deepEqual(mapStreamingDiffHook({ agent: "codex", payload }), {
+    action: "capture", args: ["capture", "--session", "codex-session", "--tool-use-id", "call-1", "--phase", "pre", "--path", "lib/a.mjs", "--path", "lib/b.mjs", "--path", "lib/c.mjs", "--path", "lib/old.mjs", "--path", "lib/new.mjs"], degraded: false,
+  });
+});
+
+test("hook adapters cap capture arguments before spawning a capture subprocess", () => {
+  const paths = Array.from({ length: 70 }, (_, index) => `lib/${index}.mjs`);
+  const payload = {
+    session_id: "codex-session", tool_name: "apply_patch", tool_use_id: "call-many",
+    tool_input: { command: `*** Begin Patch\n${paths.map((path) => `*** Add File: ${path}`).join("\n")}\n*** Add File: ${"x".repeat(513)}\n*** End Patch` },
+  };
+  const codex = mapStreamingDiffHook({ agent: "codex", event: "pre", payload });
+  const codexPaths = codex.args.filter((value, index) => codex.args[index - 1] === "--path");
+  assert.equal(codexPaths.length, 64);
+  assert.ok(codexPaths.every((path) => path.length <= 512 && Buffer.byteLength(path, "utf8") <= 512));
+  assert.equal(codex.degraded, true);
+
+  const context = worktree();
+  try {
+    const claude = mapStreamingDiffHook({
+      agent: "claude", event: "pre", cwd: context.root,
+      payload: { session_id: "claude-session", tool_name: "Write", tool_use_id: "call-long", tool_input: { file_path: join(context.root, ...Array.from({ length: 10 }, () => "x".repeat(60))) } },
+    });
+    assert.equal(claude.args.includes("--path"), false);
+    assert.equal(claude.degraded, true);
+  } finally { context.cleanup(); }
+});
+
+test("Codex file-tool payload fields remain bounded path hints", () => {
+  const payload = { session_id: "codex-session", tool_name: "write_file", tool_use_id: "call-2", tool_input: { file_path: "lib/generated.mjs", content: "export {};" } };
+  assert.deepEqual(mapStreamingDiffHook({ agent: "codex", event: "post", payload }).args, [
+    "capture", "--session", "codex-session", "--tool-use-id", "call-2", "--phase", "post", "--path", "lib/generated.mjs",
+  ]);
+});
+
+test("managed hooks use portable commands and narrow host matchers", () => {
+  assert.deepEqual(managedHookEntry("claude", "post"), {
+    matcher: "Edit|Write|MultiEdit|NotebookEdit",
+    hooks: [{ type: "command", command: "burnlist streaming-diff hook --agent claude --event post" }],
+  });
+  assert.doesNotMatch(managedHookEntry("codex", "post", "win32").hooks[0].command, /cmd|REM|#/iu);
+});
+
+test("non-mutating, malformed, and missing-identity payloads are safe no-ops or bounded partial captures", () => {
+  assert.equal(mapStreamingDiffHook({ agent: "claude", event: "pre", payload: { tool_name: "Bash" } }).action, "noop");
+  assert.doesNotThrow(() => mapStreamingDiffHook({ agent: "claude", event: "post", payload: null }));
+  const mapped = mapStreamingDiffHook({ agent: "codex", event: "post", payload: { tool_name: "write_file", tool_input: {} } });
+  assert.equal(mapped.action, "capture");
+  assert.equal(mapped.degraded, true);
+});
diff --git a/ovens/streaming-diff/engine/streaming-diff-hook-contract.mjs b/ovens/streaming-diff/engine/streaming-diff-hook-contract.mjs
new file mode 100644
index 0000000..678349a
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-hook-contract.mjs
@@ -0,0 +1,60 @@
+import { STREAMING_DIFF_CAPTURE_LIMITS } from "./streaming-diff-capture.mjs";
+
+const FALLBACK_SESSION = "unknown-session";
+const FALLBACK_TOOL_USE = "unknown-tool-use";
+
+function text(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+function boundedPaths(hintedPaths) {
+  const paths = [];
+  const seen = new Set();
+  let truncated = false;
+  for (const value of Array.isArray(hintedPaths) ? hintedPaths : []) {
+    const path = text(value);
+    if (!path || seen.has(path)) continue;
+    seen.add(path);
+    if (path.length > STREAMING_DIFF_CAPTURE_LIMITS.maxPathLength
+      || Buffer.byteLength(path, "utf8") > STREAMING_DIFF_CAPTURE_LIMITS.maxPathLength
+      || paths.length >= STREAMING_DIFF_CAPTURE_LIMITS.maxPaths) {
+      truncated = true;
+      continue;
+    }
+    paths.push(path);
+  }
+  return { paths, truncated };
+}
+
+export function hookCapture({ event, session, toolUseId, hintedPaths = [] } = {}) {
+  const safeSession = text(session) ?? FALLBACK_SESSION;
+  const safeToolUseId = text(toolUseId) ?? FALLBACK_TOOL_USE;
+  const bounded = boundedPaths(hintedPaths);
+  const reasons = [
+    !text(session) && "missing session",
+    !text(toolUseId) && "missing tool use id",
+    bounded.paths.length === 0 && "missing path hints",
+    bounded.truncated && "path hints truncated",
+  ].filter(Boolean);
+  const degraded = reasons.length > 0;
+  if (event === "ensure") {
+    return { action: "ensure-feed", args: ["ensure-feed", "--session", safeSession], degraded: !text(session), ...(!text(session) ? { degradedReason: "missing session" } : {}) };
+  }
+  if (!["pre", "post", "failure"].includes(event)) return { action: "noop", args: [], degraded: true };
+  const terminalReason = event === "failure" ? "tool-failed" : bounded.truncated ? "path-hints-truncated" : null;
+  return {
+    action: "capture",
+    args: ["capture", "--session", safeSession, "--tool-use-id", safeToolUseId, "--phase", event === "pre" ? "pre" : "post", ...(terminalReason ? ["--terminal-reason", terminalReason] : []), ...bounded.paths.flatMap((path) => ["--path", path])],
+    degraded,
+    ...(terminalReason ? { terminalReason } : {}),
+    ...(degraded ? { degradedReason: reasons.join("; ") } : {}),
+  };
+}
+
+export function hookNoop() {
+  return { action: "noop", args: [], degraded: false };
+}
+
+export function hookText(value) {
+  return text(value);
+}
diff --git a/ovens/streaming-diff/engine/streaming-diff-journal-lock-race.test.mjs b/ovens/streaming-diff/engine/streaming-diff-journal-lock-race.test.mjs
new file mode 100644
index 0000000..6aa5c6d
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-journal-lock-race.test.mjs
@@ -0,0 +1,95 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { readJournal } from "./streaming-diff-journal.mjs";
+
+const identity = { logicalRepoKey: "logical", worktreeKey: "worktree", session: "session" };
+
+function card(name) {
+  return { revId: `r-${name.repeat(24)}`, toolUseId: name, ts: "2026-07-15T09:00:00.000Z", status: "captured", files: [] };
+}
+
+function waitFor(path) {
+  return new Promise((resolve, reject) => {
+    const deadline = Date.now() + 10_000;
+    const timer = setInterval(() => {
+      if (existsSync(path)) { clearInterval(timer); resolve(); }
+      else if (Date.now() > deadline) { clearInterval(timer); reject(new Error(`timed out waiting for ${path}`)); }
+    }, 5);
+  });
+}
+
+function child(source, args) {
+  return new Promise((resolve, reject) => {
+    const process = spawn(globalThis.process.execPath, ["--input-type=module", "--eval", source, ...args], { stdio: "pipe" });
+    let stderr = "";
+    process.stderr.on("data", (chunk) => { stderr += chunk; });
+    process.on("error", reject);
+    process.on("exit", (status) => resolve({ status, stderr }));
+  });
+}
+
+test("a dead-lock takeover cannot steal a live journal writer between inspection and reclaim", async () => {
+  const root = mkdtempSync(join(tmpdir(), "burnlist-journal-lock-race-"));
+  const feed = join(root, "feed");
+  const ready = join(root, "ready");
+  const go = join(root, "go");
+  const held = join(root, "held");
+  const release = join(root, "release");
+  const result = join(root, "first-result.json");
+  const journalUrl = new URL("./streaming-diff-journal.mjs", import.meta.url).href;
+  const safeUrl = new URL("../../../src/server/fs-safe.mjs", import.meta.url).href;
+  try {
+    mkdirSync(feed);
+    writeFileSync(join(feed, ".lock"), JSON.stringify({ pid: 2147483646, token: "dead" }));
+    const firstSource = `
+      import fs, { existsSync, writeFileSync } from "node:fs";
+      import { syncBuiltinESMExports } from "node:module";
+      const [feed, ready, go, result, journalUrl, safeUrl] = process.argv.slice(1);
+      const original = fs.renameSync;
+      fs.renameSync = (from, to, ...rest) => {
+        const oldTakeover = from === feed + "/.lock" && to.startsWith(feed + "/.lock.claim.");
+        const newPublication = from.includes(".lock.candidate.") && to === feed + "/.lock";
+        if (oldTakeover || newPublication) {
+          writeFileSync(ready, "");
+          while (!existsSync(go)) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
+        }
+        return original(from, to, ...rest);
+      };
+      syncBuiltinESMExports();
+      await import(safeUrl);
+      const { appendCard } = await import(journalUrl);
+      const card = { revId: "r-aaaaaaaaaaaaaaaaaaaaaaaa", toolUseId: "a", ts: "2026-07-15T09:00:00.000Z", status: "captured", files: [] };
+      try { appendCard(feed, card, { identity: ${JSON.stringify(identity)} }); writeFileSync(result, JSON.stringify({ ok: true })); }
+      catch (error) { writeFileSync(result, JSON.stringify({ ok: false, code: error.code })); }
+    `;
+    const secondSource = `
+      import { existsSync, rmSync, writeFileSync } from "node:fs";
+      const [feed, ready, held, release, journalUrl] = process.argv.slice(1);
+      while (!existsSync(ready)) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
+      rmSync(feed + "/.lock");
+      const { appendCard } = await import(journalUrl);
+      const card = { revId: "r-bbbbbbbbbbbbbbbbbbbbbbbb", toolUseId: "b", ts: "2026-07-15T09:00:00.000Z", status: "captured", files: [] };
+      appendCard(feed, card, { identity: ${JSON.stringify(identity)}, beforeManifestSwap() {
+        writeFileSync(held, "");
+        while (!existsSync(release)) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
+      } });
+    `;
+    const first = child(firstSource, [feed, ready, go, result, journalUrl, safeUrl]);
+    const second = child(secondSource, [feed, ready, held, release, journalUrl]);
+    await waitFor(ready);
+    await waitFor(held);
+    writeFileSync(go, "");
+    await waitFor(result);
+    writeFileSync(release, "");
+    const [firstExit, secondExit] = await Promise.all([first, second]);
+    assert.equal(firstExit.status, 0, firstExit.stderr);
+    assert.equal(secondExit.status, 0, secondExit.stderr);
+    assert.deepEqual(JSON.parse(readFileSync(result, "utf8")), { ok: false, code: "ELOCKED" });
+    assert.deepEqual(readJournal(feed).cards.map((entry) => entry.toolUseId), ["b"]);
+  } finally { rmSync(root, { recursive: true, force: true }); }
+});
diff --git a/ovens/streaming-diff/engine/streaming-diff-journal.mjs b/ovens/streaming-diff/engine/streaming-diff-journal.mjs
new file mode 100644
index 0000000..8a043f7
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-journal.mjs
@@ -0,0 +1,256 @@
+import { randomBytes } from "node:crypto";
+import { closeSync, constants, existsSync, fsyncSync, mkdirSync, openSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { realpathSync } from "node:fs";
+
+import { withDirectoryLock } from "../../../src/server/dir-lock.mjs";
+import { readContainedFile } from "./streaming-diff-capture-git.mjs";
+import { STREAMING_DIFF_ABSENT } from "./streaming-diff-capture.mjs";
+import { assertCard, assertManifest, STREAMING_DIFF_CONTRACT_LIMITS, STREAMING_DIFF_DATA_CONTRACT } from "./streaming-diff-data-contract.mjs";
+
+export const STREAMING_DIFF_RETENTION = Object.freeze({ maxRevs: 128, maxBytes: 4 * 1024 * 1024 });
+export const STREAMING_DIFF_JOURNAL_LIMITS = Object.freeze({ maxManifestBytes: 64 * 1024, maxCardBytes: STREAMING_DIFF_CONTRACT_LIMITS.maxCardBytes });
+
+function cardPath(feedDir, revId) {
+  return join(feedDir, `rev-${revId}.json`);
+}
+
+function manifestPath(feedDir) {
+  return join(feedDir, "manifest.json");
+}
+
+function fsyncDirectory(path) {
+  const fd = openSync(path, constants.O_RDONLY);
+  try {
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+
+// A published name is not enough: the card and its parent directory must both
+// be durable before a durable manifest may reference it.
+function writeDurableAtomic(path, contents) {
+  const temporary = `${path}.${randomBytes(8).toString("hex")}.tmp`;
+  let fd;
+  try {
+    fd = openSync(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 0o600);
+    writeFileSync(fd, contents);
+    fsyncSync(fd);
+    closeSync(fd);
+    fd = undefined;
+    renameSync(temporary, path);
+    fsyncDirectory(dirname(path));
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+    rmSync(temporary, { force: true });
+  }
+}
+
+function cardBytes(card) {
+  return Buffer.byteLength(JSON.stringify(card), "utf8");
+}
+
+function limitedCard(card) {
+  return { revId: card.revId, toolUseId: card.toolUseId, ts: card.ts, status: "partial", partialReason: "card exceeds journal retention byte limit", files: [] };
+}
+
+function retention(value) {
+  const result = { ...STREAMING_DIFF_RETENTION, ...value };
+  if (!Number.isSafeInteger(result.maxRevs) || result.maxRevs < 1 || result.maxRevs > STREAMING_DIFF_CONTRACT_LIMITS.maxRevs) throw new Error(`journal maxRevs must be between 1 and ${STREAMING_DIFF_CONTRACT_LIMITS.maxRevs}`);
+  if (!Number.isSafeInteger(result.maxBytes) || result.maxBytes < 1_024) throw new Error("journal maxBytes must be at least 1024 bytes");
+  return result;
+}
+
+function readBoundedJson(path, maxBytes, label) {
+  const root = realpathSync(dirname(path));
+  const contents = readContainedFile(root, path, maxBytes);
+  if (contents === STREAMING_DIFF_ABSENT) {
+    const error = new Error(`${label} is unavailable`);
+    error.code = "ENOENT";
+    throw error;
+  }
+  if (!Buffer.isBuffer(contents)) throw new Error(`${label} is unavailable or exceeds its ${maxBytes}-byte limit`);
+  return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(contents));
+}
+
+function loadManifest(feedDir) {
+  const path = manifestPath(feedDir);
+  try {
+    return assertManifest(readBoundedJson(path, STREAMING_DIFF_JOURNAL_LIMITS.maxManifestBytes, "manifest"));
+  } catch (error) {
+    if (error?.code === "ENOENT") return null;
+    throw error;
+  }
+}
+
+// Dashboard readers use this manifest-only entrypoint. It must remain pure:
+// no lock acquisition, recovery, pruning, or write is permitted on this path.
+export function readManifestPure(feedDir) {
+  return loadManifest(feedDir);
+}
+
+function loadCard(feedDir, revId) {
+  return assertCard(readBoundedJson(cardPath(feedDir, revId), STREAMING_DIFF_JOURNAL_LIMITS.maxCardBytes, "card"));
+}
+
+function cardsForManifest(feedDir, manifest) {
+  const cards = [];
+  let invalid = false;
+  for (const revId of manifest.revs) {
+    try {
+      const card = loadCard(feedDir, revId);
+      if (card.revId !== revId) {
+        invalid = true;
+        continue;
+      }
+      cards.push(card);
+    } catch {
+      invalid = true;
+    }
+  }
+  return { cards, invalid };
+}
+
+function healManifestUnsafe(feedDir) {
+  const manifest = loadManifest(feedDir);
+  if (!manifest) return { manifest: null, cards: [], changed: false };
+  const valid = [];
+  const cards = [];
+  for (const revId of manifest.revs) {
+    try {
+      const card = loadCard(feedDir, revId);
+      if (card.revId !== revId) continue;
+      valid.push(revId);
+      cards.push(card);
+    } catch {
+      // A lost, malformed, oversized, or mismatched referenced card cannot be
+      // replayed safely; drop it from the durable manifest.
+    }
+  }
+  if (valid.length === manifest.revs.length) return { manifest, cards, changed: false };
+  const healed = assertManifest({ ...manifest, revs: valid });
+  writeDurableAtomic(manifestPath(feedDir), JSON.stringify(healed));
+  pruneUnreferencedCards(feedDir, valid);
+  return { manifest: healed, cards, changed: true };
+}
+
+function retained(feedDir, revs, limits) {
+  const selected = [];
+  let bytes = 0;
+  for (const revId of [...revs].reverse()) {
+    const card = loadCard(feedDir, revId);
+    const size = cardBytes(card);
+    // Retention is a newest contiguous suffix: never skip a middle revision.
+    if (selected.length >= limits.maxRevs || bytes + size > limits.maxBytes) break;
+    selected.unshift(revId);
+    bytes += size;
+  }
+  return selected;
+}
+
+function pruneUnreferencedCards(feedDir, revs) {
+  const retainedRevs = new Set(revs);
+  let removed = false;
+  for (const entry of readdirSync(feedDir, { withFileTypes: true })) {
+    if (!entry.name.startsWith("rev-") || !entry.name.endsWith(".json") || !entry.isFile()) continue;
+    if (!retainedRevs.has(entry.name.slice(4, -5))) {
+      rmSync(join(feedDir, entry.name), { force: true });
+      removed = true;
+    }
+  }
+  if (removed) fsyncDirectory(feedDir);
+}
+
+function sameIdentity(left, right) {
+  return left?.logicalRepoKey === right?.logicalRepoKey
+    && left?.worktreeKey === right?.worktreeKey
+    && left?.session === right?.session;
+}
+
+function isUnterminatedAttempt(card) {
+  return card.status === "partial" && card.files.length === 0 && card.partialReason?.includes("attempt in progress / unterminated");
+}
+
+export function appendCard(feedDir, card, { identity, now = () => new Date().toISOString(), limits, beforeManifestSwap, dedupeToolUseId = false, dedupeTerminalToolUseId = false } = {}) {
+  assertCard(card);
+  const bounded = retention(limits);
+  mkdirSync(feedDir, { recursive: true });
+  return withDirectoryLock({
+    lockPath: join(feedDir, ".lock"),
+    fn: () => {
+    const healed = healManifestUnsafe(feedDir);
+    const previous = healed.manifest;
+    if (!previous && !identity) throw new Error("new streaming feed requires an identity");
+    if (previous && identity && !sameIdentity(previous.identity, identity)) throw new Error("streaming diff feed identity does not match its immutable manifest identity");
+    if (dedupeToolUseId) {
+      const existing = healed.cards.find((entry) => entry.toolUseId === card.toolUseId);
+      if (existing) return { card: existing, manifest: previous, existing: true };
+    }
+    if (dedupeTerminalToolUseId) {
+      const existing = healed.cards.find((entry) => entry.toolUseId === card.toolUseId && !isUnterminatedAttempt(entry));
+      if (existing) return { card: existing, manifest: previous, existing: true };
+    }
+    let published = card;
+    if (cardBytes(published) > bounded.maxBytes) published = limitedCard(card);
+    assertCard(published);
+    const revision = cardPath(feedDir, published.revId);
+    if (existsSync(revision)) throw new Error(`streaming diff revision already exists: ${published.revId}`);
+    writeDurableAtomic(revision, JSON.stringify(published));
+    const revs = retained(feedDir, [...(previous?.revs ?? []), published.revId], bounded);
+    const manifest = assertManifest({ contract: STREAMING_DIFF_DATA_CONTRACT, identity: previous?.identity ?? identity, generation: previous?.generation ?? `g-${randomBytes(12).toString("hex")}`, updatedAt: now(), revs });
+    beforeManifestSwap?.({ feedDir, card: published, manifest });
+    writeDurableAtomic(manifestPath(feedDir), JSON.stringify(manifest));
+    pruneUnreferencedCards(feedDir, manifest.revs);
+    return { card: published, manifest };
+    },
+    errorFactory: () => Object.assign(new Error(`${basename(feedDir)} is busy (locked)`), { code: "ELOCKED" }),
+  });
+}
+
+// This is the dashboard-safe reader. A referenced-card fault is reported as a
+// race/reset with the readable cards, but is never repaired by an observer.
+export function readJournal(feedDir) {
+  const manifest = loadManifest(feedDir);
+  if (!manifest) return { manifest: null, cards: [], race: false };
+  const initial = cardsForManifest(feedDir, manifest);
+  return { manifest, cards: initial.cards, race: initial.invalid };
+}
+
+export function resolveReconnect(manifest, availableRevs, since = null) {
+  assertManifest(manifest);
+  const cards = availableRevs instanceof Map ? availableRevs : new Map(Array.isArray(availableRevs) ? availableRevs.map((card) => [card.revId, card]) : []);
+  const retained = [];
+  for (const revId of manifest.revs) {
+    const card = cards.get(revId);
+    if (!card || card.revId !== revId) return { type: "reset", reread: true, cards: [] };
+    retained.push(card);
+  }
+  const index = typeof since === "string" ? manifest.revs.indexOf(since) : -1;
+  return index < 0 ? { type: "reset", cards: retained } : { type: "replay", cards: retained.slice(index + 1) };
+}
+
+export function reconnectFeed(feedDir, since = null) {
+  let journal = readJournal(feedDir);
+  if (!journal.manifest) return { type: "reset", cards: [] };
+  if (journal.race) {
+    // Recovery belongs exclusively to the CLI append/reconnect writer path.
+    const healed = withDirectoryLock({
+      lockPath: join(feedDir, ".lock"),
+      fn: () => healManifestUnsafe(feedDir),
+      errorFactory: () => Object.assign(new Error(`${basename(feedDir)} is busy (locked)`), { code: "ELOCKED" }),
+    });
+    return { type: "reset", cards: healed.cards };
+  }
+  return resolveReconnect(journal.manifest, journal.cards, since);
+}
+
+export function reconnectFeedPure(feedDir, since = null) {
+  const journal = readJournal(feedDir);
+  if (!journal.manifest || journal.race) return { type: "reset", cards: journal.cards };
+  return resolveReconnect(journal.manifest, journal.cards, since);
+}
+
+export function journalRevisionBytes(feedDir, revId) {
+  return statSync(cardPath(feedDir, revId)).size;
+}
diff --git a/ovens/streaming-diff/engine/streaming-diff-journal.test.mjs b/ovens/streaming-diff/engine/streaming-diff-journal.test.mjs
new file mode 100644
index 0000000..2b3d878
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-journal.test.mjs
@@ -0,0 +1,138 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdtempSync, readFileSync, rmSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { appendCard, readJournal, reconnectFeed, resolveReconnect } from "./streaming-diff-journal.mjs";
+
+const identity = Object.freeze({ logicalRepoKey: "logical", worktreeKey: "worktree", session: "session" });
+
+function card(number, diff = "diff") {
+  return { revId: `r-${number.toString(16).padStart(24, "0")}`, toolUseId: `tool-${number}`, ts: `2026-07-15T09:0${number}:00.000Z`, status: "captured", files: [{ path: `src/${number}.mjs`, kind: "modified", diff }] };
+}
+
+function fixture() {
+  const root = mkdtempSync(join(tmpdir(), "burnlist-streaming-journal-"));
+  return { root, cleanup: () => rmSync(root, { recursive: true, force: true }) };
+}
+
+test("journal makes a durable card visible before its durable manifest and ignores card-first crash orphans", () => {
+  const context = fixture();
+  try {
+    assert.throws(() => appendCard(context.root, card(1), { identity, beforeManifestSwap: () => { throw new Error("simulated crash"); } }), /simulated crash/u);
+    assert.equal(existsSync(join(context.root, `rev-${card(1).revId}.json`)), true);
+    assert.deepEqual(readJournal(context.root), { manifest: null, cards: [], race: false });
+    const published = appendCard(context.root, card(2), { identity });
+    assert.deepEqual(published.manifest.revs, [card(2).revId]);
+    assert.equal(readJournal(context.root).cards[0].revId, card(2).revId);
+  } finally {
+    context.cleanup();
+  }
+});
+
+test("an established feed rejects a card carrying a different immutable identity", () => {
+  const context = fixture();
+  try {
+    appendCard(context.root, card(1), { identity });
+    assert.throws(
+      () => appendCard(context.root, card(2), { identity: { ...identity, session: "other-session" } }),
+      /identity does not match/u,
+    );
+    assert.deepEqual(readJournal(context.root).manifest.identity, identity);
+  } finally { context.cleanup(); }
+});
+
+test("retention keeps a contiguous newest suffix when a large middle card no longer fits", () => {
+  const context = fixture();
+  try {
+    appendCard(context.root, card(1, "a"), { identity, limits: { maxRevs: 8, maxBytes: 4_096 } });
+    appendCard(context.root, card(2, "b".repeat(700)), { identity, limits: { maxRevs: 8, maxBytes: 4_096 } });
+    appendCard(context.root, card(3, "c"), { identity, limits: { maxRevs: 8, maxBytes: 4_096 } });
+    const appended = appendCard(context.root, card(4, "d"), { identity, limits: { maxRevs: 8, maxBytes: 1_024 } });
+    assert.deepEqual(appended.manifest.revs, [card(3).revId, card(4).revId]);
+    for (const number of [1, 2]) assert.equal(existsSync(join(context.root, `rev-${card(number).revId}.json`)), false);
+  } finally {
+    context.cleanup();
+  }
+});
+
+test("oversized cards become a bounded partial card before retention", () => {
+  const context = fixture();
+  try {
+    const appended = appendCard(context.root, card(1, "x".repeat(2_000)), { identity, limits: { maxBytes: 1_024 } });
+    assert.equal(appended.card.status, "partial");
+    assert.deepEqual(appended.card.files, []);
+  } finally {
+    context.cleanup();
+  }
+});
+
+test("append and reconnect self-heal manifest entries whose card vanished or mismatched", () => {
+  const context = fixture();
+  try {
+    appendCard(context.root, card(1), { identity });
+    appendCard(context.root, card(2), { identity });
+    unlinkSync(join(context.root, `rev-${card(1).revId}.json`));
+    const reset = reconnectFeed(context.root, card(1).revId);
+    assert.deepEqual(reset, { type: "reset", cards: [card(2)] });
+    assert.deepEqual(readJournal(context.root).manifest.revs, [card(2).revId]);
+    writeFileSync(join(context.root, `rev-${card(2).revId}.json`), JSON.stringify({ ...card(2), revId: card(3).revId }));
+    const appended = appendCard(context.root, card(3), { identity });
+    assert.deepEqual(appended.manifest.revs, [card(3).revId]);
+  } finally {
+    context.cleanup();
+  }
+});
+
+test("bounded readers reject oversized manifests and report oversized referenced cards as races", () => {
+  const context = fixture();
+  try {
+    appendCard(context.root, card(1), { identity });
+    writeFileSync(join(context.root, "manifest.json"), "x".repeat(70 * 1024));
+    assert.throws(() => readJournal(context.root), /manifest is unavailable or exceeds/u);
+    rmSync(join(context.root, "manifest.json"));
+    appendCard(context.root, card(2), { identity });
+    writeFileSync(join(context.root, `rev-${card(2).revId}.json`), "x".repeat(600 * 1024));
+    const journal = readJournal(context.root);
+    assert.equal(journal.race, true);
+    assert.equal(journal.cards.some((entry) => entry.revId === card(2).revId), false);
+  } finally {
+    context.cleanup();
+  }
+});
+
+test("descriptor journal reads reject a symlinked revision instead of following it", () => {
+  const context = fixture();
+  const outside = mkdtempSync(join(tmpdir(), "burnlist-streaming-outside-"));
+  try {
+    appendCard(context.root, card(1), { identity });
+    const revision = join(context.root, `rev-${card(1).revId}.json`);
+    const secret = join(outside, "secret.json");
+    writeFileSync(secret, JSON.stringify(card(1)));
+    unlinkSync(revision);
+    symlinkSync(secret, revision);
+    const journal = readJournal(context.root);
+    assert.equal(journal.race, true);
+    assert.deepEqual(journal.cards, []);
+  } finally {
+    context.cleanup();
+    rmSync(outside, { recursive: true, force: true });
+  }
+});
+
+test("reconnect uses manifest order, resets unknown ids, and never replays a stale race", () => {
+  const context = fixture();
+  try {
+    appendCard(context.root, card(1), { identity });
+    appendCard(context.root, card(2), { identity });
+    const journal = readJournal(context.root);
+    assert.deepEqual(resolveReconnect(journal.manifest, journal.cards, card(1).revId), { type: "replay", cards: [card(2)] });
+    assert.deepEqual(resolveReconnect(journal.manifest, journal.cards, "r-ffffffffffffffffffffffff"), { type: "reset", cards: journal.cards });
+    const manifest = { ...journal.manifest, updatedAt: "2000-01-01T00:00:00.000Z", revs: [card(2).revId, card(1).revId] };
+    assert.deepEqual(resolveReconnect(manifest, [card(1), card(2)], null).cards.map((entry) => entry.revId), [card(2).revId, card(1).revId]);
+    assert.equal(readFileSync(join(context.root, "manifest.json"), "utf8").includes(card(2).revId), true);
+  } finally {
+    context.cleanup();
+  }
+});
diff --git a/ovens/streaming-diff/engine/streaming-diff-linediff.mjs b/ovens/streaming-diff/engine/streaming-diff-linediff.mjs
new file mode 100644
index 0000000..e485c04
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-linediff.mjs
@@ -0,0 +1,112 @@
+function normalizedLines(value) {
+  const text = String(value).replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+  if (!text) return [];
+  return text.endsWith("\n") ? text.slice(0, -1).split("\n") : text.split("\n");
+}
+
+function lcsPrefix(left, leftStart, leftEnd, right, rightStart, rightEnd) {
+  const width = rightEnd - rightStart;
+  let previous = new Uint32Array(width + 1);
+  let current = new Uint32Array(width + 1);
+  for (let index = leftStart; index < leftEnd; index += 1) {
+    for (let offset = 0; offset < width; offset += 1) {
+      current[offset + 1] = left[index] === right[rightStart + offset]
+        ? previous[offset] + 1
+        : Math.max(previous[offset + 1], current[offset]);
+    }
+    [previous, current] = [current, previous];
+  }
+  return previous;
+}
+
+function lcsSuffix(left, leftStart, leftEnd, right, rightStart, rightEnd) {
+  const width = rightEnd - rightStart;
+  let previous = new Uint32Array(width + 1);
+  let current = new Uint32Array(width + 1);
+  for (let index = leftEnd - 1; index >= leftStart; index -= 1) {
+    for (let offset = width - 1; offset >= 0; offset -= 1) {
+      current[offset] = left[index] === right[rightStart + offset]
+        ? previous[offset + 1] + 1
+        : Math.max(previous[offset], current[offset + 1]);
+    }
+    [previous, current] = [current, previous];
+  }
+  return previous;
+}
+
+function commonLines(left, leftStart, leftEnd, right, rightStart, rightEnd, result) {
+  const length = leftEnd - leftStart;
+  if (!length || rightEnd === rightStart) return;
+  if (length === 1) {
+    if (right.slice(rightStart, rightEnd).includes(left[leftStart])) result.push(left[leftStart]);
+    return;
+  }
+  const middle = leftStart + Math.floor(length / 2);
+  const prefix = lcsPrefix(left, leftStart, middle, right, rightStart, rightEnd);
+  const suffix = lcsSuffix(left, middle, leftEnd, right, rightStart, rightEnd);
+  let split = 0;
+  for (let offset = 1; offset < prefix.length; offset += 1) {
+    if (prefix[offset] + suffix[offset] > prefix[split] + suffix[split]) split = offset;
+  }
+  commonLines(left, leftStart, middle, right, rightStart, rightStart + split, result);
+  commonLines(left, middle, leftEnd, right, rightStart + split, rightEnd, result);
+}
+
+function operations(before, after) {
+  const common = [];
+  commonLines(before, 0, before.length, after, 0, after.length, common);
+  const result = [];
+  let oldIndex = 0;
+  let newIndex = 0;
+  for (const line of common) {
+    while (before[oldIndex] !== line) result.push({ type: "-", line: before[oldIndex++] });
+    while (after[newIndex] !== line) result.push({ type: "+", line: after[newIndex++] });
+    result.push({ type: " ", line });
+    oldIndex += 1;
+    newIndex += 1;
+  }
+  while (oldIndex < before.length) result.push({ type: "-", line: before[oldIndex++] });
+  while (newIndex < after.length) result.push({ type: "+", line: after[newIndex++] });
+  return result;
+}
+
+function range(start, count) {
+  return count === 1 ? String(start) : `${start},${count}`;
+}
+
+// Hirschberg LCS produces a minimal line edit script while keeping memory linear.
+// The line cap bounds its worst-case work before a hostile text file can monopolize
+// synchronous hook execution.
+export function unifiedLineDiff(path, beforeText, afterText, { context = 3, maxLines = 4_096 } = {}) {
+  const before = normalizedLines(beforeText);
+  const after = normalizedLines(afterText);
+  if (before.length + after.length > maxLines) throw new RangeError("line diff limit exceeded");
+  const changes = operations(before, after);
+  const ranges = [];
+  for (let index = 0; index < changes.length;) {
+    if (changes[index].type === " ") {
+      index += 1;
+      continue;
+    }
+    const start = Math.max(0, index - context);
+    let end = index + 1;
+    while (end < changes.length && changes[end].type !== " ") end += 1;
+    end = Math.min(changes.length, end + context);
+    const previous = ranges.at(-1);
+    if (previous && start <= previous.end) previous.end = end;
+    else ranges.push({ start, end });
+    index = end;
+  }
+  const result = [`--- a/${path}`, `+++ b/${path}`];
+  for (const section of ranges) {
+    const prior = changes.slice(0, section.start);
+    const hunk = changes.slice(section.start, section.end);
+    const oldBefore = prior.filter((entry) => entry.type !== "+").length;
+    const newBefore = prior.filter((entry) => entry.type !== "-").length;
+    const oldCount = hunk.filter((entry) => entry.type !== "+").length;
+    const newCount = hunk.filter((entry) => entry.type !== "-").length;
+    result.push(`@@ -${range(oldCount ? oldBefore + 1 : oldBefore, oldCount)} +${range(newCount ? newBefore + 1 : newBefore, newCount)} @@`);
+    result.push(...hunk.map((entry) => `${entry.type}${entry.line}`));
+  }
+  return result.join("\n");
+}
diff --git a/ovens/streaming-diff/engine/streaming-diff-racefix.test.mjs b/ovens/streaming-diff/engine/streaming-diff-racefix.test.mjs
new file mode 100644
index 0000000..4de864b
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-racefix.test.mjs
@@ -0,0 +1,77 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { captureStreamingDiff } from "./streaming-diff-feed-capture.mjs";
+import { resolveStreamingDiffIdentity } from "./streaming-diff-feed.mjs";
+import { readJournal } from "./streaming-diff-journal.mjs";
+import { closeActiveWindows, inspectActiveWindowOverlap, markPreSnapshotRegistered, registerActiveWindows, writePreSnapshot } from "./streaming-diff-snapshot-store.mjs";
+
+function git(cwd, ...args) {
+  execFileSync("git", ["-C", cwd, ...args], { stdio: "ignore" });
+}
+
+function fixture() {
+  const root = mkdtempSync(join(tmpdir(), "burnlist-streaming-racefix-"));
+  git(root, "init", "--quiet");
+  git(root, "config", "user.email", "test@example.invalid");
+  git(root, "config", "user.name", "Test");
+  writeFileSync(join(root, "target.txt"), "before\n");
+  git(root, "add", "target.txt");
+  git(root, "commit", "--quiet", "-m", "initial");
+  return { root, cleanup: () => rmSync(root, { recursive: true, force: true }) };
+}
+
+test("future-skewed peer windows survive and make both closes unattributed", () => {
+  const context = fixture();
+  try {
+    const first = resolveStreamingDiffIdentity({ cwd: context.root, session: "future-first" });
+    const second = resolveStreamingDiffIdentity({ cwd: context.root, session: "future-second" });
+    for (const [identity, toolUseId] of [[first, "first-tool"], [second, "second-tool"]]) {
+      writePreSnapshot({ identity, toolUseId, hintedPaths: ["target.txt"] });
+      markPreSnapshotRegistered({ identity, toolUseId });
+    }
+    registerActiveWindows({ identity: first, toolUseId: "first-tool", hintedPaths: ["target.txt"], openedAt: 2_000 });
+    registerActiveWindows({ identity: second, toolUseId: "second-tool", hintedPaths: ["target.txt"], openedAt: 1_900 });
+
+    const registry = JSON.parse(readFileSync(join(context.root, ".local", "burnlist", "streaming-diff-active-windows.json"), "utf8"));
+    assert.deepEqual(registry.windows.map((window) => window.toolUseId).sort(), ["first-tool", "second-tool"]);
+    assert.deepEqual(closeActiveWindows({ identity: first, toolUseId: "first-tool", closedAt: 2_001 }).paths, ["target.txt"]);
+    assert.deepEqual(closeActiveWindows({ identity: second, toolUseId: "second-tool", closedAt: 2_002 }).paths, ["target.txt"]);
+  } finally { context.cleanup(); }
+});
+
+test("an expired own active window makes a post capture partial", () => {
+  const context = fixture();
+  const openedAt = 10_000;
+  let inspections = 0;
+  const windows = {
+    registerActiveWindows: (args) => registerActiveWindows({ ...args, openedAt }),
+    inspectActiveWindowOverlap: (args) => inspectActiveWindowOverlap({ ...args, inspectedAt: openedAt + (inspections++ < 2 ? 1 : 301_000) }),
+    closeActiveWindows: (args) => closeActiveWindows({ ...args, closedAt: openedAt + 301_000 }),
+  };
+  try {
+    captureStreamingDiff({ cwd: context.root, session: "long-tool", toolUseId: "long", phase: "pre", hintedPaths: ["target.txt"], activeWindows: windows });
+    captureStreamingDiff({ cwd: context.root, session: "peer-tool", toolUseId: "peer", phase: "pre", hintedPaths: ["target.txt"], activeWindows: windows });
+    writeFileSync(join(context.root, "target.txt"), "after\n");
+    const result = captureStreamingDiff({ cwd: context.root, session: "long-tool", toolUseId: "long", phase: "post", hintedPaths: ["target.txt"], activeWindows: windows });
+    assert.equal(result.card.status, "partial");
+    assert.match(result.card.partialReason, /active window expired before close/u);
+  } finally { context.cleanup(); }
+});
+
+test("a retried post publishes only one terminal card for a tool use", () => {
+  const context = fixture();
+  try {
+    const pre = captureStreamingDiff({ cwd: context.root, session: "dedupe", toolUseId: "one-tool", phase: "pre", hintedPaths: ["target.txt"] });
+    writeFileSync(join(context.root, "target.txt"), "after\n");
+    captureStreamingDiff({ cwd: context.root, session: "dedupe", toolUseId: "one-tool", phase: "post", hintedPaths: ["target.txt"] });
+    captureStreamingDiff({ cwd: context.root, session: "dedupe", toolUseId: "one-tool", phase: "post", hintedPaths: ["target.txt"] });
+    const cards = readJournal(pre.identity.feedDir).cards.filter((card) => !card.partialReason?.includes("attempt in progress / unterminated"));
+    assert.equal(cards.length, 1);
+    assert.equal(cards[0].toolUseId, "one-tool");
+  } finally { context.cleanup(); }
+});
diff --git a/ovens/streaming-diff/engine/streaming-diff-snapshot-store.mjs b/ovens/streaming-diff/engine/streaming-diff-snapshot-store.mjs
new file mode 100644
index 0000000..f463e1c
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-snapshot-store.mjs
@@ -0,0 +1,371 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+import { createGitCaptureIo } from "./streaming-diff-capture-git.mjs";
+import { captureLimits, isBinaryContent, redact, STREAMING_DIFF_ABSENT, STREAMING_DIFF_CAPTURE_LIMITS, STREAMING_DIFF_MISSING } from "./streaming-diff-capture.mjs";
+import { identifierPathComponent, snapshotDirectory, streamingDiffIdentifier } from "./streaming-diff-feed.mjs";
+import { fsyncDirectory, writeDurableAtomic, writeDurableExclusive } from "./streaming-diff-durable-write.mjs";
+import { containedJoin, withRepoStateLock } from "../../../src/server/repo-state.mjs";
+
+const SNAPSHOT_SCHEMA = 1;
+const ACTIVE_WINDOW_SCHEMA = 1;
+const ACTIVE_WINDOW_MAX_AGE_MS = 5 * 60_000;
+export const STREAMING_DIFF_ACTIVE_WINDOW_MAX_ENTRIES = 128;
+export const STREAMING_DIFF_ACTIVE_WINDOW_MAX_BYTES = 64 * 1024;
+const ACTIVE_WINDOW_OVERFLOW_REASON = "attribution unavailable: too many concurrent windows";
+const ACTIVE_WINDOW_READ_ERROR_REASON = "attribution unavailable: active-window registry unreadable";
+const ACTIVE_WINDOW_EXPIRED_REASON = "attribution unavailable: active window expired before close";
+export const STREAMING_DIFF_SNAPSHOT_MAX_BYTES = 512 * 1024;
+const terminalReasons = new Set(["tool failed", "path hints truncated", "hook adapter mapping was incomplete", "hook payload exceeded byte limit", "hook payload read timed out"]);
+
+export function streamingDiffToolUseId(value) {
+  return streamingDiffIdentifier(value, "tool use id");
+}
+
+function safePath(path, limits) {
+  return typeof path === "string" && path.length > 0 && path.length <= limits.maxPathLength && Buffer.byteLength(path, "utf8") <= limits.maxPathLength
+    && !path.startsWith("/") && !path.includes("\\")
+    && !path.split("/").some((part) => !part || part === "." || part === "..");
+}
+
+function hardDenied(path) {
+  return path.split("/").some((part) => {
+    const name = part.toLowerCase();
+    return name === ".git" || name.startsWith(".env")
+      || /(?:^|[._-])(?:key|keys|cert|certificate|credential|credentials|secret|secrets|password|token)(?:[._-]|$)/u.test(name)
+      || /^(?:id_rsa|id_dsa|id_ecdsa|id_ed25519)$/u.test(name)
+      || /\.(?:pem|p12|pfx|key|crt)$/u.test(name);
+  });
+}
+
+function snapshotPath(identity, toolUseId) {
+  return join(snapshotDirectory(identity), `${identifierPathComponent(toolUseId)}.json`);
+}
+
+function markerPath(identity, toolUseId, marker) {
+  return join(snapshotDirectory(identity), `${identifierPathComponent(toolUseId)}.${marker}`);
+}
+
+function createMarker(identity, toolUseId, marker, value = "") {
+  mkdirSync(snapshotDirectory(identity), { recursive: true, mode: 0o700 });
+  return writeDurableExclusive(markerPath(identity, toolUseId, marker), value);
+}
+
+function readUnavailableMarker(identity, toolUseId) {
+  try {
+    const value = readFileSync(markerPath(identity, toolUseId, "unavailable"), "utf8");
+    return { unavailable: true, reason: value.length <= 256 ? value || undefined : undefined };
+  } catch (error) {
+    return error?.code === "ENOENT" ? { unavailable: false } : { unavailable: true };
+  }
+}
+
+function activeWindowPath(identity) {
+  return containedJoin(identity.worktreeRoot, "streaming-diff-active-windows.json");
+}
+
+function readActiveWindows(path, now) {
+  try {
+    const stored = JSON.parse(readFileSync(path, "utf8"));
+    if (stored?.schemaVersion !== ACTIVE_WINDOW_SCHEMA || !Array.isArray(stored.windows)) {
+      return { windows: [], attributionUnavailableUntil: 0, unavailable: true, attributionUnavailableReason: ACTIVE_WINDOW_READ_ERROR_REASON };
+    }
+    const validWindow = (window) => window && typeof window === "object"
+      && typeof window.session === "string" && typeof window.toolUseId === "string" && typeof window.path === "string"
+      && Number.isFinite(window.openedAt)
+      && (!Object.hasOwn(window, "overlappedPaths") || Array.isArray(window.overlappedPaths));
+    if (!stored.windows.every(validWindow)) {
+      return { windows: [], attributionUnavailableUntil: 0, unavailable: true, attributionUnavailableReason: ACTIVE_WINDOW_READ_ERROR_REASON };
+    }
+    return {
+      windows: stored.windows.filter((window) => window.openedAt >= now - ACTIVE_WINDOW_MAX_AGE_MS),
+      attributionUnavailableUntil: Number.isFinite(stored.attributionUnavailableUntil) && stored.attributionUnavailableUntil > now
+        ? stored.attributionUnavailableUntil : 0,
+    };
+  } catch (error) {
+    if (error?.code === "ENOENT") return { windows: [], attributionUnavailableUntil: 0 };
+    return { windows: [], attributionUnavailableUntil: 0, unavailable: true, attributionUnavailableReason: ACTIVE_WINDOW_READ_ERROR_REASON };
+  }
+}
+
+function activeWindowsPayload(windows, attributionUnavailableUntil = 0) {
+  return {
+    schemaVersion: ACTIVE_WINDOW_SCHEMA,
+    windows,
+    ...(attributionUnavailableUntil ? { attributionUnavailableUntil } : {}),
+  };
+}
+
+function pruneActiveWindows(windows, now) {
+  return windows
+    .filter((window) => window.openedAt >= now - ACTIVE_WINDOW_MAX_AGE_MS)
+    .sort((left, right) => left.openedAt - right.openedAt);
+}
+
+function activeWindowsFit(windows, attributionUnavailableUntil) {
+  return windows.length <= STREAMING_DIFF_ACTIVE_WINDOW_MAX_ENTRIES
+    && Buffer.byteLength(JSON.stringify(activeWindowsPayload(windows, attributionUnavailableUntil || Number.MAX_SAFE_INTEGER)), "utf8") <= STREAMING_DIFF_ACTIVE_WINDOW_MAX_BYTES;
+}
+
+function saveActiveWindows(path, windows, now, attributionUnavailableUntil = 0) {
+  const pruned = pruneActiveWindows(windows, now);
+  const unavailableUntil = attributionUnavailableUntil > now ? attributionUnavailableUntil : 0;
+  if (!activeWindowsFit(pruned, unavailableUntil)) throw new Error(ACTIVE_WINDOW_OVERFLOW_REASON);
+  if (pruned.length || unavailableUntil) writeDurableAtomic(path, JSON.stringify(activeWindowsPayload(pruned, unavailableUntil)));
+  else {
+    rmSync(path, { force: true });
+    try { fsyncDirectory(dirname(path)); } catch (error) { if (error?.code !== "ENOENT") throw error; }
+  }
+}
+
+// The registry deliberately lives under each physical worktree. Sessions from
+// separate worktrees are isolated and can therefore be attributed normally.
+export function registerActiveWindows({ identity, toolUseId, hintedPaths = [], openedAt } = {}) {
+  const safeId = streamingDiffToolUseId(toolUseId);
+  const paths = [...new Set(hintedPaths.filter((path) => typeof path === "string"))];
+  return withRepoStateLock(identity.worktreeRoot, () => {
+    const now = Number.isFinite(openedAt) ? openedAt : Date.now();
+    const path = activeWindowPath(identity);
+    const registry = readActiveWindows(path, now);
+    if (registry.unavailable) {
+      return { path, openedAt: now, attributionUnavailable: true, attributionUnavailableReason: registry.attributionUnavailableReason };
+    }
+    const windows = registry.windows;
+    let attributionUnavailableUntil = registry.attributionUnavailableUntil;
+    for (const hintedPath of paths) {
+      if (!windows.some((window) => window.session === identity.session && window.toolUseId === safeId && window.path === hintedPath)) {
+        const window = { session: identity.session, toolUseId: safeId, path: hintedPath, openedAt: now };
+        if (activeWindowsFit([...windows, window], attributionUnavailableUntil)) windows.push(window);
+        else attributionUnavailableUntil = Math.max(attributionUnavailableUntil, now + ACTIVE_WINDOW_MAX_AGE_MS);
+      }
+    }
+    saveActiveWindows(path, windows, now, attributionUnavailableUntil);
+    return { path, openedAt: now, attributionUnavailable: attributionUnavailableUntil > now };
+  });
+}
+
+function activeWindowOverlap(windows, identity, toolUseId) {
+  const mine = windows.filter((window) => window.session === identity.session && window.toolUseId === toolUseId);
+  const paths = new Set(mine.flatMap((window) => window.overlappedPaths ?? []));
+  for (const window of mine) {
+    for (const other of windows) {
+      if ((other.session === identity.session && other.toolUseId === toolUseId) || other.path !== window.path) continue;
+      paths.add(window.path);
+    }
+  }
+  return { mine, paths };
+}
+
+export function inspectActiveWindowOverlap({ identity, toolUseId, inspectedAt } = {}) {
+  const safeId = streamingDiffToolUseId(toolUseId);
+  return withRepoStateLock(identity.worktreeRoot, () => {
+    const now = Number.isFinite(inspectedAt) ? inspectedAt : Date.now();
+    const registry = readActiveWindows(activeWindowPath(identity), now);
+    if (registry.unavailable) {
+      return { paths: [], attributionUnavailable: true, attributionUnavailableReason: registry.attributionUnavailableReason };
+    }
+    const overlap = activeWindowOverlap(registry.windows, identity, safeId);
+    return { paths: [...overlap.paths], attributionUnavailable: registry.attributionUnavailableUntil > now };
+  });
+}
+
+export function closeActiveWindows({ identity, toolUseId, closedAt } = {}) {
+  const safeId = streamingDiffToolUseId(toolUseId);
+  return withRepoStateLock(identity.worktreeRoot, () => {
+    const now = Number.isFinite(closedAt) ? closedAt : Date.now();
+    const path = activeWindowPath(identity);
+    const registry = readActiveWindows(path, now);
+    if (registry.unavailable) {
+      return { paths: [], closed: false, attributionUnavailable: true, attributionUnavailableReason: registry.attributionUnavailableReason };
+    }
+    const windows = registry.windows;
+    const overlap = activeWindowOverlap(windows, identity, safeId);
+    const peers = new Map();
+    for (const window of overlap.mine) {
+      for (const other of windows) {
+        if ((other.session === identity.session && other.toolUseId === safeId) || other.path !== window.path) continue;
+        const overlaps = new Set(other.overlappedPaths ?? []);
+        overlaps.add(other.path);
+        other.overlappedPaths = [...overlaps];
+        peers.set(`${other.session}\u0000${other.toolUseId}`, other);
+      }
+    }
+    const remaining = windows.filter((window) => window.session !== identity.session || window.toolUseId !== safeId);
+    for (const peer of peers.values()) {
+      const peerIdentity = { ...identity, session: peer.session, sessionPath: identifierPathComponent(peer.session) };
+      if (peerIdentity.logicalRepoRoot === identity.worktreeRoot) markPreSnapshotOverlappedLocked(peerIdentity, peer.toolUseId);
+      else markPreSnapshotOverlapped({ identity: peerIdentity, toolUseId: peer.toolUseId });
+    }
+    try {
+      saveActiveWindows(path, remaining, now, registry.attributionUnavailableUntil);
+      const closed = overlap.mine.length > 0;
+      const registryUnavailable = registry.attributionUnavailableUntil > now;
+      return {
+        paths: [...overlap.paths],
+        closed,
+        attributionUnavailable: registryUnavailable,
+        ...(registryUnavailable
+          ? { attributionUnavailableReason: ACTIVE_WINDOW_OVERFLOW_REASON }
+          : !closed ? { attributionUnavailableReason: ACTIVE_WINDOW_EXPIRED_REASON } : {}),
+      };
+    } catch (error) {
+      if (error?.message !== ACTIVE_WINDOW_OVERFLOW_REASON) throw error;
+      const withoutNewOverlapMarks = registry.windows
+        .filter((window) => window.session !== identity.session || window.toolUseId !== safeId)
+        .map(({ overlappedPaths, ...window }) => window);
+      saveActiveWindows(path, withoutNewOverlapMarks, now, now + ACTIVE_WINDOW_MAX_AGE_MS);
+      return { paths: [...overlap.paths], closed: overlap.mine.length > 0, attributionUnavailable: true, attributionUnavailableReason: ACTIVE_WINDOW_OVERFLOW_REASON };
+    }
+  });
+}
+
+function encode(value) {
+  if (value === STREAMING_DIFF_ABSENT) return { kind: "absent" };
+  if (value === STREAMING_DIFF_MISSING) return { kind: "missing" };
+  if (value?.truncated === true) return { kind: "truncated", bytes: value.bytes };
+  if (Buffer.isBuffer(value)) {
+    if (isBinaryContent(value)) return { kind: "binary", bytes: value.length };
+    const redacted = redact(value.toString("utf8"));
+    return redacted.redacted || redacted.marker ? { kind: "missing" } : { kind: "text", text: redacted.text };
+  }
+  if (typeof value === "string") {
+    const redacted = redact(value);
+    return redacted.redacted || redacted.marker ? { kind: "missing" } : { kind: "text", text: redacted.text };
+  }
+  return { kind: "missing" };
+}
+
+function decode(entry) {
+  if (!entry || typeof entry !== "object") return STREAMING_DIFF_MISSING;
+  if (entry.kind === "absent") return STREAMING_DIFF_ABSENT;
+  if (entry.kind === "missing") return STREAMING_DIFF_MISSING;
+  if (entry.kind === "binary" && Number.isSafeInteger(entry.bytes) && entry.bytes >= 0) return { binary: true, bytes: entry.bytes };
+  if (entry.kind === "text" && typeof entry.text === "string") return entry.text;
+  if (entry.kind === "truncated" && Number.isSafeInteger(entry.bytes) && entry.bytes >= 0) return { truncated: true, bytes: entry.bytes };
+  return STREAMING_DIFF_MISSING;
+}
+
+function validStoredSnapshot(value, toolUseId) {
+  return value && typeof value === "object" && !Array.isArray(value)
+    && value.schemaVersion === SNAPSHOT_SCHEMA && value.toolUseId === toolUseId
+    && Array.isArray(value.hintedPaths) && value.hintedPaths.every((path) => typeof path === "string")
+    && (!Object.hasOwn(value, "terminalReason") || typeof value.terminalReason === "string")
+    && value.entries && typeof value.entries === "object" && !Array.isArray(value.entries);
+}
+
+export function writePreSnapshot({ identity, toolUseId, hintedPaths = [], terminalReason, policy = {} } = {}) {
+  const limits = captureLimits(policy);
+  const safeId = streamingDiffToolUseId(toolUseId);
+  const unique = [...new Set(Array.isArray(hintedPaths) ? hintedPaths : [])].slice(0, limits.maxPaths);
+  const entries = {};
+  const io = createGitCaptureIo(identity.worktreeRoot, limits);
+  const safeHints = unique.filter((path) => safePath(path, limits));
+  const candidates = safeHints.filter((path) => !hardDenied(path));
+  let tracked = new Set();
+  try {
+    tracked = new Set(io.listTracked(candidates));
+  } catch {
+    // Without a trustworthy tracked classification, fail closed rather than
+    // accidentally retaining an ignored path in the local snapshot.
+    candidates.length = 0;
+  }
+  for (const path of candidates) {
+    try {
+      const info = io.inspect(path);
+      if (info.type && info.type !== "file" || info.contained === false || info.symlinkEscape === true || (!tracked.has(path) && io.isIgnored(path))) continue;
+      entries[path] = encode(io.readPost(path));
+    } catch {
+      entries[path] = { kind: "missing" };
+    }
+  }
+  const path = snapshotPath(identity, safeId);
+  if (existsSync(path)) {
+    const existing = takePreSnapshot({ identity, toolUseId: safeId });
+    return { path, hintedPaths: existing.found ? existing.hintedPaths : safeHints };
+  }
+  const record = {
+    schemaVersion: SNAPSHOT_SCHEMA,
+    toolUseId: safeId,
+    hintedPaths: safeHints,
+    ...(terminalReasons.has(terminalReason) ? { terminalReason } : {}),
+    entries,
+  };
+  const serialized = JSON.stringify(record);
+  if (Buffer.byteLength(serialized, "utf8") > STREAMING_DIFF_SNAPSHOT_MAX_BYTES) throw new Error(`snapshot exceeds its ${STREAMING_DIFF_SNAPSHOT_MAX_BYTES}-byte limit`);
+  const dir = snapshotDirectory(identity);
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  if (!writeDurableExclusive(path, serialized)) {
+    const existing = takePreSnapshot({ identity, toolUseId: safeId });
+    return { path, hintedPaths: existing.found ? existing.hintedPaths : record.hintedPaths };
+  }
+  return { path, hintedPaths: record.hintedPaths };
+}
+
+// A post hook reads this immutable pre-state before publication. It is deleted
+// only after a durable terminal card, so a failed append can safely retry.
+export function takePreSnapshot({ identity, toolUseId } = {}) {
+  const safeId = streamingDiffToolUseId(toolUseId);
+  const path = snapshotPath(identity, safeId);
+  let parsed = null;
+  try {
+    const stat = statSync(path);
+    if (!stat.isFile() || stat.size > STREAMING_DIFF_SNAPSHOT_MAX_BYTES) throw new Error(`snapshot exceeds its ${STREAMING_DIFF_SNAPSHOT_MAX_BYTES}-byte limit`);
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch { return unavailableSnapshot(); }
+  if (!validStoredSnapshot(parsed, safeId)) return unavailableSnapshot();
+  const unavailable = readUnavailableMarker(identity, safeId);
+  return {
+    found: true,
+    hintedPaths: parsed.hintedPaths,
+    registered: existsSync(markerPath(identity, safeId, "registered")),
+    overlapped: existsSync(markerPath(identity, safeId, "overlapped")),
+    attributionUnavailable: unavailable.unavailable,
+    attributionUnavailableReason: unavailable.reason,
+    terminalReason: parsed.terminalReason,
+    preSnapshot: new Map(parsed.hintedPaths.map((path) => [path, decode(parsed.entries[path])])),
+  };
+}
+
+function unavailableSnapshot() {
+  return {
+    found: false,
+    hintedPaths: [],
+    registered: false,
+    attributionUnavailable: true,
+    attributionUnavailableReason: "attribution unavailable: pre-snapshot unreadable",
+    preSnapshot: new Map(),
+  };
+}
+
+function markPreSnapshotOverlappedLocked(identity, safeId) {
+  const found = existsSync(snapshotPath(identity, safeId));
+  if (found) createMarker(identity, safeId, "overlapped");
+  return { found, overlapped: found };
+}
+
+export function markPreSnapshotOverlapped({ identity, toolUseId } = {}) {
+  const safeId = streamingDiffToolUseId(toolUseId);
+  return markPreSnapshotOverlappedLocked(identity, safeId);
+}
+
+export function markPreSnapshotAttributionUnavailable({ identity, toolUseId, reason } = {}) {
+  const safeId = streamingDiffToolUseId(toolUseId);
+  const found = existsSync(snapshotPath(identity, safeId));
+  if (found) createMarker(identity, safeId, "unavailable", typeof reason === "string" ? reason.slice(0, 256) : "");
+  return { found, attributionUnavailable: found };
+}
+
+export function markPreSnapshotRegistered({ identity, toolUseId } = {}) {
+  const safeId = streamingDiffToolUseId(toolUseId);
+  const found = existsSync(snapshotPath(identity, safeId));
+  if (found) createMarker(identity, safeId, "registered");
+  return { found, registered: found, overlapped: found && existsSync(markerPath(identity, safeId, "overlapped")) };
+}
+
+export function removePreSnapshot({ identity, toolUseId } = {}) {
+  const safeId = streamingDiffToolUseId(toolUseId);
+  const path = snapshotPath(identity, safeId);
+  for (const marker of ["registered", "overlapped", "unavailable"]) rmSync(markerPath(identity, safeId, marker), { force: true });
+  rmSync(path, { force: true });
+  try { fsyncDirectory(dirname(path)); } catch (error) { if (error?.code !== "ENOENT") throw error; }
+}
diff --git a/ovens/streaming-diff/engine/streaming-diff-snapshot-store.test.mjs b/ovens/streaming-diff/engine/streaming-diff-snapshot-store.test.mjs
new file mode 100644
index 0000000..ea8ae56
--- /dev/null
+++ b/ovens/streaming-diff/engine/streaming-diff-snapshot-store.test.mjs
@@ -0,0 +1,190 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { captureCard, STREAMING_DIFF_ABSENT, STREAMING_DIFF_MISSING } from "./streaming-diff-capture.mjs";
+import { resolveStreamingDiffIdentity, snapshotDirectory } from "./streaming-diff-feed.mjs";
+import {
+  closeActiveWindows,
+  inspectActiveWindowOverlap,
+  markPreSnapshotAttributionUnavailable,
+  markPreSnapshotOverlapped,
+  markPreSnapshotRegistered,
+  registerActiveWindows,
+  removePreSnapshot,
+  STREAMING_DIFF_ACTIVE_WINDOW_MAX_BYTES,
+  STREAMING_DIFF_ACTIVE_WINDOW_MAX_ENTRIES,
+  takePreSnapshot,
+  writePreSnapshot,
+} from "./streaming-diff-snapshot-store.mjs";
+
+function git(cwd, ...args) {
+  execFileSync("git", ["-C", cwd, ...args], { stdio: "ignore" });
+}
+
+function fixture() {
+  const root = mkdtempSync(join(tmpdir(), "burnlist-streaming-snapshot-"));
+  git(root, "init", "--quiet");
+  git(root, "config", "user.email", "test@example.invalid");
+  git(root, "config", "user.name", "Test");
+  return { root, identity: resolveStreamingDiffIdentity({ cwd: root, session: "session-a" }), cleanup: () => rmSync(root, { recursive: true, force: true }) };
+}
+
+test("pre-snapshots round-trip bounded safe content and remain until durable post publication", () => {
+  const context = fixture();
+  try {
+    writeFileSync(join(context.root, "safe.txt"), "before\n");
+    const written = writePreSnapshot({ identity: context.identity, toolUseId: "tool-1", hintedPaths: ["safe.txt", "gone.txt"] });
+    assert.equal(existsSync(written.path), true);
+    const taken = takePreSnapshot({ identity: context.identity, toolUseId: "tool-1" });
+    assert.equal(taken.found, true);
+    assert.deepEqual(taken.hintedPaths, ["safe.txt", "gone.txt"]);
+    assert.equal(taken.preSnapshot.get("safe.txt"), "before\n");
+    assert.equal(taken.preSnapshot.get("gone.txt"), STREAMING_DIFF_ABSENT);
+    assert.equal(existsSync(written.path), true);
+    markPreSnapshotRegistered({ identity: context.identity, toolUseId: "tool-1" });
+    markPreSnapshotOverlapped({ identity: context.identity, toolUseId: "tool-1" });
+    markPreSnapshotAttributionUnavailable({ identity: context.identity, toolUseId: "tool-1", reason: "test unavailable" });
+    removePreSnapshot({ identity: context.identity, toolUseId: "tool-1" });
+    assert.equal(existsSync(written.path), false);
+    for (const marker of ["registered", "overlapped", "unavailable"]) assert.equal(existsSync(written.path.replace(/\.json$/u, `.${marker}`)), false);
+    assert.equal(takePreSnapshot({ identity: context.identity, toolUseId: "tool-1" }).found, false);
+  } finally { context.cleanup(); }
+});
+
+test("snapshot storage never writes denied, ignored, binary, or secret-looking source content", () => {
+  const context = fixture();
+  try {
+    writeFileSync(join(context.root, ".gitignore"), "ignored.txt\n");
+    writeFileSync(join(context.root, ".env"), "SHOULD_NOT_PERSIST\n");
+    writeFileSync(join(context.root, "private.pem"), "SHOULD_NOT_PERSIST\n");
+    writeFileSync(join(context.root, "ignored.txt"), "SHOULD_NOT_PERSIST\n");
+    writeFileSync(join(context.root, "safe.txt"), "api_key=SHOULD_NOT_PERSIST\n");
+    writeFileSync(join(context.root, "binary.bin"), Buffer.from([1, 0, 2]));
+    writeFileSync(join(context.root, "unhinted.txt"), "UNHINTED_CONTENT\n");
+    const outside = mkdtempSync(join(tmpdir(), "burnlist-streaming-snapshot-outside-"));
+    writeFileSync(join(outside, "outside.txt"), "SHOULD_NOT_PERSIST\n");
+    symlinkSync(join(outside, "outside.txt"), join(context.root, "escape.txt"));
+    const written = writePreSnapshot({
+      identity: context.identity,
+      toolUseId: "tool-2",
+      hintedPaths: [".env", "private.pem", "ignored.txt", "safe.txt", "binary.bin", "escape.txt", "../outside"],
+    });
+    const stored = JSON.parse(readFileSync(written.path, "utf8"));
+    assert.doesNotMatch(JSON.stringify(stored), /SHOULD_NOT_PERSIST/u);
+    assert.doesNotMatch(JSON.stringify(stored), /UNHINTED_CONTENT/u);
+    assert.equal(Object.hasOwn(stored.entries, ".env"), false);
+    assert.equal(Object.hasOwn(stored.entries, "private.pem"), false);
+    assert.equal(Object.hasOwn(stored.entries, "ignored.txt"), false);
+    assert.equal(Object.hasOwn(stored.entries, "escape.txt"), false);
+    assert.deepEqual(stored.hintedPaths, [".env", "private.pem", "ignored.txt", "safe.txt", "binary.bin", "escape.txt"]);
+    const taken = takePreSnapshot({ identity: context.identity, toolUseId: "tool-2" });
+    assert.equal(taken.preSnapshot.get("safe.txt"), STREAMING_DIFF_MISSING);
+    assert.deepEqual(taken.preSnapshot.get("binary.bin"), { binary: true, bytes: 3 });
+    for (const path of [".env", "private.pem", "ignored.txt", "escape.txt"]) {
+      assert.equal(taken.preSnapshot.get(path), STREAMING_DIFF_MISSING);
+    }
+    rmSync(outside, { recursive: true, force: true });
+  } finally { context.cleanup(); }
+});
+
+test("an invalid UTF-8 pre-snapshot stays captured binary metadata after a valid-text post", () => {
+  const context = fixture();
+  try {
+    const path = join(context.root, "invalid.txt");
+    writeFileSync(path, Buffer.from([0xc3, 0x28]));
+    const written = writePreSnapshot({ identity: context.identity, toolUseId: "invalid-utf8", hintedPaths: ["invalid.txt"] });
+    const stored = JSON.parse(readFileSync(written.path, "utf8"));
+    assert.deepEqual(stored.entries["invalid.txt"], { kind: "binary", bytes: 2 });
+    writeFileSync(path, "valid text\n");
+    const { preSnapshot } = takePreSnapshot({ identity: context.identity, toolUseId: "invalid-utf8" });
+    const card = captureCard({
+      hintedPaths: ["invalid.txt"],
+      preSnapshot,
+      readPost: () => readFileSync(path),
+      listUntracked: () => ["invalid.txt"],
+      toolUseId: "invalid-utf8",
+      revId: "r-0123456789abcdef01234567",
+      now: () => "2026-07-15T09:00:00.000Z",
+    });
+    assert.deepEqual(card.files, [{ path: "invalid.txt", kind: "binary", meta: { bytes: 11 } }]);
+    assert.equal(card.status, "captured");
+    assert.equal(card.files[0].diff, undefined);
+  } finally { context.cleanup(); }
+});
+
+test("snapshot records enforce a serialized byte cap before write and fail closed when unreadable", () => {
+  const context = fixture();
+  try {
+    writeFileSync(join(context.root, "one.txt"), "a".repeat(256 * 1024));
+    writeFileSync(join(context.root, "two.txt"), "b".repeat(256 * 1024));
+    assert.throws(
+      () => writePreSnapshot({ identity: context.identity, toolUseId: "too-large", hintedPaths: ["one.txt", "two.txt"] }),
+      /snapshot exceeds/u,
+    );
+    const names = existsSync(snapshotDirectory(context.identity)) ? readdirSync(snapshotDirectory(context.identity)) : [];
+    assert.equal(names.some((name) => name.endsWith(".json")), false);
+    const written = writePreSnapshot({ identity: context.identity, toolUseId: "small", hintedPaths: [] });
+    writeFileSync(written.path, "x".repeat(600 * 1024));
+    assert.equal(statSync(written.path).size > 512 * 1024, true);
+    const unreadable = takePreSnapshot({ identity: context.identity, toolUseId: "small" });
+    assert.equal(unreadable.found, false);
+    assert.equal(unreadable.attributionUnavailable, true);
+  } finally { context.cleanup(); }
+});
+
+test("active-window registry preserves normal overlaps and flags overflow without evicting live windows", () => {
+  const context = fixture();
+  try {
+    const openedAt = Date.now();
+    const first = resolveStreamingDiffIdentity({ cwd: context.root, session: "overlap-first" });
+    const second = resolveStreamingDiffIdentity({ cwd: context.root, session: "overlap-second" });
+    registerActiveWindows({ identity: first, toolUseId: "overlap-a", hintedPaths: ["shared.txt"], openedAt });
+    registerActiveWindows({ identity: second, toolUseId: "overlap-b", hintedPaths: ["shared.txt"], openedAt: openedAt + 1 });
+    assert.deepEqual(closeActiveWindows({ identity: first, toolUseId: "overlap-a", closedAt: openedAt + 2 }).paths, ["shared.txt"]);
+    assert.deepEqual(closeActiveWindows({ identity: second, toolUseId: "overlap-b", closedAt: openedAt + 3 }).paths, ["shared.txt"]);
+
+    for (let index = 0; index < STREAMING_DIFF_ACTIVE_WINDOW_MAX_ENTRIES; index += 1) {
+      const identity = resolveStreamingDiffIdentity({ cwd: context.root, session: `session-${index}` });
+      registerActiveWindows({ identity, toolUseId: `tool-${index}`, hintedPaths: [`unique-${index}.txt`], openedAt: openedAt + index });
+    }
+    const overflow = resolveStreamingDiffIdentity({ cwd: context.root, session: "overflow" });
+    registerActiveWindows({ identity: overflow, toolUseId: "overflow-tool", hintedPaths: ["overflow.txt"], openedAt: openedAt + 1_000 });
+    const path = join(context.root, ".local", "burnlist", "streaming-diff-active-windows.json");
+    const serialized = readFileSync(path, "utf8");
+    assert.ok(JSON.parse(serialized).windows.length <= STREAMING_DIFF_ACTIVE_WINDOW_MAX_ENTRIES);
+    assert.ok(Buffer.byteLength(serialized, "utf8") <= STREAMING_DIFF_ACTIVE_WINDOW_MAX_BYTES);
+    assert.equal(closeActiveWindows({ identity: overflow, toolUseId: "overflow-tool", closedAt: openedAt + 1_001 }).attributionUnavailable, true);
+  } finally { context.cleanup(); }
+});
+
+test("closing an overlap durably marks the peer snapshot after its window expires", () => {
+  const context = fixture();
+  try {
+    const openedAt = Date.now();
+    const first = resolveStreamingDiffIdentity({ cwd: context.root, session: "first" });
+    const second = resolveStreamingDiffIdentity({ cwd: context.root, session: "second" });
+    writePreSnapshot({ identity: first, toolUseId: "a", hintedPaths: ["shared.txt"] });
+    writePreSnapshot({ identity: second, toolUseId: "b", hintedPaths: ["shared.txt"] });
+    registerActiveWindows({ identity: first, toolUseId: "a", hintedPaths: ["shared.txt"], openedAt });
+    registerActiveWindows({ identity: second, toolUseId: "b", hintedPaths: ["shared.txt"], openedAt: openedAt + 1 });
+    closeActiveWindows({ identity: first, toolUseId: "a", closedAt: openedAt + 2 });
+    assert.equal(takePreSnapshot({ identity: second, toolUseId: "b" }).overlapped, true);
+    assert.deepEqual(inspectActiveWindowOverlap({ identity: second, toolUseId: "b", inspectedAt: openedAt + 5 * 60_000 + 2 }).paths, []);
+    assert.equal(takePreSnapshot({ identity: second, toolUseId: "b" }).overlapped, true);
+  } finally { context.cleanup(); }
+});
+
+test("a corrupt active-window registry fails closed as attribution unavailable", () => {
+  const context = fixture();
+  try {
+    const path = join(context.root, ".local", "burnlist", "streaming-diff-active-windows.json");
+    mkdirSync(join(context.root, ".local", "burnlist"), { recursive: true });
+    writeFileSync(path, "{ broken");
+    const overlap = inspectActiveWindowOverlap({ identity: context.identity, toolUseId: "corrupt" });
+    assert.equal(overlap.attributionUnavailable, true);
+  } finally { context.cleanup(); }
+});
diff --git a/ovens/streaming-diff/instructions.md b/ovens/streaming-diff/instructions.md
new file mode 100644
index 0000000..f7414fa
--- /dev/null
+++ b/ovens/streaming-diff/instructions.md
@@ -0,0 +1,12 @@
+# Streaming Diff
+
+Streaming Diff is a declarative, read-only Oven for recently published,
+session-scoped pre-to-post diff cards. Producers write immutable cards to the
+local feed; the dashboard observes them through the Oven data endpoint.
+
+Select a feed with its logical repository key, worktree key, and session. A
+feed's activity time indicates recent publication only; it does not indicate
+that an agent or process is live.
+
+This package contains no executable renderer, hook, or producer code. The
+server-side adapter validates and reads the local feed without mutating it.
diff --git a/ovens/streaming-diff/renderer/streaming-diff.css b/ovens/streaming-diff/renderer/streaming-diff.css
new file mode 100644
index 0000000..7d7a296
--- /dev/null
+++ b/ovens/streaming-diff/renderer/streaming-diff.css
@@ -0,0 +1,59 @@
+/* Oven-specific browser view; shared variables and primitives come from index.css. */
+.streaming-diff-view {
+  width: min(960px, calc(100% - 32px));
+  margin: 0 auto;
+  padding: 24px 0 40px;
+}
+
+.streaming-diff-heading { margin-bottom: 20px; }
+.streaming-diff-heading h1 { margin: 0; font: 400 24px/1.2 var(--dashboard-title-font); }
+.streaming-diff-heading p { margin: 6px 0 0; color: var(--muted-foreground); }
+.streaming-diff-back { display: inline-block; margin-bottom: 12px; color: var(--primary); font-size: 13px; }
+.streaming-diff-back:hover { text-decoration: underline; text-underline-offset: 4px; }
+
+.streaming-diff-message {
+  margin: 0;
+  padding: 16px;
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+  background: var(--panel);
+  color: var(--muted-foreground);
+}
+
+.streaming-diff-message.is-error { border-color: rgba(239, 68, 68, .35); color: var(--destructive-foreground); }
+.streaming-diff-feed-list, .streaming-diff-cards { display: grid; gap: 12px; }
+
+.streaming-diff-feed {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) max-content;
+  gap: 4px 16px;
+  padding: 16px;
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+  background: var(--panel);
+  transition: border-color 120ms ease, background-color 120ms ease;
+}
+
+.streaming-diff-feed:hover, .streaming-diff-feed:focus-visible { border-color: rgba(90, 162, 255, .55); background: var(--accent); outline: none; }
+.streaming-diff-feed-session { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.streaming-diff-feed-worktree, .streaming-diff-feed-time { color: var(--muted-foreground); font-size: 12px; }
+.streaming-diff-feed-time { grid-column: 2; grid-row: 1 / span 2; align-self: center; white-space: nowrap; }
+
+.streaming-diff-card { gap: 16px; padding: 16px 0; }
+.streaming-diff-card-header { grid-template-columns: minmax(0, 1fr) max-content; grid-template-rows: auto; padding: 0 16px; }
+.streaming-diff-card-content { display: grid; gap: 12px; padding: 0 16px; }
+.streaming-diff-card .ui-card-title { overflow-wrap: anywhere; font-size: 15px; }
+.streaming-diff-card .ui-card-description { margin-top: 5px; font-family: var(--dashboard-font); font-size: 12px; overflow-wrap: anywhere; }
+.streaming-diff-partial { margin: 0; padding: 8px 10px; border-left: 2px solid var(--destructive); background: rgba(239, 68, 68, .08); color: var(--destructive-foreground); font-size: 13px; }
+
+.streaming-diff-file { overflow: hidden; border: 1px solid rgba(232, 232, 232, .1); border-radius: 6px; }
+.streaming-diff-file-head { display: flex; align-items: center; justify-content: space-between; gap: 12px; padding: 8px 10px; background: rgba(232, 232, 232, .03); }
+.streaming-diff-file-head code { min-width: 0; overflow-wrap: anywhere; color: var(--foreground); }
+.streaming-diff-file-meta { margin: 0; padding: 8px 10px; color: var(--muted-foreground); font-size: 12px; }
+.streaming-diff-unified { max-height: 440px; margin: 0; padding: 12px; overflow: auto; background: #080808; color: #d4d4d8; font: 12px/1.5 var(--dashboard-font); white-space: pre; }
+
+@media (max-width: 640px) {
+  .streaming-diff-view { width: min(100% - 24px, 960px); padding-top: 16px; }
+  .streaming-diff-feed { grid-template-columns: minmax(0, 1fr); }
+  .streaming-diff-feed-time { grid-column: auto; grid-row: auto; }
+}
diff --git a/scripts/verify-oven-assertions.mjs b/scripts/verify-oven-assertions.mjs
index 68dd12c..0012014 100644
--- a/scripts/verify-oven-assertions.mjs
+++ b/scripts/verify-oven-assertions.mjs
@@ -1,11 +1,12 @@
-import { readFileSync, readdirSync } from "node:fs";
-import { resolve } from "node:path";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join, resolve } from "node:path";
 import { normalizeOvenPackage } from "../src/ovens/oven-contract.mjs";
 
 export function assertBuiltInOvenSet(repoRoot, expected) {
   const ovensRoot = resolve(repoRoot, "ovens");
   const actual = readdirSync(ovensRoot, { withFileTypes: true })
     .filter((entry) => entry.isDirectory())
+    .filter((entry) => ["instructions.md", "detail.json"].every((name) => existsSync(join(ovensRoot, entry.name, name))))
     .map((entry) => entry.name)
     .sort();
   const wanted = [...expected].sort();
diff --git a/scripts/verify-test-files.mjs b/scripts/verify-test-files.mjs
index 7602eb2..28007b3 100644
--- a/scripts/verify-test-files.mjs
+++ b/scripts/verify-test-files.mjs
@@ -12,6 +12,18 @@ export const verificationTestFiles = [
   "ovens/differential-testing/engine/differential-testing-contract.test.mjs",
   "ovens/differential-testing/engine/differential-testing-data-contract.test.mjs",
   "ovens/differential-testing/engine/differential-testing-transport-server.test.mjs",
+  "ovens/streaming-diff/engine/streaming-diff-data-contract.test.mjs",
+  "ovens/streaming-diff/engine/streaming-diff-capture.test.mjs",
+  "ovens/streaming-diff/engine/streaming-diff-capture-git.test.mjs",
+  "ovens/streaming-diff/engine/streaming-diff-journal.test.mjs",
+  "ovens/streaming-diff/engine/streaming-diff-feed.test.mjs",
+  "ovens/streaming-diff/engine/streaming-diff-snapshot-store.test.mjs",
+  "ovens/streaming-diff/engine/streaming-diff-ensure-feed.test.mjs",
+  "ovens/streaming-diff/engine/streaming-diff-feed-capture.test.mjs",
+  "ovens/streaming-diff/engine/streaming-diff-racefix.test.mjs",
+  "ovens/streaming-diff/engine/streaming-diff-journal-lock-race.test.mjs",
+  "ovens/streaming-diff/engine/streaming-diff-handler.test.mjs",
+  "ovens/streaming-diff/e2e/synthetic-hook-events.test.mjs",
   "src/server/discovery.test.mjs",
   "src/server/plan-model.test.mjs",
   "src/server/fs-safe.test.mjs",
@@ -20,14 +32,20 @@ export const verificationTestFiles = [
   "src/cli/registry-cli.test.mjs",
   "src/cli/git-ignore.test.mjs",
   "src/cli/oven-cli.test.mjs",
+  "src/cli/oven-cli-stdout.test.mjs",
   "src/cli/oven-storage.test.mjs",
   "src/cli/umbrella.test.mjs",
+  "src/cli/streaming-diff-cli.test.mjs",
+  "src/cli/hooks-config.test.mjs",
+  "ovens/streaming-diff/engine/streaming-diff-hook-adapters.test.mjs",
   "src/server/oven-bindings.test.mjs",
   "src/server/oven-warm.test.mjs",
   "src/server/registry.test.mjs",
+  "src/server/dir-lock.test.mjs",
   "src/server/repo-map.test.mjs",
   "src/server/repo-state.test.mjs",
   "dashboard/src/components/ProjectGroup/BurnlistRow.test.mjs",
+  "dashboard/src/lib/streaming-diff.test.mjs",
   "dashboard/src/lib/project-open.test.mjs",
   "dashboard/src/lib/oven-identity.test.mjs",
 ];
diff --git a/scripts/verify.mjs b/scripts/verify.mjs
index 19c9a21..8ca6788 100755
--- a/scripts/verify.mjs
+++ b/scripts/verify.mjs
@@ -219,6 +219,7 @@ const jsFiles = [...new Set([
   ...walkFiles(resolve(repoRoot, "scripts"), (path) => path.endsWith(".mjs")),
   ...walkFiles(resolve(repoRoot, "src"), (path) => path.endsWith(".mjs")),
   ...walkFiles(resolve(repoRoot, "ovens/differential-testing/engine"), (path) => path.endsWith(".mjs")),
+  ...walkFiles(resolve(repoRoot, "ovens/streaming-diff/engine"), (path) => path.endsWith(".mjs")),
   resolve(repoRoot, "src/ovens/oven-registry.mjs"),
   resolve(repoRoot, "src/ovens/built-in-handlers.mjs"),
   resolve(repoRoot, "src/ovens/handlers/generic-json-handler.mjs"),
@@ -369,9 +370,10 @@ assertSourceExcludes("src/server/burnlist-dashboard-server.mjs", '"/targets"', "
 assertSourceExcludes("dashboard/src/App.tsx", '"/targets"', "React dashboard still exposes the removed Targets route.");
 assertSourceExcludes("src/ovens/oven-contract.mjs", '"target"', "Oven contract still accepts the removed Target widget.");
 assertSkillSet(repoRoot, ["burnlist"]);
-assertBuiltInOvenSet(repoRoot, ["checklist", "differential-testing"]);
+assertBuiltInOvenSet(repoRoot, ["checklist", "differential-testing", "streaming-diff"]);
 assertBuiltInOven(repoRoot, "checklist", "Checklist");
 assertBuiltInOven(repoRoot, "differential-testing", "Differential Testing");
+assertBuiltInOven(repoRoot, "streaming-diff", "Streaming Diff");
 assertDifferentialTestingContractAssets();
 assertPublishablePackage();
 
diff --git a/src/cli/hooks-cli.mjs b/src/cli/hooks-cli.mjs
new file mode 100644
index 0000000..fa052eb
--- /dev/null
+++ b/src/cli/hooks-cli.mjs
@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { hookConfigStatus, updateHookConfigs } from "./hooks-config.mjs";
+
+const tokens = process.argv.slice(2);
+if (tokens[0] === "hooks") tokens.shift();
+const subcommand = tokens.shift() ?? "status";
+
+function fail(message) { console.error(`burnlist hooks: ${message}`); process.exitCode = 2; }
+function agents(values) {
+  const names = values ?? "codex,claude";
+  const result = names.split(",").filter(Boolean);
+  if (!result.length || result.some((name) => !["codex", "claude"].includes(name))) throw new Error("--agent must be codex, claude, or a comma-separated pair");
+  return [...new Set(result)];
+}
+function parse() {
+  let requestedAgents;
+  let untracked = false;
+  for (let index = 0; index < tokens.length; index += 1) {
+    if (tokens[index] === "--agent") requestedAgents = tokens[++index];
+    else if (tokens[index] === "--untracked") untracked = true;
+    else throw new Error(`unexpected argument: ${tokens[index]}`);
+  }
+  return { agents: agents(requestedAgents), untracked };
+}
+function print(result, { install = false } = {}) {
+  for (const entry of result) {
+    const shared = entry.mode === "tracked" ? "shared with the team; info/exclude cannot hide tracked config" : entry.excluded ? "local (listed in .git/info/exclude)" : "local (not listed in .git/info/exclude)";
+    console.log(`${entry.agent}: ${entry.state ?? (entry.installed ? "installed" : "none")}; ${shared}`);
+    const capability = entry.capability;
+    console.log(`${entry.agent}: ${capability.state}${capability.minimumVersion ? ` (needs >= ${capability.minimumVersion})` : ""}`);
+    if (install && capability.state === "installed-but-hooks-unsupported") console.warn(`${entry.agent}: hooks were configured but this installed CLI cannot run them.`);
+    if (entry.forcedUntracked) console.warn(`${entry.agent}: --untracked cannot hide an already tracked config.`);
+  }
+}
+try {
+  if (["--help", "-h"].includes(subcommand)) console.log("Usage: burnlist hooks <install|uninstall|status> [--agent codex,claude] [--untracked]");
+  else {
+    const options = parse();
+    if (subcommand === "install") print(updateHookConfigs({ ...options, install: true }), { install: true });
+    else if (subcommand === "uninstall") print(updateHookConfigs({ ...options, install: false }));
+    else if (subcommand === "status") print(hookConfigStatus(options));
+    else fail(`unknown subcommand \"${subcommand}\"`);
+  }
+} catch (error) { console.error(`burnlist hooks: ${error.message}`); process.exitCode = 1; }
diff --git a/src/cli/hooks-config.mjs b/src/cli/hooks-config.mjs
new file mode 100644
index 0000000..e3678a5
--- /dev/null
+++ b/src/cli/hooks-config.mjs
@@ -0,0 +1,320 @@
+import { randomBytes } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { closeSync, constants, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
+
+import { gitProbe } from "./git-ignore.mjs";
+import { containedJoin, withRepoStateLock } from "../server/repo-state.mjs";
+
+export const HOOK_MARKER = "burnlist-managed:streaming-diff-hooks@1";
+const PROVENANCE_SCHEMA = 1;
+const AGENTS = { codex: { file: ".codex/hooks.json" }, claude: { file: ".claude/settings.json" } };
+const CODEX_HOOKS_MINIMUM_VERSION = "0.124.0";
+const EVENTS = {
+  // Codex supports SessionStart, PreToolUse, and PostToolUse. It does not
+  // expose Claude's PostToolUseFailure event.
+  codex: ["ensure", "pre", "post"],
+  claude: ["ensure", "pre", "post", "failure"],
+};
+const MANAGED_EVENTS = ["ensure", "pre", "post", "failure"];
+const MUTATING_MATCHERS = {
+  claude: "Edit|Write|MultiEdit|NotebookEdit",
+  codex: "apply_patch|write_file|edit_file|create_file|delete_file|rename_file|move_file",
+};
+
+function fsyncDirectory(path) {
+  const fd = openSync(path, constants.O_RDONLY);
+  try { fsyncSync(fd); } finally { closeSync(fd); }
+}
+
+function writeDurableText(path, text) {
+  mkdirSync(dirname(path), { recursive: true });
+  const temporary = join(dirname(path), `.${basename(path)}.${randomBytes(8).toString("hex")}.tmp`);
+  let fd;
+  try {
+    fd = openSync(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 0o600);
+    writeFileSync(fd, text); fsyncSync(fd); closeSync(fd); fd = undefined;
+    renameSync(temporary, path); fsyncDirectory(dirname(path));
+  } finally { if (fd !== undefined) closeSync(fd); rmSync(temporary, { force: true }); }
+}
+
+export function writeDurableJson(path, value) { writeDurableText(path, `${JSON.stringify(value, null, 2)}\n`); }
+
+function provenancePath(repoRoot) { return containedJoin(repoRoot, "hooks-config-provenance.json"); }
+function configKey(repoRoot, path) { return relative(resolve(repoRoot), path).replace(/\\/gu, "/"); }
+
+function readProvenance(repoRoot) {
+  try {
+    const stored = JSON.parse(readFileSync(provenancePath(repoRoot), "utf8"));
+    if (stored?.schemaVersion !== PROVENANCE_SCHEMA || !Array.isArray(stored.createdConfigPaths)
+      || !stored.createdConfigPaths.every((path) => typeof path === "string")) return new Set();
+    return new Set(stored.createdConfigPaths);
+  } catch (error) {
+    if (error?.code === "ENOENT") return new Set();
+    return new Set();
+  }
+}
+
+function readConfigState(path) {
+  if (!existsSync(path)) return { config: {}, text: undefined };
+  const text = readFileSync(path, "utf8");
+  try {
+    const config = JSON.parse(text);
+    if (!config || typeof config !== "object" || Array.isArray(config)) throw new Error("must be a JSON object");
+    return { config, text };
+  } catch (error) {
+    throw new Error(`refusing to modify malformed hook config ${path}: ${error.message}`);
+  }
+}
+
+function readConfig(path) { return readConfigState(path).config; }
+
+function readOptionalText(path) {
+  try { return readFileSync(path, "utf8"); } catch (error) {
+    if (error?.code === "ENOENT") return undefined;
+    throw error;
+  }
+}
+
+function command(agent, event) { return `burnlist streaming-diff hook --agent ${agent} --event ${event}`; }
+function eventName(event) { return ({ ensure: "SessionStart", pre: "PreToolUse", post: "PostToolUse", failure: "PostToolUseFailure" })[event]; }
+function eventsFor(agent) { return EVENTS[agent] ?? []; }
+
+export function managedHookEntry(agent, event) {
+  const entry = { hooks: [{ type: "command", command: command(agent, event) }] };
+  if (event !== "ensure") entry.matcher = MUTATING_MATCHERS[agent];
+  return entry;
+}
+
+// Ownership is intentionally an exact, event-specific structural match. The
+// marker belongs only to info/exclude, never to a host command string.
+function ownedEntry(entry, agent, event) {
+  const expected = managedHookEntry(agent, event);
+  return entry && typeof entry === "object" && !Array.isArray(entry)
+    && entry.matcher === expected.matcher && Array.isArray(entry.hooks) && entry.hooks.length === 1
+    && entry.hooks[0]?.type === "command" && entry.hooks[0]?.command === expected.hooks[0].command;
+}
+
+function removeOwnedEntries(entries, agent, event) {
+  if (!Array.isArray(entries)) throw new Error("hook event must be an array; refusing to clobber it");
+  return entries.filter((entry) => !ownedEntry(entry, agent, event));
+}
+
+function eventEntries(config, event) {
+  const entries = config.hooks?.[eventName(event)];
+  return Array.isArray(entries) ? entries : [];
+}
+
+function hasCorruptHooks(config) {
+  if (config.hooks === undefined) return false;
+  if (!config.hooks || typeof config.hooks !== "object" || Array.isArray(config.hooks)) return true;
+  return Object.values(config.hooks).some((entries) => !Array.isArray(entries));
+}
+
+function hasOwnedEntries(config, agent) {
+  return eventsFor(agent).every((event) => eventEntries(config, event).some((entry) => ownedEntry(entry, agent, event)));
+}
+
+function ownershipState(config, agent) {
+  const events = eventsFor(agent);
+  const found = events.filter((event) => eventEntries(config, event).some((entry) => ownedEntry(entry, agent, event))).length;
+  return found === events.length ? "installed" : found === 0 ? "none" : "partial";
+}
+
+function mergeConfig(config, agent, install) {
+  const next = { ...config, hooks: { ...(config.hooks ?? {}) } };
+  if (!config.hooks || typeof config.hooks !== "object" || Array.isArray(config.hooks)) {
+    if (config.hooks !== undefined) throw new Error("hooks must be an object; refusing to clobber it");
+  }
+  for (const event of MANAGED_EVENTS) {
+    const name = eventName(event);
+    const clean = removeOwnedEntries(next.hooks[name] ?? [], agent, event);
+    if (install && eventsFor(agent).includes(event)) clean.push(managedHookEntry(agent, event));
+    if (clean.length) next.hooks[name] = clean;
+    else delete next.hooks[name];
+  }
+  if (Object.keys(next.hooks).length === 0) delete next.hooks;
+  return next;
+}
+
+function configPath(repoRoot, agent) {
+  const spec = AGENTS[agent];
+  if (!spec) throw new Error(`unsupported agent: ${agent}`);
+  return join(resolve(repoRoot), spec.file);
+}
+
+function worktreeRoot(repoRoot) {
+  const cwd = resolve(repoRoot);
+  const gitRoot = gitProbe(cwd, ["rev-parse", "--show-toplevel"]);
+  if (gitRoot.status !== 0) throw new Error(gitRoot.error?.message || gitRoot.stderr?.trim() || "could not determine Git worktree root");
+  const root = gitRoot.stdout.trim();
+  if (!root) throw new Error("could not determine Git worktree root");
+  return resolve(cwd, root);
+}
+
+function preflight(repoRoot, agents) {
+  const root = worktreeRoot(repoRoot);
+  const targets = agents.map((agent) => {
+    const path = configPath(root, agent);
+    const target = relative(root, path).replace(/\\/gu, "/");
+    const result = gitProbe(root, ["ls-files", "--error-unmatch", "--", target]);
+    if (result.status !== 0 && result.status !== 1) throw new Error(result.error?.message || result.stderr?.trim() || "could not determine Git tracking state");
+    return { agent, path, tracked: result.status === 0 };
+  });
+  return { root, targets };
+}
+
+function excludePath(repoRoot) {
+  const result = gitProbe(repoRoot, ["rev-parse", "--git-path", "info/exclude"]);
+  if (result.status !== 0) throw new Error(result.error?.message || result.stderr?.trim() || "could not locate .git/info/exclude");
+  return resolve(repoRoot, result.stdout.trim());
+}
+
+function excludeTarget(repoRoot, path) { return `/${relative(resolve(repoRoot), path).replace(/\\/gu, "/")}`; }
+
+function addLocalExcludeText(content, target) {
+  if (content.split(/\r?\n/u).includes(target)) return;
+  const prefix = content && !content.endsWith("\n") ? `${content}\n` : content;
+  return `${prefix}# ${HOOK_MARKER}\n${target}\n`;
+}
+
+function removeLocalExcludeText(content, target) {
+  const lines = content.split(/\r?\n/u);
+  const kept = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    if (lines[index] === `# ${HOOK_MARKER}` && lines[index + 1] === target) { index += 1; continue; }
+    kept.push(lines[index]);
+  }
+  return kept.join("\n");
+}
+
+function locallyExcluded(repoRoot, path) {
+  const exclude = excludePath(repoRoot);
+  return existsSync(exclude) && readFileSync(exclude, "utf8").split(/\r?\n/u).includes(excludeTarget(repoRoot, path));
+}
+
+function excludedIn(content, target) { return content.split(/\r?\n/u).includes(target); }
+
+function applyFileChange(change, writeJson) {
+  if (change.after === undefined) {
+    rmSync(change.path, { force: true });
+    fsyncDirectory(dirname(change.path));
+  } else if (change.value) writeJson(change.path, change.value);
+  else writeDurableText(change.path, change.after);
+}
+
+function restoreFileChange(change) {
+  if (change.before === undefined) {
+    rmSync(change.path, { force: true });
+    fsyncDirectory(dirname(change.path));
+  } else writeDurableText(change.path, change.before);
+}
+
+function versionAtLeast(version, minimum) {
+  const parse = (value) => /^v?(\d+)\.(\d+)\.(\d+)/u.exec(value)?.slice(1).map(Number);
+  const actual = parse(version);
+  const target = parse(minimum);
+  if (!actual || !target) return false;
+  for (let index = 0; index < actual.length; index += 1) {
+    if (actual[index] !== target[index]) return actual[index] > target[index];
+  }
+  return true;
+}
+
+export function hookCapability(agent, { spawn = spawnSync, env = process.env } = {}) {
+  const binary = agent === "codex" ? "codex" : agent === "claude" ? "claude" : null;
+  if (!binary) throw new Error(`unsupported agent: ${agent}`);
+  const result = spawn(binary, ["--version"], { encoding: "utf8", env, shell: false, stdio: ["ignore", "pipe", "pipe"] });
+  if (result?.error?.code === "ENOENT") return { state: "not-installed" };
+  if (result?.error || result?.status !== 0) return { state: "not-installed" };
+  const version = `${result.stdout ?? ""}\n${result.stderr ?? ""}`.match(/\d+\.\d+\.\d+/u)?.[0];
+  if (agent === "codex" && (!version || !versionAtLeast(version, CODEX_HOOKS_MINIMUM_VERSION))) {
+    return { state: "installed-but-hooks-unsupported", version, minimumVersion: CODEX_HOOKS_MINIMUM_VERSION };
+  }
+  return { state: "installed+hooks-supported", version };
+}
+
+export function hookConfigStatus({ repoRoot = process.cwd(), agents = Object.keys(AGENTS), capability = hookCapability } = {}) {
+  const { root, targets } = preflight(repoRoot, agents);
+  return targets.map(({ agent, path, tracked }) => {
+    let installed = false;
+    let malformed = false;
+    let corrupt = false;
+    let config = {};
+    try {
+      config = readConfig(path);
+      corrupt = hasCorruptHooks(config);
+      installed = !corrupt && hasOwnedEntries(config, agent);
+    } catch { malformed = true; }
+    return {
+      agent, path, installed, state: malformed || corrupt ? "corrupt" : ownershipState(config, agent),
+      malformed: malformed || corrupt, mode: tracked ? "tracked" : "untracked", excluded: locallyExcluded(root, path),
+      capability: capability(agent),
+    };
+  });
+}
+
+export function updateHookConfigs({ repoRoot = process.cwd(), agents = Object.keys(AGENTS), install, untracked = false, capability = hookCapability, writeJson = writeDurableJson, restoreFile = restoreFileChange } = {}) {
+  if (typeof install !== "boolean") throw new Error("install must be true or false");
+  const { root, targets } = preflight(repoRoot, agents);
+  return withRepoStateLock(root, () => {
+    const capabilities = new Map(targets.map(({ agent }) => [agent, capability(agent)]));
+    const created = readProvenance(root);
+    let provenanceChanged = false;
+    const prepared = targets.map(({ agent, path, tracked }) => {
+      const key = configKey(root, path);
+      const state = readConfigState(path);
+      const config = state.config;
+      if (hasCorruptHooks(config)) throw new Error(`refusing to modify malformed hook config ${path}: hooks must contain event arrays`);
+      const next = mergeConfig(config, agent, install);
+      const changed = JSON.stringify(config) !== JSON.stringify(next);
+      const configDidNotExist = state.text === undefined;
+      const remove = !install && Object.keys(next).length === 0 && created.has(key);
+      if (install && configDidNotExist) { created.add(key); provenanceChanged = true; }
+      if (!install && created.delete(key)) provenanceChanged = true;
+      return {
+        agent, path, tracked, key, next, changed, remove,
+        change: changed || remove ? { path, before: state.text, after: remove ? undefined : "", value: remove ? undefined : next } : null,
+      };
+    });
+    const exclude = excludePath(root);
+    const excludeBefore = readOptionalText(exclude);
+    let excludeAfter = excludeBefore ?? "";
+    for (const { path, tracked } of prepared) {
+      const target = excludeTarget(root, path);
+      if (install && (!tracked || untracked)) excludeAfter = addLocalExcludeText(excludeAfter, target) ?? excludeAfter;
+      if (!install) excludeAfter = removeLocalExcludeText(excludeAfter, target);
+    }
+    if (excludeBefore === undefined && excludeAfter === "") excludeAfter = undefined;
+    const changes = prepared.flatMap(({ change }) => change ? [change] : []);
+    if (excludeBefore !== excludeAfter) changes.push({ path: exclude, before: excludeBefore, after: excludeAfter });
+    const provenance = provenancePath(root);
+    const provenanceBefore = readOptionalText(provenance);
+    const provenanceAfter = created.size ? `${JSON.stringify({ schemaVersion: PROVENANCE_SCHEMA, createdConfigPaths: [...created].sort() }, null, 2)}\n` : undefined;
+    if (provenanceChanged) changes.push({ path: provenance, before: provenanceBefore, after: provenanceAfter });
+    const written = [];
+    try {
+      for (const change of changes) {
+        written.push(change);
+        applyFileChange(change, writeJson);
+      }
+    } catch (error) {
+      const rollbackFailures = [];
+      for (const change of written.reverse()) {
+        try { restoreFile(change); } catch { rollbackFailures.push(change.path); }
+      }
+      if (rollbackFailures.length) {
+        throw new Error(`rollback failed for ${rollbackFailures.join(", ")}; those files may be in a partial state and manual cleanup may be needed`, { cause: error });
+      }
+      throw error;
+    }
+    return prepared.map(({ agent, path, tracked, next }) => {
+      const resulting = install ? next : Object.keys(next).length === 0 ? {} : next;
+      return {
+        agent, path, installed: hasOwnedEntries(resulting, agent), state: ownershipState(resulting, agent),
+        mode: tracked ? "tracked" : "untracked", excluded: excludedIn(excludeAfter ?? "", excludeTarget(root, path)),
+        forcedUntracked: untracked && tracked, capability: capabilities.get(agent),
+      };
+    });
+  });
+}
diff --git a/src/cli/hooks-config.test.mjs b/src/cli/hooks-config.test.mjs
new file mode 100644
index 0000000..9d8f95e
--- /dev/null
+++ b/src/cli/hooks-config.test.mjs
@@ -0,0 +1,291 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { HOOK_MARKER, hookCapability, hookConfigStatus, managedHookEntry, updateHookConfigs } from "./hooks-config.mjs";
+
+function fixture() {
+  const root = mkdtempSync(join(tmpdir(), "burnlist-hooks-"));
+  execFileSync("git", ["init", "--quiet", root]);
+  execFileSync("git", ["-C", root, "config", "user.email", "test@example.invalid"]);
+  execFileSync("git", ["-C", root, "config", "user.name", "Test"]);
+  return { root, cleanup: () => rmSync(root, { recursive: true, force: true }) };
+}
+
+test("hook install merges existing hooks, is idempotent, and uninstall is ownership-scoped", () => {
+  const context = fixture();
+  try {
+    const configPath = join(context.root, ".claude", "settings.json");
+    mkdirSync(join(context.root, ".claude"));
+    writeFileSync(configPath, JSON.stringify({ keep: true, hooks: { PreToolUse: [{ matcher: "Bash", hooks: [{ type: "command", command: "user-hook" }] }] } }));
+    updateHookConfigs({ repoRoot: context.root, agents: ["claude"], install: true });
+    const installed = JSON.parse(readFileSync(configPath, "utf8"));
+    assert.equal(installed.keep, true);
+    assert.equal(installed.hooks.PreToolUse[0].hooks[0].command, "user-hook");
+    assert.equal(installed.hooks.PreToolUse.at(-1).matcher, "Edit|Write|MultiEdit|NotebookEdit");
+    assert.equal(JSON.stringify(installed).includes(HOOK_MARKER), false);
+    updateHookConfigs({ repoRoot: context.root, agents: ["claude"], install: true });
+    assert.equal(JSON.parse(readFileSync(configPath, "utf8")).hooks.PreToolUse.filter((entry) => entry.hooks[0].command === "burnlist streaming-diff hook --agent claude --event pre").length, 1);
+    updateHookConfigs({ repoRoot: context.root, agents: ["claude"], install: false });
+    const removed = JSON.parse(readFileSync(configPath, "utf8"));
+    assert.equal(removed.keep, true);
+    assert.deepEqual(removed.hooks.PreToolUse, [{ matcher: "Bash", hooks: [{ type: "command", command: "user-hook" }] }]);
+    assert.doesNotMatch(JSON.stringify(removed), /streaming-diff hook/u);
+  } finally { context.cleanup(); }
+});
+
+test("hook install reports the current local exclusion on idempotent install", () => {
+  const context = fixture();
+  try {
+    const [result] = updateHookConfigs({ repoRoot: context.root, agents: ["codex"], install: true });
+    assert.equal(result.mode, "untracked");
+    assert.equal(result.excluded, true);
+    const exclude = readFileSync(join(context.root, ".git", "info", "exclude"), "utf8");
+    assert.match(exclude, /\.codex\/hooks\.json/u);
+    assert.equal(hookConfigStatus({ repoRoot: context.root, agents: ["codex"] })[0].installed, true);
+    assert.equal(updateHookConfigs({ repoRoot: context.root, agents: ["codex"], install: true })[0].excluded, true);
+  } finally { context.cleanup(); }
+});
+
+test("Codex install contains only its supported hook events", () => {
+  const context = fixture();
+  try {
+    const path = join(context.root, ".codex", "hooks.json");
+    updateHookConfigs({ repoRoot: context.root, agents: ["codex"], install: true });
+    assert.deepEqual(Object.keys(JSON.parse(readFileSync(path, "utf8")).hooks).sort(), ["PostToolUse", "PreToolUse", "SessionStart"]);
+  } finally { context.cleanup(); }
+});
+
+test("Claude install includes its failure hook while Codex does not", () => {
+  const context = fixture();
+  try {
+    updateHookConfigs({ repoRoot: context.root, agents: ["codex", "claude"], install: true });
+    const codex = JSON.parse(readFileSync(join(context.root, ".codex", "hooks.json"), "utf8"));
+    const claude = JSON.parse(readFileSync(join(context.root, ".claude", "settings.json"), "utf8"));
+    assert.equal(Object.hasOwn(codex.hooks, "PostToolUseFailure"), false);
+    assert.equal(Object.hasOwn(claude.hooks, "PostToolUseFailure"), true);
+  } finally { context.cleanup(); }
+});
+
+test("Codex reinstall removes stale owned unsupported events while preserving user hooks", () => {
+  const context = fixture();
+  try {
+    const path = join(context.root, ".codex", "hooks.json");
+    mkdirSync(join(context.root, ".codex"));
+    const userHook = { matcher: "user-tool", hooks: [{ type: "command", command: "user-hook" }] };
+    writeFileSync(path, JSON.stringify({ hooks: { PostToolUseFailure: [managedHookEntry("codex", "failure"), userHook] } }));
+    updateHookConfigs({ repoRoot: context.root, agents: ["codex"], install: true });
+    const reinstalled = JSON.parse(readFileSync(path, "utf8"));
+    assert.deepEqual(reinstalled.hooks.PostToolUseFailure, [userHook]);
+    assert.deepEqual(Object.keys(reinstalled.hooks).sort(), ["PostToolUse", "PostToolUseFailure", "PreToolUse", "SessionStart"]);
+    for (const event of ["SessionStart", "PreToolUse", "PostToolUse"]) {
+      assert.equal(reinstalled.hooks[event].some((entry) => entry.hooks[0].command.includes("--agent codex")), true);
+    }
+  } finally { context.cleanup(); }
+});
+
+test("uninstall removes only exact owned hooks and its paired exclude line, then removes an empty created config", () => {
+  const context = fixture();
+  try {
+    const path = join(context.root, ".codex", "hooks.json");
+    updateHookConfigs({ repoRoot: context.root, agents: ["codex"], install: true });
+    const excludePath = join(context.root, ".git", "info", "exclude");
+    const collision = "burnlist streaming-diff hook --agent codex --event post --user-option";
+    const config = JSON.parse(readFileSync(path, "utf8"));
+    config.hooks.PostToolUse.unshift({ matcher: "apply_patch|write_file|edit_file|create_file|delete_file|rename_file|move_file", hooks: [{ type: "command", command: collision }] });
+    writeFileSync(path, JSON.stringify(config));
+    updateHookConfigs({ repoRoot: context.root, agents: ["codex"], install: false });
+    const removed = JSON.parse(readFileSync(path, "utf8"));
+    assert.equal(removed.hooks.PostToolUse[0].hooks[0].command, collision);
+    assert.doesNotMatch(readFileSync(excludePath, "utf8"), /\.codex\/hooks\.json/u);
+    // A config containing exactly Burnlist's entries is the local config it created.
+    updateHookConfigs({ repoRoot: context.root, agents: ["claude"], install: true });
+    const created = join(context.root, ".claude", "settings.json");
+    updateHookConfigs({ repoRoot: context.root, agents: ["claude"], install: false });
+    assert.equal(existsSync(created), false);
+  } finally { context.cleanup(); }
+});
+
+test("uninstall preserves an empty config that existed before Burnlist installed hooks", () => {
+  const context = fixture();
+  try {
+    const path = join(context.root, ".codex", "hooks.json");
+    mkdirSync(join(context.root, ".codex"));
+    writeFileSync(path, "{}\n");
+    updateHookConfigs({ repoRoot: context.root, agents: ["codex"], install: true });
+    updateHookConfigs({ repoRoot: context.root, agents: ["codex"], install: false });
+    assert.equal(existsSync(path), true);
+    assert.deepEqual(JSON.parse(readFileSync(path, "utf8")), {});
+  } finally { context.cleanup(); }
+});
+
+test("status is partial when one expected event is absent", () => {
+  const context = fixture();
+  try {
+    const path = join(context.root, ".claude", "settings.json");
+    updateHookConfigs({ repoRoot: context.root, agents: ["claude"], install: true });
+    const config = JSON.parse(readFileSync(path, "utf8"));
+    delete config.hooks.PostToolUseFailure;
+    writeFileSync(path, JSON.stringify(config));
+    const status = hookConfigStatus({ repoRoot: context.root, agents: ["claude"] })[0];
+    assert.equal(status.installed, false);
+    assert.equal(status.state, "partial");
+  } finally { context.cleanup(); }
+});
+
+test("a fatal Git preflight fails before a config write", () => {
+  const root = mkdtempSync(join(tmpdir(), "burnlist-hooks-not-git-"));
+  try {
+    assert.throws(() => updateHookConfigs({ repoRoot: root, agents: ["codex"], install: true }), /Git|git/u);
+    assert.equal(existsSync(join(root, ".codex", "hooks.json")), false);
+  } finally { rmSync(root, { recursive: true, force: true }); }
+});
+
+test("install from a subdirectory writes and excludes the worktree-root config", () => {
+  const context = fixture();
+  try {
+    const subdirectory = join(context.root, "nested", "work");
+    mkdirSync(subdirectory, { recursive: true });
+    const [result] = updateHookConfigs({ repoRoot: subdirectory, agents: ["codex"], install: true });
+    assert.equal(result.path.endsWith("/.codex/hooks.json"), true);
+    assert.equal(result.excluded, true);
+    assert.equal(existsSync(join(subdirectory, ".codex", "hooks.json")), false);
+    assert.match(readFileSync(join(context.root, ".git", "info", "exclude"), "utf8"), /\.codex\/hooks\.json/u);
+  } finally { context.cleanup(); }
+});
+
+test("--untracked forces a tracked config into the local exclusion list", () => {
+  const context = fixture();
+  try {
+    const path = join(context.root, ".codex", "hooks.json");
+    mkdirSync(join(context.root, ".codex"));
+    writeFileSync(path, "{}\n");
+    execFileSync("git", ["-C", context.root, "add", ".codex/hooks.json"]);
+    execFileSync("git", ["-C", context.root, "commit", "--quiet", "-m", "tracked config"]);
+    const [result] = updateHookConfigs({ repoRoot: context.root, agents: ["codex"], install: true, untracked: true });
+    assert.equal(result.mode, "tracked");
+    assert.equal(result.forcedUntracked, true);
+    assert.equal(result.excluded, true);
+    assert.match(readFileSync(join(context.root, ".git", "info", "exclude"), "utf8"), /\.codex\/hooks\.json/u);
+  } finally { context.cleanup(); }
+});
+
+test("malformed hook JSON is never overwritten", () => {
+  const context = fixture();
+  try {
+    const path = join(context.root, ".claude", "settings.json");
+    mkdirSync(join(context.root, ".claude"));
+    writeFileSync(path, "{ broken");
+    assert.throws(() => updateHookConfigs({ repoRoot: context.root, agents: ["claude"], install: true }), /malformed/u);
+    assert.equal(readFileSync(path, "utf8"), "{ broken");
+  } finally { context.cleanup(); }
+});
+
+test("status reports structurally corrupt hook config without throwing", () => {
+  const context = fixture();
+  try {
+    const path = join(context.root, ".codex", "hooks.json");
+    mkdirSync(join(context.root, ".codex"));
+    writeFileSync(path, JSON.stringify({ hooks: { PostToolUse: "not an array" } }));
+    const [status] = hookConfigStatus({ repoRoot: context.root, agents: ["codex"] });
+    assert.equal(status.state, "corrupt");
+    assert.equal(status.installed, false);
+  } finally { context.cleanup(); }
+});
+
+test("status distinguishes an old Codex from an absent Claude CLI", () => {
+  const context = fixture();
+  try {
+    const capability = (agent) => hookCapability(agent, {
+      spawn: (binary) => binary === "codex"
+        ? { status: 0, stdout: "codex-cli 0.39.0\n", stderr: "" }
+        : { error: { code: "ENOENT" }, status: null, stdout: "", stderr: "" },
+    });
+    const status = hookConfigStatus({ repoRoot: context.root, agents: ["codex", "claude"], capability });
+    assert.deepEqual(status.map(({ agent, capability: result }) => [agent, result.state, result.minimumVersion]), [
+      ["codex", "installed-but-hooks-unsupported", "0.124.0"],
+      ["claude", "not-installed", undefined],
+    ]);
+  } finally { context.cleanup(); }
+});
+
+test("Codex apply_patch hooks require version 0.124.0", () => {
+  const capability = (version) => hookCapability("codex", {
+    spawn: () => ({ status: 0, stdout: `codex-cli ${version}\n`, stderr: "" }),
+  });
+
+  assert.deepEqual(capability("0.123.9"), {
+    state: "installed-but-hooks-unsupported", version: "0.123.9", minimumVersion: "0.124.0",
+  });
+  assert.deepEqual(capability("0.124.0"), { state: "installed+hooks-supported", version: "0.124.0" });
+});
+
+test("multi-agent install preflights every config before writing either one", () => {
+  const context = fixture();
+  try {
+    const claudePath = join(context.root, ".claude", "settings.json");
+    mkdirSync(join(context.root, ".claude"));
+    writeFileSync(claudePath, "{ malformed");
+    assert.throws(() => updateHookConfigs({ repoRoot: context.root, agents: ["codex", "claude"], install: true }), /malformed hook config.*settings\.json/u);
+    assert.equal(existsSync(join(context.root, ".codex", "hooks.json")), false);
+    assert.equal(readFileSync(claudePath, "utf8"), "{ malformed");
+    assert.equal(existsSync(join(context.root, ".local", "burnlist", "hooks-config-provenance.json")), false);
+  } finally { context.cleanup(); }
+});
+
+test("a second config write failure restores the first config and leaves provenance unsaved", () => {
+  const context = fixture();
+  try {
+    const codexPath = join(context.root, ".codex", "hooks.json");
+    const claudePath = join(context.root, ".claude", "settings.json");
+    mkdirSync(join(context.root, ".codex"));
+    mkdirSync(join(context.root, ".claude"));
+    writeFileSync(codexPath, '{"codexBefore":true}\n');
+    writeFileSync(claudePath, '{"claudeBefore":true}\n');
+    let writes = 0;
+    assert.throws(() => updateHookConfigs({
+      repoRoot: context.root,
+      agents: ["codex", "claude"],
+      install: true,
+      writeJson(path, value) {
+        writes += 1;
+        if (writes === 2) throw new Error("simulated second config write failure");
+        writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`);
+      },
+    }), /simulated second config write failure/u);
+    assert.equal(readFileSync(codexPath, "utf8"), '{"codexBefore":true}\n');
+    assert.equal(readFileSync(claudePath, "utf8"), '{"claudeBefore":true}\n');
+    assert.equal(existsSync(join(context.root, ".local", "burnlist", "hooks-config-provenance.json")), false);
+  } finally { context.cleanup(); }
+});
+
+test("a rollback restore failure identifies the config that may need manual cleanup", () => {
+  const context = fixture();
+  try {
+    const codexPath = join(context.root, ".codex", "hooks.json");
+    const claudePath = join(context.root, ".claude", "settings.json");
+    mkdirSync(join(context.root, ".codex"));
+    mkdirSync(join(context.root, ".claude"));
+    writeFileSync(codexPath, '{"codexBefore":true}\n');
+    writeFileSync(claudePath, '{"claudeBefore":true}\n');
+    let writes = 0;
+    assert.throws(() => updateHookConfigs({
+      repoRoot: context.root,
+      agents: ["codex", "claude"],
+      install: true,
+      writeJson(path, value) {
+        writes += 1;
+        if (writes === 2) throw new Error("simulated second config write failure");
+        writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`);
+      },
+      restoreFile(change) {
+        if (change.path.endsWith("/.codex/hooks.json")) throw new Error("simulated rollback restore failure");
+        writeFileSync(change.path, change.before);
+      },
+    }), /rollback failed for .*\.codex\/hooks\.json.*partial state.*manual cleanup/u);
+    assert.equal(existsSync(join(context.root, ".local", "burnlist", "hooks-config-provenance.json")), false);
+  } finally { context.cleanup(); }
+});
diff --git a/src/cli/oven-cli-stdout.test.mjs b/src/cli/oven-cli-stdout.test.mjs
new file mode 100644
index 0000000..f3ecf28
--- /dev/null
+++ b/src/cli/oven-cli-stdout.test.mjs
@@ -0,0 +1,53 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import test from "node:test";
+
+const repoRoot = resolve(new URL("../..", import.meta.url).pathname);
+const binPath = join(repoRoot, "bin", "burnlist.mjs");
+
+function largeDetail() {
+  return {
+    version: 1,
+    columns: 2,
+    rows: 5,
+    rowHeight: 48,
+    cells: Array.from({ length: 10 }, (_, index) => ({
+      id: `cell-${index + 1}`,
+      title: `Cell ${index + 1}`,
+      description: "x".repeat(2_000),
+      widget: "metric",
+      source: `/cell-${index + 1}`,
+      format: "plain",
+      column: (index % 2) + 1,
+      row: Math.floor(index / 2) + 1,
+      columnSpan: 1,
+      rowSpan: 1,
+    })),
+  };
+}
+
+test("oven list --json drains complete large stdout captured through a pipe", () => {
+  const root = mkdtempSync(join(tmpdir(), "burnlist-oven-cli-stdout-"));
+  const repo = join(root, "repo");
+  const ovensDir = join(repo, ".local", "burnlist", "ovens");
+  try {
+    mkdirSync(join(ovensDir, "large-oven"), { recursive: true });
+    writeFileSync(join(ovensDir, "large-oven", "instructions.md"), "# Large Oven\n\nPipe flush regression fixture.\n");
+    writeFileSync(join(ovensDir, "large-oven", "detail.json"), JSON.stringify(largeDetail()));
+
+    const stdout = execFileSync(process.execPath, [binPath, "oven", "list", "--json", "--ovens-dir", ovensDir], {
+      cwd: repo,
+      encoding: "utf8",
+    });
+    assert.ok(Buffer.byteLength(stdout) > 16 * 1024, "fixture output must exceed the pipe buffer");
+    const ovens = JSON.parse(stdout);
+    const largeOven = ovens.find((oven) => oven.id === "large-oven");
+    assert.equal(largeOven.detail.cells.length, 10);
+    assert.equal(largeOven.detail.cells[9].description.length, 2_000);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
diff --git a/src/cli/oven-cli.mjs b/src/cli/oven-cli.mjs
index f356a20..31a55a7 100644
--- a/src/cli/oven-cli.mjs
+++ b/src/cli/oven-cli.mjs
@@ -129,21 +129,22 @@ Options:
 Custom Ovens live under ignored local state and only affect future Runs.
 Built-in Ovens are read-only; this command never executes Oven instructions.`;
 
+function main() {
 try {
   if (subcommand === "help" || flags.has("help")) {
     console.log(HELP);
-    process.exit(0);
+    return;
   }
 
   if (subcommand === "list") {
     const ovens = discoverOvens();
     if (flags.has("json")) {
       console.log(JSON.stringify(ovens.map(({ instructions, ...rest }) => rest), null, 2));
-      process.exit(0);
+      return;
     }
     if (ovens.length === 0) {
       console.log("No Ovens found.");
-      process.exit(0);
+      return;
     }
     const rows = ovens.map((oven) => [
       oven.id,
@@ -159,7 +160,7 @@ try {
     console.log(line(header));
     console.log(line(widths.map((width) => "─".repeat(width))));
     for (const row of rows) console.log(line(row));
-    process.exit(0);
+    return;
   }
 
   if (subcommand === "view") {
@@ -177,10 +178,10 @@ try {
         ovenRevision: oven.ovenRevision,
         ...(oven.forkedFrom ? { forkedFrom: oven.forkedFrom } : {}),
       }, null, 2));
-      process.exit(0);
+      return;
     }
     printOven(oven);
-    process.exit(0);
+    return;
   }
 
   if (subcommand === "bind") {
@@ -189,7 +190,7 @@ try {
     const repoRoot = bindingRepo();
     const result = writeBinding(repoRoot, id, logicalPath, new Date().toISOString());
     console.log(`Bound Oven ${ovenId(id)} to ${logicalPath}\nStore: ${result.path}`);
-    process.exit(0);
+    return;
   }
 
   if (subcommand === "unbind") {
@@ -198,7 +199,7 @@ try {
     const repoRoot = bindingRepo();
     if (removeBinding(repoRoot, id)) console.log(`Unbound Oven ${ovenId(id)} from ${bindingStorePath(repoRoot)}`);
     else console.log(`No binding exists for Oven ${ovenId(id)} in ${bindingStorePath(repoRoot)}.`);
-    process.exit(0);
+    return;
   }
 
   if (subcommand === "bindings") {
@@ -210,7 +211,7 @@ try {
       console.log(`Oven bindings: ${bindingStorePath(repoRoot)}`);
       for (const [id, binding] of entries) console.log(`${id}  ${binding.path}  ${binding.boundAt}`);
     }
-    process.exit(0);
+    return;
   }
 
   if (subcommand === "create" || subcommand === "update") {
@@ -221,7 +222,7 @@ try {
     const saved = readOvenDir(customOvensDir, pkg.id, false);
     console.log(`${subcommand === "update" ? "Updated" : "Created"} Oven ${pkg.id} at ${path}\n`);
     printOven(saved);
-    process.exit(0);
+    return;
   }
 
   if (subcommand === "fork") {
@@ -237,10 +238,13 @@ try {
       sidecar: { forkedFrom: { ovenId: source.id, revision: sourceRevision } },
     });
     console.log(`Forked Oven ${pkg.id} at ${path}\nForked from ${source.id}@${sourceRevision}`);
-    process.exit(0);
+    return;
   }
 
   fail(`Unknown subcommand "${subcommand}". Run \`burnlist oven help\`.`);
 } catch (error) {
   fail(error.message);
 }
+}
+
+main();
diff --git a/src/cli/streaming-diff-cli.mjs b/src/cli/streaming-diff-cli.mjs
new file mode 100644
index 0000000..bcd51f7
--- /dev/null
+++ b/src/cli/streaming-diff-cli.mjs
@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+import { captureStreamingDiff } from "../../ovens/streaming-diff/engine/streaming-diff-feed-capture.mjs";
+import { ensureStreamingDiffFeed } from "../../ovens/streaming-diff/engine/streaming-diff-ensure-feed.mjs";
+import { resolveStreamingDiffIdentity } from "../../ovens/streaming-diff/engine/streaming-diff-feed.mjs";
+import { mapStreamingDiffHook } from "../../ovens/streaming-diff/engine/streaming-diff-hook-adapters.mjs";
+import { execFile } from "node:child_process";
+
+const tokens = process.argv.slice(2);
+if (tokens[0] === "streaming-diff") tokens.shift();
+const subcommand = tokens.shift() ?? "help";
+
+function fail(message, status = 1) {
+  console.error(`burnlist streaming-diff: ${message}`);
+  process.exit(status);
+}
+
+function parseFlags(values) {
+  const flags = new Map();
+  for (let index = 0; index < values.length; index += 1) {
+    const token = values[index];
+    if (!token.startsWith("--")) fail(`unexpected argument: ${token}`, 2);
+    const name = token.slice(2);
+    const value = values[index + 1];
+    // Values occupy the slot immediately following their flag, so a filename
+    // such as --path is data, never a second flag.
+    if (value === undefined || value === "") fail(`${token} requires a value.`, 2);
+    const entries = flags.get(name) ?? [];
+    entries.push(value);
+    flags.set(name, entries);
+    index += 1;
+  }
+  return flags;
+}
+
+function one(flags, name, { required = false } = {}) {
+  const values = flags.get(name) ?? [];
+  if (values.length > 1) fail(`--${name} may only be supplied once.`, 2);
+  if (required && values.length === 0) fail(`--${name} is required.`, 2);
+  return values[0];
+}
+
+const HELP = `burnlist streaming-diff — write a bounded, session-scoped diff feed
+
+Usage:
+  burnlist streaming-diff ensure-feed --session <id>
+  burnlist streaming-diff capture --session <id> --tool-use-id <id> --phase <pre|post> [--terminal-reason <reason>] [--path <repo-path> ...]
+  burnlist streaming-diff url --session <id>
+  burnlist streaming-diff hook --agent <codex|claude> --event <ensure|pre|post|failure>
+
+The producer writes only under the logical repository's ignored .local state.
+Hook adapters always return success so an agent hook cannot block the agent.`;
+
+const MAX_HOOK_PAYLOAD_BYTES = 256 * 1024;
+const HOOK_CAPTURE_TIMEOUT_MS = 2_000;
+const HOOK_STDIN_TIMEOUT_MS = 750;
+
+function readStdinCapped(limit) {
+  return new Promise((resolveRead) => {
+    const chunks = [];
+    let bytes = 0;
+    let settled = false;
+    const finish = (text, degradedReason) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      process.stdin.off("data", onData);
+      process.stdin.off("end", onEnd);
+      process.stdin.off("error", onError);
+      resolveRead({ text, degradedReason });
+    };
+    const stop = (reason) => {
+      finish(null, reason);
+      try { process.stdin.destroy(); } catch { /* The hook must remain advisory. */ }
+    };
+    const onData = (chunk) => {
+      bytes += chunk.length;
+      if (bytes > limit) return stop("hook payload exceeded byte limit");
+      chunks.push(Buffer.from(chunk));
+    };
+    const onEnd = () => finish(Buffer.concat(chunks, bytes).toString("utf8"));
+    const onError = () => finish(null, "hook payload was incomplete");
+    const timer = setTimeout(() => stop("hook payload read timed out"), HOOK_STDIN_TIMEOUT_MS);
+    process.stdin.on("data", onData);
+    process.stdin.once("end", onEnd);
+    process.stdin.once("error", onError);
+    process.stdin.resume();
+  });
+}
+
+async function hookPayload() {
+  const fromEnvironment = process.env.BURNLIST_HOOK_PAYLOAD ?? process.env.CODEX_HOOK_PAYLOAD ?? process.env.CLAUDE_HOOK_PAYLOAD;
+  const input = fromEnvironment === undefined
+    ? await readStdinCapped(MAX_HOOK_PAYLOAD_BYTES).catch(() => ({ text: null, degradedReason: "hook payload was incomplete" }))
+    : { text: fromEnvironment };
+  const { text } = input;
+  if (text === null) return { payload: {}, degradedReason: input.degradedReason ?? "hook payload was incomplete" };
+  if (Buffer.byteLength(text, "utf8") > MAX_HOOK_PAYLOAD_BYTES) return { payload: {}, degradedReason: "hook payload exceeded byte limit" };
+  if (!text?.trim()) return { payload: {}, degradedReason: "missing hook payload" };
+  try {
+    const payload = JSON.parse(text);
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) return { payload: {}, degradedReason: "hook payload was not an object" };
+    return { payload };
+  } catch { return { payload: {}, degradedReason: "hook payload was invalid" }; }
+}
+
+function parseHookFlags(values) {
+  const flags = new Map();
+  for (let index = 0; index < values.length; index += 2) {
+    const token = values[index];
+    const value = values[index + 1];
+    if (!token?.startsWith("--") || !value || value.startsWith("--")) return null;
+    flags.set(token.slice(2), value);
+  }
+  return flags;
+}
+
+function runHookCapture(args) {
+  return new Promise((resolve) => {
+    execFile(process.execPath, [process.argv[1], "streaming-diff", ...args], {
+      cwd: process.cwd(),
+      env: process.env,
+      shell: false,
+      timeout: HOOK_CAPTURE_TIMEOUT_MS,
+      maxBuffer: 64 * 1024,
+    }, () => resolve());
+  });
+}
+
+function withTerminalReason(args, reason) {
+  if (!reason) return args;
+  const index = args.indexOf("--terminal-reason");
+  if (index === -1) return [...args, "--terminal-reason", "adapter-incomplete"];
+  return args;
+}
+
+function incompleteHookCapture(event, reason) {
+  if (!["pre", "post", "failure"].includes(event)) return null;
+  return {
+    action: "capture",
+    args: ["capture", "--session", "unknown-session", "--tool-use-id", "unknown-tool-use", "--phase", event === "pre" ? "pre" : "post", "--terminal-reason", reason.includes("byte limit") ? "payload-too-large" : reason.includes("timed out") ? "payload-read-timed-out" : "adapter-incomplete"],
+    degraded: true,
+  };
+}
+
+async function main() {
+try {
+  if (subcommand === "help" || tokens.includes("--help") || tokens.includes("-h")) {
+    console.log(HELP);
+    return;
+  }
+  if (subcommand === "hook") {
+    const flags = parseHookFlags(tokens);
+    const agent = flags?.get("agent");
+    const event = flags?.get("event");
+    if (!agent || !event || [...flags.keys()].some((key) => !["agent", "event"].includes(key))) return;
+    try {
+      const input = await hookPayload();
+      const mapped = input.degradedReason
+        ? incompleteHookCapture(event, input.degradedReason)
+        : mapStreamingDiffHook({ agent, event, payload: input.payload, cwd: process.cwd() });
+      if (mapped?.action === "ensure-feed" || mapped?.action === "capture") {
+        await runHookCapture(withTerminalReason(mapped.args, mapped.degraded ? mapped.terminalReason ?? "adapter-incomplete" : undefined));
+      }
+    } catch { /* Hooks are advisory and must never block their host agent. */ }
+    return;
+  }
+  const flags = parseFlags(tokens);
+  if (subcommand === "ensure-feed") {
+    const session = one(flags, "session", { required: true });
+    if ([...flags.keys()].some((key) => key !== "session")) fail("ensure-feed accepts only --session.", 2);
+    const result = ensureStreamingDiffFeed({ session });
+    console.log(`Feed: ${result.identity.feedDir}`);
+    console.log(`Binding: ${result.binding.created ? "created" : "existing"} (${result.binding.binding.path})`);
+    return;
+  }
+  if (subcommand === "capture") {
+    const session = one(flags, "session", { required: true });
+    const toolUseId = one(flags, "tool-use-id", { required: true });
+    const phase = one(flags, "phase", { required: true });
+    if ([...flags.keys()].some((key) => !["session", "tool-use-id", "phase", "path", "terminal-reason"].includes(key))) fail("capture received an unsupported option.", 2);
+    if (phase !== "pre" && phase !== "post") fail("--phase must be pre or post.", 2);
+    const result = captureStreamingDiff({ session, toolUseId, phase, hintedPaths: flags.get("path") ?? [], terminalReason: one(flags, "terminal-reason") });
+    if (result.error) fail(result.error.message);
+    if (phase === "pre") console.log(`Snapshot: ${result.snapshot.path}`);
+    else console.log(`Card: ${result.card.revId} (${result.card.status})`);
+    return;
+  }
+  if (subcommand === "url") {
+    const session = one(flags, "session", { required: true });
+    if ([...flags.keys()].some((key) => key !== "session")) fail("url accepts only --session.", 2);
+    const identity = resolveStreamingDiffIdentity({ session });
+    console.log(`/ovens/streaming-diff/view?repoKey=${encodeURIComponent(identity.logicalRepoKey)}&worktreeKey=${encodeURIComponent(identity.worktreeKey)}&session=${encodeURIComponent(identity.session)}`);
+    return;
+  }
+  fail(`unknown subcommand "${subcommand}". Run \`burnlist streaming-diff help\`.`, 2);
+} catch (error) {
+  fail(error.message);
+}
+}
+
+await main();
diff --git a/src/cli/streaming-diff-cli.test.mjs b/src/cli/streaming-diff-cli.test.mjs
new file mode 100644
index 0000000..4878ba5
--- /dev/null
+++ b/src/cli/streaming-diff-cli.test.mjs
@@ -0,0 +1,243 @@
+import assert from "node:assert/strict";
+import { execFileSync, spawn } from "node:child_process";
+import { chmodSync, mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { delimiter, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import test from "node:test";
+
+import { resolveStreamingDiffIdentity } from "../../ovens/streaming-diff/engine/streaming-diff-feed.mjs";
+import { readJournal } from "../../ovens/streaming-diff/engine/streaming-diff-journal.mjs";
+
+const repoRoot = resolve(fileURLToPath(new URL("../..", import.meta.url)));
+const binPath = join(repoRoot, "bin", "burnlist.mjs");
+
+function git(cwd, ...args) {
+  execFileSync("git", ["-C", cwd, ...args], { stdio: "ignore" });
+}
+
+function fixture() {
+  const root = mkdtempSync(join(tmpdir(), "burnlist-streaming-cli-"));
+  git(root, "init", "--quiet");
+  git(root, "config", "user.email", "test@example.invalid");
+  git(root, "config", "user.name", "Test");
+  writeFileSync(join(root, "target.txt"), "before\n");
+  writeFileSync(join(root, "other.txt"), "clean\n");
+  git(root, "add", "target.txt", "other.txt");
+  git(root, "commit", "--quiet", "-m", "initial");
+  return { root, cleanup: () => rmSync(root, { recursive: true, force: true }) };
+}
+
+function run(context, ...args) {
+  return execFileSync(process.execPath, [binPath, "streaming-diff", ...args], { cwd: context.root, encoding: "utf8" });
+}
+
+function hookProcess(context, agent, event) {
+  const child = spawn(process.execPath, [binPath, "streaming-diff", "hook", "--agent", agent, "--event", event], {
+    cwd: context.root, stdio: ["pipe", "ignore", "ignore"],
+  });
+  child.stdin.on("error", () => {});
+  return child;
+}
+
+function hook(context, agent, event, payload, env = process.env) {
+  return execFileSync(process.execPath, [binPath, "streaming-diff", "hook", "--agent", agent, "--event", event], {
+    cwd: context.root, env, input: JSON.stringify(payload), stdio: "pipe", timeout: 5_000,
+  });
+}
+
+function exitsWithin(child, milliseconds) {
+  return new Promise((resolveExit, reject) => {
+    const timer = setTimeout(() => {
+      child.kill();
+      reject(new Error(`hook did not exit within ${milliseconds}ms`));
+    }, milliseconds);
+    child.once("error", (error) => { clearTimeout(timer); reject(error); });
+    child.once("exit", (code, signal) => { clearTimeout(timer); resolveExit({ code, signal }); });
+  });
+}
+
+test("CLI pre/post capture excludes pre-existing dirty-tree changes from a tool card", () => {
+  const context = fixture();
+  try {
+    writeFileSync(join(context.root, "other.txt"), "dirty before tool\n");
+    assert.match(run(context, "ensure-feed", "--session", "agent-one"), /Binding: created/u);
+    assert.match(run(context, "capture", "--session", "agent-one", "--tool-use-id", "tool-one", "--phase", "pre", "--path", "target.txt"), /Snapshot:/u);
+    writeFileSync(join(context.root, "target.txt"), "after\n");
+    assert.match(run(context, "capture", "--session", "agent-one", "--tool-use-id", "tool-one", "--phase", "post", "--path", "target.txt"), /Card: r-[a-f0-9]+ \(captured\)/u);
+    const identity = resolveStreamingDiffIdentity({ cwd: context.root, session: "agent-one" });
+    const card = readJournal(identity.feedDir).cards.find((entry) => entry.status === "captured");
+    assert.deepEqual(card.files.map((file) => file.path), ["target.txt"]);
+    assert.match(card.files[0].diff, /-before\n\+after/u);
+    assert.doesNotMatch(card.files[0].diff, /dirty before tool/u);
+  } finally { context.cleanup(); }
+});
+
+test("CLI url prints the URL-addressed logical/worktree/session route", () => {
+  const context = fixture();
+  try {
+    const identity = resolveStreamingDiffIdentity({ cwd: context.root, session: "agent-one" });
+    assert.equal(
+      run(context, "url", "--session", "agent-one").trim(),
+      `/ovens/streaming-diff/view?repoKey=${identity.logicalRepoKey}&worktreeKey=${identity.worktreeKey}&session=agent-one`,
+    );
+  } finally { context.cleanup(); }
+});
+
+test("CLI reports an invalid capture phase as a usage error", () => {
+  const context = fixture();
+  try {
+    assert.throws(
+      () => run(context, "capture", "--session", "agent-one", "--tool-use-id", "tool-one", "--phase", "later"),
+      (error) => error.status === 2 && /phase must be pre or post/u.test(error.stderr),
+    );
+  } finally { context.cleanup(); }
+});
+
+test("hook entrypoint accepts malformed or non-mutating payloads without failing the host agent", () => {
+  const context = fixture();
+  try {
+    assert.doesNotThrow(() => execFileSync(process.execPath, [binPath, "streaming-diff", "hook", "--agent", "claude", "--event", "pre"], {
+      cwd: context.root, input: "not JSON", stdio: "pipe", timeout: 5_000,
+    }));
+    assert.doesNotThrow(() => execFileSync(process.execPath, [binPath, "streaming-diff", "hook", "--agent", "codex", "--event", "post"], {
+      cwd: context.root, input: JSON.stringify({ tool_name: "shell" }), stdio: "pipe", timeout: 5_000,
+    }));
+  } finally { context.cleanup(); }
+});
+
+test("malformed hook flags still exit zero without using the regular flag parser", () => {
+  const context = fixture();
+  try {
+    assert.doesNotThrow(() => execFileSync(process.execPath, [binPath, "streaming-diff", "hook", "--agent"], {
+      cwd: context.root, stdio: "pipe", timeout: 5_000,
+    }));
+  } finally { context.cleanup(); }
+});
+
+test("hook stdin stops at its byte cap and timeout instead of waiting for EOF", { timeout: 4_000 }, async () => {
+  const context = fixture();
+  try {
+    const oversized = hookProcess(context, "codex", "post");
+    oversized.stdin.write("x".repeat(300 * 1024));
+    assert.deepEqual(await exitsWithin(oversized, 1_500), { code: 0, signal: null });
+
+    const slow = hookProcess(context, "codex", "post");
+    slow.stdin.write("{");
+    assert.deepEqual(await exitsWithin(slow, 1_500), { code: 0, signal: null });
+
+    const identity = resolveStreamingDiffIdentity({ cwd: context.root, session: "unknown-session" });
+    const cards = readJournal(identity.feedDir).cards.filter((card) => card.toolUseId === "unknown-tool-use");
+    assert.equal(cards.every((card) => card.status === "partial"), true);
+    assert.equal(cards.some((card) => /byte limit/u.test(card.partialReason)), true);
+    assert.equal(cards.some((card) => /timed out/u.test(card.partialReason)), true);
+  } finally { context.cleanup(); }
+});
+
+test("a Codex payload with truncated path hints records a partial terminal card", () => {
+  const context = fixture();
+  try {
+    const paths = Array.from({ length: 65 }, (_, index) => `file-${index}.txt`);
+    const payload = {
+      session_id: "codex-many", tool_name: "apply_patch", tool_use_id: "call-many",
+      tool_input: { command: `*** Begin Patch\n${paths.map((path) => `*** Add File: ${path}`).join("\n")}\n*** End Patch` },
+    };
+    hook(context, "codex", "pre", payload);
+    writeFileSync(join(context.root, "file-0.txt"), "after\n");
+    hook(context, "codex", "post", payload);
+    const identity = resolveStreamingDiffIdentity({ cwd: context.root, session: "codex-many" });
+    const card = readJournal(identity.feedDir).cards.find((entry) => entry.toolUseId === "call-many" && entry.files.length > 0);
+    assert.equal(card.status, "partial");
+    assert.match(card.partialReason, /path hints truncated/u);
+  } finally { context.cleanup(); }
+});
+
+test("missing hook fields record a partial terminal card instead of a captured fallback", () => {
+  const context = fixture();
+  try {
+    hook(context, "codex", "post", { tool_name: "write_file", tool_input: {} });
+    const identity = resolveStreamingDiffIdentity({ cwd: context.root, session: "unknown-session" });
+    const card = readJournal(identity.feedDir).cards.find((entry) => entry.toolUseId === "unknown-tool-use");
+    assert.equal(card.status, "partial");
+    assert.match(card.partialReason, /hook adapter mapping was incomplete/u);
+  } finally { context.cleanup(); }
+});
+
+test("hook payloads with dash-prefixed hints and missing fields remain partial", () => {
+  const context = fixture();
+  try {
+    hook(context, "codex", "post", { tool_name: "write_file", tool_use_id: "dash-call", tool_input: { file_path: "--phase" } });
+    hook(context, "codex", "post", {});
+    const identity = resolveStreamingDiffIdentity({ cwd: context.root, session: "unknown-session" });
+    const cards = readJournal(identity.feedDir).cards;
+    assert.equal(cards.some((card) => card.toolUseId === "dash-call" && card.status === "partial" && /hook adapter mapping/u.test(card.partialReason)), true);
+    assert.equal(cards.some((card) => card.toolUseId === "unknown-tool-use" && card.status === "partial"), true);
+  } finally { context.cleanup(); }
+});
+
+test("JSON-valid non-object hook payloads produce partial cards and exit zero", () => {
+  const context = fixture();
+  try {
+    assert.doesNotThrow(() => execFileSync(process.execPath, [binPath, "streaming-diff", "hook", "--agent", "codex", "--event", "post"], {
+      cwd: context.root, input: "[]", stdio: "pipe", timeout: 5_000,
+    }));
+    const identity = resolveStreamingDiffIdentity({ cwd: context.root, session: "unknown-session" });
+    const card = readJournal(identity.feedDir).cards.find((entry) => entry.toolUseId === "unknown-tool-use");
+    assert.equal(card.status, "partial");
+    assert.match(card.partialReason, /hook adapter mapping was incomplete/u);
+  } finally { context.cleanup(); }
+});
+
+test("a Claude git-timeout mapping records a partial terminal card", { timeout: 5_000 }, () => {
+  const context = fixture();
+  const originalPath = process.env.PATH;
+  try {
+    const bin = join(context.root, "slow-bin");
+    const count = join(context.root, "git-count");
+    mkdirSync(bin);
+    writeFileSync(join(bin, "git"), `#!/bin/sh\nif [ ! -f ${JSON.stringify(count)} ]; then touch ${JSON.stringify(count)}; sleep 1; fi\nexec \"$BURNLIST_REAL_GIT\" \"$@\"\n`);
+    chmodSync(join(bin, "git"), 0o755);
+    const realGit = execFileSync("which", ["git"], { encoding: "utf8" }).trim();
+    const env = { ...process.env, PATH: `${bin}${delimiter}${originalPath}`, BURNLIST_REAL_GIT: realGit };
+    const payload = { session_id: "claude-timeout", tool_name: "Write", tool_use_id: "call-timeout", tool_input: { file_path: join(context.root, "target.txt") } };
+    hook(context, "claude", "post", payload, env);
+    const identity = resolveStreamingDiffIdentity({ cwd: context.root, session: "claude-timeout" });
+    const card = readJournal(identity.feedDir).cards.find((entry) => entry.toolUseId === "call-timeout");
+    assert.equal(card.status, "partial");
+    assert.match(card.partialReason, /missing path hints/u);
+  } finally { context.cleanup(); }
+});
+
+test("a child capture timeout preserves the degraded pre-hook partial and exits zero", { timeout: 5_000 }, () => {
+  const context = fixture();
+  const originalPath = process.env.PATH;
+  try {
+    const paths = Array.from({ length: 65 }, (_, index) => `file-${index}.txt`);
+    const payload = { session_id: "codex-timeout", tool_name: "apply_patch", tool_use_id: "call-timeout", tool_input: { command: `*** Begin Patch\n${paths.map((path) => `*** Add File: ${path}`).join("\n")}\n*** End Patch` } };
+    hook(context, "codex", "pre", payload);
+    const bin = join(context.root, "slow-bin");
+    mkdirSync(bin);
+    writeFileSync(join(bin, "git"), "#!/bin/sh\nsleep 3\n");
+    chmodSync(join(bin, "git"), 0o755);
+    const env = { ...process.env, PATH: `${bin}${delimiter}${originalPath}` };
+    assert.doesNotThrow(() => hook(context, "codex", "post", payload, env));
+    const identity = resolveStreamingDiffIdentity({ cwd: context.root, session: "codex-timeout" });
+    const cards = readJournal(identity.feedDir).cards.filter((entry) => entry.toolUseId === "call-timeout");
+    assert.equal(cards.every((card) => card.status === "partial"), true);
+    assert.equal(cards.some((card) => /path hints truncated/u.test(card.partialReason)), true);
+  } finally { process.env.PATH = originalPath; context.cleanup(); }
+});
+
+test("a real failure hook event writes a partial terminal card", () => {
+  const context = fixture();
+  try {
+    const payload = { session_id: "claude-session", tool_name: "Edit", tool_use_id: "tool-1", tool_input: { file_path: join(context.root, "target.txt"), old_string: "before", new_string: "after" } };
+    execFileSync(process.execPath, [binPath, "streaming-diff", "hook", "--agent", "claude", "--event", "pre"], { cwd: context.root, input: JSON.stringify(payload), stdio: "pipe", timeout: 5_000 });
+    writeFileSync(join(context.root, "target.txt"), "after\n");
+    execFileSync(process.execPath, [binPath, "streaming-diff", "hook", "--agent", "claude", "--event", "failure"], { cwd: context.root, input: JSON.stringify(payload), stdio: "pipe", timeout: 5_000 });
+    const identity = resolveStreamingDiffIdentity({ cwd: context.root, session: "claude-session" });
+    const card = readJournal(identity.feedDir).cards.find((entry) => entry.toolUseId === "tool-1" && entry.files.length > 0);
+    assert.equal(card.status, "partial");
+    assert.match(card.partialReason, /tool failed/u);
+  } finally { context.cleanup(); }
+});
diff --git a/src/cli/umbrella.mjs b/src/cli/umbrella.mjs
index 08eddca..11940ed 100644
--- a/src/cli/umbrella.mjs
+++ b/src/cli/umbrella.mjs
@@ -2,12 +2,16 @@ import { spawnSync } from "node:child_process";
 import { existsSync, realpathSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 
+export const GIT_PROBE_TIMEOUT_MS = 2_000;
+
 export function gitProbe(cwd, args) {
   const result = spawnSync("git", ["-C", cwd, ...args], {
     cwd,
     encoding: "utf8",
     shell: false,
     stdio: ["ignore", "pipe", "ignore"],
+    timeout: GIT_PROBE_TIMEOUT_MS,
+    maxBuffer: 64 * 1024,
   });
   return result.status === 0 ? result.stdout.trim() : null;
 }
diff --git a/src/cli/umbrella.test.mjs b/src/cli/umbrella.test.mjs
index 6de8ec4..6b13ea6 100644
--- a/src/cli/umbrella.test.mjs
+++ b/src/cli/umbrella.test.mjs
@@ -1,10 +1,10 @@
 import assert from "node:assert/strict";
 import { execFileSync } from "node:child_process";
-import { mkdirSync, mkdtempSync, realpathSync, rmSync } from "node:fs";
+import { chmodSync, mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { delimiter, join } from "node:path";
 import test from "node:test";
-import { resolveUmbrella } from "./umbrella.mjs";
+import { gitProbe, resolveUmbrella } from "./umbrella.mjs";
 
 function git(cwd, ...args) {
   execFileSync("git", ["-C", cwd, ...args], { stdio: "ignore" });
@@ -58,3 +58,22 @@ test("resolveUmbrella resolves a primary worktree with a separate git directory"
     cleanup();
   }
 });
+
+test("gitProbe times out rather than indefinitely blocking hook identity resolution", { timeout: 3_000 }, () => {
+  const { root, cleanup } = fixture();
+  const originalPath = process.env.PATH;
+  try {
+    const bin = join(root, "slow-bin");
+    mkdirSync(bin);
+    const gitPath = join(bin, "git");
+    writeFileSync(gitPath, "#!/bin/sh\nsleep 3\n");
+    chmodSync(gitPath, 0o755);
+    process.env.PATH = `${bin}${delimiter}${originalPath}`;
+    const started = Date.now();
+    assert.equal(gitProbe(root, ["rev-parse", "--show-toplevel"]), null);
+    assert.ok(Date.now() - started < 2_500);
+  } finally {
+    process.env.PATH = originalPath;
+    cleanup();
+  }
+});
diff --git a/src/ovens/built-in-handlers.mjs b/src/ovens/built-in-handlers.mjs
index 1e6a06e..5d0ee77 100644
--- a/src/ovens/built-in-handlers.mjs
+++ b/src/ovens/built-in-handlers.mjs
@@ -1,2 +1,3 @@
 import "./handlers/checklist.mjs";
 import "../../ovens/differential-testing/engine/differential-testing-handler.mjs";
+import "../../ovens/streaming-diff/engine/streaming-diff-handler.mjs";
diff --git a/src/server/burnlist-dashboard-server.mjs b/src/server/burnlist-dashboard-server.mjs
index d37aad3..93fd77a 100644
--- a/src/server/burnlist-dashboard-server.mjs
+++ b/src/server/burnlist-dashboard-server.mjs
@@ -317,7 +317,7 @@ function blockedDashboardEntry(handler, error) {
   };
 }
 
-function ovenHandlerContext({ id, oven, req, res, url, bindingPath, ovenDataBindings = resolvedOvenDataBindings() } = {}) {
+function ovenHandlerContext({ id, oven, req, res, url, binding, bindingPath, ovenDataBindings = resolvedOvenDataBindings() } = {}) {
   const cacheId = id ?? oven?.id;
   if (cacheId && !ovenHandlerCaches.has(cacheId)) ovenHandlerCaches.set(cacheId, new Map());
   return {
@@ -326,7 +326,8 @@ function ovenHandlerContext({ id, oven, req, res, url, bindingPath, ovenDataBind
     req,
     res,
     url,
-    bindingPath,
+    binding,
+    bindingPath: bindingPath ?? binding?.path,
     cache: cacheId ? ovenHandlerCaches.get(cacheId) : new Map(),
     ovenDataBindings,
     maxOvenDataBytes,
@@ -1105,18 +1106,31 @@ const server = createServer(async (req, res) => {
       const oven = findOven(id, requestedRepoKey);
       const handler = oven?.builtIn || !oven ? getOvenHandler(id) : null;
       const ovenDataBindings = resolvedOvenDataBindings();
+      if (id === "streaming-diff") {
+        const repoKeys = url.searchParams.getAll("repoKey");
+        if (repoKeys.length > 1 || (url.searchParams.has("list") && repoKeys.length !== 1)
+          || repoKeys.some((repoKey) => !/^[a-f0-9]{12}$/u.test(repoKey))) {
+          return json(res, 400, { error: url.searchParams.has("list")
+            ? "Streaming Diff list requires one lowercase 12-character hexadecimal repoKey"
+            : "repoKey must be a lowercase 12-character hexadecimal key" });
+        }
+      }
       const binding = selectedOvenDataBinding(ovenDataBindings, id, url);
       if (!handler && !oven) return json(res, 404, { validated: false, error: `Oven ${id} is not available` });
       if (!binding) return json(res, 404, { error: `no data binding configured for Oven ${id}` });
       try {
         const active = handler ?? genericJsonHandler;
-        const response = active.serveData?.(ovenHandlerContext({ id, oven, req, res, url, bindingPath: binding.path, ovenDataBindings }));
+        const response = active.serveData?.(ovenHandlerContext({ id, oven, req, res, url, binding, ovenDataBindings }));
         if (response !== undefined) json(res, 200, response);
       } catch (error) {
-        json(res, Number.isInteger(error.status) ? error.status : 422, {
-          error: error instanceof SyntaxError ? `Oven ${id} data is not valid JSON: ${error.message}` : error.message,
-          issues: Array.isArray(error.issues) ? error.issues : undefined,
-        });
+        if (!res.headersSent) {
+          json(res, Number.isInteger(error.status) ? error.status : 422, {
+            error: error instanceof SyntaxError ? `Oven ${id} data is not valid JSON: ${error.message}` : error.message,
+            issues: Array.isArray(error.issues) ? error.issues : undefined,
+          });
+        } else {
+          res.end();
+        }
       }
       return;
     }
diff --git a/src/server/dir-lock.mjs b/src/server/dir-lock.mjs
new file mode 100644
index 0000000..194c0ab
--- /dev/null
+++ b/src/server/dir-lock.mjs
@@ -0,0 +1,311 @@
+import { randomBytes } from "node:crypto";
+import {
+  closeSync,
+  constants,
+  fsyncSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmdirSync,
+  unlinkSync,
+  writeSync,
+} from "node:fs";
+import os from "node:os";
+import { basename, dirname, join } from "node:path";
+
+export const LOCK_MAX_AGE_MS = 15 * 60_000;
+export const MAX_ATTEMPTS = 100;
+export const RETRY_DELAY_MS = 20;
+export const CANDIDATE_GC_AGE_MS = 2 * LOCK_MAX_AGE_MS;
+export const CANDIDATE_CREATE_MAX_TRIES = 3;
+
+const ownerName = (token) => `owner-${token}.json`;
+const tokenPattern = /^[0-9a-f]{64}$/u;
+const legacyTokenPattern = /^[0-9a-f]{24}$/u;
+const safePid = (value) => Number.isSafeInteger(value) && value > 0;
+const safeTime = (value) => Number.isFinite(value) && Number.isInteger(value) && value >= 0;
+const sleepSync = (milliseconds) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
+const defaultFs = { closeSync, fsyncSync, lstatSync, mkdirSync, openSync, readdirSync, renameSync, rmdirSync, unlinkSync, writeSync };
+
+function ignored(error) {
+  return error?.code === "ENOENT";
+}
+
+function harmlessRmdir(error) {
+  return ignored(error) || error?.code === "ENOTEMPTY" || error?.code === "EEXIST";
+}
+
+function log(logger, error) {
+  try { logger(error); } catch { /* logging must not alter lock behavior */ }
+}
+
+function fsyncDirectory(fs, path) {
+  const fd = fs.openSync(path, constants.O_RDONLY);
+  let primary;
+  try { fs.fsyncSync(fd); } catch (error) { primary = error; }
+  try { fs.closeSync(fd); } catch (error) { if (!primary) primary = error; }
+  if (primary) throw primary;
+}
+
+function removeCandidate(fs, path, { logger, afterOwnerUnlink } = {}) {
+  let entries;
+  try { entries = fs.readdirSync(path, { withFileTypes: true }); } catch (error) {
+    if (!ignored(error)) log(logger, error);
+    return;
+  }
+  for (const entry of entries) {
+    try { fs.unlinkSync(join(path, entry.name)); } catch (error) {
+      if (!ignored(error)) log(logger, error);
+    }
+  }
+  try { afterOwnerUnlink?.(); } catch (error) { log(logger, error); }
+  try { fs.rmdirSync(path); } catch (error) {
+    if (!ignored(error) && error?.code !== "ENOTEMPTY" && error?.code !== "EEXIST") log(logger, error);
+  }
+}
+
+function parseRecord(text) {
+  try {
+    const value = JSON.parse(text);
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+  } catch { return null; }
+}
+
+function validV2(record, token) {
+  return record?.version === 1 && safePid(record.pid) && typeof record.hostname === "string" && record.hostname !== ""
+    && tokenPattern.test(record.token) && record.token === token && safeTime(record.createdAt);
+}
+
+function legacyRecord(record) {
+  if (!record || Object.hasOwn(record, "version") || !safePid(record.pid) || !legacyTokenPattern.test(record.token)
+    || !safeTime(record.createdAt)) return null;
+  // §7/2.3: v0.0.2 used a same-machine link()-based regular-file lock. Its
+  // complete record is { pid, token, createdAt }; hostname was never stored.
+  return !Object.hasOwn(record, "hostname") ? record : null;
+}
+
+function stale(record, now, hostname, pidProbe) {
+  if (record.hostname !== hostname) return false;
+  return staleSameHost(record, now, pidProbe);
+}
+
+function staleSameHost(record, now, pidProbe) {
+  let live = true;
+  try { pidProbe(record.pid); } catch (error) { live = error?.code !== "ESRCH"; }
+  return !live || now - record.createdAt >= LOCK_MAX_AGE_MS;
+}
+
+function inspectCanonical(fs, lockPath, { now, hostname, pidProbe, readFile }) {
+  const inspectionNow = now();
+  let stat;
+  try { stat = fs.lstatSync(lockPath); } catch (error) {
+    if (ignored(error)) return { kind: "missing" };
+    throw error;
+  }
+  if (stat.isSymbolicLink()) return { kind: "corrupt" };
+  if (stat.isDirectory()) {
+    let entries;
+    try { entries = fs.readdirSync(lockPath, { withFileTypes: true }); } catch (error) {
+      if (ignored(error)) return { kind: "missing" };
+      throw error;
+    }
+    if (entries.length === 0) return { kind: "empty" };
+    if (entries.length !== 1) return { kind: "corrupt" };
+    const match = /^owner-([0-9a-f]{64})\.json$/u.exec(entries[0].name);
+    if (!match) return { kind: "corrupt" };
+    const path = join(lockPath, entries[0].name);
+    let ownerStat;
+    try { ownerStat = fs.lstatSync(path); } catch (error) {
+      if (ignored(error)) return { kind: "missing" };
+      throw error;
+    }
+    if (!ownerStat.isFile()) return { kind: "corrupt" };
+    let record;
+    try { record = parseRecord(readFile(path, "utf8")); } catch (error) {
+      if (ignored(error)) return { kind: "missing" };
+      throw error;
+    }
+    if (!validV2(record, match[1])) return { kind: "corrupt" };
+    return { kind: "v2", record, token: match[1], stale: stale(record, inspectionNow, hostname, pidProbe) };
+  }
+  if (!stat.isFile()) return { kind: "corrupt" };
+  let text;
+  try { text = readFile(lockPath, "utf8"); } catch (error) {
+    if (ignored(error)) return { kind: "missing" };
+    throw error;
+  }
+  const record = legacyRecord(parseRecord(text));
+  if (!record) return { kind: "corrupt" };
+  // Only v2 directory records use hostname as a cross-host safety boundary.
+  return { kind: "legacy", record, text, stale: staleSameHost(record, inspectionNow, pidProbe) };
+}
+
+function buildCandidate(fs, lockPath, context) {
+  const { hostname, now, token, logger, hooks } = context;
+  const parent = dirname(lockPath);
+  fs.mkdirSync(parent, { recursive: true });
+  let candidate;
+  let lastError;
+  for (let count = 0; count < CANDIDATE_CREATE_MAX_TRIES; count += 1) {
+    const value = token();
+    const createdAt = now();
+    candidate = `${lockPath}.candidate.${value}`;
+    try { fs.mkdirSync(candidate, { mode: 0o700 }); } catch (error) {
+      lastError = error;
+      if (error?.code === "EEXIST") continue;
+      throw error;
+    }
+    try {
+      hooks.afterCandidateDirectory?.({ candidate, token: value });
+      const path = join(candidate, ownerName(value));
+      const record = `${JSON.stringify({ version: 1, pid: process.pid, hostname, token: value, createdAt })}\n`;
+      const bytes = Buffer.from(record, "utf8");
+      const fd = fs.openSync(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 0o600);
+      let primary;
+      try {
+        let offset = 0;
+        while (offset < bytes.length) {
+          const written = fs.writeSync(fd, bytes, offset, bytes.length - offset);
+          if (!Number.isSafeInteger(written) || written <= 0) throw new Error("Could not write complete lock owner record.");
+          offset += written;
+        }
+        fs.fsyncSync(fd);
+      } catch (error) { primary = error; }
+      try { fs.closeSync(fd); } catch (error) { if (!primary) primary = error; }
+      if (primary) throw primary;
+      hooks.afterCandidateOwner?.({ candidate, token: value });
+      fsyncDirectory(fs, candidate);
+      return { candidate, token: value };
+    } catch (error) {
+      removeCandidate(fs, candidate, { logger });
+      throw error;
+    }
+  }
+  throw lastError;
+}
+
+function release(fs, lockPath, token, { logger, hooks }) {
+  try { hooks.beforeReleaseUnlink?.({ token }); } catch (error) { log(logger, error); }
+  let unlinkWorked = false;
+  try { fs.unlinkSync(join(lockPath, ownerName(token))); unlinkWorked = true; } catch (error) {
+    if (!ignored(error)) { log(logger, error); return; }
+  }
+  if (unlinkWorked) {
+    try { hooks.betweenReleaseUnlinkAndRmdir?.({ token }); } catch (error) { log(logger, error); }
+  }
+  try { fs.rmdirSync(lockPath); } catch (error) { if (!harmlessRmdir(error)) log(logger, error); }
+}
+
+function reclaimLegacy(fs, lockPath, { record, text }, readFile) {
+  let stat;
+  try { stat = fs.lstatSync(lockPath); } catch (error) { if (ignored(error)) return; throw error; }
+  if (!stat.isFile()) return;
+  let current;
+  try { current = readFile(lockPath, "utf8"); } catch (error) { if (ignored(error)) return; throw error; }
+  const currentRecord = legacyRecord(parseRecord(current));
+  if (current !== text || !currentRecord || currentRecord.token !== record.token) return;
+  try { fs.unlinkSync(lockPath); } catch (error) {
+    if (ignored(error) || error?.code === "EISDIR") return;
+    if (error?.code !== "EPERM") throw error;
+    let stat;
+    try { stat = fs.lstatSync(lockPath); } catch (again) { if (ignored(again)) return; throw again; }
+    if (stat.isDirectory() || stat.isSymbolicLink() || !stat.isFile()) return;
+    throw error;
+  }
+}
+
+function gc(fs, lockPath, context) {
+  const parent = dirname(lockPath);
+  const candidatePrefix = `${basename(lockPath)}.candidate.`;
+  let entries;
+  try { entries = fs.readdirSync(parent, { withFileTypes: true }); } catch (error) { log(context.logger, error); return; }
+  const gcNow = context.now();
+  for (const entry of entries) {
+    const suffix = entry.name.slice(candidatePrefix.length);
+    if (entry.name.length !== candidatePrefix.length + 64 || !entry.name.startsWith(candidatePrefix) || !tokenPattern.test(suffix)) continue;
+    const path = join(parent, entry.name);
+    try {
+      const stat = fs.lstatSync(path);
+      if (!stat.isDirectory() || gcNow - stat.mtimeMs < CANDIDATE_GC_AGE_MS) continue;
+      removeCandidate(fs, path, { logger: context.logger, afterOwnerUnlink: () => context.hooks.afterGcOwnerUnlink?.({ candidate: path }) });
+    } catch (error) { log(context.logger, error); }
+  }
+}
+
+/** Test seams are deliberately optional; production callers use only lockPath, fn, and errorFactory. */
+export function withDirectoryLock({ lockPath, fn, errorFactory, adapters = {}, hooks = {} }) {
+  const fs = { ...defaultFs, ...adapters.fs };
+  const context = {
+    hostname: adapters.hostname?.() ?? os.hostname(), now: adapters.now ?? Date.now,
+    pidProbe: adapters.pidProbe ?? ((pid) => process.kill(pid, 0)), sleep: adapters.sleep ?? sleepSync,
+    token: adapters.token ?? (() => randomBytes(32).toString("hex")), logger: adapters.logger ?? (() => {}),
+    readFile: adapters.readFileSync ?? readFileSync, hooks,
+  };
+  if (typeof context.hostname !== "string" || context.hostname === "") throw new Error("Cannot create a lock without a hostname.");
+  fs.mkdirSync(dirname(lockPath), { recursive: true });
+  gc(fs, lockPath, context);
+  let candidate = buildCandidate(fs, lockPath, context);
+  let holderPid = null;
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt += 1) {
+    try { hooks.beforePublication?.({ attempt, ...candidate }); } catch (error) { removeCandidate(fs, candidate.candidate, context); throw error; }
+    let renameError;
+    try {
+      fs.renameSync(candidate.candidate, lockPath);
+    } catch (error) { renameError = error; }
+    if (!renameError) {
+      const mine = candidate;
+      candidate = null;
+      try { hooks.afterPublication?.({ attempt, ...mine }); } catch (error) { release(fs, lockPath, mine.token, context); throw error; }
+      let owner;
+      try { owner = fs.lstatSync(join(lockPath, ownerName(mine.token))); } catch (error) {
+        if (!ignored(error)) { release(fs, lockPath, mine.token, context); throw error; }
+        try { fs.rmdirSync(lockPath); } catch (rmdirError) { if (!harmlessRmdir(rmdirError)) log(context.logger, rmdirError); }
+        candidate = buildCandidate(fs, lockPath, context);
+        if (attempt < MAX_ATTEMPTS) context.sleep(RETRY_DELAY_MS);
+        continue;
+      }
+      if (!owner.isFile()) { release(fs, lockPath, mine.token, context); throw new Error(`Lock owner is corrupt: ${lockPath}`); }
+      try { fsyncDirectory(fs, dirname(lockPath)); } catch (error) { release(fs, lockPath, mine.token, context); throw error; }
+      try { hooks.afterSelfCheck?.({ attempt, ...mine }); } catch (error) { release(fs, lockPath, mine.token, context); throw error; }
+      let result;
+      let callbackError;
+      try { result = fn(); } catch (error) { callbackError = error; }
+      release(fs, lockPath, mine.token, context);
+      if (callbackError) throw callbackError;
+      return result;
+    }
+    if (renameError?.code !== "EEXIST" && renameError?.code !== "ENOTEMPTY" && renameError?.code !== "ENOTDIR" && renameError?.code !== "ENOENT") {
+      removeCandidate(fs, candidate.candidate, context);
+      throw renameError;
+    }
+    if (renameError?.code === "ENOENT") {
+      let source;
+      try { source = fs.lstatSync(candidate.candidate); } catch (sourceError) {
+        if (!ignored(sourceError)) { removeCandidate(fs, candidate.candidate, context); throw sourceError; }
+        candidate = buildCandidate(fs, lockPath, context);
+        if (attempt < MAX_ATTEMPTS) context.sleep(RETRY_DELAY_MS);
+        continue;
+      }
+      if (!source.isDirectory()) { removeCandidate(fs, candidate.candidate, context); throw new Error(`Lock candidate is corrupt: ${candidate.candidate}`); }
+      fs.mkdirSync(dirname(lockPath), { recursive: true });
+      if (attempt < MAX_ATTEMPTS) context.sleep(RETRY_DELAY_MS);
+      continue;
+    }
+    const observed = inspectCanonical(fs, lockPath, context);
+    holderPid = observed.record?.pid ?? holderPid;
+    if ((observed.kind === "v2" || observed.kind === "legacy") && observed.stale) {
+      try { hooks.afterStaleJudgment?.({ attempt, token: observed.token, legacy: observed.kind === "legacy" }); } catch (hookError) { removeCandidate(fs, candidate.candidate, context); throw hookError; }
+      if (observed.kind === "v2") {
+        try { fs.unlinkSync(join(lockPath, ownerName(observed.token))); } catch (unlinkError) { if (!ignored(unlinkError)) { removeCandidate(fs, candidate.candidate, context); throw unlinkError; } }
+        try { hooks.afterStaleOwnerUnlink?.({ attempt, token: observed.token }); } catch (hookError) { removeCandidate(fs, candidate.candidate, context); throw hookError; }
+        try { fs.rmdirSync(lockPath); } catch (rmdirError) { if (!harmlessRmdir(rmdirError)) { removeCandidate(fs, candidate.candidate, context); throw rmdirError; } }
+      } else reclaimLegacy(fs, lockPath, observed, context.readFile);
+    }
+    if (attempt < MAX_ATTEMPTS) context.sleep(RETRY_DELAY_MS);
+  }
+  if (candidate) removeCandidate(fs, candidate.candidate, context);
+  throw errorFactory({ holderPid, lockPath });
+}
diff --git a/src/server/dir-lock.test.mjs b/src/server/dir-lock.test.mjs
new file mode 100644
index 0000000..8bce65b
--- /dev/null
+++ b/src/server/dir-lock.test.mjs
@@ -0,0 +1,159 @@
+import assert from "node:assert/strict";
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, symlinkSync, utimesSync, writeFileSync } from "node:fs";
+import { hostname, tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { CANDIDATE_GC_AGE_MS, LOCK_MAX_AGE_MS, MAX_ATTEMPTS, RETRY_DELAY_MS, withDirectoryLock } from "./dir-lock.mjs";
+
+const token = (letter) => letter.repeat(64);
+
+function paths(t) {
+  const root = mkdtempSync(join(tmpdir(), "burnlist-dir-lock-"));
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+  return [join(root, ".lock"), join(root, "roots.lock")];
+}
+
+function writeV2(lock, { pid = process.pid, host = hostname(), value = token("a"), createdAt = Date.now() } = {}) {
+  mkdirSync(lock, { recursive: true });
+  writeFileSync(join(lock, `owner-${value}.json`), `${JSON.stringify({ version: 1, pid, hostname: host, token: value, createdAt })}\n`);
+}
+
+function writeLegacy(lock, { pid = process.pid, value = "a".repeat(24), createdAt = Date.now() } = {}) {
+  mkdirSync(dirname(lock), { recursive: true });
+  writeFileSync(lock, JSON.stringify({ pid, token: value, createdAt }));
+}
+
+function acquire(lock, fn = () => "ok", adapters = {}, hooks = {}) {
+  return withDirectoryLock({
+    lockPath: lock, fn, adapters, hooks,
+    errorFactory: ({ holderPid }) => Object.assign(new Error(`locked ${holderPid ?? "unknown"}`), { code: "ELOCKED" }),
+  });
+}
+
+function forBoth(t, name, fn) {
+  for (const lock of paths(t)) test(`${name}: ${lock.endsWith("roots.lock") ? "registry" : "repo"}`, () => fn(lock));
+}
+
+test("valid directory records acquire, release, and use the 64-hex owner name", (t) => {
+  forBoth(t, "representation", (lock) => {
+    assert.equal(acquire(lock), "ok");
+    assert.equal(existsSync(lock), false);
+  });
+});
+
+test("stale v0.0.2 regular-file locks are reclaimed but fresh live ones are respected", (t) => {
+  forBoth(t, "legacy migration", (lock) => {
+    const now = 2_000_000;
+    const dead = () => { throw Object.assign(new Error("gone"), { code: "ESRCH" }); };
+    writeLegacy(lock, { pid: 2147483646, createdAt: now });
+    assert.equal(acquire(lock, () => "dead reclaimed", { now: () => now, pidProbe: dead, sleep: () => {} }), "dead reclaimed");
+
+    writeLegacy(lock, { createdAt: now - LOCK_MAX_AGE_MS });
+    assert.equal(acquire(lock, () => "aged reclaimed", { now: () => now, pidProbe: () => {}, sleep: () => {} }), "aged reclaimed");
+
+    writeLegacy(lock, { createdAt: now - LOCK_MAX_AGE_MS + 1 });
+    assert.throws(
+      () => acquire(lock, () => assert.fail("fresh live legacy lock must be respected"), { now: () => now, pidProbe: () => {}, sleep: () => {} }),
+      { code: "ELOCKED" },
+    );
+  });
+});
+
+test("legacy reclaim only removes the exact stale record it inspected", (t) => {
+  forBoth(t, "legacy conditional reclaim", (lock) => {
+    const now = 2_000_000;
+    const staleToken = "a".repeat(24);
+    const freshToken = "b".repeat(24);
+    const fresh = JSON.stringify({ pid: process.pid, token: freshToken, createdAt: now });
+    writeLegacy(lock, { pid: 2147483646, value: staleToken, createdAt: now - LOCK_MAX_AGE_MS });
+    assert.throws(() => acquire(lock, () => assert.fail("a replacement lock must not be stolen"), {
+      now: () => now, pidProbe: () => {}, sleep: () => {},
+    }, {
+      afterStaleJudgment({ legacy }) { if (legacy) writeFileSync(lock, fresh); },
+    }), { code: "ELOCKED" });
+    assert.equal(readFileSync(lock, "utf8"), fresh);
+  });
+});
+
+test("foreign, malformed, and unsafe lock shapes remain untouched", (t) => {
+  for (const lock of paths(t)) {
+    const fixtures = [
+      () => writeV2(lock, { host: "foreign-host", createdAt: 0 }),
+      () => { mkdirSync(lock); writeFileSync(join(lock, "unexpected"), "x"); },
+      () => { mkdirSync(lock); mkdirSync(join(lock, "owner-subdir")); },
+      () => { mkdirSync(lock); symlinkSync(join(dirname(lock), "target"), join(lock, `owner-${token("b")}.json`)); },
+      () => { writeFileSync(lock, "not a legacy record"); },
+    ];
+    for (const fixture of fixtures) {
+      fixture();
+      const before = lstatSync(lock).isSymbolicLink() ? "symlink" : readShape(lock);
+      assert.throws(() => acquire(lock, () => assert.fail("must not enter"), { sleep: () => {} }), { code: "ELOCKED" });
+      assert.equal(lstatSync(lock).isSymbolicLink() ? "symlink" : readShape(lock), before);
+      rmSync(lock, { recursive: true, force: true });
+    }
+  }
+});
+
+test("stale age boundary and foreign-host protection are exact", (t) => {
+  forBoth(t, "age", (lock) => {
+    const now = 2_000_000;
+    writeV2(lock, { createdAt: now - LOCK_MAX_AGE_MS });
+    assert.equal(acquire(lock, () => "stolen", { now: () => now, sleep: () => {} }), "stolen");
+    writeV2(lock, { createdAt: now - LOCK_MAX_AGE_MS + 1 });
+    assert.throws(() => acquire(lock, () => "no", { now: () => now, sleep: () => {} }), { code: "ELOCKED" });
+  });
+});
+
+test("bounded contention performs 100 publications and 99 sleeps", (t) => {
+  forBoth(t, "bounds", (lock) => {
+    writeV2(lock);
+    let renames = 0;
+    let sleeps = 0;
+    assert.throws(() => acquire(lock, () => "no", {
+      sleep: (ms) => { assert.equal(ms, RETRY_DELAY_MS); sleeps += 1; },
+      fs: { renameSync(...args) { renames += 1; return renameSync(...args); } },
+    }), { code: "ELOCKED" });
+    assert.equal(renames, MAX_ATTEMPTS);
+    assert.equal(sleeps, MAX_ATTEMPTS - 1);
+  });
+});
+
+test("candidate ENOENT rebuild and strict candidate GC are safe", (t) => {
+  forBoth(t, "candidate recovery", (lock) => {
+    let first = true;
+    let sleeps = 0;
+    const realRename = renameSync;
+    assert.equal(acquire(lock, () => "ok", {
+      token: (() => { let n = 0; return () => token((n++ % 2) ? "b" : "a"); })(), sleep: () => { sleeps += 1; },
+      fs: { renameSync(source, destination) { if (first) { first = false; rmSync(source, { recursive: true }); } return realRename(source, destination); } },
+    }), "ok");
+    assert.equal(sleeps, 1);
+    const candidate = `${lock}.candidate.${token("c")}`;
+    mkdirSync(candidate); writeFileSync(join(candidate, "partial"), "x");
+    utimesSync(candidate, new Date(0), new Date(0));
+    const evil = `${lock}.candidate.evil`;
+    mkdirSync(evil); utimesSync(evil, new Date(0), new Date(0));
+    const newline = `${lock}.candidate.${token("d")}\n`;
+    mkdirSync(newline); utimesSync(newline, new Date(0), new Date(0));
+    acquire(lock, () => "gc", { now: () => CANDIDATE_GC_AGE_MS + 1 });
+    assert.equal(existsSync(candidate), false);
+    assert.equal(existsSync(evil), true);
+    assert.equal(existsSync(newline), true);
+  });
+});
+
+test("release errors are logged without masking callback work", (t) => {
+  forBoth(t, "release policy", (lock) => {
+    const logged = [];
+    const result = acquire(lock, () => "sentinel", { logger: (error) => logged.push(error), fs: { unlinkSync() { throw Object.assign(new Error("io"), { code: "EIO" }); } } });
+    assert.equal(result, "sentinel");
+    assert.equal(logged.length, 1);
+    rmSync(lock, { recursive: true });
+    assert.throws(() => acquire(lock, () => { throw new Error("callback"); }, { logger: () => {}, fs: { unlinkSync() { throw Object.assign(new Error("io"), { code: "EIO" }); } } }), /callback/u);
+  });
+});
+
+function readShape(path) {
+  if (lstatSync(path).isFile()) return readFileSync(path, "utf8");
+  return JSON.stringify(readdirSync(path).sort());
+}
diff --git a/src/server/oven-bindings.mjs b/src/server/oven-bindings.mjs
index 6372474..bcc47ca 100644
--- a/src/server/oven-bindings.mjs
+++ b/src/server/oven-bindings.mjs
@@ -1,7 +1,7 @@
 // Persisted bindings remain scoped to their repository; explicit --oven-data
 // bindings are global defaults. Persisted relative paths resolve per read.
 import { randomBytes } from "node:crypto";
-import { mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { closeSync, constants, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { ovenId } from "../ovens/oven-contract.mjs";
 import { repoKey } from "./registry.mjs";
@@ -87,8 +87,16 @@ function writeStore(repoRoot, store) {
   const temporary = join(dir, `.bindings.json.${randomBytes(12).toString("hex")}`);
   mkdirSync(dir, { recursive: true });
   try {
-    writeFileSync(temporary, `${JSON.stringify(store, null, 2)}\n`);
+    const fd = openSync(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 0o600);
+    try {
+      writeFileSync(fd, `${JSON.stringify(store, null, 2)}\n`);
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
     renameSync(temporary, path);
+    const directory = openSync(dir, constants.O_RDONLY);
+    try { fsyncSync(directory); } finally { closeSync(directory); }
   } catch (error) {
     rmSync(temporary, { force: true });
     throw error;
@@ -107,6 +115,24 @@ export function writeBinding(repoRoot, id, logicalPath, boundAt) {
   });
 }
 
+// Producers that establish a durable discovery root must not silently replace a
+// user-selected binding. This keeps first-run setup idempotent while preserving
+// the ordinary CLI's explicit replacement behavior above.
+export function writeBindingIfAbsent(repoRoot, id, logicalPath, boundAt) {
+  const safeId = ovenId(id);
+  if (typeof logicalPath !== "string" || logicalPath.length === 0) throw new Error("Oven binding path must be a non-empty string.");
+  if (!isTimestamp(boundAt)) throw new Error("Oven binding timestamp must be a valid ISO timestamp.");
+  return withRepoStateLock(repoRoot, () => {
+    const store = mutableBindingStore(repoRoot);
+    if (Object.hasOwn(store.bindings, safeId)) {
+      return { created: false, path: bindingStorePath(repoRoot), binding: store.bindings[safeId] };
+    }
+    store.bindings[safeId] = { path: logicalPath, boundAt };
+    writeStore(repoRoot, store);
+    return { created: true, path: bindingStorePath(repoRoot), binding: store.bindings[safeId] };
+  });
+}
+
 export function removeBinding(repoRoot, id) {
   const safeId = ovenId(id);
   return withRepoStateLock(repoRoot, () => {
diff --git a/src/server/oven-bindings.test.mjs b/src/server/oven-bindings.test.mjs
index 4882b8f..9077e44 100644
--- a/src/server/oven-bindings.test.mjs
+++ b/src/server/oven-bindings.test.mjs
@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import test from "node:test";
@@ -9,6 +10,7 @@ import {
   readBindingStore,
   removeBinding,
   writeBinding,
+  writeBindingIfAbsent,
 } from "./oven-bindings.mjs";
 
 const BOUND_AT = "2026-07-14T12:00:00.000Z";
@@ -42,6 +44,46 @@ test("binding stores round-trip logical paths atomically", () => {
   } finally { cleanup(); }
 });
 
+test("writeBindingIfAbsent preserves the first binding", () => {
+  const { root, cleanup } = fixture();
+  try {
+    const first = writeBindingIfAbsent(root, "sample-oven", "first.json", BOUND_AT);
+    const second = writeBindingIfAbsent(root, "sample-oven", "second.json", "2026-07-14T12:01:00.000Z");
+    assert.equal(first.created, true);
+    assert.equal(second.created, false);
+    assert.deepEqual(readBindingStore(root).bindings["sample-oven"], { path: "first.json", boundAt: BOUND_AT });
+  } finally { cleanup(); }
+});
+
+test("barrier-synchronized first writers create exactly one binding and preserve its path", async () => {
+  const { root, cleanup } = fixture();
+  const ready = join(root, "ready");
+  const go = join(root, "go");
+  const moduleUrl = new URL("./oven-bindings.mjs", import.meta.url).href;
+  const child = (logicalPath) => new Promise((resolveChild, reject) => {
+    const source = `import { existsSync, writeFileSync } from "node:fs"; import { writeBindingIfAbsent } from ${JSON.stringify(moduleUrl)}; const [root, path, ready, go] = process.argv.slice(1); writeFileSync(ready + "-" + process.pid, ""); while (!existsSync(go)) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10); process.stdout.write(JSON.stringify(writeBindingIfAbsent(root, "sample-oven", path, "${BOUND_AT}")));`;
+    const processChild = spawn(process.execPath, ["--input-type=module", "--eval", source, root, logicalPath, ready, go], { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    processChild.stdout.on("data", (chunk) => { stdout += chunk; });
+    processChild.stderr.on("data", (chunk) => { stderr += chunk; });
+    processChild.on("error", reject);
+    processChild.on("exit", (status) => status === 0 ? resolveChild(JSON.parse(stdout)) : reject(new Error(stderr)));
+  });
+  try {
+    const first = child("first.json");
+    const second = child("second.json");
+    for (let attempt = 0; attempt < 100 && readdirSync(root).filter((name) => name.startsWith("ready-")).length < 2; attempt += 1) await new Promise((resolveWait) => setTimeout(resolveWait, 5));
+    assert.equal(readdirSync(root).filter((name) => name.startsWith("ready-")).length, 2);
+    // Both children are waiting at the same barrier before either can write.
+    await new Promise((resolveWait) => setTimeout(resolveWait, 20));
+    writeFileSync(go, "go");
+    const results = await Promise.all([first, second]);
+    assert.equal(results.filter((result) => result.created).length, 1);
+    assert.equal(readBindingStore(root).bindings["sample-oven"].path, results.find((result) => result.created).binding.path);
+  } finally { cleanup(); }
+});
+
 test("missing, corrupt, and obsolete binding stores fail closed", () => {
   const { root, cleanup } = fixture();
   try {
@@ -68,6 +110,9 @@ test("binding mutations preserve malformed stores and create or update valid sto
     assert.equal(readFileSync(path, "utf8"), malformed);
     assert.throws(() => removeBinding(root, "sample-oven"), /Refusing to modify malformed Oven binding store/u);
     assert.equal(readFileSync(path, "utf8"), malformed);
+    assert.throws(() => writeBindingIfAbsent(root, "sample-oven", "lost.json", BOUND_AT), /Refusing to modify malformed Oven binding store/u);
+    writeFileSync(path, '{"schemaVersion":2,"bindings":{}}');
+    assert.throws(() => writeBindingIfAbsent(root, "sample-oven", "lost.json", BOUND_AT), /Refusing to modify malformed Oven binding store/u);
   } finally { cleanup(); }
 });
 
diff --git a/src/server/registry.mjs b/src/server/registry.mjs
index da649c7..18300e3 100644
--- a/src/server/registry.mjs
+++ b/src/server/registry.mjs
@@ -1,10 +1,10 @@
 import { createHash, randomBytes } from "node:crypto";
-import { linkSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { closeSync, constants, fsyncSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import os from "node:os";
-import { basename, isAbsolute, join, resolve } from "node:path";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { withDirectoryLock } from "./dir-lock.mjs";
 
 export const REGISTRY_SCHEMA_VERSION = 1;
-const LOCK_STALE_MS = 60_000;
 
 export class RegistryError extends Error {
   constructor(message, code) {
@@ -42,39 +42,28 @@ function validateRegistry(registry, path) {
   return registry;
 }
 
-function sleep(milliseconds) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
+function fsyncDirectory(path) {
+  const fd = openSync(path, constants.O_RDONLY);
+  try { fsyncSync(fd); } finally { closeSync(fd); }
 }
 
-function lockHolder(lock) {
+function writeDurableAtomic(path, value) {
+  const temporary = `${path}.${randomBytes(12).toString("hex")}.tmp`;
+  let fd;
   try {
-    const holder = JSON.parse(readFileSync(lock, "utf8"));
-    return Number.isInteger(holder?.pid) && holder.pid > 0 ? holder.pid : null;
-  } catch {
-    return null;
+    fd = openSync(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 0o600);
+    writeFileSync(fd, value);
+    fsyncSync(fd);
+    closeSync(fd);
+    fd = undefined;
+    renameSync(temporary, path);
+    fsyncDirectory(dirname(path));
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+    rmSync(temporary, { force: true });
   }
 }
 
-function isAlive(pid) {
-  if (!pid) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error?.code !== "ESRCH";
-  }
-}
-
-function lockIsStealable(lock) {
-  try {
-    if (Date.now() - statSync(lock).mtimeMs > LOCK_STALE_MS) return true;
-  } catch (error) {
-    if (error?.code === "ENOENT") return true;
-    throw error;
-  }
-  return !isAlive(lockHolder(lock));
-}
-
 export function readRegistry({ home = os.homedir() } = {}) {
   const path = registryPath(home);
   let text;
@@ -99,66 +88,17 @@ export function writeRegistry(registry, { home = os.homedir() } = {}) {
   mkdirSync(dir, { recursive: true });
   const roots = [...new Map(registry.roots.map((entry) => [entry.root, entry])).values()]
     .sort((left, right) => left.root.localeCompare(right.root));
-  const temp = join(dir, `.roots.json.${randomBytes(12).toString("hex")}`);
-  try {
-    writeFileSync(temp, `${JSON.stringify({ schemaVersion: REGISTRY_SCHEMA_VERSION, roots })}\n`);
-    renameSync(temp, path);
-  } catch (error) {
-    rmSync(temp, { force: true });
-    throw error;
-  }
+  writeDurableAtomic(path, `${JSON.stringify({ schemaVersion: REGISTRY_SCHEMA_VERSION, roots })}\n`);
 }
 
 export function withRegistryLock({ home = os.homedir() } = {}, fn) {
   const dir = registryDir(home);
   const lock = join(dir, "roots.lock");
-  const token = randomBytes(12).toString("hex");
-  const temp = join(dir, `.lock.${token}`);
-  const stale = join(dir, `.stale.${token}`);
-  let holderPid = null;
-  mkdirSync(dir, { recursive: true });
-  for (let attempt = 0; attempt < 50; attempt += 1) {
-    let acquired = false;
-    try {
-      writeFileSync(temp, JSON.stringify({ pid: process.pid, token, createdAt: Date.now() }), { flag: "wx" });
-      try {
-        linkSync(temp, lock);
-        acquired = true;
-      } catch (error) {
-        if (error?.code !== "EEXIST") throw error;
-      } finally {
-        rmSync(temp, { force: true });
-      }
-    } catch (error) {
-      rmSync(temp, { force: true });
-      throw error;
-    }
-    if (!acquired) {
-      holderPid = lockHolder(lock);
-      if (lockIsStealable(lock)) {
-        try {
-          renameSync(lock, stale);
-        } catch (error) {
-          if (error?.code === "ENOENT") continue;
-          throw error;
-        }
-        rmSync(stale, { force: true });
-        continue;
-      }
-      sleep(20);
-      continue;
-    }
-    try {
-      return fn();
-    } finally {
-      try {
-        if (JSON.parse(readFileSync(lock, "utf8")).token === token) rmSync(lock, { force: true });
-      } catch {
-        // A replaced or removed lock must not be released by this owner.
-      }
-    }
-  }
-  throw new RegistryError(`Registry is locked by pid ${holderPid ?? "unknown"}: ${lock}`, "ELOCKED");
+  return withDirectoryLock({
+    lockPath: lock,
+    fn,
+    errorFactory: ({ holderPid, lockPath }) => new RegistryError(`Registry is locked by pid ${holderPid ?? "unknown"}: ${lockPath}`, "ELOCKED"),
+  });
 }
 
 function canonicalRoot(rootInput, { missing = false } = {}) {
diff --git a/src/server/registry.test.mjs b/src/server/registry.test.mjs
index 8c5811a..e59588f 100644
--- a/src/server/registry.test.mjs
+++ b/src/server/registry.test.mjs
@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
-import { mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, symlinkSync, utimesSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { hostname, tmpdir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import test from "node:test";
@@ -15,6 +15,11 @@ function fixture() {
   return { home, cleanup: () => rmSync(home, { recursive: true, force: true }) };
 }
 
+function writeV2Lock(lock, { pid, host = hostname(), token = "a".repeat(64), createdAt = Date.now() } = {}) {
+  mkdirSync(lock, { recursive: true });
+  writeFileSync(join(lock, `owner-${token}.json`), `${JSON.stringify({ version: 1, pid, hostname: host, token, createdAt })}\n`);
+}
+
 test("fresh registry reads as empty", () => {
   const { home, cleanup } = fixture();
   try {
@@ -156,8 +161,7 @@ test("a stale lock can be stolen", () => {
   const { home, cleanup } = fixture();
   const root = mkdtempSync(join(tmpdir(), "burnlist-stale-"));
   try {
-    mkdirSync(registryDir(home), { recursive: true });
-    writeFileSync(join(registryDir(home), "roots.lock"), JSON.stringify({ pid: 2147483646, token: "x" }));
+    writeV2Lock(join(registryDir(home), "roots.lock"), { pid: 2147483646 });
     assert.equal(registerRoot(root, { home }).added, true);
   } finally { rmSync(root, { recursive: true, force: true }); cleanup(); }
 });
@@ -166,21 +170,39 @@ test("a live, fresh lock is not stolen", () => {
   const { home, cleanup } = fixture();
   const root = mkdtempSync(join(tmpdir(), "burnlist-live-lock-"));
   try {
-    mkdirSync(registryDir(home), { recursive: true });
-    writeFileSync(join(registryDir(home), "roots.lock"), JSON.stringify({ pid: process.pid, token: "live" }));
+    writeV2Lock(join(registryDir(home), "roots.lock"), { pid: process.pid });
     assert.throws(() => registerRoot(root, { home }), { code: "ELOCKED" });
   } finally { rmSync(root, { recursive: true, force: true }); cleanup(); }
 });
 
-test("an old lock with a live pid can be stolen", () => {
+test("an old lock with a live pid is not stolen", () => {
   const { home, cleanup } = fixture();
   const root = mkdtempSync(join(tmpdir(), "burnlist-old-lock-"));
   try {
-    mkdirSync(registryDir(home), { recursive: true });
     const lock = join(registryDir(home), "roots.lock");
-    writeFileSync(lock, JSON.stringify({ pid: process.pid, token: "old" }));
-    const oldDate = new Date(Date.now() - 61_000);
-    utimesSync(lock, oldDate, oldDate);
+    writeV2Lock(lock, { pid: process.pid, createdAt: Date.now() - 120_000 });
+    assert.throws(() => registerRoot(root, { home }), { code: "ELOCKED" });
+  } finally { rmSync(root, { recursive: true, force: true }); cleanup(); }
+});
+
+test("old registry recovery artifacts are ignored and foreign-host locks are respected", () => {
+  const { home, cleanup } = fixture();
+  const root = mkdtempSync(join(tmpdir(), "burnlist-recovery-"));
+  try {
+    const dead = 2147483646;
+    writeV2Lock(join(registryDir(home), "roots.lock"), { pid: dead });
+    writeFileSync(join(registryDir(home), ".roots.lock.recovery"), "old artifact");
+    assert.equal(registerRoot(root, { home }).added, true);
+    writeV2Lock(join(registryDir(home), "roots.lock"), { pid: dead, host: "foreign-host", createdAt: Date.now() - 60 * 60_000 });
+    assert.throws(() => unregisterRoot(root, { home }), { code: "ELOCKED" });
+  } finally { rmSync(root, { recursive: true, force: true }); cleanup(); }
+});
+
+test("an expired same-host live registry pid is reclaimable", () => {
+  const { home, cleanup } = fixture();
+  const root = mkdtempSync(join(tmpdir(), "burnlist-reused-pid-"));
+  try {
+    writeV2Lock(join(registryDir(home), "roots.lock"), { pid: process.pid, createdAt: Date.now() - 16 * 60_000 });
     assert.equal(registerRoot(root, { home }).added, true);
   } finally { rmSync(root, { recursive: true, force: true }); cleanup(); }
 });
diff --git a/src/server/repo-state.mjs b/src/server/repo-state.mjs
index 9ed9e2b..b09cb9f 100644
--- a/src/server/repo-state.mjs
+++ b/src/server/repo-state.mjs
@@ -1,17 +1,6 @@
-import { randomBytes } from "node:crypto";
-import {
-  linkSync,
-  mkdirSync,
-  readFileSync,
-  realpathSync,
-  renameSync,
-  rmSync,
-  statSync,
-  writeFileSync,
-} from "node:fs";
+import { realpathSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-
-const LOCK_STALE_MS = 60_000;
+import { withDirectoryLock } from "./dir-lock.mjs";
 
 export function repoStateDir(repoRoot) {
   return join(resolve(repoRoot), ".local", "burnlist");
@@ -54,87 +43,15 @@ export function containedJoin(repoRoot, ...segments) {
   return target;
 }
 
-function sleep(milliseconds) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
-}
-
-function lockHolder(lock) {
-  try {
-    const holder = JSON.parse(readFileSync(lock, "utf8"));
-    return Number.isInteger(holder?.pid) && holder.pid > 0 ? holder.pid : null;
-  } catch {
-    return null;
-  }
-}
-
-function isAlive(pid) {
-  if (!pid) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error?.code !== "ESRCH";
-  }
-}
-
-function lockIsStealable(lock) {
-  try {
-    if (Date.now() - statSync(lock).mtimeMs > LOCK_STALE_MS) return true;
-  } catch (error) {
-    if (error?.code === "ENOENT") return true;
-    throw error;
-  }
-  return !isAlive(lockHolder(lock));
-}
-
 export function withRepoStateLock(repoRoot, fn) {
-  const dir = containedJoin(repoRoot);
-  mkdirSync(dir, { recursive: true });
   const lock = containedJoin(repoRoot, ".lock");
-  const token = randomBytes(12).toString("hex");
-  const temp = containedJoin(repoRoot, `.lock.${token}`);
-  const stale = containedJoin(repoRoot, `.stale.${token}`);
-  let holderPid = null;
-  for (let attempt = 0; attempt < 50; attempt += 1) {
-    let acquired = false;
-    try {
-      writeFileSync(temp, JSON.stringify({ pid: process.pid, token, createdAt: Date.now() }), { flag: "wx" });
-      try {
-        linkSync(temp, lock);
-        acquired = true;
-      } catch (error) {
-        if (error?.code !== "EEXIST") throw error;
-      } finally {
-        rmSync(temp, { force: true });
-      }
-    } catch (error) {
-      rmSync(temp, { force: true });
-      throw error;
-    }
-    if (!acquired) {
-      holderPid = lockHolder(lock);
-      if (lockIsStealable(lock)) {
-        try {
-          renameSync(lock, stale);
-        } catch (error) {
-          if (error?.code === "ENOENT") continue;
-          throw error;
-        }
-        rmSync(stale, { force: true });
-        continue;
-      }
-      sleep(20);
-      continue;
-    }
-    try {
-      return fn();
-    } finally {
-      try {
-        if (JSON.parse(readFileSync(lock, "utf8")).token === token) rmSync(lock, { force: true });
-      } catch {
-        // A replaced or removed lock must not be released by this owner.
-      }
-    }
-  }
-  throw new Error(`Repo state is locked by pid ${holderPid ?? "unknown"}: ${lock}`);
+  return withDirectoryLock({
+    lockPath: lock,
+    fn,
+    errorFactory: ({ holderPid, lockPath }) => {
+      const error = new Error(`Repo state is locked by pid ${holderPid ?? "unknown"}: ${lockPath}`);
+      error.code = "ELOCKED";
+      return error;
+    },
+  });
 }
diff --git a/src/server/repo-state.test.mjs b/src/server/repo-state.test.mjs
index 632f934..00958a1 100644
--- a/src/server/repo-state.test.mjs
+++ b/src/server/repo-state.test.mjs
@@ -7,7 +7,6 @@ import {
   readFileSync,
   rmSync,
   symlinkSync,
-  utimesSync,
   writeFileSync,
 } from "node:fs";
 import os from "node:os";
@@ -22,6 +21,11 @@ function tempDir(t) {
   return path;
 }
 
+function writeV2Lock(lock, { pid, host = os.hostname(), token = "a".repeat(64), createdAt = Date.now() } = {}) {
+  mkdirSync(lock, { recursive: true });
+  writeFileSync(join(lock, `owner-${token}.json`), `${JSON.stringify({ version: 1, pid, hostname: host, token, createdAt })}\n`);
+}
+
 test("repoStateDir returns the repo-local state directory", (t) => {
   const repo = tempDir(t);
   assert.equal(repoStateDir(repo), join(repo, ".local", "burnlist"));
@@ -47,33 +51,65 @@ test("containedJoin rejects a .local symlink outside the repo", (t) => {
 test("withRepoStateLock refuses a fresh lock held by a live process", (t) => {
   const repo = tempDir(t);
   const lock = join(repoStateDir(repo), ".lock");
-  mkdirSync(dirname(lock), { recursive: true });
-  writeFileSync(lock, JSON.stringify({ pid: process.pid, token: "held", createdAt: Date.now() }));
+  writeV2Lock(lock, { pid: process.pid });
   assert.throws(() => withRepoStateLock(repo, () => assert.fail("lock must not be acquired")), /locked by pid/u);
 });
 
 test("withRepoStateLock steals a fresh lock whose holder is dead", (t) => {
   const repo = tempDir(t);
   const lock = join(repoStateDir(repo), ".lock");
-  mkdirSync(dirname(lock), { recursive: true });
   const dead = spawnSync(process.execPath, ["-e", ""]);
   assert.equal(dead.status, 0);
-  writeFileSync(lock, JSON.stringify({ pid: dead.pid, token: "dead", createdAt: Date.now() }));
+  writeV2Lock(lock, { pid: dead.pid });
   assert.equal(withRepoStateLock(repo, () => "returned"), "returned");
   assert.equal(existsSync(lock), false);
 });
 
-test("withRepoStateLock steals an aged lock and releases its own lock", (t) => {
+test("withRepoStateLock steals an aged lock whose holder is dead", (t) => {
   const repo = tempDir(t);
   const lock = join(repoStateDir(repo), ".lock");
-  mkdirSync(dirname(lock), { recursive: true });
-  writeFileSync(lock, JSON.stringify({ pid: process.pid, token: "aged", createdAt: Date.now() - 120_000 }));
-  const old = new Date(Date.now() - 61_000);
-  utimesSync(lock, old, old);
+  const dead = spawnSync(process.execPath, ["-e", ""]);
+  assert.equal(dead.status, 0);
+  writeV2Lock(lock, { pid: dead.pid, createdAt: Date.now() - 120_000 });
   assert.equal(withRepoStateLock(repo, () => 42), 42);
   assert.equal(existsSync(lock), false);
 });
 
+test("withRepoStateLock does not steal an aged lock held by a live process", (t) => {
+  const repo = tempDir(t);
+  const lock = join(repoStateDir(repo), ".lock");
+  writeV2Lock(lock, { pid: process.pid, createdAt: Date.now() - 120_000 });
+  assert.throws(() => withRepoStateLock(repo, () => assert.fail("lock must not be acquired")), /locked by pid/u);
+  assert.equal(existsSync(lock), true);
+});
+
+test("withRepoStateLock ignores old recovery artifacts", (t) => {
+  const repo = tempDir(t);
+  const state = repoStateDir(repo);
+  const lock = join(state, ".lock");
+  mkdirSync(state, { recursive: true });
+  const dead = spawnSync(process.execPath, ["-e", ""]);
+  writeV2Lock(lock, { pid: dead.pid });
+  writeFileSync(join(state, ".lock.recovery"), "arbitrary old artifact");
+  assert.equal(withRepoStateLock(repo, () => "recovered"), "recovered");
+  assert.equal(existsSync(join(state, ".lock.recovery")), true);
+});
+
+test("withRepoStateLock never steals a foreign-host lock and eventually breaks local pid reuse", (t) => {
+  const repo = tempDir(t);
+  const lock = join(repoStateDir(repo), ".lock");
+  writeV2Lock(lock, { pid: 1, host: "foreign-host", createdAt: Date.now() - 60 * 60_000 });
+  assert.throws(() => withRepoStateLock(repo, () => assert.fail("foreign lock must be respected")), { code: "ELOCKED" });
+  rmSync(lock, { recursive: true });
+  writeV2Lock(lock, { pid: process.pid, createdAt: Date.now() - 16 * 60_000 });
+  assert.equal(withRepoStateLock(repo, () => "reclaimed"), "reclaimed");
+});
+
+test("withRepoStateLock release cleanup does not mask a callback result", (t) => {
+  const repo = tempDir(t);
+  assert.equal(withRepoStateLock(repo, () => "sentinel"), "sentinel");
+});
+
 function completedChild(child) {
   return new Promise((resolve, reject) => {
     let stderr = "";
@@ -89,26 +125,31 @@ function completedChild(child) {
 test("withRepoStateLock serializes writers across processes", async (t) => {
   const repo = tempDir(t);
   const shared = join(repo, "shared.txt");
+  const metrics = join(repo, "metrics.json");
   const moduleUrl = pathToFileURL(join(dirname(fileURLToPath(import.meta.url)), "repo-state.mjs")).href;
   const script = `
     import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
     import { withRepoStateLock } from ${JSON.stringify(moduleUrl)};
-    const [repo, shared, writer] = process.argv.slice(1);
+    const [repo, shared, metrics, writer] = process.argv.slice(1);
     withRepoStateLock(repo, () => {
       const previous = existsSync(shared) ? readFileSync(shared, "utf8").trim().split(/\\n/u).filter(Boolean).length : 0;
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+      const state = existsSync(metrics) ? JSON.parse(readFileSync(metrics, "utf8")) : { active: 0, max: 0 };
+      state.active += 1; state.max = Math.max(state.max, state.active); writeFileSync(metrics, JSON.stringify(state));
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 30);
       appendFileSync(shared, writer + ":" + (previous + 1) + ":" + "x".repeat(4096) + "\\n");
+      state.active -= 1; writeFileSync(metrics, JSON.stringify(state));
     });
   `;
-  const children = Array.from({ length: 6 }, (_, index) => spawn(
+  const children = Array.from({ length: 8 }, (_, index) => spawn(
     process.execPath,
-    ["--input-type=module", "-e", script, repo, shared, String(index)],
+    ["--input-type=module", "-e", script, repo, shared, metrics, String(index)],
     { stdio: ["ignore", "ignore", "pipe"] },
   ));
   await Promise.all(children.map(completedChild));
   const lines = readFileSync(shared, "utf8").trim().split("\n");
-  assert.equal(lines.length, 6);
-  assert.deepEqual(lines.map((line) => Number(line.split(":", 3)[1])).sort((a, b) => a - b), [1, 2, 3, 4, 5, 6]);
-  for (const line of lines) assert.match(line, /^\d:[1-6]:x{4096}$/u);
+  assert.equal(lines.length, 8);
+  assert.deepEqual(lines.map((line) => Number(line.split(":", 3)[1])).sort((a, b) => a - b), [1, 2, 3, 4, 5, 6, 7, 8]);
+  for (const line of lines) assert.match(line, /^\d:[1-8]:x{4096}$/u);
+  assert.deepEqual(JSON.parse(readFileSync(metrics, "utf8")), { active: 0, max: 1 });
   assert.equal(existsSync(join(repoStateDir(repo), ".lock")), false);
 });