diff --git a/CHANGELOG.md b/CHANGELOG.md
index d9ac7c7..74b2bd5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,18 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.1.2] - 2026-06-16
+
+A patch release. Fixes a regression introduced in 1.1.0 where successive `/kasper apply` invocations on a project whose `AGENTS.md` (or agent prompt) had a `# Title` and intro paragraph BEFORE the `## Kasper Inferred Instructions` section produced nested `## Kasper Inferred Instructions` headers and lost earlier improvements on every apply.
+
+### Fixed
+
+- **`injectSection` accumulation broke when the target section was preceded by other content** — `agents-md.ts:injectSection` and `agent-prompts.ts:injectSection` shared a `bodyStrip` regex anchored at `^##` that required a literal `\r?\n` after the header name. `sectionRegex` captured a leading `\n` via `(?:^|\n)##...` whenever the section was not at the start of the file, so `match[0]` started with `\n## Section` and `bodyStrip.replace()` was a no-op. The un-stripped header was then re-emitted by the subsequent `existing.replace(sectionRegex, ...)`, producing a nested duplicate header on every apply. Real-world AGENTS.md / agent-prompt files always start with a `# Title` and intro paragraph, so the bug was triggered on first use for every user. The fix extracts `injectSectionContent()` as a pure helper in `src/prompt-utils.ts` that uses `match[0].slice(match[1].length)` to extract the body (robust to leading newlines, missing-newline-at-EOF, and CRLF line endings) and strips the optional existing provenance line so it does not stack on repeated applies. Both managers now delegate to the helper, eliminating the duplicated buggy logic. The helper always produces a file that ends with a single trailing newline.
+
+### Added
+
+- **End-to-end regression test** — `tests/e2e/inject-accumulation.test.ts` (run with `OPENCODE_E2E=1 bun test tests/e2e/inject-accumulation.test.ts`) exactly reproduces the bug-report steps: a realistic AGENTS.md with `# My Project` + intro + `## Kasper Inferred Instructions` + `## Conventions`, three `injectSection` calls back-to-back (mirroring three `/kasper apply` invocations), and an assertion that the file ends with exactly ONE `## Kasper Inferred Instructions` header and contains all three improvements. The test fails on the original buggy code with `Expected: 1, Received: 4`, proving it would have caught the original bug. A parallel test exercises the same scenario on `AgentPromptManager` with a YAML-frontmatter agent prompt, and a third covers the freshly-created-file path. The 1.1.0 release's unit tests covered only the case where the target section was the first thing in the file, which is why the bug slipped through.
+
 ## [1.1.1] - 2026-06-11
 
 A patch release. Fixes a false-positive on every startup, removes a startup-time hang in the worst case, and corrects a misleading example in the README.
diff --git a/package.json b/package.json
index 34bebb7..2b7e173 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@atonev/opencode-kasper",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "type": "module",
   "description": "OpenCode plugin that monitors agent sessions, scores adherence to user instructions via LLM-as-judge, and injects corrective instructions into AGENTS.md and per-agent prompt files.",
   "author": "andrejtonev <29177572+andrejtonev@users.noreply.github.com>",
@@ -30,7 +30,9 @@
       "types": "./dist/index.d.ts"
     }
   },
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "engines": {
     "node": ">=20.0.0"
   },
diff --git a/src/agent-prompts.ts b/src/agent-prompts.ts
index fbca29c..a497bcb 100644
--- a/src/agent-prompts.ts
+++ b/src/agent-prompts.ts
@@ -9,6 +9,7 @@ import { acquireLock } from "./lock.js"
 import {
   escapeRegex,
   exists,
+  injectSectionContent,
   timestampFilename,
   writeTextAtomic,
 } from "./prompt-utils.js"
@@ -278,27 +279,22 @@ export class AgentPromptManager {
       let updated: string
       if (injectMode === "inline") {
         updated = appendInlineImprovement(existing, content.trim())
+      } else if (!existing.trim()) {
+        // Empty file: create with frontmatter + a fresh section.
+        const sectionBlock = `## ${sectionName}\n<!-- kasper: ${new Date().toISOString()} -->\n${content.trim()}\n`
+        const frontmatter = `---\nmode: ${mode}\n---\n\n`
+        updated = `${frontmatter + sectionBlock}\n`
       } else {
-        const header = `## ${sectionName}`
-        const sectionRegex = new RegExp(
-          `((?:^|\\n)##\\s*${escapeRegex(sectionName)})[\\s\\S]*?(?=\\r?\\n##|$)`,
+        // Section-mode on a non-empty file: delegate to the shared helper.
+        // The helper handles accumulation when the section already exists and
+        // appends a new section when it does not. In both cases the file ends
+        // with a trailing newline.
+        const result = injectSectionContent(
+          existing,
+          sectionName,
+          content.trim(),
         )
-        const provenance = `<!-- kasper: ${new Date().toISOString()} -->\n`
-        const sectionBlock = `${header}\n${provenance}${content.trim()}\n`
-
-        if (!existing.trim()) {
-          const frontmatter = `---\nmode: ${mode}\n---\n\n`
-          updated = `${frontmatter + sectionBlock}\n`
-        } else if (sectionRegex.test(existing)) {
-          updated = existing.replace(
-            sectionRegex,
-            `$1\n${provenance}${content.trim()}`,
-          )
-        } else {
-          const eofSection = `${sectionBlock}\n`
-          const trimmed = existing.trimEnd()
-          updated = trimmed ? `${trimmed}\n\n${eofSection}` : eofSection
-        }
+        updated = result.updated
       }
 
       let backupPath: string | undefined
diff --git a/src/agents-md.ts b/src/agents-md.ts
index 77058ce..573ecc3 100644
--- a/src/agents-md.ts
+++ b/src/agents-md.ts
@@ -11,6 +11,7 @@ import { acquireLock } from "./lock.js"
 import {
   escapeRegex,
   exists,
+  injectSectionContent,
   parseTimestampFromFilename,
   timestampFilename,
   writeTextAtomic,
@@ -170,23 +171,9 @@ export class AgentsMdManager {
     sectionName: string,
     content: string,
   ): string {
-    const header = this.sectionHeader(sectionName)
-    const sectionRegex = new RegExp(
-      `((?:^|\\n)##\\s*${escapeRegex(sectionName)})[\\s\\S]*?(?=\\r?\\n##|$)`,
-    )
-    const provenance = `<!-- kasper: ${new Date().toISOString()} -->\n`
-    const sectionBlock = `${header}\n${provenance}${content.trim()}\n`
-
-    if (sectionRegex.test(existing)) {
-      return existing.replace(
-        sectionRegex,
-        `$1\n${provenance}${content.trim()}`,
-      )
-    }
-
-    const eofSection = `${sectionBlock}\n`
-    const trimmed = existing.trimEnd()
-    return trimmed ? `${trimmed}\n\n${eofSection}` : eofSection
+    // Delegates to the shared helper. Kept as a method on AgentsMdManager
+    // because the existing public API is `(existing, sectionName, content)`.
+    return injectSectionContent(existing, sectionName, content).updated
   }
 
   removeSection(existing: string, sectionName: string): string {
diff --git a/src/prompt-utils.ts b/src/prompt-utils.ts
index 268695d..bc90d44 100644
--- a/src/prompt-utils.ts
+++ b/src/prompt-utils.ts
@@ -117,3 +117,55 @@ export async function writeTextAtomic(
       : new Error(String(lastError ?? "atomic write failed"))
   })
 }
+
+/**
+ * Inject content into a markdown section. If the section already exists, the
+ * existing body is preserved and the new content is appended after a blank
+ * line. A provenance comment `<!-- kasper: ISO -->` is always written directly
+ * after the section header so the section's "last updated" timestamp is
+ * visible without scanning the body.
+ *
+ * Always produces a file that ends with a single trailing newline.
+ *
+ * Pure function (no I/O) so it is trivially testable.
+ */
+export function injectSectionContent(
+  existing: string,
+  sectionName: string,
+  newContent: string,
+  now: Date = new Date(),
+): { updated: string; existed: boolean } {
+  const sectionRegex = new RegExp(
+    `((?:^|\\n)##\\s*${escapeRegex(sectionName)})[\\s\\S]*?(?=\\r?\\n##|$)`,
+  )
+  const provenance = `<!-- kasper: ${now.toISOString()} -->\n`
+
+  const match = existing.match(sectionRegex)
+  if (match) {
+    // match[1] is the captured header (including the optional leading \n).
+    // Slice it off the front of match[0] to get the body — this is robust to
+    // the body starting with a newline (when the section is not at the start
+    // of the file) or directly after the header (EOF case).
+    const headerMatched = match[1]
+    const body = match[0].slice(headerMatched.length)
+    // Strip the optional provenance line at the start of the body so we
+    // don't stack timestamps on every apply.
+    const bodyStripped = body.replace(/^\r?\n(?:<!-- kasper:.*?-->\r?\n)?/, "")
+    const existingBody = bodyStripped.trim()
+    const finalContent = existingBody
+      ? `${existingBody}\n\n${newContent.trim()}`
+      : newContent.trim()
+    const updated = existing.replace(
+      sectionRegex,
+      `${headerMatched}\n${provenance}${finalContent}\n`,
+    )
+    return { updated, existed: true }
+  }
+
+  // Section does not exist — append it at the end of the file.
+  const header = `## ${sectionName}`
+  const sectionBlock = `${header}\n${provenance}${newContent.trim()}\n`
+  const trimmed = existing.trimEnd()
+  const updated = trimmed ? `${trimmed}\n\n${sectionBlock}` : sectionBlock
+  return { updated, existed: false }
+}
diff --git a/tests/agent-prompts.test.ts b/tests/agent-prompts.test.ts
index 671e442..cf76911 100644
--- a/tests/agent-prompts.test.ts
+++ b/tests/agent-prompts.test.ts
@@ -68,7 +68,7 @@ describe("AgentPromptManager", () => {
       expect(content).toContain("be faster")
     })
 
-    test("replaces existing section with same name", async () => {
+    test("accumulates content in existing section", async () => {
       await manager.write(
         "build",
         "## Kasper Rules\nold rule\n\n## Other\nstuff",
@@ -76,7 +76,7 @@ describe("AgentPromptManager", () => {
       await manager.injectSection("build", "Kasper Rules", "new rule")
       const content = await manager.read("build")
       expect(content).toContain("new rule")
-      expect(content).not.toContain("old rule")
+      expect(content).toContain("old rule")
       expect(content).toContain("## Other")
     })
 
@@ -87,6 +87,199 @@ describe("AgentPromptManager", () => {
       expect(content).toContain("## Other")
       expect(content).toContain("## New Section")
     })
+
+    test("preserves existing section body and adds new content", async () => {
+      await manager.write(
+        "build",
+        "## Kasper Rules\nold rule\n\n## Other\nstuff",
+      )
+      await manager.injectSection(
+        "build",
+        "Kasper Rules",
+        "new rule",
+        true, // backupEnabled
+        20, // maxBackups
+        "subagent", // mode
+        "section", // injectMode
+      )
+      const content = await manager.read("build")
+      expect(content).toContain("old rule")
+      expect(content).toContain("new rule")
+      expect(content).toContain("## Other")
+    })
+
+    test("accumulates multiple improvements", async () => {
+      await manager.write("build", "")
+      await manager.injectSection(
+        "build",
+        "Rules",
+        "rule 1",
+        true,
+        20,
+        "subagent",
+        "section",
+      )
+      await manager.injectSection(
+        "build",
+        "Rules",
+        "rule 2",
+        true,
+        20,
+        "subagent",
+        "section",
+      )
+      const content = await manager.read("build")
+      expect(content).toContain("rule 1")
+      expect(content).toContain("rule 2")
+    })
+
+    test("default call accumulates existing content", async () => {
+      await manager.write(
+        "build",
+        "## Kasper Rules\nold rule\n\n## Other\nstuff",
+      )
+      await manager.injectSection("build", "Kasper Rules", "new rule")
+      const content = await manager.read("build")
+      expect(content).toContain("new rule")
+      expect(content).toContain("old rule")
+    })
+
+    // ---- Regression tests for the critical regex-anchoring bug (Issue #1) ----
+
+    test("does NOT produce nested headers when section is preceded by frontmatter", async () => {
+      // The most common real-world case for an agent prompt file: it
+      // starts with YAML frontmatter and a description.
+      const frontmatter = [
+        "---",
+        "description: My agent",
+        "mode: subagent",
+        "---",
+        "",
+        "# My Agent",
+        "",
+        "Follow these rules:",
+        "  1. Be polite",
+        "  2. Be thorough",
+        "",
+        "## Kasper Inferred Instructions",
+        "old rule",
+        "",
+      ].join("\n")
+      await manager.write("build", frontmatter)
+      await manager.injectSection(
+        "build",
+        "Kasper Inferred Instructions",
+        "new rule",
+      )
+      const content = await manager.read("build")
+      // Critical: exactly ONE ## Kasper Inferred Instructions header
+      const headerCount = (
+        content.match(/^## Kasper Inferred Instructions/gm) || []
+      ).length
+      expect(headerCount).toBe(1)
+      expect(content).toContain("old rule")
+      expect(content).toContain("new rule")
+      // Frontmatter and pre-section content preserved
+      expect(content).toContain("description: My agent")
+      expect(content).toContain("Follow these rules:")
+      expect(content).toContain("Be polite")
+      // Chronological order
+      expect(content.indexOf("old rule")).toBeLessThan(
+        content.indexOf("new rule"),
+      )
+    })
+
+    test("does NOT produce nested headers when section is preceded by # Title and intro", async () => {
+      const existing =
+        "# My Build Agent\n\nIntro paragraph.\n\n## Kasper Inferred Instructions\nold rule\n\n## Other\nstuff"
+      await manager.write("build", existing)
+      await manager.injectSection(
+        "build",
+        "Kasper Inferred Instructions",
+        "new rule",
+      )
+      const content = await manager.read("build")
+      const headerCount = (
+        content.match(/^## Kasper Inferred Instructions/gm) || []
+      ).length
+      expect(headerCount).toBe(1)
+      expect(content).toContain("Intro paragraph.")
+      expect(content).toContain("old rule")
+      expect(content).toContain("new rule")
+    })
+
+    test("double-apply produces only ONE provenance line (no stacking)", async () => {
+      await manager.write("build", "# Title\n\nintro\n\n## Rules\nold\n")
+      await manager.injectSection("build", "Rules", "rule 1")
+      await manager.injectSection("build", "Rules", "rule 2")
+      const content = await manager.read("build")
+      const provenanceCount = (content.match(/<!-- kasper:/g) || []).length
+      expect(provenanceCount).toBe(1)
+    })
+
+    test("triple-apply still produces only ONE header (no accumulation bug)", async () => {
+      await manager.write("build", "## Rules\nold\n")
+      await manager.injectSection("build", "Rules", "a")
+      await manager.injectSection("build", "Rules", "b")
+      await manager.injectSection("build", "Rules", "c")
+      const content = await manager.read("build")
+      const headerCount = (content.match(/^## Rules/gm) || []).length
+      expect(headerCount).toBe(1)
+      expect(content).toContain("old")
+      expect(content).toContain("a")
+      expect(content).toContain("b")
+      expect(content).toContain("c")
+    })
+
+    test("preserves trailing newline when section is the last thing in the file", async () => {
+      await manager.write("build", "## My Section\nold")
+      await manager.injectSection("build", "My Section", "new")
+      const content = await manager.read("build")
+      expect(content.endsWith("\n")).toBe(true)
+    })
+
+    test("preserves content order: A < Target < B when target is in the middle", async () => {
+      await manager.write("build", "## A\naaa\n\n## Target\nold\n\n## B\nbbb")
+      await manager.injectSection("build", "Target", "new")
+      const content = await manager.read("build")
+      expect(content.indexOf("## A")).toBeGreaterThan(-1)
+      expect(content.indexOf("## Target")).toBeGreaterThan(
+        content.indexOf("## A"),
+      )
+      expect(content.indexOf("## B")).toBeGreaterThan(
+        content.indexOf("## Target"),
+      )
+      expect(content.indexOf("aaa")).toBeLessThan(content.indexOf("old"))
+      expect(content.indexOf("old")).toBeLessThan(content.indexOf("new"))
+      expect(content.indexOf("new")).toBeLessThan(content.indexOf("bbb"))
+    })
+
+    test("CRLF line endings: still produces only one header", async () => {
+      await manager.write(
+        "build",
+        "# Title\r\n\r\n## My Section\r\nold rule\r\n\r\n## Other\r\nstuff\r\n",
+      )
+      await manager.injectSection("build", "My Section", "new rule")
+      const content = await manager.read("build")
+      const headerCount = (content.match(/^## My Section/gm) || []).length
+      expect(headerCount).toBe(1)
+      expect(content).toContain("old rule")
+      expect(content).toContain("new rule")
+    })
+
+    test("5x repeated apply: exactly one header, exactly one provenance, all rules preserved", async () => {
+      await manager.write("build", "## Rules\nold\n")
+      for (let i = 0; i < 5; i++) {
+        await manager.injectSection("build", "Rules", `r${i}`)
+      }
+      const content = await manager.read("build")
+      expect((content.match(/^## Rules/gm) || []).length).toBe(1)
+      expect((content.match(/<!-- kasper:/g) || []).length).toBe(1)
+      expect(content).toContain("old")
+      for (let i = 0; i < 5; i++) {
+        expect(content).toContain(`r${i}`)
+      }
+    })
   })
 
   describe("backup and rollback", () => {
diff --git a/tests/agents-md.test.ts b/tests/agents-md.test.ts
index d23c616..95f8452 100644
--- a/tests/agents-md.test.ts
+++ b/tests/agents-md.test.ts
@@ -84,7 +84,7 @@ describe("AgentsMdManager", () => {
       )
     })
 
-    test("replaces existing section with same name", () => {
+    test("accumulates content in existing section", () => {
       const existing = "## My Section\nold content\n## Other\nother stuff"
       const result = manager.injectSection(
         existing,
@@ -92,17 +92,17 @@ describe("AgentsMdManager", () => {
         "new content",
       )
       expect(result).toContain("new content")
-      expect(result).not.toContain("old content")
+      expect(result).toContain("old content")
       expect(result).toContain("## Other")
     })
 
-    test("trims trailing whitespace from replacement", () => {
+    test("trims trailing whitespace and preserves old", () => {
       const existing = "## My Section\nold\n"
       const result = manager.injectSection(existing, "My Section", "new\n\n")
       expect(result).toContain("## My Section")
       expect(result).toContain("new")
+      expect(result).toContain("old")
       expect(result).toMatch(/<!-- kasper:/)
-      expect(result).not.toContain("old")
     })
 
     test("section header includes section name", () => {
@@ -113,6 +113,145 @@ describe("AgentsMdManager", () => {
       )
       expect(result).toContain("## Kasper Inferred Instructions")
     })
+
+    test("preserves existing section body and adds new content", () => {
+      const existing = "## My Section\nold rule\n## Other\nstuff"
+      const result = manager.injectSection(existing, "My Section", "new rule")
+      expect(result).toContain("old rule")
+      expect(result).toContain("new rule")
+      expect(result).toContain("## Other")
+      expect(result).toMatch(/<!-- kasper:/)
+    })
+
+    test("when section doesn't exist, creates it as normal", () => {
+      const existing = "## Existing\nstuff"
+      const result = manager.injectSection(
+        existing,
+        "New Section",
+        "fresh content",
+      )
+      expect(result).toContain("fresh content")
+      expect(result).toContain("## New Section")
+      expect(result).toContain("## Existing")
+    })
+
+    test("accumulates multiple improvements in order", () => {
+      let doc = "## Rules\ncode of conduct\n"
+      doc = manager.injectSection(doc, "Rules", "first rule")
+      doc = manager.injectSection(doc, "Rules", "second rule")
+      expect(doc).toContain("first rule")
+      expect(doc).toContain("second rule")
+      expect(doc).toContain("code of conduct")
+    })
+
+    // ---- Regression tests for the critical regex-anchoring bug (Issue #1) ----
+
+    test("does NOT produce nested headers when section is preceded by # Title", () => {
+      // This is the real-world case that the original PR did not cover: a
+      // typical AGENTS.md starts with a # Title and intro paragraphs.
+      const existing =
+        "# My Project\n\nIntro paragraph.\n\n## Kasper Inferred Instructions\nold rule\n\n## Other\nstuff"
+      const result = manager.injectSection(
+        existing,
+        "Kasper Inferred Instructions",
+        "new rule",
+      )
+      // Critical assertion: exactly ONE ## Kasper Inferred Instructions header
+      const headerCount = (
+        result.match(/^## Kasper Inferred Instructions/gm) || []
+      ).length
+      expect(headerCount).toBe(1)
+      expect(result).toContain("old rule")
+      expect(result).toContain("new rule")
+      expect(result).toContain("## Other")
+      expect(result).toContain("# My Project")
+      // Chronological order: old < new
+      expect(result.indexOf("old rule")).toBeLessThan(
+        result.indexOf("new rule"),
+      )
+    })
+
+    test("does NOT produce nested headers when section is preceded by another ## section", () => {
+      const existing =
+        "## Intro\nWelcome.\n\n## Kasper Inferred Instructions\nold\n\n## Notes\nsee below"
+      const result = manager.injectSection(
+        existing,
+        "Kasper Inferred Instructions",
+        "new",
+      )
+      const headerCount = (
+        result.match(/^## Kasper Inferred Instructions/gm) || []
+      ).length
+      expect(headerCount).toBe(1)
+      const totalHeaders = (result.match(/^## /gm) || []).length
+      expect(totalHeaders).toBe(3)
+    })
+
+    test("double-apply produces only ONE provenance line (no stacking)", () => {
+      let doc = "# Title\n\nintro\n\n## Rules\nold\n"
+      doc = manager.injectSection(doc, "Rules", "rule 1")
+      doc = manager.injectSection(doc, "Rules", "rule 2")
+      const provenanceCount = (doc.match(/<!-- kasper:/g) || []).length
+      expect(provenanceCount).toBe(1)
+    })
+
+    test("triple-apply still produces only ONE header (no accumulation bug)", () => {
+      let doc = "## Rules\nold\n"
+      doc = manager.injectSection(doc, "Rules", "a")
+      doc = manager.injectSection(doc, "Rules", "b")
+      doc = manager.injectSection(doc, "Rules", "c")
+      const headerCount = (doc.match(/^## Rules/gm) || []).length
+      expect(headerCount).toBe(1)
+      expect(doc).toContain("old")
+      expect(doc).toContain("a")
+      expect(doc).toContain("b")
+      expect(doc).toContain("c")
+    })
+
+    test("preserves trailing newline when section is the last thing in the file", () => {
+      // Issue #3: the new-section path always ended with \n; the old
+      // replace path sometimes dropped the trailing newline.
+      const result = manager.injectSection(
+        "## My Section\nold",
+        "My Section",
+        "new",
+      )
+      expect(result.endsWith("\n")).toBe(true)
+    })
+
+    test("preserves content order: A < Target < B when target is in the middle", () => {
+      const existing = "## A\naaa\n\n## Target\nold\n\n## B\nbbb"
+      const result = manager.injectSection(existing, "Target", "new")
+      const aIdx = result.indexOf("## A")
+      const tIdx = result.indexOf("## Target")
+      const bIdx = result.indexOf("## B")
+      expect(aIdx).toBeGreaterThan(-1)
+      expect(tIdx).toBeGreaterThan(aIdx)
+      expect(bIdx).toBeGreaterThan(tIdx)
+      expect(result.indexOf("aaa")).toBeLessThan(result.indexOf("old"))
+      expect(result.indexOf("old")).toBeLessThan(result.indexOf("new"))
+      expect(result.indexOf("new")).toBeLessThan(result.indexOf("bbb"))
+    })
+
+    test("handles section name with regex special characters", () => {
+      const existing = "## My Section (v2.0)\nold\n"
+      const result = manager.injectSection(existing, "My Section (v2.0)", "new")
+      const headerCount = (result.match(/^## My Section \(v2\.0\)/gm) || [])
+        .length
+      expect(headerCount).toBe(1)
+      expect(result).toContain("old")
+      expect(result).toContain("new")
+    })
+
+    test("CRLF line endings: still produces only one header", () => {
+      const existing =
+        "# Title\r\n\r\n## My Section\r\nold rule\r\n\r\n## Other\r\nstuff\r\n"
+      const result = manager.injectSection(existing, "My Section", "new rule")
+      const headerCount = (result.match(/^## My Section/gm) || []).length
+      expect(headerCount).toBe(1)
+      expect(result).toContain("old rule")
+      expect(result).toContain("new rule")
+    })
   })
 
   describe("removeSection", () => {
diff --git a/tests/e2e/inject-accumulation.test.ts b/tests/e2e/inject-accumulation.test.ts
new file mode 100644
index 0000000..f8bab80
--- /dev/null
+++ b/tests/e2e/inject-accumulation.test.ts
@@ -0,0 +1,263 @@
+/**
+ * End-to-end regression test for the `injectSection` accumulation bug.
+ *
+ * REPRODUCES: https://github.com/andrejtonev/opencode-kasper/issues/<this-PR>
+ * Steps from the bug report:
+ *   1. Apply improvement #1 → AGENTS.md gets `## Kasper Inferred Instructions`
+ *      with improvement 1
+ *   2. Apply improvement #2 → AGENTS.md now contains only improvement 2
+ *      (improvement 1 is GONE)   ← THE BUG
+ *   3. Apply improvement #3 → AGENTS.md now contains only improvement 3
+ *
+ * Root cause (from the PR review):
+ *   `injectSection` used a `bodyStrip` regex anchored at `^##` that fails
+ *   when the target section is NOT at the start of the file (which is the
+ *   common case — AGENTS.md normally starts with a `# Title` and an intro).
+ *   When the strip fails, `existingBody` retains the original `## Section`
+ *   header, and the subsequent `replace` produces a NESTED header on every
+ *   apply. The original PR's tests didn't catch this because they all
+ *   started the fixture file with the target `## Section` at position 0.
+ *
+ * This test runs against the LIVE plugin (symlinked from
+ * `~/.config/opencode/plugins/opencode-kasper.ts` to
+ * `src/index.ts`) so it tests the actual `AgentsMdManager` and
+ * `AgentPromptManager` shipped to users.
+ *
+ * Run with: OPENCODE_E2E=1 bun test tests/e2e/inject-accumulation.test.ts
+ *
+ * The test does not require `opencode serve`; it drives the managers
+ * directly, which is the exact code path `/kasper apply` invokes in
+ * handlers.ts:1281 → AgentsMdManager.injectSection and
+ * handlers.ts:1235 → AgentPromptManager.injectSection.
+ */
+import { afterAll, beforeAll, describe, expect, test } from "bun:test"
+import { execSync } from "node:child_process"
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { AgentPromptManager } from "../../src/agent-prompts.js"
+import { AgentsMdManager } from "../../src/agents-md.js"
+
+const ENABLED =
+  process.env.OPENCODE_E2E === "1" &&
+  (() => {
+    try {
+      execSync("opencode --version", { stdio: "pipe" })
+      return true
+    } catch {
+      return false
+    }
+  })()
+
+const SECTION_NAME = "Kasper Inferred Instructions"
+
+function countHeaders(content: string, sectionName: string): number {
+  // Count top-level (line-anchored) `## {sectionName}` headers. We use
+  // `\\s+` to also catch any whitespace between `##` and the name, mirroring
+  // how markdown renderers tolerate it.
+  const re = new RegExp(
+    `^##\\s+${sectionName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`,
+    "gm",
+  )
+  return (content.match(re) || []).length
+}
+
+function countProvenanceLines(content: string): number {
+  return (content.match(/<!-- kasper:/g) || []).length
+}
+
+describe.skipIf(!ENABLED)(
+  "e2e: injectSection accumulation — reproduces issue, verifies fix",
+  () => {
+    // The "user's project" with a realistic AGENTS.md layout: starts with
+    // a # Title and an intro paragraph BEFORE the target section. This is
+    // the case that triggered the bug for real users.
+    const realisticAgentsMd = [
+      "# My Project",
+      "",
+      "This is a typical AGENTS.md that starts with a project title and a",
+      "short description. The user's instructions live below.",
+      "",
+      `## ${SECTION_NAME}`,
+      "old improvement from a prior apply",
+      "",
+      "## Conventions",
+      "Follow the existing code style.",
+      "",
+    ].join("\n")
+
+    const threeImprovements = [
+      "improvement 1: be polite to users",
+      "improvement 2: always run tests before committing",
+      "improvement 3: prefer functional over imperative code",
+    ]
+
+    let projectDir: string
+    let agentsMdManager: AgentsMdManager
+
+    beforeAll(() => {
+      projectDir = mkdtempSync(join(tmpdir(), "kasper-e2e-accum-"))
+      const opencodeDir = join(projectDir, ".opencode", "kasper")
+      execSync(`mkdir -p "${opencodeDir}"`, { stdio: "pipe" })
+      writeFileSync(join(projectDir, "AGENTS.md"), realisticAgentsMd, "utf-8")
+      agentsMdManager = new AgentsMdManager(projectDir, opencodeDir, 5)
+    })
+
+    afterAll(() => {
+      if (projectDir) {
+        rmSync(projectDir, { recursive: true, force: true })
+      }
+    })
+
+    test("REGRESSION: 3x /kasper apply accumulates into one section, no nested headers", async () => {
+      // Sanity: the fixture file has exactly one header and one prior body.
+      const before = readFileSync(join(projectDir, "AGENTS.md"), "utf-8")
+      expect(countHeaders(before, SECTION_NAME)).toBe(1)
+      expect(before).toContain("old improvement from a prior apply")
+
+      // ── Mirror the bug-report's steps 1, 2, 3: apply three improvements
+      //    back-to-back, exactly like the user did.
+      for (const improvement of threeImprovements) {
+        await agentsMdManager.lockedUpdate(async (existing) =>
+          agentsMdManager.injectSection(existing, SECTION_NAME, improvement),
+        )
+      }
+
+      const after = readFileSync(join(projectDir, "AGENTS.md"), "utf-8")
+
+      // ── Primary assertion: exactly ONE `## Kasper Inferred Instructions`
+      //    header. With the original bug this would be 2 (apply #1) then
+      //    3 (apply #2) then 4 (apply #3). The PR-fix must keep it at 1.
+      const headerCount = countHeaders(after, SECTION_NAME)
+      expect(headerCount).toBe(1)
+
+      // ── Secondary: ALL improvements are present, none lost.
+      //    (The original bug lost improvement 1 after apply #2, and lost
+      //    improvement 2 after apply #3.)
+      expect(after).toContain("old improvement from a prior apply")
+      for (const imp of threeImprovements) {
+        expect(after).toContain(imp)
+      }
+
+      // ── Tertiary: only ONE provenance line, not stacked.
+      expect(countProvenanceLines(after)).toBe(1)
+
+      // ── Quaternary: order is chronological (oldest first, newest last).
+      const idxOld = after.indexOf("old improvement from a prior apply")
+      const idx1 = after.indexOf(threeImprovements[0])
+      const idx2 = after.indexOf(threeImprovements[1])
+      const idx3 = after.indexOf(threeImprovements[2])
+      expect(idxOld).toBeGreaterThan(-1)
+      expect(idx1).toBeGreaterThan(idxOld)
+      expect(idx2).toBeGreaterThan(idx1)
+      expect(idx3).toBeGreaterThan(idx2)
+
+      // ── Quinary: surrounding content untouched.
+      expect(after).toContain("# My Project")
+      expect(after).toContain("This is a typical AGENTS.md")
+      expect(after).toContain("## Conventions")
+      expect(after).toContain("Follow the existing code style.")
+    })
+
+    test("REGRESSION: AgentPromptManager accumulates with frontmatter (agent prompt case)", async () => {
+      // Common case for an agent prompt: starts with YAML frontmatter and
+      // a # Title and an intro before the target section.
+      const promptDir = join(projectDir, ".opencode", "agents")
+      execSync(`mkdir -p "${promptDir}"`, { stdio: "pipe" })
+
+      const agentName = "build"
+      const realisticPrompt = [
+        "---",
+        "description: My build agent",
+        "mode: subagent",
+        "---",
+        "",
+        "# Build Agent",
+        "",
+        "You are a build agent. Be thorough.",
+        "",
+        `## ${SECTION_NAME}`,
+        "prior rule",
+        "",
+        "## Output Format",
+        "Always print the build result.",
+        "",
+      ].join("\n")
+      const promptPath = join(promptDir, `${agentName}.md`)
+      writeFileSync(promptPath, realisticPrompt, "utf-8")
+
+      // Register the agent so AgentPromptManager's resolver finds it as a
+      // project-level file (this is the real path /kasper apply takes).
+      const apm = new AgentPromptManager(
+        projectDir,
+        join(projectDir, ".opencode", "kasper"),
+      )
+      const source = await apm.resolve(agentName)
+      expect(source.kind).toBe("project_file")
+
+      // Apply three improvements via the same code path /kasper apply uses.
+      for (const imp of threeImprovements) {
+        await apm.injectSection(
+          agentName,
+          SECTION_NAME,
+          imp,
+          true, // backupEnabled
+          20, // maxBackups
+          "subagent", // mode
+          "section", // injectMode (default)
+        )
+      }
+
+      const after = readFileSync(promptPath, "utf-8")
+
+      // Same primary assertion: exactly ONE header.
+      const headerCount = countHeaders(after, SECTION_NAME)
+      expect(headerCount).toBe(1)
+
+      // All improvements preserved.
+      expect(after).toContain("prior rule")
+      for (const imp of threeImprovements) {
+        expect(after).toContain(imp)
+      }
+
+      // Frontmatter and pre-section content preserved.
+      expect(after).toContain("description: My build agent")
+      expect(after).toContain("# Build Agent")
+      expect(after).toContain("You are a build agent. Be thorough.")
+      expect(after).toContain("## Output Format")
+    })
+
+    test("REGRESSION: a freshly-created AGENTS.md (no prior Kasper section) gets a single header on first apply", async () => {
+      // The other half of the bug surface: even on the very first apply,
+      // when the file is realistic (has # Title + intro) and the section
+      // does not yet exist, we must NOT somehow produce a malformed result.
+      const freshDir = mkdtempSync(join(tmpdir(), "kasper-e2e-accum-fresh-"))
+      const opencodeDir = join(freshDir, ".opencode", "kasper")
+      execSync(`mkdir -p "${opencodeDir}"`, { stdio: "pipe" })
+      writeFileSync(
+        join(freshDir, "AGENTS.md"),
+        [
+          "# Brand New Project",
+          "",
+          "Fresh project, no Kasper history.",
+          "",
+        ].join("\n"),
+        "utf-8",
+      )
+
+      const mgr = new AgentsMdManager(freshDir, opencodeDir, 5)
+      await mgr.lockedUpdate(async (existing) =>
+        mgr.injectSection(existing, SECTION_NAME, "first improvement"),
+      )
+
+      const after = readFileSync(join(freshDir, "AGENTS.md"), "utf-8")
+      expect(countHeaders(after, SECTION_NAME)).toBe(1)
+      expect(after).toContain("first improvement")
+      expect(after).toContain("# Brand New Project")
+      // File should end with a trailing newline (POSIX-correct).
+      expect(after.endsWith("\n")).toBe(true)
+
+      rmSync(freshDir, { recursive: true, force: true })
+    })
+  },
+)
diff --git a/tests/prompt-utils.test.ts b/tests/prompt-utils.test.ts
index 8d9dd9f..ee3193b 100644
--- a/tests/prompt-utils.test.ts
+++ b/tests/prompt-utils.test.ts
@@ -6,6 +6,7 @@ import { join } from "node:path"
 import {
   escapeRegex,
   exists,
+  injectSectionContent,
   parseTimestampFromFilename,
   timestampFilename,
   withPathWriteLock,
@@ -141,3 +142,263 @@ describe("writeTextAtomic", () => {
     await rm(dir, { recursive: true, force: true })
   })
 })
+
+describe("injectSectionContent", () => {
+  const NOW = new Date("2026-06-16T05:33:11.079Z")
+  const countMatches = (s: string, re: RegExp) => (s.match(re) || []).length
+
+  // ---- Section exists — accumulation behavior ----
+
+  test("A) section at start of file — no regression", () => {
+    const existing = "## My Section\nold rule\n## Other\nstuff"
+    const { updated, existed } = injectSectionContent(
+      existing,
+      "My Section",
+      "new rule",
+      NOW,
+    )
+    expect(existed).toBe(true)
+    expect(updated).toContain("old rule")
+    expect(updated).toContain("new rule")
+    expect(countMatches(updated, /^## My Section/gm)).toBe(1)
+    expect(updated).toContain("## Other\nstuff")
+  })
+
+  test("B) section preceded by # Title — the bug case (regression test for Issue #1)", () => {
+    const existing =
+      "# Title\n\nIntro paragraph.\n\n## My Section\nold rule\n\n## Other\nstuff"
+    const { updated, existed } = injectSectionContent(
+      existing,
+      "My Section",
+      "new rule",
+      NOW,
+    )
+    expect(existed).toBe(true)
+    expect(updated).toContain("Intro paragraph.")
+    expect(updated).toContain("old rule")
+    expect(updated).toContain("new rule")
+    // Critical: exactly ONE ## My Section header, not two.
+    expect(countMatches(updated, /^## My Section/gm)).toBe(1)
+    // Chronological order: old before new
+    expect(updated.indexOf("old rule")).toBeLessThan(
+      updated.indexOf("new rule"),
+    )
+    // Surrounding sections preserved
+    expect(updated).toContain("## Other")
+  })
+
+  test("C) section preceded by YAML frontmatter — common agent-prompt case", () => {
+    const existing =
+      "---\nmode: subagent\n---\n\nYou are a build agent.\n\n## Kasper Rules\nold rule\n\n## Other\nstuff"
+    const { updated, existed } = injectSectionContent(
+      existing,
+      "Kasper Rules",
+      "new rule",
+      NOW,
+    )
+    expect(existed).toBe(true)
+    expect(updated).toContain("mode: subagent")
+    expect(updated).toContain("You are a build agent.")
+    expect(updated).toContain("old rule")
+    expect(updated).toContain("new rule")
+    // Critical: exactly ONE ## Kasper Rules header
+    expect(countMatches(updated, /^## Kasper Rules/gm)).toBe(1)
+  })
+
+  test("D) section at EOF with no trailing newline", () => {
+    const existing = "## My Section\nold rule" // no final \n
+    const { updated, existed } = injectSectionContent(
+      existing,
+      "My Section",
+      "new rule",
+      NOW,
+    )
+    expect(existed).toBe(true)
+    expect(updated).toContain("old rule")
+    expect(updated).toContain("new rule")
+    expect(countMatches(updated, /^## My Section/gm)).toBe(1)
+    // The file should now end with a newline (Issue #3 consistency)
+    expect(updated.endsWith("\n")).toBe(true)
+  })
+
+  test("E) section preceded by other section content", () => {
+    const existing =
+      "## Intro\nWelcome.\n\n## Kasper Rules\nfirst\n\n## Notes\nsee below"
+    const { updated, existed } = injectSectionContent(
+      existing,
+      "Kasper Rules",
+      "second",
+      NOW,
+    )
+    expect(existed).toBe(true)
+    expect(updated).toContain("Welcome.")
+    expect(updated).toContain("first")
+    expect(updated).toContain("second")
+    expect(countMatches(updated, /^## Kasper Rules/gm)).toBe(1)
+    expect(countMatches(updated, /^## /gm)).toBe(3) // Intro, Kasper Rules, Notes
+  })
+
+  test("F) header-only section (## Section with no body)", () => {
+    const existing = "# Title\n\n## My Section"
+    const { updated, existed } = injectSectionContent(
+      existing,
+      "My Section",
+      "first rule",
+      NOW,
+    )
+    expect(existed).toBe(true)
+    expect(countMatches(updated, /^## My Section/gm)).toBe(1)
+    expect(updated).toContain("first rule")
+    expect(updated.endsWith("\n")).toBe(true)
+  })
+
+  test("G) double-apply accumulation — no nested headers, no stacked provenance", () => {
+    const existing = "# Title\n\nintro\n\n## Rules\nold\n"
+    const r1 = injectSectionContent(existing, "Rules", "rule 1", NOW)
+    const r2 = injectSectionContent(r1.updated, "Rules", "rule 2", NOW)
+    expect(r2.existed).toBe(true)
+    expect(r2.updated).toContain("old")
+    expect(r2.updated).toContain("rule 1")
+    expect(r2.updated).toContain("rule 2")
+    expect(countMatches(r2.updated, /^## Rules/gm)).toBe(1)
+    // Exactly ONE provenance line, not stacked
+    expect(countMatches(r2.updated, /<!-- kasper: 2026-06-16/g)).toBe(1)
+    // Order: old < rule 1 < rule 2
+    expect(r2.updated.indexOf("old")).toBeLessThan(r2.updated.indexOf("rule 1"))
+    expect(r2.updated.indexOf("rule 1")).toBeLessThan(
+      r2.updated.indexOf("rule 2"),
+    )
+  })
+
+  test("H) triple-apply accumulation", () => {
+    const existing = "# Title\n\n## Rules\nold\n"
+    let r = injectSectionContent(existing, "Rules", "a", NOW)
+    r = injectSectionContent(r.updated, "Rules", "b", NOW)
+    r = injectSectionContent(r.updated, "Rules", "c", NOW)
+    expect(r.updated).toContain("old")
+    expect(r.updated).toContain("a")
+    expect(r.updated).toContain("b")
+    expect(r.updated).toContain("c")
+    expect(countMatches(r.updated, /^## Rules/gm)).toBe(1)
+    expect(countMatches(r.updated, /<!-- kasper: 2026-06-16/g)).toBe(1)
+  })
+
+  test("I) section doesn't exist — appends new section at end", () => {
+    const existing = "# Title\n\nintro\n\n## Other\nstuff"
+    const { updated, existed } = injectSectionContent(
+      existing,
+      "Kasper Rules",
+      "new rule",
+      NOW,
+    )
+    expect(existed).toBe(false)
+    expect(updated).toContain("## Kasper Rules")
+    expect(updated).toContain("new rule")
+    expect(updated).toContain("## Other")
+    // New section appears AFTER existing sections
+    expect(updated.indexOf("## Other")).toBeLessThan(
+      updated.indexOf("## Kasper Rules"),
+    )
+  })
+
+  test("J) section doesn't exist, empty file", () => {
+    const { updated, existed } = injectSectionContent(
+      "",
+      "Kasper Rules",
+      "new rule",
+      NOW,
+    )
+    expect(existed).toBe(false)
+    expect(updated).toContain("## Kasper Rules")
+    expect(updated).toContain("new rule")
+    expect(updated.endsWith("\n")).toBe(true)
+  })
+
+  test("K) section name with regex special chars", () => {
+    const existing = "## My Section (v2.0)\nold\n"
+    const { updated, existed } = injectSectionContent(
+      existing,
+      "My Section (v2.0)",
+      "new",
+      NOW,
+    )
+    expect(existed).toBe(true)
+    expect(updated).toContain("old")
+    expect(updated).toContain("new")
+    expect(countMatches(updated, /^## My Section \(v2\.0\)/gm)).toBe(1)
+  })
+
+  test("L) CRLF line endings (Windows file)", () => {
+    const existing =
+      "# Title\r\n\r\n## My Section\r\nold rule\r\n\r\n## Other\r\nstuff\r\n"
+    const { updated, existed } = injectSectionContent(
+      existing,
+      "My Section",
+      "new rule",
+      NOW,
+    )
+    expect(existed).toBe(true)
+    expect(updated).toContain("old rule")
+    expect(updated).toContain("new rule")
+    expect(countMatches(updated, /^## My Section/gm)).toBe(1)
+  })
+
+  test("M) section with extra whitespace in header (##   Section)", () => {
+    const existing = "# Title\n\n##   My Section\nold\n"
+    const { updated, existed } = injectSectionContent(
+      existing,
+      "My Section",
+      "new",
+      NOW,
+    )
+    expect(existed).toBe(true)
+    expect(updated).toContain("old")
+    expect(updated).toContain("new")
+    expect(countMatches(updated, /^##\s+My Section/gm)).toBe(1)
+  })
+
+  test("N) middle section preserves order: A < Target < B", () => {
+    const existing = "## A\naaa\n\n## Target\nold\n\n## B\nbbb"
+    const { updated } = injectSectionContent(existing, "Target", "new", NOW)
+    const aIdx = updated.indexOf("## A")
+    const tIdx = updated.indexOf("## Target")
+    const bIdx = updated.indexOf("## B")
+    expect(aIdx).toBeGreaterThan(-1)
+    expect(tIdx).toBeGreaterThan(aIdx)
+    expect(bIdx).toBeGreaterThan(tIdx)
+    expect(updated.indexOf("aaa")).toBeLessThan(updated.indexOf("old"))
+    expect(updated.indexOf("old")).toBeLessThan(updated.indexOf("new"))
+    expect(updated.indexOf("new")).toBeLessThan(updated.indexOf("bbb"))
+  })
+
+  test("O) accumulated content has blank-line separator", () => {
+    const existing = "## Rules\nfirst"
+    const { updated } = injectSectionContent(existing, "Rules", "second", NOW)
+    // The helper should join with `\n\n` between old and new
+    expect(updated).toMatch(/first\n\nsecond/)
+  })
+
+  test("P) provenance line appears immediately after section header", () => {
+    const existing = "## Rules\nfirst"
+    const { updated } = injectSectionContent(existing, "Rules", "second", NOW)
+    const headerIdx = updated.indexOf("## Rules")
+    const provIdx = updated.indexOf("<!-- kasper:")
+    const bodyIdx = updated.indexOf("first")
+    expect(headerIdx).toBeGreaterThan(-1)
+    expect(provIdx).toBeGreaterThan(headerIdx)
+    expect(bodyIdx).toBeGreaterThan(provIdx)
+  })
+
+  test("Q) repeated apply strips old provenance so it doesn't stack", () => {
+    // If the bug is reintroduced, every apply will add a provenance line at
+    // the top of the body, leading to N provenance lines after N applies.
+    let existing = "# Title\n\n## Rules\nold\n"
+    for (let i = 0; i < 5; i++) {
+      const r = injectSectionContent(existing, "Rules", `r${i}`, NOW)
+      existing = r.updated
+    }
+    expect(countMatches(existing, /<!-- kasper:/g)).toBe(1)
+    // And still only one header
+    expect(countMatches(existing, /^## Rules/gm)).toBe(1)
+  })
+})