Pre-push review: T-1259 strip-md-markers-a11y

diff --git a/prism/Services/FootnoteAccessibility.swift b/prism/Services/FootnoteAccessibility.swift
index 683d459..0d2c649 100644
--- a/prism/Services/FootnoteAccessibility.swift
+++ b/prism/Services/FootnoteAccessibility.swift
@@ -6,18 +6,17 @@
 //

 import Foundation
+import Markdown

 /// Accessibility-layer helpers for inline footnote references.
 ///
 /// Used by `HighlightedInlineText` to override the paragraph's VoiceOver
 /// label so each `[^id]` reads as "footnote N", and to expose one
 /// accessibility action per unique footnote referenced in the paragraph.
-/// See `specs/footnote-badge-a11y/smolspec.md` for the design.
-///
-/// Known limitation (tracked as T-1259): markdown markers (`**bold**`,
-/// `*italic*`, `` `code` ``) in surrounding prose are copied verbatim into
-/// the rebuilt label, so VoiceOver narrates the raw markers. A follow-up
-/// will strip common inline markdown markers before emitting the label.
+/// See `specs/footnote-badge-a11y/smolspec.md` for the design. Surrounding
+/// prose is run through `swift-markdown`'s `Markup.plainText` so VoiceOver
+/// narrates the visible text without inline markdown markers — see
+/// `specs/strip-md-markers-a11y/smolspec.md` (T-1259).
 enum FootnoteAccessibility {
     /// A single resolved footnote reference with its visible display number.
     struct Entry: Equatable, Sendable {
@@ -49,7 +48,7 @@ enum FootnoteAccessibility {
         var label = ""
         var cursor = markdown.startIndex
         for match in markdown.matches(of: FootnoteData.referencePattern) {
-            label.append(contentsOf: markdown[cursor..<match.range.lowerBound])
+            label.append(renderedPlainText(markdown[cursor..<match.range.lowerBound]))
             let identifier = String(match.1)
             if let definition = data.definition(for: identifier) {
                 if seen.insert(identifier).inserted {
@@ -64,10 +63,70 @@ enum FootnoteAccessibility {
             }
             cursor = match.range.upperBound
         }
-        label.append(contentsOf: markdown[cursor...])
+        label.append(renderedPlainText(markdown[cursor...]))
         return Analysis(entries: entries, rebuiltLabel: label)
     }

+    /// Renders `segment` to its visible text by parsing the inline markdown
+    /// and walking the AST. Wrapper elements (emphasis, strong, strikethrough,
+    /// link, image) contribute only their children's text; inline code spans
+    /// emit their literal `code` without the surrounding backticks; unbalanced
+    /// markers survive as literal text, matching the visual rendering. The
+    /// `InlineCode` override is the load-bearing one — swift-markdown's own
+    /// `InlineCode.plainText` re-wraps the code in backticks, which would
+    /// defeat the point.
+    ///
+    /// Leading and trailing whitespace are stripped from the slice before
+    /// parsing so `Document(parsing:)` doesn't treat 4+ leading spaces as an
+    /// indented code block, then re-attached around the result so spacing
+    /// between footnote substitutions survives intact.
+    private static func renderedPlainText(_ segment: Substring) -> String {
+        guard !segment.isEmpty else { return "" }
+        let leadingCount = segment.prefix(while: \.isWhitespace).count
+        let trailingCount = segment.reversed().prefix(while: \.isWhitespace).count
+        guard leadingCount + trailingCount < segment.count else {
+            return String(segment)
+        }
+        let core = segment.dropFirst(leadingCount).dropLast(trailingCount)
+        let leading = segment.prefix(leadingCount)
+        let trailing = segment.suffix(trailingCount)
+        var collector = InlinePlainTextCollector()
+        collector.visit(Document(parsing: String(core)))
+        return String(leading) + collector.result + String(trailing)
+    }
+
+    /// `MarkupWalker` that emits the visible text of an inline AST. Default
+    /// `visit(_:)` recurses into children, so wrapper elements (Emphasis,
+    /// Strong, Strikethrough, Link, Image) contribute only their inner text.
+    /// Leaf overrides emit code content without the `` ` `` delimiters.
+    private struct InlinePlainTextCollector: MarkupWalker {
+        var result = ""
+
+        mutating func visitText(_ text: Text) {
+            result.append(text.string)
+        }
+
+        mutating func visitInlineCode(_ inlineCode: InlineCode) {
+            result.append(inlineCode.code)
+        }
+
+        mutating func visitSymbolLink(_ symbolLink: SymbolLink) {
+            result.append(symbolLink.destination ?? "")
+        }
+
+        mutating func visitInlineHTML(_ inlineHTML: InlineHTML) {
+            result.append(inlineHTML.rawHTML)
+        }
+
+        mutating func visitSoftBreak(_ softBreak: SoftBreak) {
+            result.append(" ")
+        }
+
+        mutating func visitLineBreak(_ lineBreak: LineBreak) {
+            result.append("\n")
+        }
+    }
+
     /// Returns one `Entry` per unique footnote identifier referenced in
     /// `markdown`, in first-occurrence order. Identifiers without a matching
     /// definition in `data` are excluded.

diff --git a/prismTests/FootnoteAccessibilityTests.swift b/prismTests/FootnoteAccessibilityTests.swift
index 2b7a507..24039c7 100644
--- a/prismTests/FootnoteAccessibilityTests.swift
+++ b/prismTests/FootnoteAccessibilityTests.swift
@@ -147,4 +147,183 @@ struct FootnoteAccessibilityTests {
         )
         #expect(result == markdown)
     }
+
+    // MARK: - Inline markdown marker stripping (T-1259)
+
+    @Test("Strong emphasis markers are stripped from surrounding prose")
+    func strongMarkersStripped() {
+        // Exact-match assertion to pin the rebuilt-label shape (prose
+        // preserved, footnote phrase appended in place of `[^a]`).
+        let markdown = "Read **bold** [^a]."
+        let data = Self.footnoteData([("a", 1)])
+        let phrase = String(localized: "a11y.footnote.inline \(1)")
+        let result = FootnoteAccessibility.rebuiltAccessibilityLabel(
+            for: markdown,
+            data: data
+        )
+        #expect(result == "Read bold \(phrase).")
+    }
+
+    @Test("Emphasis markers are stripped from surrounding prose")
+    func emphasisMarkersStripped() {
+        let markdown = "Read *italic* [^a]."
+        let data = Self.footnoteData([("a", 1)])
+        let result = FootnoteAccessibility.rebuiltAccessibilityLabel(
+            for: markdown,
+            data: data
+        )
+        // Asterisks around italic are gone; no leftover stray *
+        #expect(!result.contains("*"))
+        #expect(result.contains("italic"))
+    }
+
+    @Test("Inline code delimiters stripped, code body emitted verbatim")
+    func inlineCodeStripped() {
+        // Inside backticks the asterisks are literal user content, so the
+        // spoken label keeps them — only the surrounding ` delimiters are
+        // removed.
+        let markdown = "Run `**not bold**` [^a] now."
+        let data = Self.footnoteData([("a", 1)])
+        let result = FootnoteAccessibility.rebuiltAccessibilityLabel(
+            for: markdown,
+            data: data
+        )
+        #expect(!result.contains("`"))
+        #expect(result.contains("**not bold**"))
+        #expect(result.hasPrefix("Run "))
+    }
+
+    @Test("Link reduces to its visible text, URL is dropped")
+    func linkUrlDropped() {
+        let markdown = "See [the docs](https://example.com) [^a]."
+        let data = Self.footnoteData([("a", 1)])
+        let result = FootnoteAccessibility.rebuiltAccessibilityLabel(
+            for: markdown,
+            data: data
+        )
+        #expect(!result.contains("https://example.com"))
+        #expect(!result.contains("["))
+        #expect(!result.contains("]"))
+        #expect(!result.contains("("))
+        #expect(!result.contains(")"))
+        #expect(result.contains("the docs"))
+    }
+
+    @Test("Image reduces to its alt text, source is dropped")
+    func imageReducesToAltText() {
+        let markdown = "Spans ![diagram](img.png) [^a]."
+        let data = Self.footnoteData([("a", 1)])
+        let result = FootnoteAccessibility.rebuiltAccessibilityLabel(
+            for: markdown,
+            data: data
+        )
+        #expect(!result.contains("img.png"))
+        #expect(!result.contains("!["))
+        #expect(result.contains("diagram"))
+    }
+
+    @Test("Strikethrough markers are stripped")
+    func strikethroughStripped() {
+        let markdown = "Note ~~old~~ [^a]."
+        let data = Self.footnoteData([("a", 1)])
+        let result = FootnoteAccessibility.rebuiltAccessibilityLabel(
+            for: markdown,
+            data: data
+        )
+        #expect(!result.contains("~~"))
+        #expect(result.contains("old"))
+    }
+
+    @Test("Unbalanced markers are preserved as literal text")
+    func unbalancedMarkersPreserved() {
+        // `*broken` has no closing asterisk; swift-markdown renders the
+        // asterisk literally, so the spoken label should too.
+        let markdown = "One *broken [^a]."
+        let data = Self.footnoteData([("a", 1)])
+        let result = FootnoteAccessibility.rebuiltAccessibilityLabel(
+            for: markdown,
+            data: data
+        )
+        #expect(result.contains("*broken"))
+    }
+
+    @Test("Nested emphasis inside strong both stripped")
+    func nestedEmphasisStripped() {
+        let markdown = "Mixed **bold *italic* end** [^a]."
+        let data = Self.footnoteData([("a", 1)])
+        let result = FootnoteAccessibility.rebuiltAccessibilityLabel(
+            for: markdown,
+            data: data
+        )
+        #expect(!result.contains("*"))
+        #expect(result.contains("bold "))
+        #expect(result.contains("italic"))
+        #expect(result.contains(" end"))
+    }
+
+    @Test("Link text containing strong is fully unwrapped")
+    func linkContainingStrongStripped() {
+        let markdown = "Link [**bold link**](https://x) [^a]."
+        let data = Self.footnoteData([("a", 1)])
+        let result = FootnoteAccessibility.rebuiltAccessibilityLabel(
+            for: markdown,
+            data: data
+        )
+        #expect(!result.contains("*"))
+        #expect(!result.contains("https://x"))
+        #expect(result.contains("bold link"))
+    }
+
+    @Test("Whitespace between adjacent footnote references is preserved")
+    func whitespaceBetweenReferencesPreserved() {
+        let markdown = "First [^a], then [^b]."
+        let data = Self.footnoteData([("a", 1), ("b", 2)])
+        let phrase1 = String(localized: "a11y.footnote.inline \(1)")
+        let phrase2 = String(localized: "a11y.footnote.inline \(2)")
+        let result = FootnoteAccessibility.rebuiltAccessibilityLabel(
+            for: markdown,
+            data: data
+        )
+        #expect(result == "First \(phrase1), then \(phrase2).")
+    }
+
+    @Test("Autolink renders without the angle brackets")
+    func autolinkBracketsStripped() {
+        let markdown = "Visit <https://example.com> [^a]."
+        let data = Self.footnoteData([("a", 1)])
+        let result = FootnoteAccessibility.rebuiltAccessibilityLabel(
+            for: markdown,
+            data: data
+        )
+        #expect(!result.contains("<https://"))
+        #expect(!result.contains(">"))
+        #expect(result.contains("https://example.com"))
+    }
+
+    @Test("Backslash escape emits the literal character without the backslash")
+    func backslashEscapeStripped() {
+        let markdown = "A \\*literal\\* [^a]."
+        let data = Self.footnoteData([("a", 1)])
+        let result = FootnoteAccessibility.rebuiltAccessibilityLabel(
+            for: markdown,
+            data: data
+        )
+        #expect(!result.contains("\\"))
+        #expect(result.contains("*literal*"))
+    }
+
+    @Test("Indented segment doesn't parse as a code block")
+    func indentedSegmentNotInterpretedAsCodeBlock() {
+        // The stripper trims leading/trailing whitespace before parsing,
+        // so a segment with 4+ leading spaces is rendered as inline text
+        // rather than swallowed by an indented code block.
+        let markdown = "    leading-spaces **bold** [^a]."
+        let data = Self.footnoteData([("a", 1)])
+        let phrase = String(localized: "a11y.footnote.inline \(1)")
+        let result = FootnoteAccessibility.rebuiltAccessibilityLabel(
+            for: markdown,
+            data: data
+        )
+        #expect(result == "    leading-spaces bold \(phrase).")
+    }
 }

diff --git a/docs/agent-notes/footnotes.md b/docs/agent-notes/footnotes.md
index a40e6ef..af41d78 100644
--- a/docs/agent-notes/footnotes.md
+++ b/docs/agent-notes/footnotes.md
@@ -34,4 +34,5 @@ The Textual fork pin was updated from `6b0d7ce` (pre-footnote) to `69009d4` (inc
 - Workaround used in Prism: override the view's accessibility label at the SwiftUI layer. `HighlightedInlineText` applies a private `FootnoteAccessibilityModifier` that, when the rendered markdown contains any resolvable `[^id]` reference, replaces the auto-derived label with a string rebuilt from the source markdown by substituting each resolvable `[^id]` with the localised inline phrase ("footnote N"). The modifier is a no-op when there are no resolvable references, so paragraphs without footnotes keep VoiceOver's default narration.
 - The same modifier exposes per-paragraph accessibility actions ("Show footnote N") via `.accessibilityActions { … }`. One Button is emitted per unique footnote identifier in first-occurrence order. Each Button opens `prism://footnote/{identifier}` via `@Environment(\.openURL)`, reusing the `OpenURLAction` already wired in `DocumentReaderView`. There is no separate code path for action invocation versus tap.
 - The helpers (`FootnoteAccessibility.resolvedReferences(in:data:)` and `FootnoteAccessibility.rebuiltAccessibilityLabel(for:data:)`) live in `prism/Services/FootnoteAccessibility.swift` and are unit-tested in `prismTests/FootnoteAccessibilityTests.swift`. Both reuse `FootnoteData.referencePattern` to keep regex behaviour aligned with the rest of the footnote pipeline.
+- Surrounding-prose segments between resolved `[^id]` references are run through a private `swift-markdown`-driven `InlinePlainTextCollector` (T-1259) before being appended to the rebuilt label. The collector is a `MarkupWalker` that emits the visible text of each inline construct: emphasis/strong/strikethrough/link/image wrappers fall away because the walker recurses into their children, and inline code spans emit their literal `code` content without the surrounding backticks (swift-markdown's own `InlineCode.plainText` keeps the backticks, which would defeat the point). Unbalanced markers survive as literal text, matching the visual rendering. Leading/trailing whitespace is preserved around the parsed segment so footnote substitutions don't lose their surrounding spaces. See `specs/strip-md-markers-a11y/`.
 - Scope limit: per-paragraph `.accessibilityActions` is exposed to VoiceOver's Actions rotor. Switch Control and Full Keyboard Access still operate at paragraph granularity; an inline-focus surface for those input methods is out of scope for T-1036.

diff --git a/specs/footnote-badge-a11y/implementation.md b/specs/footnote-badge-a11y/implementation.md
index 1dc990c..143a4e6 100644
--- a/specs/footnote-badge-a11y/implementation.md
+++ b/specs/footnote-badge-a11y/implementation.md
@@ -188,13 +188,11 @@ for a given parsed block, so view identity is preserved across renders.
   VoiceOver in this session.
 - **Overriding `.accessibilityLabel` replaces SwiftUI's auto-derived
   narration.** Once footnotes appear in a paragraph, VoiceOver no
-  longer infers anything from inline markup. The label-rebuilder
-  copies non-footnote text verbatim from the markdown source, which
-  means markdown markers (`**bold**`, `*italic*`, ``code``) survive
-  unstyled into the spoken label. If this turns out to be audibly
-  awful (asterisks being read as "asterisk asterisk"), the
-  rebuilder will need a small inline-markdown stripper before it
-  emits the label.
+  longer infers anything from inline markup. Resolved by T-1259
+  (`specs/strip-md-markers-a11y/`): the label-rebuilder now runs each
+  surrounding-prose segment through a `swift-markdown` `MarkupWalker`
+  so emphasis/strong/code/link/image/strikethrough markers no longer
+  reach VoiceOver's spoken label.
 - **Switch Control / FKA gap is known and unaddressed.** Per-paragraph
   `.accessibilityActions` is a VoiceOver rotor surface; users of those
   input methods still need an inline focus target. The audit owners

diff --git a/specs/strip-md-markers-a11y/smolspec.md b/specs/strip-md-markers-a11y/smolspec.md
new file mode 100644
index 0000000..b0303cd
--- /dev/null
+++ b/specs/strip-md-markers-a11y/smolspec.md
@@ -0,0 +1,162 @@
+# Strip Inline Markdown Markers from Footnote Accessibility Label (T-1259)
+
+## Overview
+
+`FootnoteAccessibility.analyze(markdown:data:)` copies non-footnote prose
+verbatim from the source markdown into the paragraph's rebuilt VoiceOver
+label. When a paragraph contains inline markdown formatting (e.g.
+`**bold**`, `*italic*`, `` `code` ``, `[text](url)`) and at least one
+resolvable footnote reference, the modifier overrides SwiftUI's
+auto-derived narration with a string still carrying the raw markers, so
+VoiceOver reads `"asterisk asterisk bold asterisk asterisk"`. This change
+parses each surrounding-prose segment with `swift-markdown` and emits its
+`plainText` into the rebuilt label, so the spoken paragraph matches what
+the user sees on screen. Follow-up to T-1036 / PR #256, audit finding C2
+in `docs/accessibility-review.md`.
+
+## Requirements
+
+- The rebuilt label produced by
+  `FootnoteAccessibility.analyze(markdown:data:)` MUST narrate the visible
+  text content of each supported inline markdown construct without the
+  raw delimiter characters. Supported constructs: emphasis (`*…*`,
+  `_…_`), strong (`**…**`, `__…__`), inline code (`` `…` ``),
+  strikethrough (`~~…~~`), inline link (`[text](url)` → `text`), image
+  (`![alt](src)` → `alt`), and autolink (`<https://x>` → `https://x`).
+- Source text that is not part of a recognised inline construct (stray
+  asterisks, literal brackets, prose, punctuation) MUST be emitted into
+  the rebuilt label as written. Backslash escapes such as `\*` MUST emit
+  the literal escaped character without the backslash, matching how
+  `swift-markdown` renders the visible text.
+- Inline code content MUST be emitted verbatim (e.g. `` `**not bold**` ``
+  narrates as `"asterisk asterisk not bold asterisk asterisk"`), because
+  inside code spans the markers are literal user content, not styling.
+- The localised inline footnote phrase (e.g. `"footnote 1"`) substituted
+  in place of each resolvable `[^id]` MUST NOT be processed by the
+  stripper, so localisations containing marker-like characters are
+  preserved.
+- Unresolved `[^id]` runs MUST continue to be copied through unchanged,
+  as they are today (no styling, no substitution).
+- Behaviour when the paragraph has no resolvable references MUST be
+  unchanged — the call-site modifier
+  (`FootnoteAccessibilityModifier` in
+  `prism/Views/HighlightedInlineText.swift:238`) still no-ops on empty
+  entries, so VoiceOver's auto-derived narration is preserved for plain
+  paragraphs.
+
+## Implementation Approach
+
+**Single source file changed**: `prism/Services/FootnoteAccessibility.swift`.
+
+Add `import Markdown` and a private helper
+`renderedPlainText(_ segment: Substring) -> String` that parses the
+segment with `Document(parsing: String(segment))` and walks the inline
+AST with a private `InlinePlainTextCollector: MarkupWalker`. Wrapper
+elements (emphasis, strong, strikethrough, link, image) fall away
+naturally because the default `MarkupWalker.visit(_:)` recurses into
+their children. Leaf overrides emit the visible text:
+
+- `visitText`, `visitSoftBreak` (→ `" "`), `visitLineBreak` (→ `"\n"`),
+  `visitInlineHTML` — emit the textual content.
+- `visitInlineCode` emits the literal `code` content **without** the
+  surrounding backticks. swift-markdown's own `InlineCode.plainText`
+  re-wraps in backticks (see
+  `swift-markdown/.../Inline Leaves/InlineCode.swift`), which would
+  defeat the point of the helper.
+- `visitSymbolLink` emits the destination without the double backticks
+  that `SymbolLink.plainText` would inject.
+
+`swift-markdown` is already a project dependency, imported by
+`prism/Services/MarkdownBlockParser.swift:9`,
+`prism/Services/DetailsBlockParser.swift:9`, and
+`prism/Services/ExportSourceMapper.swift:12`.
+
+Update `analyze(markdown:data:)` so the two `label.append(...)` calls
+that currently splice raw `markdown[cursor..<match.range.lowerBound]` and
+`markdown[cursor...]` route through `renderedPlainText`. The localised
+phrase substituted in place of each resolvable `[^id]` is appended
+directly, not via the helper, so translations are untouched.
+
+Leading and trailing whitespace are trimmed from the slice before
+parsing so `Document(parsing:)` doesn't treat 4+ leading spaces as an
+indented code block, then re-attached around the collector's result so
+spacing between footnote substitutions survives intact.
+
+The empty-`FootnoteData` early return continues to bypass the helper and
+return the unchanged `markdown`, matching today's behaviour for the
+plain-paragraph path.
+
+Unit tests extend `prismTests/FootnoteAccessibilityTests.swift` with new
+cases listed in the test plan below.
+
+**Out of scope:**
+
+- Changing the regex-driven walk in `analyze()` to an AST-driven walk
+  over the whole paragraph. Per-segment parsing keeps the existing
+  entry-extraction logic and tests intact while still using the AST for
+  the surrounding prose.
+- Touching the Textual fork, `HighlightedInlineText`, or
+  `Localizable.xcstrings`. The behaviour change is contained to the
+  helper and the two `label.append` call sites.
+- Reference-style links `[text][ref]` with no inline definition in the
+  segment. `swift-markdown` preserves the bracketed text when the
+  reference is undefined; the rebuilt label keeps the same bracketed
+  shape and VoiceOver narrates the brackets. Documented here so the
+  behaviour is intentional, not accidental.
+- Other audit items (C1 / T-1035 heading semantics; C3 / T-1037 badge
+  contrast; Switch Control / FKA focus).
+
+## Risks and Assumptions
+
+- **Risk**: A prose segment slices a markdown construct in half (e.g.
+  the closing `**` of a strong span lives after the next `[^id]`). The
+  helper parses the partial segment and emits the unbalanced markers as
+  literal text. **Mitigation**: This matches the rendered behaviour —
+  `swift-markdown` already treats unbalanced markers as literal text in
+  the rendered paragraph, so the spoken label tracks the visual output.
+  Documented in the test plan with an explicit unbalanced-marker case.
+- **Risk**: Per-segment parsing creates many short-lived `Document`
+  values per render. **Mitigation**: Acceptable — typical paragraphs
+  have ≤ 3 footnotes, so ≤ 4 segments per paragraph. The cost is
+  dominated by SwiftUI's per-render work, same hot-path assumption as
+  the original smolspec for T-1036 in
+  `specs/footnote-badge-a11y/smolspec.md`. The modifier still short-
+  circuits on `entries.isEmpty`, so the helper never runs for plain
+  paragraphs.
+- **Risk**: `Markup.plainText` could change semantics in a future
+  `swift-markdown` upgrade and quietly alter spoken labels. **Mitigation**:
+  Pinned `swift-markdown 0.7.3` in `Package.resolved`; the unit tests
+  encode the expected substitutions so a behaviour shift surfaces as a
+  test failure, not a silent regression.
+- **Assumption**: `Document(parsing:).plainText` preserves leading and
+  trailing whitespace within a single-paragraph fragment. The test
+  plan includes a case ("`First [^a], then [^b].`") that asserts the
+  surrounding spaces are intact.
+- **Prerequisite**: `FootnoteAccessibility.analyze` from T-1036 is on
+  `main` (commit `974b6a6` and prior).
+
+### Test plan
+
+Extend `prismTests/FootnoteAccessibilityTests.swift`. Each case asserts
+on the exact `rebuiltLabel` produced by `analyze`:
+
+| Input (markdown)                                         | Expected rebuilt label                                |
+| -------------------------------------------------------- | ----------------------------------------------------- |
+| `Read **bold** [^a].`                                    | `Read bold ${phrase(1)}.`                             |
+| `Run `` `code` `` [^a] now.`                             | ``Run code ${phrase(1)} now.``                        |
+| `See [docs](http://x) [^a].`                             | `See docs ${phrase(1)}.`                              |
+| `Spans ![alt](img.png) [^a].`                            | `Spans alt ${phrase(1)}.`                             |
+| `Note ~~old~~ [^a].`                                     | `Note old ${phrase(1)}.`                              |
+| `One *broken [^a].`                                      | `One *broken ${phrase(1)}.` (unbalanced kept)         |
+| `` Quote `**inside**` [^a]. ``                           | `Quote **inside** ${phrase(1)}.` (code is literal)    |
+| `First [^a], then [^b].`                                 | `First ${phrase(1)}, then ${phrase(2)}.` (whitespace) |
+| `Mixed **bold *italic* end** [^a].`                      | `Mixed bold italic end ${phrase(1)}.`                 |
+| `Link [**bold link**](u) [^a].`                          | `Link bold link ${phrase(1)}.`                        |
+
+`${phrase(n)}` is the value of
+`String(localized: "a11y.footnote.inline %lld", defaultValue: "footnote %d")`
+for `n`, matching the existing helper at
+`FootnoteAccessibility.swift:97-100`. Tests SHOULD assert on prefix /
+suffix / `contains(phrase(n))` (consistent with the existing
+`rebuiltAccessibilityLabel` tests) so they remain stable across
+localisation tweaks.

diff --git a/specs/strip-md-markers-a11y/decision_log.md b/specs/strip-md-markers-a11y/decision_log.md
new file mode 100644
index 0000000..a446185
--- /dev/null
+++ b/specs/strip-md-markers-a11y/decision_log.md
@@ -0,0 +1,158 @@
+# Decision Log: Strip Inline Markdown Markers from Footnote Accessibility Label
+
+## Decision 1: Use `swift-markdown` AST via `Markup.plainText` rather than regex passes
+
+**Date**: 2026-05-18
+**Status**: accepted
+
+### Context
+
+`FootnoteAccessibility.analyze(markdown:data:)` (added in T-1036) appends
+non-footnote prose verbatim into the paragraph's overridden VoiceOver
+label. When the prose contains inline markdown formatting, the raw
+delimiter characters survive into the spoken label and VoiceOver narrates
+them ("asterisk asterisk bold asterisk asterisk"). The T-1259 chore
+brief proposed two implementation styles: a small inline-markdown
+stripper that runs an ordered sequence of regex substitutions over the
+common marker characters, or a parser-based extraction.
+
+### Decision
+
+Add `import Markdown` to `FootnoteAccessibility.swift` and parse each
+surrounding-prose segment with `Document(parsing: String(segment))`. A
+private `MarkupWalker` (`InlinePlainTextCollector`) walks the inline AST
+and emits visible text — wrapper elements (emphasis, strong,
+strikethrough, link, image) fall away because the default
+`MarkupWalker.visit(_:)` recurses into children; leaf overrides handle
+text/softbreak/linebreak/HTML and strip the delimiters around `InlineCode`
+and `SymbolLink` so the spoken label drops backticks. Leave the existing
+regex-driven walk over footnote references intact.
+
+### Rationale
+
+`swift-markdown` is already a project dependency, used by the same
+`prism/Services/` directory (`MarkdownBlockParser.swift:9`,
+`DetailsBlockParser.swift:9`, `ExportSourceMapper.swift:12`).
+`Markup.plainText` is the standard library API the project uses at
+`MarkdownBlockParser.swift:493,504,515` to extract visible text from
+inline AST. The walker is a thin extension of that idiom because
+swift-markdown's `InlineCode.plainText` re-wraps the literal text in
+backticks (see
+`swift-markdown/.../Inline Leaves/InlineCode.swift:51-53`) and
+`SymbolLink.plainText` re-wraps the destination in double backticks —
+both surface raw markers to VoiceOver. Otherwise the parser handles
+every case the regex approach would need to re-invent: nested emphasis,
+code-span literals (where `**not bold**` inside backticks must stay
+literal), link text vs. URL, image alt text, autolinks, backslash
+escapes, intra-word underscores, and unbalanced markers. The lever
+already exists; there is no value in reimplementing it less correctly.
+
+### Alternatives Considered
+
+- **Ordered regex substitutions over common markers** (the original
+  brief's first suggestion): Rejected after peer review surfaced several
+  correctness gaps. The code-span-first ordering still exposes
+  `` `**not bold**` `` to the later strong pass; non-greedy `\*\*…\*\*`
+  miscounts in `**outer *inner* outer**`; reference-style links
+  (`[t][ref]`), autolinks (`<https://x>`), and backslash escapes
+  (`\*literal\*`) would each need their own pass. Each new pass is more
+  code, more tests, and a wider risk of mangling unrelated punctuation.
+  Concrete in-repo example of that approach:
+  `MarkdownBlock.stripMarkdownFormatting(_:)` at
+  `prism/Models/MarkdownBlock.swift:767` (used by
+  `MarkdownBlock.searchableText` and `TableRowContextQuote.stripMarkdown`)
+  — running its regexes against the new test cases reproduces each gap
+  above, so reusing it would regress the spoken-label contract.
+- **Reuse `Markup.plainText` directly** (no custom walker): Rejected for
+  the `InlineCode`/`SymbolLink` backtick wrapping above. A minimal
+  walker keeps the AST recursion that the protocol already provides
+  while letting the two leaves drop their delimiters.
+- **Refactor `analyze()` to walk a single `Document` parse of the whole
+  paragraph**: Rejected for scope. The current entry-extraction tests
+  exercise the regex walk; replacing that walk would force a re-test of
+  the resolved-references contract and risk regressing the dedupe/order
+  guarantees. Per-segment parsing keeps the contract narrow.
+
+### Consequences
+
+**Positive:**
+- Correctness across all the inline constructs `swift-markdown` already
+  renders. No bespoke handling for nested emphasis or code-span
+  literals.
+- Spoken label tracks the visual rendering by construction — both
+  surfaces share the same parser.
+- Implementation reduces to one helper plus two call sites; the existing
+  entry-extraction walk and tests are unchanged.
+
+**Negative:**
+- Each render path that contains footnotes parses N + 1 short
+  `Document`s (one per prose segment). Acceptable given typical
+  paragraphs have ≤ 3 footnotes and the modifier still no-ops on
+  plain paragraphs.
+- Couples the accessibility label tightly to `Markup.plainText` semantics.
+  Mitigated by pinned `swift-markdown 0.7.3` and the test suite asserting
+  expected substitutions, so a future upgrade surfaces as a test
+  failure rather than a silent narration shift.
+
+### Impact
+
+Scope is contained to `prism/Services/FootnoteAccessibility.swift` and
+new cases in `prismTests/FootnoteAccessibilityTests.swift`. No view-layer
+changes, no localisation changes, no fork changes, no public-API change
+(the existing `analyze` / `rebuiltAccessibilityLabel` /
+`resolvedReferences` signatures are preserved).
+
+---
+
+## Decision 2: Trim and re-attach outer whitespace around the parsed segment
+
+**Date**: 2026-05-18
+**Status**: accepted
+
+### Context
+
+The surrounding-prose segments passed to `renderedPlainText(_:)` are
+slices of the original markdown taken between `[^id]` matches. Many of
+these slices start or end with whitespace (e.g. `", then "`). Feeding
+`Document(parsing:)` raw slices that start with four or more spaces
+would cause CommonMark to treat the segment as an indented code block,
+swallowing the prose into a `CodeBlock` whose plain-text shape is
+unsuitable for the spoken label.
+
+### Decision
+
+`renderedPlainText` trims leading and trailing whitespace from the slice
+before parsing, runs the walker over the trimmed core, and re-attaches
+the original whitespace prefix and suffix around the collector's result.
+
+### Rationale
+
+Trimming before parse keeps `Document(parsing:)` on the inline path
+regardless of the slice's offset in the source paragraph. Re-attaching
+whitespace preserves the spacing the user sees on screen (and matches
+the rendered paragraph's surface form), so the spoken label tracks the
+visible label one-for-one. The Substring `prefix(while:)` /
+`reversed().prefix(while:).count` walks are linear over already-hot
+characters and run on inline-paragraph-sized slices.
+
+### Alternatives Considered
+
+- **Parse the whole paragraph once and walk it**: discussed in
+  Decision 1 — out of scope for this chore.
+- **Skip the trim and accept the indented-code-block edge case**:
+  Rejected because slices with 4+ leading spaces appear in real
+  paragraphs (poetry, formatted lists embedded in prose). Hiding the
+  content from VoiceOver would regress accessibility silently.
+
+### Consequences
+
+**Positive:**
+- Visual spacing in the source paragraph survives into the spoken label.
+- The indented-code-block trap is closed; the test
+  `indentedSegmentNotInterpretedAsCodeBlock` locks the behaviour.
+
+**Negative:**
+- Two extra `prefix(while:)` walks per segment. Negligible at typical
+  paragraph sizes.
+
+---

diff --git a/specs/strip-md-markers-a11y/tasks.md b/specs/strip-md-markers-a11y/tasks.md
new file mode 100644
index 0000000..709ef55
--- /dev/null
+++ b/specs/strip-md-markers-a11y/tasks.md
@@ -0,0 +1,29 @@
+---
+references:
+    - specs/strip-md-markers-a11y/smolspec.md
+    - specs/strip-md-markers-a11y/decision_log.md
+---
+# Strip Inline Markdown Markers from Footnote Accessibility Label (T-1259)
+
+- [ ] 1. Inline-markdown stripper helper with unit tests
+  - Add `import Markdown` to `prism/Services/FootnoteAccessibility.swift` and a private static helper `renderedPlainText(_:)` that parses a `Substring` with `Document(parsing:)` and walks the inline AST with a private `InlinePlainTextCollector: MarkupWalker`. Leaf overrides emit text/softbreak/linebreak/HTML; explicit overrides on `visitInlineCode` and `visitSymbolLink` drop the delimiters that swift-markdown's built-in `plainText` would re-wrap. Pattern reference: `prism/Services/MarkdownBlockParser.swift:493,504,515`.
+  - Wire the helper into `analyze(markdown:data:)` so both `label.append(...)` sites that splice raw `markdown[…]` route through the helper. The substituted localised footnote phrase must NOT pass through the helper.
+  - Trim leading/trailing whitespace from the slice before parsing so `Document(parsing:)` doesn't treat 4+ leading spaces as an indented code block; re-attach the same whitespace around the collector's result.
+  - Add fixtures in `prismTests/FootnoteAccessibilityTests.swift` covering: emphasis/strong (exact-match), inline code with literal asterisks preserved, link text vs. URL, image alt vs. src, strikethrough, autolink, backslash escape, unbalanced markers, nested emphasis, link text containing strong, whitespace preservation between two footnote refs (exact-match), and an indented segment to guard the code-block edge case (exact-match). Assertions use a mix of prefix/suffix/`contains` and explicit `==` so they remain stable across localisation tweaks while still pinning the rebuilt-label shape.
+  - Verification: `make test-quick` stays green (or, given the project's known parallel-runner flakiness, isolated `xcodebuild test -only-testing:prismTests/FootnoteAccessibilityTests` plus `make build-macos` / `make build-ios` clean).
+
+- [ ] 2. Sync the agent-notes footnotes entry
+  - Update `docs/agent-notes/footnotes.md` to note that the rebuilt VoiceOver label now strips inline markdown markers via `swift-markdown`'s `Markup.plainText`. Reference: `specs/strip-md-markers-a11y/smolspec.md` and `specs/strip-md-markers-a11y/decision_log.md`.
+  - Replace the doc-comment caveat at the top of `prism/Services/FootnoteAccessibility.swift:17-20` (the 'Known limitation' block referring to T-1259) with a one-line note describing the current behaviour and the helper that handles it.
+  - Verification: file diffs show only the doc-comment / agent-note edits; no behaviour change.
+
+- [ ] 3. Dual-platform build and lint clean
+  - Run `make lint`, `make build-ios`, and `make build-macos` with zero warnings and zero errors.
+  - Spot-check that no unrelated warnings have appeared in `FootnoteAccessibility.swift` or `HighlightedInlineText.swift`.
+  - Verification: each command exits 0 with clean output.
+
+- [ ] 4. VoiceOver verification on iOS and macOS
+  - iOS Simulator (iPhone 17, iOS 26): open a document with a paragraph mixing `**bold**`, `*italic*`, `` `code` ``, `[text](url)`, and at least one `[^id]` reference. Enable VoiceOver and confirm the paragraph reads without 'asterisk' / 'backtick' narration; footnote phrases still read as 'footnote N'.
+  - macOS: repeat the same check with VoiceOver.
+  - Repeat both checks with search active so the second `HighlightedInlineText` render path is covered.
+  - Verification: spoken labels match the visual paragraph for all four supported constructs plus the unbalanced-marker fixture.