diff --git a/src-tauri/src/agent/tools.rs b/src-tauri/src/agent/tools.rs
index 67be466d5..3870961ec 100644
--- a/src-tauri/src/agent/tools.rs
+++ b/src-tauri/src/agent/tools.rs
@@ -1941,7 +1941,10 @@ fn provider_payload_error(provider: &str, value: &Value) -> Option<String> {
                 .and_then(Value::as_str)
                 .filter(|message| !message.trim().is_empty())
                 .unwrap_or("unknown API error");
-            return Some(format!("{provider} failed (code {}): {message}", code.unwrap_or(0)));
+            return Some(format!(
+                "{provider} failed (code {}): {message}",
+                code.unwrap_or(0)
+            ));
         }
     }
     if provider == "Brave Search" && value.get("web").is_none() {
diff --git a/src/lib/index-generator.test.ts b/src/lib/index-generator.test.ts
new file mode 100644
index 000000000..72ed42e9d
--- /dev/null
+++ b/src/lib/index-generator.test.ts
@@ -0,0 +1,151 @@
+import { describe, it, expect } from "vitest"
+import {
+  generateIndexMd,
+  extractIndexDescription,
+  buildLogEntry,
+  type IndexInputPage,
+} from "./index-generator"
+
+function page(relativePath: string, frontmatter: Record<string, string>, body: string): IndexInputPage {
+  const fm = Object.entries(frontmatter)
+    .map(([k, v]) => `${k}: ${v}`)
+    .join("\n")
+  return { relativePath, content: `---\n${fm}\n---\n\n${body}` }
+}
+
+describe("generateIndexMd", () => {
+  it("groups pages by type in a stable display order", () => {
+    const pages: IndexInputPage[] = [
+      page("wiki/concepts/cot.md", { type: "concept", title: "Chain of Thought" }, "# Chain of Thought\n\nA prompting technique."),
+      page("wiki/entities/openai.md", { type: "entity", title: "OpenAI" }, "# OpenAI\n\nAn AI research company."),
+      page("wiki/sources/wei-2022.md", { type: "source", title: "Wei 2022" }, "# Wei 2022\n\nA paper on CoT."),
+    ]
+    const out = generateIndexMd(pages, { date: "2026-06-27" })
+    // Entities before Concepts before Sources
+    const entIdx = out.indexOf("## Entities")
+    const conIdx = out.indexOf("## Concepts")
+    const srcIdx = out.indexOf("## Sources")
+    expect(entIdx).toBeGreaterThan(-1)
+    expect(entIdx).toBeLessThan(conIdx)
+    expect(conIdx).toBeLessThan(srcIdx)
+  })
+
+  it("emits `- [[slug]] — description` entries using the first body sentence", () => {
+    const pages = [
+      page("wiki/entities/openai.md", { type: "entity", title: "OpenAI" }, "# OpenAI\n\nAn AI research company. Founded in 2015."),
+    ]
+    const out = generateIndexMd(pages, { date: "2026-06-27" })
+    expect(out).toContain("- [[openai]] — An AI research company.")
+  })
+
+  it("includes a deterministic overview-typed frontmatter header", () => {
+    const out = generateIndexMd([], { date: "2026-06-27" })
+    expect(out).toMatch(/^---\ntype: overview\ntitle: Wiki Index\n/)
+    expect(out).toContain("created: 2026-06-27")
+    expect(out).toContain("updated: 2026-06-27")
+    expect(out).toContain("# Wiki Index")
+  })
+
+  it("carries an existing created date forward, refreshing only updated", () => {
+    const out = generateIndexMd([], { date: "2026-06-27", created: "2026-01-05" })
+    expect(out).toContain("created: 2026-01-05")
+    expect(out).toContain("updated: 2026-06-27")
+  })
+
+  it("falls back to the ingest date when created is absent or blank", () => {
+    expect(generateIndexMd([], { date: "2026-06-27", created: "   " })).toContain(
+      "created: 2026-06-27",
+    )
+  })
+
+  it("excludes index.md, log.md, and overview.md themselves", () => {
+    const pages = [
+      page("wiki/index.md", { type: "overview", title: "Wiki Index" }, "# Wiki Index"),
+      page("wiki/log.md", { type: "overview", title: "Log" }, "# Log"),
+      page("wiki/overview.md", { type: "overview", title: "Overview" }, "# Overview\n\nSummary."),
+      page("wiki/entities/foo.md", { type: "entity", title: "Foo" }, "# Foo\n\nA thing."),
+    ]
+    const out = generateIndexMd(pages, { date: "2026-06-27" })
+    expect(out).toContain("- [[foo]]")
+    expect(out).not.toContain("[[index]]")
+    expect(out).not.toContain("[[log]]")
+    expect(out).not.toContain("[[overview]]")
+  })
+
+  it("infers type from path when frontmatter type is missing", () => {
+    const pages: IndexInputPage[] = [
+      { relativePath: "wiki/entities/bar.md", content: "---\ntitle: Bar\n---\n\n# Bar\n\nAn entity." },
+    ]
+    const out = generateIndexMd(pages, { date: "2026-06-27" })
+    expect(out).toContain("## Entities")
+    expect(out).toContain("- [[bar]] — An entity.")
+  })
+
+  it("sorts entries within a type alphabetically by slug", () => {
+    const pages = [
+      page("wiki/entities/zebra.md", { type: "entity", title: "Zebra" }, "# Zebra\n\nLast."),
+      page("wiki/entities/alpha.md", { type: "entity", title: "Alpha" }, "# Alpha\n\nFirst."),
+    ]
+    const out = generateIndexMd(pages, { date: "2026-06-27" })
+    expect(out.indexOf("[[alpha]]")).toBeLessThan(out.indexOf("[[zebra]]"))
+  })
+
+  it("falls back to a placeholder when there are no pages", () => {
+    const out = generateIndexMd([], { date: "2026-06-27" })
+    expect(out).toContain("_No pages yet._")
+  })
+
+  it("places custom/unknown types after known types, alphabetically", () => {
+    const pages = [
+      page("wiki/entities/foo.md", { type: "entity", title: "Foo" }, "# Foo\n\nE."),
+      page("wiki/people/jane.md", { type: "people", title: "Jane" }, "# Jane\n\nP."),
+    ]
+    const out = generateIndexMd(pages, { date: "2026-06-27" })
+    expect(out.indexOf("## Entities")).toBeLessThan(out.indexOf("## People"))
+  })
+})
+
+describe("extractIndexDescription", () => {
+  it("takes the first sentence of the body", () => {
+    expect(extractIndexDescription("# Title\n\nFirst sentence. Second sentence.", "Title", "slug")).toBe("First sentence.")
+  })
+
+  it("skips headings, comments, blockquotes, and lists", () => {
+    const body = "# Heading\n\n<!-- comment -->\n\n> placeholder\n\n- a list item\n\nReal prose here."
+    expect(extractIndexDescription(body, "Title", "slug")).toBe("Real prose here.")
+  })
+
+  it("flattens wikilinks and markdown to plain text", () => {
+    const body = "# T\n\nSee [[other-page|the other page]] and **bold** `code`."
+    expect(extractIndexDescription(body, "T", "slug")).toBe("See the other page and bold code.")
+  })
+
+  it("falls back to title when the body has no prose", () => {
+    expect(extractIndexDescription("# Only Heading", "My Title", "slug")).toBe("My Title")
+  })
+
+  it("falls back to a de-slugified slug when title is empty too", () => {
+    expect(extractIndexDescription("", "", "my-page-slug")).toBe("my page slug")
+  })
+
+  it("truncates very long sentences", () => {
+    const long = "x".repeat(300) + "."
+    const out = extractIndexDescription(`# T\n\n${long}`, "T", "slug")
+    expect(out.length).toBeLessThanOrEqual(200)
+    expect(out.endsWith("…")).toBe(true)
+  })
+})
+
+describe("buildLogEntry", () => {
+  it("formats a log line with date and title", () => {
+    expect(buildLogEntry("2026-06-27", "My Source")).toBe("## [2026-06-27] ingest | My Source")
+  })
+
+  it("collapses whitespace in the title", () => {
+    expect(buildLogEntry("2026-06-27", "  My   Source  ")).toBe("## [2026-06-27] ingest | My Source")
+  })
+
+  it("uses a placeholder for an empty title", () => {
+    expect(buildLogEntry("2026-06-27", "")).toBe("## [2026-06-27] ingest | (untitled source)")
+  })
+})
diff --git a/src/lib/index-generator.ts b/src/lib/index-generator.ts
new file mode 100644
index 000000000..265e36cb0
--- /dev/null
+++ b/src/lib/index-generator.ts
@@ -0,0 +1,256 @@
+/**
+ * Deterministic wiki/index.md and wiki/log.md generation.
+ *
+ * Why this exists: ingest used to ask the LLM to emit an updated
+ * index.md (full file) and a log.md entry on every wave. Because the
+ * Claude/Codex CLI transports are stateless and the HTTP providers see
+ * only a snapshot of the current index, the model routinely dropped
+ * existing index entries, re-referenced deleted pages, or echoed the
+ * entire log (which the append-only writer then duplicated). The index
+ * is fully derivable from each page's frontmatter, so we generate it
+ * from disk instead — the LLM never writes it. The log is append-only
+ * and its single new line is composed here from the ingest date + the
+ * source title rather than trusted to the model.
+ *
+ * These functions are pure (string in, string out); the caller in
+ * ingest.ts is responsible for reading every page off disk and writing
+ * the result back inside the project lock.
+ */
+
+import { parseFrontmatter } from "@/lib/frontmatter"
+import { inferWikiTypeFromPath, wikiTypeLabel } from "@/lib/wiki-page-types"
+import { normalizePath, getFileName } from "@/lib/path-utils"
+
+export interface IndexInputPage {
+  /** Wiki-root-relative path, e.g. "wiki/entities/foo.md". */
+  relativePath: string
+  content: string
+}
+
+/** Display order for known page types; unknown/custom types follow,
+ * sorted alphabetically. Mirrors WIKI_TYPE_DIRS ordering in
+ * wiki-page-types.ts so the rendered index is stable run-to-run. */
+const TYPE_DISPLAY_ORDER = [
+  "entity",
+  "concept",
+  "source",
+  "query",
+  "comparison",
+  "synthesis",
+  "finding",
+  "thesis",
+  "methodology",
+]
+
+// Aggregate / structural files that are never themselves index entries.
+// schema.md and purpose.md are project-scaffolding pages (some projects
+// place them under wiki/); excluding them by basename keeps stray
+// `[[schema]]` / `[[purpose]]` entries out of the index.
+const EXCLUDED_BASENAMES = new Set([
+  "index.md",
+  "log.md",
+  "overview.md",
+  "schema.md",
+  "purpose.md",
+])
+
+interface IndexEntry {
+  slug: string
+  type: string
+  description: string
+}
+
+/**
+ * Build the complete wiki/index.md content deterministically from the
+ * frontmatter + first body sentence of every content page.
+ *
+ * Pages are grouped by type (entity, concept, …) in a stable order;
+ * each entry is `- [[slug]] — description`. The slug is the page's
+ * filename without extension so it resolves as an Obsidian wikilink.
+ *
+ * `opts.created` carries the existing index's creation date forward:
+ * the file is rewritten wholesale every wave, so without it `created`
+ * would be stamped to the current date each run and never mean
+ * anything but "last ingest". Omit it for a brand-new index, where
+ * `opts.date` is the creation date.
+ */
+export function generateIndexMd(
+  pages: IndexInputPage[],
+  opts: { date: string; created?: string },
+): string {
+  const entries: IndexEntry[] = []
+  for (const page of pages) {
+    const rel = normalizePath(page.relativePath)
+    const baseName = getFileName(rel).toLowerCase()
+    if (EXCLUDED_BASENAMES.has(baseName)) continue
+    if (!rel.endsWith(".md")) continue
+    // Source summary pages live under wiki/sources/ and ARE indexed
+    // (type "source"); only the three aggregate files above are skipped.
+
+    const { frontmatter, body } = parseFrontmatter(page.content)
+    const slug = getFileName(rel).replace(/\.md$/i, "")
+    if (!slug) continue
+
+    const fmType =
+      typeof frontmatter?.type === "string" ? frontmatter.type.trim() : ""
+    const type = fmType || inferWikiTypeFromPath(rel) || "other"
+    // overview-typed stray pages (other than overview.md, already
+    // excluded) shouldn't appear as index entries either.
+    if (type === "overview") continue
+
+    const title =
+      typeof frontmatter?.title === "string" ? frontmatter.title.trim() : ""
+    const description = extractIndexDescription(body, title, slug)
+    entries.push({ slug, type, description })
+  }
+
+  // Group by type.
+  const byType = new Map<string, IndexEntry[]>()
+  for (const entry of entries) {
+    const bucket = byType.get(entry.type) ?? []
+    bucket.push(entry)
+    byType.set(entry.type, bucket)
+  }
+
+  const orderedTypes = [...byType.keys()].sort(compareTypes)
+
+  const sections: string[] = []
+  for (const type of orderedTypes) {
+    const bucket = byType.get(type)
+    if (!bucket || bucket.length === 0) continue
+    bucket.sort((a, b) => a.slug.localeCompare(b.slug))
+    const heading = pluralizeTypeLabel(type)
+    const lines = bucket.map((entry) =>
+      entry.description
+        ? `- [[${entry.slug}]] — ${entry.description}`
+        : `- [[${entry.slug}]]`,
+    )
+    sections.push(`## ${heading}\n\n${lines.join("\n")}`)
+  }
+
+  const frontmatter = [
+    "---",
+    "type: overview",
+    "title: Wiki Index",
+    "tags: []",
+    "related: []",
+    `created: ${opts.created?.trim() || opts.date}`,
+    `updated: ${opts.date}`,
+    "---",
+  ].join("\n")
+
+  const body =
+    sections.length > 0
+      ? sections.join("\n\n")
+      : "_No pages yet._"
+
+  return `${frontmatter}\n\n# Wiki Index\n\n${body}\n`
+}
+
+/** Order known types by TYPE_DISPLAY_ORDER, then unknown types A→Z. */
+function compareTypes(a: string, b: string): number {
+  const ia = TYPE_DISPLAY_ORDER.indexOf(a)
+  const ib = TYPE_DISPLAY_ORDER.indexOf(b)
+  if (ia !== -1 && ib !== -1) return ia - ib
+  if (ia !== -1) return -1
+  if (ib !== -1) return 1
+  return a.localeCompare(b)
+}
+
+/** Section heading for a type: known labels pluralized, custom types
+ * title-cased via wikiTypeLabel. */
+function pluralizeTypeLabel(type: string): string {
+  switch (type) {
+    case "entity":
+      return "Entities"
+    case "concept":
+      return "Concepts"
+    case "source":
+      return "Sources"
+    case "query":
+      return "Queries"
+    case "comparison":
+      return "Comparisons"
+    case "synthesis":
+      return "Synthesis"
+    case "finding":
+      return "Findings"
+    case "thesis":
+      return "Theses"
+    case "methodology":
+      return "Methodologies"
+    case "other":
+      return "Other"
+    default:
+      return wikiTypeLabel(type)
+  }
+}
+
+const MAX_DESCRIPTION_CHARS = 200
+
+/**
+ * Derive a one-line description for an index entry: the first sentence
+ * of the page body, falling back to the title, then the slug. Markdown
+ * decoration (wikilinks, links, emphasis, inline code) is flattened to
+ * plain text so the index line stays readable.
+ */
+export function extractIndexDescription(
+  body: string,
+  title: string,
+  slug: string,
+): string {
+  const firstSentence = firstBodySentence(body)
+  const chosen = firstSentence || title || slug.replace(/[-_]+/g, " ")
+  return truncate(flattenInlineMarkdown(chosen), MAX_DESCRIPTION_CHARS)
+}
+
+/** Pull the first prose sentence from a markdown body, skipping the H1
+ * heading, blank lines, HTML comments, and block markup. */
+function firstBodySentence(body: string): string {
+  const lines = body.split(/\r?\n/)
+  for (const raw of lines) {
+    const line = raw.trim()
+    if (!line) continue
+    if (line.startsWith("#")) continue // headings (incl. the H1)
+    if (line.startsWith("<!--")) continue // HTML comments
+    if (line.startsWith("---")) continue // stray fences / hrules
+    if (line.startsWith("```")) continue // code fences
+    if (line.startsWith(">")) continue // blockquote placeholders
+    if (/^[-*+]\s/.test(line)) continue // list items (rarely a good summary)
+    if (/^\|/.test(line)) continue // table rows
+    // Found a prose line. Take up to the first sentence terminator.
+    const sentence = line.match(/^(.+?[.!?])(?:\s|$)/)
+    return sentence ? sentence[1] : line
+  }
+  return ""
+}
+
+/** Strip inline markdown so a description renders as clean text. */
+function flattenInlineMarkdown(text: string): string {
+  return text
+    // [[target|alias]] → alias ; [[target]] → target
+    .replace(/\[\[([^\]|]+)\|([^\]]+)\]\]/g, "$2")
+    .replace(/\[\[([^\]]+)\]\]/g, "$1")
+    // [label](url) → label
+    .replace(/\[([^\]]+)\]\([^)]*\)/g, "$1")
+    // **bold** / *italic* / _italic_ / `code`
+    .replace(/[*_`]+/g, "")
+    .replace(/\s+/g, " ")
+    .trim()
+}
+
+function truncate(text: string, max: number): string {
+  if (text.length <= max) return text
+  return `${text.slice(0, max - 1).trimEnd()}…`
+}
+
+/**
+ * Build the single log.md line for an ingest. Append-only: the caller
+ * concatenates this onto the existing log, never rewriting prior
+ * entries. Format matches the historical LLM-emitted shape so existing
+ * logs stay consistent: `## [YYYY-MM-DD] ingest | Title`.
+ */
+export function buildLogEntry(date: string, title: string): string {
+  const clean = title.trim().replace(/\s+/g, " ") || "(untitled source)"
+  return `## [${date}] ingest | ${clean}`
+}
diff --git a/src/lib/ingest-parse.test.ts b/src/lib/ingest-parse.test.ts
index 60cd06272..8a3962c36 100644
--- a/src/lib/ingest-parse.test.ts
+++ b/src/lib/ingest-parse.test.ts
@@ -22,14 +22,11 @@ import {
   parseFileBlocks,
   isSafeIngestPath,
   stampGeneratedFrontmatterDates,
-  stampGeneratedLogDate,
   buildGenerationPrompt,
   sourceSummaryMediaRefsForExternalMarkdown,
-  buildDeterministicIngestLog,
   rewriteIngestPathFromTitleForTargetLanguage,
   canonicalizeSourcesField,
   isAppManagedAggregatePath,
-  updateBoundedRecentIndexSection,
   filterTruncatedFileRepairOutput,
 } from "./ingest"
 
@@ -112,18 +109,6 @@ describe("source summary media refs", () => {
   })
 })
 
-describe("deterministic ingest log", () => {
-  it("builds a deterministic append-only log entry without another LLM call", () => {
-    expect(buildDeterministicIngestLog("", "raw/sources/a.pdf", "2026-07-20")).toBe(
-      "# Wiki Log\n\n## [2026-07-20] ingest | raw/sources/a.pdf\n",
-    )
-    expect(buildDeterministicIngestLog("# Wiki Log\n", "raw/sources/b.pdf", "2026-07-20")).toBe(
-      "# Wiki Log\n\n## [2026-07-20] ingest | raw/sources/b.pdf\n",
-    )
-  })
-
-})
-
 // ── H1: CRLF normalization ─────────────────────────────────────────
 
 describe("parseFileBlocks — H1: CRLF line endings", () => {
@@ -582,13 +567,6 @@ describe("generated ingest dates", () => {
     expect(out).toContain("updated: 2026-06-07")
   })
 
-  it("stamps generated log headings to the application date", () => {
-    expect(stampGeneratedLogDate("## [2024-01-01] ingest | Foo", "2026-06-07"))
-      .toBe("## [2026-06-07] ingest | Foo")
-    expect(stampGeneratedLogDate("## [YYYY-MM-DD] ingest | Foo", "2026-06-07"))
-      .toBe("## [2026-06-07] ingest | Foo")
-  })
-
   it("tells the model the exact current date in the generation prompt", () => {
     const prompt = buildGenerationPrompt("", "", "", "paper.pdf")
 
@@ -666,21 +644,4 @@ describe("application-managed aggregate boundaries", () => {
     expect(isAppManagedAggregatePath("wiki\\overview.MD")).toBe(true)
     expect(isAppManagedAggregatePath("wiki/entities/index.md")).toBe(false)
   })
-
-  it("bounds recent entries and preserves following sections", () => {
-    const existing = [
-      "# Wiki Index",
-      "",
-      "## Recently Updated",
-      ...Array.from({ length: 205 }, (_, index) => `- [[old-${index}]] — Old ${index}`),
-      "",
-      "## Other",
-      "Keep me",
-    ].join("\n")
-    const result = updateBoundedRecentIndexSection(existing, ["- [[new]] — New"])
-    const recent = result.split("## Recently Updated")[1].split("## Other")[0]
-    expect(recent.match(/^- \[\[/gm)).toHaveLength(200)
-    expect(recent).toContain("[[new]]")
-    expect(result).toContain("## Other\nKeep me")
-  })
 })
diff --git a/src/lib/ingest.scenarios.test.ts b/src/lib/ingest.scenarios.test.ts
index b9d1e9031..90b5d6c29 100644
--- a/src/lib/ingest.scenarios.test.ts
+++ b/src/lib/ingest.scenarios.test.ts
@@ -157,6 +157,17 @@ async function assertOutcome(
     }
   }
 
+  // 2b. Forbidden substrings must NOT appear (drop-guard assertions)
+  if (expected.fileExcludes) {
+    for (const [relPath, substrs] of Object.entries(expected.fileExcludes)) {
+      const full = path.join(tmpPath, relPath)
+      const content = await readFileRaw(full)
+      for (const sub of substrs) {
+        expect(content, `${relPath} unexpectedly contains "${sub}"`).not.toContain(sub)
+      }
+    }
+  }
+
   // 3. Review store has the expected items
   const expectedReviews = expected.reviewsCreated ?? []
   const actualReviews = useReviewStore.getState().items
diff --git a/src/lib/ingest.ts b/src/lib/ingest.ts
index 2e3af438c..e6fbe903e 100644
--- a/src/lib/ingest.ts
+++ b/src/lib/ingest.ts
@@ -30,6 +30,7 @@ import { mergePageContent, type MergeFn } from "@/lib/page-merge"
 import { withProjectLock } from "@/lib/project-mutex"
 import { parseFrontmatter } from "@/lib/frontmatter"
 import { makeQuerySlug } from "@/lib/wiki-filename"
+import { generateIndexMd, buildLogEntry, type IndexInputPage } from "@/lib/index-generator"
 import type { FileNode } from "@/types/wiki"
 import {
   extractAndSaveSourceImages,
@@ -55,7 +56,6 @@ const INGEST_GENERATION_TOKENS_256K = 24_576
 const INGEST_GENERATION_TOKENS_512K = 32_768
 const REVIEW_STAGE_MIN_SIGNAL_CHARS = 10_000
 const REVIEW_STAGE_MIN_FILE_BLOCKS = 4
-const AGGREGATE_WIKI_PATHS = ["wiki/index.md", "wiki/overview.md", "wiki/log.md"] as const
 
 function appendSavedImageRefsForCaption(content: string, images: SavedImage[]): string {
   if (images.length === 0) return content
@@ -606,17 +606,6 @@ export function formatIngestWarningLogEntry(
   ].join("\n")
 }
 
-export function buildDeterministicIngestLog(
-  existing: string,
-  sourceIdentity: string,
-  date = currentWikiDate(),
-): string {
-  const entry = `## [${date}] ingest | ${sourceIdentity}`
-  return existing.trim()
-    ? `${existing.trimEnd()}\n\n${entry}\n`
-    : `# Wiki Log\n\n${entry}\n`
-}
-
 async function appendIngestWarningLog(
   projectPath: string,
   sourceIdentity: string,
@@ -1231,48 +1220,6 @@ async function autoIngestImpl(
     }
   }
 
-  try {
-    if (await updateWikiIndexDeterministically(pp, writtenPaths)) {
-      writtenPaths.push("wiki/index.md")
-      onFileWritten?.("wiki/index.md")
-    }
-  } catch (err) {
-    writeWarnings.push(
-      `Deterministic index update failed: ${err instanceof Error ? err.message : String(err)}`,
-    )
-  }
-
-  // log.md is append-only structural metadata. If the model omitted its FILE
-  // block, write a deterministic entry instead of starting another LLM turn.
-  // This keeps multi-file imports at two generation stages per source and
-  // prevents a slow provider from making the queue appear stuck in "repair".
-  if (!writtenPaths.some((path) => normalizePath(path).toLowerCase() === "wiki/log.md") && !signal?.aborted) {
-    try {
-      const logPath = `${pp}/wiki/log.md`
-      const existingLog = await tryReadFile(logPath)
-      await writeFile(logPath, buildDeterministicIngestLog(existingLog, sourceIdentity))
-      writtenPaths.push("wiki/log.md")
-      onFileWritten?.("wiki/log.md")
-    } catch (err) {
-      writeWarnings.push(
-        `Deterministic log update failed: ${err instanceof Error ? err.message : String(err)}`,
-      )
-    }
-  }
-
-  // Surface parser / writer warnings to the activity panel so users
-  // don't have to open devtools to find out a block was dropped.
-  // Keeping the base "Writing files..." detail on top and appending the
-  // first few warnings; full list is also persisted to .llm-wiki.
-  let warningSummary = ""
-  if (writeWarnings.length > 0) {
-    await appendIngestWarningLog(pp, sourceIdentity, writeWarnings)
-    warningSummary = writeWarnings.length === 1
-      ? writeWarnings[0]
-      : `${writeWarnings.length} ingest warnings: ${writeWarnings.slice(0, 2).join(" · ")}${writeWarnings.length > 2 ? ` … (+${writeWarnings.length - 2} more in .llm-wiki/ingest-warnings.log)` : ""}`
-    activity.updateItem(activityId, { detail: `${warningSummary} — saved to .llm-wiki/ingest-warnings.log` })
-  }
-
   // Ensure source summary page exists (LLM may not have generated it correctly)
   const sourceSummaryFullPath = `${pp}/${sourceSummaryPath}`
   const hasSourceSummary = writtenPaths.some((p) => normalizePath(p) === sourceSummaryPath)
@@ -1304,6 +1251,39 @@ async function autoIngestImpl(
     await injectImagesIntoSourceSummary(pp, sourceIdentity, sourceSummarySlug, savedImages)
   }
 
+  // ── Step 3.6: Regenerate deterministic aggregate files ──────────
+  // index.md and log.md are NOT written by the LLM (their blocks were
+  // dropped in writeFileBlocks). Now that every content page for this
+  // source is on disk, rebuild index.md from all page frontmatter and
+  // append a single log line. Runs inside the project lock (autoIngest
+  // wraps this), so "last writer regenerates from disk" is race-free.
+  if (writtenPaths.length > 0 && !signal?.aborted) {
+    try {
+      const logTitle = await sourceSummaryTitle(sourceSummaryFullPath, sourceIdentity)
+      const aggregateWarnings = await regenerateAggregateFiles(pp, logTitle, currentWikiDate())
+      writeWarnings.push(...aggregateWarnings)
+    } catch (err) {
+      // Non-fatal: a failed index/log regen shouldn't fail the ingest.
+      const msg = `Aggregate file regeneration failed: ${err instanceof Error ? err.message : String(err)}`
+      console.warn(`[ingest] ${msg}`)
+      writeWarnings.push(msg)
+    }
+  }
+
+  // Surface parser / writer / aggregate warnings to the activity panel so
+  // users don't have to open devtools to find out a block was dropped or
+  // aggregate regen failed. Runs AFTER Step 3.6 so late-added warnings
+  // (from regenerateAggregateFiles) are included in both the log and the
+  // activity detail. Full list is also persisted to .llm-wiki.
+  let warningSummary = ""
+  if (writeWarnings.length > 0) {
+    await appendIngestWarningLog(pp, sourceIdentity, writeWarnings)
+    warningSummary = writeWarnings.length === 1
+      ? writeWarnings[0]
+      : `${writeWarnings.length} ingest warnings: ${writeWarnings.slice(0, 2).join(" · ")}${writeWarnings.length > 2 ? ` … (+${writeWarnings.length - 2} more in .llm-wiki/ingest-warnings.log)` : ""}`
+    activity.updateItem(activityId, { detail: `${warningSummary} — saved to .llm-wiki/ingest-warnings.log` })
+  }
+
   if (writtenPaths.length > 0) {
     try {
       await refreshProjectFileTree(pp, { bumpDataVersion: true })
@@ -1416,6 +1396,10 @@ function isLogPath(relativePath: string): boolean {
   return relativePath === "wiki/log.md" || relativePath.endsWith("/log.md")
 }
 
+function isIndexPath(relativePath: string): boolean {
+  return relativePath === "wiki/index.md" || relativePath.endsWith("/index.md")
+}
+
 function isListingPath(relativePath: string): boolean {
   return (
     relativePath === "wiki/index.md" ||
@@ -1472,63 +1456,6 @@ export function rewriteIngestPathFromTitleForTargetLanguage(
   return isSafeIngestPath(nextPath) ? nextPath : relativePath
 }
 
-async function updateWikiIndexDeterministically(
-  projectPath: string,
-  writtenPaths: string[],
-): Promise<boolean> {
-  const candidates = Array.from(new Set(writtenPaths.map(normalizePath))).filter((path) =>
-    path.startsWith("wiki/")
-      && path.endsWith(".md")
-      && !AGGREGATE_WIKI_PATHS.includes(path as (typeof AGGREGATE_WIKI_PATHS)[number]),
-  )
-  if (candidates.length === 0) return false
-
-  const indexPath = `${projectPath}/wiki/index.md`
-  const index = await readFile(indexPath).catch(() => "# Wiki Index\n")
-  const knownTargets = new Set(
-    Array.from(index.matchAll(/\[\[([^\]|#]+)(?:#[^\]|]+)?(?:\|[^\]]+)?\]\]/g))
-      .map((match) => normalizeIndexTarget(match[1])),
-  )
-  const additions: string[] = []
-  for (const path of candidates) {
-    const target = path.replace(/^wiki\//, "").replace(/\.md$/i, "")
-    if (knownTargets.has(normalizeIndexTarget(target))) continue
-    const content = await readFile(`${projectPath}/${path}`).catch(() => "")
-    const parsed = parseFrontmatter(content)
-    const title = typeof parsed.frontmatter?.title === "string"
-      ? parsed.frontmatter.title.trim()
-      : getFileName(path).replace(/\.md$/i, "")
-    additions.push(`- [[${target}]] — ${title}`)
-  }
-  if (additions.length === 0) return false
-
-  await writeFile(indexPath, updateBoundedRecentIndexSection(index, additions))
-  return true
-}
-
-function normalizeIndexTarget(target: string): string {
-  return normalizePath(target)
-    .replace(/^wiki\//i, "")
-    .replace(/\.md$/i, "")
-    .toLowerCase()
-}
-
-export function updateBoundedRecentIndexSection(index: string, additions: string[]): string {
-  const section = "## Recently Updated"
-  const lines = index.trimEnd().split("\n")
-  const start = lines.findIndex((line) => line.trim() === section)
-  const prefix = start >= 0 ? lines.slice(0, start) : lines
-  const sectionEnd = start >= 0
-    ? lines.findIndex((line, position) => position > start && /^##\s+/.test(line))
-    : -1
-  const existing = start >= 0
-    ? lines.slice(start + 1, sectionEnd >= 0 ? sectionEnd : undefined).filter((line) => /^-\s+/.test(line))
-    : []
-  const suffix = sectionEnd >= 0 ? lines.slice(sectionEnd) : []
-  const recent = Array.from(new Set([...additions, ...existing])).slice(0, 200)
-  return [...prefix, "", section, ...recent, ...(suffix.length ? ["", ...suffix] : []), ""].join("\n")
-}
-
 function isValidSourceReference(source: string, activeSourceIdentity: string): boolean {
   const normalized = normalizePath(source).replace(/^(?:\.\/)+/, "")
   const key = normalized.toLowerCase()
@@ -1766,17 +1693,6 @@ export function stampGeneratedFrontmatterDates(content: string, date: string): s
   return `${match[1]}${payload}${match[3]}${content.slice(match[0].length)}`
 }
 
-export function stampGeneratedLogDate(content: string, date: string): string {
-  const normalized = content.replace(/\bYYYY-MM-DD\b/g, date)
-  if (/^\s*##\s*\[?\d{4}-\d{2}-\d{2}\]?/m.test(normalized)) {
-    return normalized.replace(
-      /^(\s*##\s*\[?)\d{4}-\d{2}-\d{2}(\]?)/m,
-      `$1${date}$2`,
-    )
-  }
-  return normalized
-}
-
 function setOrAppendFrontmatterDate(payload: string, key: "created" | "updated", date: string): string {
   const lineRe = new RegExp(`(^|\\n)(${key}\\s*:\\s*)[^\\n\\r]*`, "i")
   if (lineRe.test(payload)) {
@@ -1835,6 +1751,18 @@ async function writeFileBlocks(
       continue
     }
 
+    // index.md and log.md are generated deterministically after all
+    // content pages land (see regenerateAggregateFiles). Drop any
+    // blocks the model emitted for them — this is what stops the LLM
+    // from clobbering the index (dropping existing entries) or
+    // duplicating the entire log on every wave.
+    if (isIndexPath(relativePath) || isLogPath(relativePath)) {
+      warnings.push(
+        `Dropped LLM-emitted "${relativePath}" — generated deterministically by the system.`,
+      )
+      continue
+    }
+
     // Sanitize at the boundary — strip stray code-fence wrappers,
     // `frontmatter:` prefixes, and repair invalid wikilink-list
     // YAML lines so the file we write is canonical regardless of
@@ -1843,13 +1771,12 @@ async function writeFileBlocks(
     // step ~45% of generated entity pages went to disk with
     // unparseable frontmatter and the read-time fallback had to
     // paper over it forever.
+    // index.md / log.md are already dropped above; only overview.md
+    // reaches here as a listing path, and its frontmatter dates are
+    // managed by the LLM aggregate-repair pass, so skip stamping it.
     let content = sanitizeIngestedFileContent(rawContent)
-    if (isLogPath(relativePath)) {
-      content = stampGeneratedLogDate(content, today)
-    } else if (!isListingPath(relativePath)) {
+    if (!isListingPath(relativePath)) {
       content = stampGeneratedFrontmatterDates(content, today)
-    }
-    if (!isLogPath(relativePath) && !isListingPath(relativePath)) {
       content = canonicalizeSourcesField(content, sourceFileName)
     }
     if (sourceSummaryPath && relativePath === sourceSummaryPath) {
@@ -1877,13 +1804,12 @@ async function writeFileBlocks(
 
     // Language guard: reject individual FILE blocks whose body contradicts
     // the user-set target language. Skip:
-    // - log.md (structural, short)
     // - /sources/ and /entities/ pages: these legitimately cite cross-
     //   language proper nouns (a German philosophy source summary naturally
     //   quotes Russian philosophers) which confuses naive script-based
     //   detection. Keep the check for /concepts/ pages, which should be
     //   authoritative content in the target language.
-    const isLog = isLogPath(relativePath)
+    // (log.md never reaches here — it's dropped above.)
     const isEntityOrSource =
       relativePath.startsWith("wiki/entities/") ||
       relativePath.includes("/entities/") ||
@@ -1892,7 +1818,6 @@ async function writeFileBlocks(
     if (
       targetLang &&
       targetLang !== "auto" &&
-      !isLog &&
       !isEntityOrSource &&
       !contentMatchesTargetLanguage(content, targetLang)
     ) {
@@ -1904,17 +1829,11 @@ async function writeFileBlocks(
 
     const fullPath = `${projectPath}/${relativePath}`
     try {
-      if (isLogPath(relativePath)) {
-        const existing = await tryReadFile(fullPath)
-        const appended = existing ? `${existing}\n\n${content.trim()}` : content.trim()
-        await writeFile(fullPath, appended)
-      } else if (
-        isListingPath(relativePath)
-      ) {
-        // Listing pages (index / overview) are always overwritten
-        // wholesale — their sources field is incidental and merging
-        // wouldn't make semantic sense (they aren't source-derived
-        // content pages).
+      if (isListingPath(relativePath)) {
+        // Only overview.md reaches here (index.md was dropped above).
+        // Listing pages are overwritten wholesale — their sources
+        // field is incidental and merging wouldn't make semantic
+        // sense (they aren't source-derived content pages).
         await writeFile(fullPath, content)
       } else {
         // Content pages (entities / concepts / queries / synthesis /
@@ -1977,6 +1896,97 @@ async function writeFileBlocks(
   }
 }
 
+/** Recursively collect every `.md` FileNode under a directory tree. */
+function collectMdNodes(nodes: FileNode[]): FileNode[] {
+  const out: FileNode[] = []
+  for (const node of nodes) {
+    if (node.is_dir) {
+      if (node.children) out.push(...collectMdNodes(node.children))
+    } else if (node.name.endsWith(".md")) {
+      out.push(node)
+    }
+  }
+  return out
+}
+
+/** Title for the log entry: the source summary page's title, falling
+ * back to the source identity's basename. */
+async function sourceSummaryTitle(
+  summaryFullPath: string,
+  sourceIdentity: string,
+): Promise<string> {
+  const content = await tryReadFile(summaryFullPath)
+  if (content) {
+    const title = extractGeneratedPageTitle(content)
+    if (title) return title
+  }
+  return getFileName(sourceIdentity).replace(/\.[^.]+$/, "")
+}
+
+/**
+ * Rebuild wiki/index.md deterministically from every page's
+ * frontmatter and append a single line to wiki/log.md. The LLM never
+ * authors either file (its blocks are dropped in writeFileBlocks);
+ * this is the only writer. Returns non-fatal warnings — a failure here
+ * must not fail the ingest. Callers run this inside the project lock.
+ */
+async function regenerateAggregateFiles(
+  projectPath: string,
+  logTitle: string,
+  date: string,
+): Promise<string[]> {
+  const warnings: string[] = []
+  const pp = normalizePath(projectPath)
+  const wikiRoot = `${pp}/wiki`
+
+  // index.md — read all pages, regenerate from frontmatter, write.
+  // The rewrite is wholesale, so carry the existing `created` forward;
+  // otherwise it would be restamped to `date` on every ingest.
+  try {
+    const indexPath = `${wikiRoot}/index.md`
+    const existingIndex = await tryReadFile(indexPath)
+    const existingCreated = existingIndex
+      ? parseFrontmatter(existingIndex).frontmatter?.created
+      : undefined
+    const tree = await listDirectory(wikiRoot)
+    const mdNodes = collectMdNodes(tree)
+    const pages: IndexInputPage[] = []
+    for (const node of mdNodes) {
+      const abs = normalizePath(node.path)
+      const wikiIdx = abs.toLowerCase().lastIndexOf("/wiki/")
+      const relativePath =
+        wikiIdx >= 0 ? abs.slice(wikiIdx + 1) : `wiki/${node.name}`
+      const content = await tryReadFile(node.path)
+      if (content) pages.push({ relativePath, content })
+    }
+    const indexContent = generateIndexMd(pages, {
+      date,
+      created: typeof existingCreated === "string" ? existingCreated : undefined,
+    })
+    await writeFile(indexPath, indexContent)
+  } catch (err) {
+    warnings.push(
+      `index.md regeneration failed: ${err instanceof Error ? err.message : String(err)}`,
+    )
+  }
+
+  // log.md — rewrite with prior entries preserved verbatim plus one
+  // new line. Read-modify-write, so callers must hold the project lock.
+  try {
+    const logPath = `${wikiRoot}/log.md`
+    const existing = await tryReadFile(logPath)
+    const entry = buildLogEntry(date, logTitle)
+    const next = existing.trim() ? `${existing.trim()}\n\n${entry}` : entry
+    await writeFile(logPath, `${next}\n`)
+  } catch (err) {
+    warnings.push(
+      `log.md append failed: ${err instanceof Error ? err.message : String(err)}`,
+    )
+  }
+
+  return warnings
+}
+
 function isOwnedOnlyBySource(content: string, sourceIdentity: string): boolean {
   const sources = parseSources(content)
   if (sources.length === 0) return false
@@ -2149,7 +2159,7 @@ export function buildGenerationPrompt(
     `## IMPORTANT: Source File`,
     `The original source file is: **${sourceFileName}**`,
     `All wiki pages generated from this source MUST include this filename in their frontmatter \`sources\` field.`,
-    `Today's date is **${today}**. Use this exact date for all new \`created\`, \`updated\`, and wiki/log.md ingest dates.`,
+    `Today's date is **${today}**. Use this exact date for all new \`created\` and \`updated\` frontmatter dates.`,
     "",
     schema
       ? [
@@ -2168,8 +2178,8 @@ export function buildGenerationPrompt(
     `1. A source summary page at **${summaryPath}** (MUST use this exact path)`,
     "2. Entity or schema-defined typed pages for key named things identified in the analysis. Prefer schema-defined directories when present; otherwise use wiki/entities/.",
     "3. Concept or schema-defined typed pages for key ideas, methods, techniques, and abstractions. Prefer schema-defined directories when present; otherwise use wiki/concepts/.",
-    "4. A log entry for wiki/log.md (just the new entry to append, format: ## [YYYY-MM-DD] ingest | Title)",
-    "Do not generate wiki/index.md or wiki/overview.md. The application maintains aggregate navigation separately so large wikis are never rewritten through model output.",
+    "",
+    "DO NOT output wiki/index.md, wiki/log.md, or wiki/overview.md. index.md and log.md are generated automatically by the system from page frontmatter, and the application maintains aggregate navigation separately so large wikis are never rewritten through model output. Any FILE block for them is discarded.",
     "",
     "## Frontmatter Rules (CRITICAL — parser is strict)",
     "",
@@ -2249,7 +2259,7 @@ export function buildGenerationPrompt(
     "  SEARCH: automated technical debt detection AI generated code | software quality metrics LLM code generation | static analysis tools agentic software development",
     "",
     purpose ? `## Wiki Purpose\n${purpose}` : "",
-    index ? `## Current Wiki Index (preserve all existing entries, add new ones)\n${index}` : "",
+    index ? `## Current Wiki Index (READ-ONLY context for cross-linking and de-duplication — do NOT output an index file)\n${index}` : "",
     overview ? `## Current Overview (update this to reflect the new source)\n${overview}` : "",
     "",
     // ── OUTPUT FORMAT MUST BE THE LAST SECTION — models weight recent instructions highest ──
@@ -3277,8 +3287,8 @@ async function executeIngestWritesImpl(
     "---END FILE---",
     "```",
     "",
-    "For wiki/log.md, include a log entry to append. For all other files, output the complete file content.",
-    "Do not generate wiki/index.md or wiki/overview.md. The application owns those aggregate files.",
+    "DO NOT output wiki/index.md, wiki/log.md, or wiki/overview.md — the application owns the aggregate files; any FILE block for them is discarded.",
+    "For all other files, output the complete file content.",
     "Use relative paths from the project root (e.g., wiki/sources/topic.md).",
     "Do not include any other text outside the FILE blocks.",
   ]
@@ -3347,32 +3357,49 @@ async function executeIngestWritesImpl(
       continue
     }
 
-    if (
-      activeSourceIdentity &&
-      !isLogPath(relativePath) &&
-      !isListingPath(relativePath)
-    ) {
+    // index.md / log.md are generated deterministically after the loop;
+    // drop any blocks the model emitted for them.
+    if (isIndexPath(relativePath) || isLogPath(relativePath)) {
+      continue
+    }
+
+    if (activeSourceIdentity && !isListingPath(relativePath)) {
       content = canonicalizeSourcesField(content, activeSourceIdentity)
     }
 
     const fullPath = `${pp}/${relativePath}`
 
     try {
-      if (isLogPath(relativePath)) {
-        const existing = await tryReadFile(fullPath)
-        const appended = existing
-          ? `${existing}\n\n${content.trim()}`
-          : content.trim()
-        await writeFile(fullPath, appended)
-      } else {
-        await writeFile(fullPath, content)
-      }
+      await writeFile(fullPath, content)
       writtenPaths.push(fullPath)
     } catch (err) {
       console.error(`Failed to write ${fullPath}:`, err)
     }
   }
 
+  // Regenerate index.md + append a log line deterministically, matching
+  // the autoIngest path so the chat "Save to Wiki" flow never clobbers
+  // the index or duplicates the log either. log.md is read-modify-write,
+  // but the whole write path already runs inside withProjectLock (see
+  // executeIngestWrites), so the regen is serialized against concurrent
+  // queue ingests without taking the (non-reentrant) lock again here.
+  if (writtenPaths.length > 0) {
+    try {
+      const logTitle = activeSourceIdentity
+        ? await sourceSummaryTitle(
+            activeSourceSummaryPath ? `${pp}/${activeSourceSummaryPath}` : "",
+            activeSourceIdentity,
+          )
+        : "chat ingest"
+      await regenerateAggregateFiles(pp, logTitle, currentWikiDate())
+    } catch (err) {
+      console.warn(
+        `[executeIngestWrites] aggregate regeneration failed:`,
+        err instanceof Error ? err.message : err,
+      )
+    }
+  }
+
   if (writtenPaths.length > 0) {
     const fileList = writtenPaths.map((p) => `- ${p}`).join("\n")
     getStore().addMessage("system", `Files written to wiki:\n${fileList}`)
diff --git a/src/lib/templates.ts b/src/lib/templates.ts
index a16d58e95..bb4de78a7 100644
--- a/src/lib/templates.ts
+++ b/src/lib/templates.ts
@@ -43,20 +43,11 @@ url: ""
 venue: ""
 \`\`\``
 
-const BASE_INDEX_FORMAT = `\`wiki/index.md\` lists all pages grouped by type. Each entry:
-\`\`\`
-- [[page-slug]] — one-line description
-\`\`\``
+const BASE_INDEX_FORMAT = `\`wiki/index.md\` is generated automatically by LLM Wiki from every page's frontmatter — do not edit it by hand or ask the assistant to write it. Entries are grouped by type as \`- [[page-slug]] — description\`.`
 
-const BASE_LOG_FORMAT = `\`wiki/log.md\` records activity in reverse chronological order:
-\`\`\`
-## YYYY-MM-DD
-
-- Action taken / finding noted
-\`\`\``
+const BASE_LOG_FORMAT = `\`wiki/log.md\` is generated automatically by LLM Wiki — one append-only line per ingest (\`## [YYYY-MM-DD] ingest | Title\`). Do not edit it by hand or ask the assistant to write it.`
 
 const BASE_CROSSREF = `- Use \`[[page-slug]]\` syntax to link between wiki pages
-- Every entity and concept should appear in \`wiki/index.md\`
 - Queries link to the sources and concepts they draw on
 - Synthesis pages cite all contributing sources via \`related:\``
 
diff --git a/src/test-helpers/scenarios/ingest-scenarios.ts b/src/test-helpers/scenarios/ingest-scenarios.ts
index 2966d26bf..fd6eec7f8 100644
--- a/src/test-helpers/scenarios/ingest-scenarios.ts
+++ b/src/test-helpers/scenarios/ingest-scenarios.ts
@@ -267,4 +267,112 @@ export const ingestScenarios: IngestScenario[] = [
       },
     },
   },
+
+  // 5. drops-llm-index-and-log — index.md / log.md emitted by the LLM
+  //    must be discarded and regenerated deterministically. The index
+  //    is rebuilt from all page frontmatter (existing + new), and the
+  //    log gets one appended line while prior entries are preserved.
+  {
+    name: "drops-llm-index-and-log",
+    description:
+      "Stage 2 emits bogus index.md and log.md FILE blocks alongside real " +
+      "content pages. The runner must DROP both, regenerate index.md from " +
+      "page frontmatter (keeping the pre-existing attention page), and " +
+      "append exactly one deterministic log line without losing the old one.",
+    initialWiki: {
+      "purpose.md": BASIC_PURPOSE,
+      "schema.md": BASIC_SCHEMA,
+      "wiki/index.md": BASIC_INDEX,
+      "wiki/log.md": "# Log\n\n## [2026-01-01] ingest | Old Entry",
+      "wiki/concepts/attention.md": [
+        "---",
+        "type: concept",
+        "title: Attention",
+        "---",
+        "",
+        "# Attention",
+        "",
+        "Attention lets a model weigh different input positions.",
+      ].join("\n"),
+    },
+    source: {
+      path: "raw/sources/rope-paper.md",
+      content: [
+        "# Rotary Position Embedding",
+        "",
+        "RoPE encodes positional information by rotating query/key dimensions.",
+      ].join("\n"),
+    },
+    analysisResponse: [
+      "## Key Concepts",
+      "- Rotary Position Embedding (RoPE)",
+      "",
+      "## Recommendations",
+      "- Create wiki/concepts/rope.md",
+    ].join("\n"),
+    generationResponse: [
+      "---FILE: wiki/concepts/rope.md---",
+      "---",
+      "type: concept",
+      "title: Rotary Position Embedding",
+      "sources: [rope-paper.md]",
+      "---",
+      "",
+      "# Rotary Position Embedding",
+      "",
+      "RoPE rotates pairs of dimensions in query and key vectors.",
+      "---END FILE---",
+      "",
+      "---FILE: wiki/sources/rope-paper.md---",
+      "---",
+      "type: source",
+      "title: \"Source: rope-paper.md\"",
+      "sources: [rope-paper.md]",
+      "---",
+      "",
+      "# Source: rope-paper.md",
+      "",
+      "Paper introducing RoPE.",
+      "---END FILE---",
+      "",
+      "---FILE: wiki/index.md---",
+      "# Index",
+      "LLM_BOGUS_INDEX should never reach disk",
+      "- [[rope]]",
+      "---END FILE---",
+      "",
+      "---FILE: wiki/log.md---",
+      "# Log",
+      "LLM_BOGUS_LOG full rewrite should be discarded",
+      "---END FILE---",
+    ].join("\n"),
+    expected: {
+      // index.md / log.md are NOT in writtenPaths — they're dropped from
+      // the LLM output and regenerated out-of-band.
+      writtenPaths: [
+        "wiki/concepts/rope.md",
+        "wiki/sources/rope-paper.md",
+      ],
+      fileContains: {
+        // Deterministic index: overview frontmatter + both the new page
+        // and the pre-existing attention page.
+        "wiki/index.md": [
+          "type: overview",
+          "# Wiki Index",
+          "[[rope]]",
+          "[[attention]]",
+        ],
+        // Deterministic log: old entry preserved, one new line appended.
+        "wiki/log.md": [
+          "Old Entry",
+          "] ingest |",
+        ],
+      },
+      fileExcludes: {
+        "wiki/index.md": ["LLM_BOGUS_INDEX"],
+        "wiki/log.md": ["LLM_BOGUS_LOG"],
+      },
+      reviewsCreated: [],
+    },
+  },
 ]
diff --git a/src/test-helpers/scenarios/types.ts b/src/test-helpers/scenarios/types.ts
index 8e3501ccd..5bee4dd67 100644
--- a/src/test-helpers/scenarios/types.ts
+++ b/src/test-helpers/scenarios/types.ts
@@ -120,6 +120,8 @@ export interface IngestScenario {
     writtenPaths: string[]
     /** Substring matches for specific files (path → list of substrings to find). */
     fileContains?: Record<string, string[]>
+    /** Substrings that must NOT appear in specific files (path → forbidden substrings). */
+    fileExcludes?: Record<string, string[]>
     /**
      * Expected review items (subset match). Each entry matches if an injected
      * review has the same type and a title containing titleContains.