diff --git a/claude-notes/plans/2026-09-10-q2-preview-task-checkbox-layout.md b/claude-notes/plans/2026-09-10-q2-preview-task-checkbox-layout.md
new file mode 100644
index 000000000..03cc5ff2c
--- /dev/null
+++ b/claude-notes/plans/2026-09-10-q2-preview-task-checkbox-layout.md
@@ -0,0 +1,280 @@
+# q2-preview: task-list checkbox renders on its own line above the item text
+
+**Strand:** bd-qif9l4cx
+**Related:** bd-q2wqj24c (CommentBlock wrapper `<div>` breaks parent > child
+parity in general), bd-tvtknbhx (interactive checkboxes; its open polish item
+(2) — loose/Para-leading task items — is fixed by this plan as a by-product).
+**Status:** done 2026-09-10 (all phases; see evidence under Phase 3). PR: https://github.com/quarto-dev/q2/pull/673
+
+## Overview
+
+Reported 2026-09-10 on quarto-hub.com: in the `q2-preview` format a task item
+such as
+
+```markdown
+* \[Elliot\]
+  * looking into QH file sync bug a bit
+  * [x] working with Julia on getting her work on replacing vdocs in Positron merged
+```
+
+renders the checkbox on an empty line by itself, with the item text (and the
+list bullet) on the line below.
+
+### Reproduction (done, 2026-09-10)
+
+Fixture: the snippet above as `tasklist.qmd`, served with
+`target/debug/q2 preview tasklist.qmd --no-browser`, inspected with a headless
+Playwright script (`inspect.mjs`, scratchpad) that finds the checkbox in the
+preview frame and dumps its `<li>`'s outerHTML plus bounding rects. Live DOM of
+the item:
+
+```html
+<li>
+  <label>
+    <input disabled="" type="checkbox" checked="">
+    <div style="position: relative; box-shadow: none; transition: box-shadow 0.15s;">
+      working with Julia on getting her work on replacing vdocs in Positron merged
+    </div>
+  </label>
+</li>
+```
+
+The checkbox's rect is at y=180.8 (13px tall) and the label's at y=175.8 with
+height 51px: two line boxes. A second fixture with only task items
+(`- [x] done item` / `- [ ] todo item`) shows the same DOM under
+`<ul class="task-list">`, so this is not specific to nested or mixed lists —
+**every task item in q2-preview is broken**, hub-client and `q2 preview` alike
+(both mount `PreviewRoot` from `@quarto/preview-renderer`).
+
+The native writer (`pampa -t html`) is fine:
+`<li><label><input type="checkbox" checked="" />working with …</label></li>`.
+There is no CSS involved; the only rules matching are bootstrap's
+`label { display: inline-block }` and `input[type="checkbox"] { margin-right: 0.5ch }`.
+
+### Root cause
+
+`ts-packages/preview-renderer/src/q2-preview/blocks/taskList.tsx`
+(`TaskItemBody`) builds the task `<li>` at the *list* level:
+
+```tsx
+<label>
+  <input type="checkbox" …/>
+  <Node node={strippedTaskHead(item[0])} …/>   // the item's Plain, marker removed
+</label>
+```
+
+`<Node>` for a block routes through the registry's `Block` entry, which since
+Comments v1 (#441, 2026-07-30 — nine days *after* the task-list work in #407,
+2026-07-21) is `CommentBlock`. For every commentable block whose source
+resolves, `CommentBlock` renders a positioned `<div>` wrapper around the block
+so the comment bubble can anchor to it (`custom/CommentBlock.tsx` ~line 980).
+That `<div>` lands *inside* the inline `<label>`, after the `<input>`: a
+block-level box inside an inline container forces the text onto its own line.
+The `<li>` marker attaches to the first line box, which is now the text line
+(a block-level replaced element like a bare `<input>` creates no line box of
+its own), which is why the bullet sits beside the text, not the checkbox.
+
+`CommentBlock` is not the only block wrapper that can appear at that spot:
+
+- `dispatchers.tsx` `Block` wraps its output in `AttributionWrap … as="div"`
+  whenever attribution is resolved (Authors overlay on);
+- `renderMeasuredEdit` replaces the block with a `<div id="q2-active-edit-region">`
+  + textarea while it is being edited, which today would mount the editor
+  *inside* the `<label>`.
+
+So the existing design — "wrap `<Node node={Plain}>` in a `<label>` from the
+outside" — is fragile against every block-level decoration the dispatcher
+stack adds, present or future. The `task-list.integration.test.tsx` suite did
+not catch it because its assertions are structural on `li > label > input`
+only; the wrapper `<div>` sits *after* the input and violates nothing the tests
+check.
+
+(bd-q2wqj24c tracks removing the CommentBlock wrapper element altogether for
+parent > child CSS parity. Even if that lands, the attribution and edit
+wrappers remain, so this fix must not depend on it.)
+
+## Fix design
+
+Move the `<label>` **inside** the item's head block renderer instead of
+outside it, so every block-level wrapper (comment chrome, attribution, edit
+surface) stays *around* the label and the checkbox + text always share one
+inline formatting context. This mirrors the native writer, which rewrites the
+item's head `Plain`/`Paragraph` inlines to
+`RawInline "<label><input …/>" … RawInline "</label>"`
+(`crates/pampa/src/writers/html.rs` `rewrite_task_item`): tight items render
+`<li><label>…</label></li>`, loose items `<li><p><label>…</label></p></li>`.
+
+Mechanism: a small React context carried from the `<li>` to its head block.
+
+```
+BulletList / OrderedList
+  └─ <li data-block-pool-id=…>              (borrow logic unchanged)
+       └─ <TaskItemContext.Provider value={{checked, onToggle}}>   only around item[0], only when taskItemChecked(item) !== null
+            └─ <Node node={item[0]}>        (UNstripped — the head block strips the marker itself)
+                 └─ CommentBlock → AttributionWrap → Plain | Para
+                                                      └─ <label><input …/>{inlines.slice(2)}</label>
+       └─ item.slice(1) blocks              (outside the provider, as today)
+```
+
+- `taskList.tsx` keeps `taskItemChecked`, `allTaskItems`, `makeTaskToggle`
+  (unchanged) and gains `TaskItemContext` + a `TaskLabel` component holding the
+  current `<label>`/`<input>` markup and the pointer-event guards (checkbox
+  clicks must not open the block editor; label-text clicks must not toggle).
+  `TaskItemBody` and `strippedTaskHead` go away.
+- `Plain.tsx`: read `TaskItemContext`; if set **and** this node's inlines start
+  with `Str "☐"|"☒"` + `Space`, render `<TaskLabel …>{inlines.slice(2)}</TaskLabel>`;
+  otherwise the current fragment. The label re-provides `TaskItemContext`
+  as `null` so nothing nested (a footnote's blocks, a custom inline) can
+  inherit it.
+- `Para.tsx`: same check inside the `<p>` (`<p …><TaskLabel …>…</TaskLabel></p>`),
+  which fixes the loose-item gap left open in bd-tvtknbhx ("label can't wrap
+  `<p>`" — it never needed to; the `<p>` wraps the label, as in the writer).
+- `BulletList.tsx` / `OrderedList.tsx` (both the incremental and the plain
+  branches): replace the `checked !== null ? <TaskItemBody/> : …` fork with
+  the provider around `item[0]`; the `task-list` class logic and the pool-id
+  borrow are untouched. The incremental (reveal) branch provides
+  `{checked, onToggle: undefined}` — inert checkbox, as today.
+- The edit path needs no change: when the head `Plain` becomes the edit target,
+  the `Block` dispatcher swaps it for the measured-edit wrapper *before* Plain
+  runs, so the label is simply absent while editing (today it would host the
+  textarea). The rich-text editor still shows the raw ballot glyph — that is
+  bd-tvtknbhx polish item (3), out of scope here.
+
+Why not the alternatives:
+
+- **Bypass the Block dispatcher for the head block** (render its inlines
+  directly inside the label): loses comment extraction — `[>> …]` comment
+  spans would leak into the label text — and loses the comment bubble,
+  attribution colouring, and edit activation for task items.
+- **CSS (`label > div { display: inline }`) or a "no wrapper inside labels"
+  flag on CommentBlock**: patches one wrapper; the attribution and edit
+  wrappers would still break it, and it fights the CSS-parity direction of
+  bd-q2wqj24c.
+
+## Work items
+
+### Phase 1 — tests first (must fail on `main` before Phase 2)
+
+Done 2026-09-10. Before the fix: 5 failed / 5 passed — the three inline-label
+tests failed on `expected <div …> to be null` (the CommentBlock wrapper inside
+the label), the two loose-item tests on `expected +0 to be 2` (no label at
+all). After Phase 2: 10 / 10; full package suites 578 unit + 656 integration
+green. Fixtures: `__fixtures__/task-list-{nested,loose,ordered}.{qmd,ast.json}`.
+
+All in `ts-packages/preview-renderer/src/q2-preview/` (run with
+`npx vitest run task-list` from that package; fixtures generated verbatim with
+`pampa <(printf …) -t json` like the existing ones).
+
+- [x] `task-list.integration.test.tsx`: add a structural assertion to the
+      existing tight-list test — the `<label>` wrapping each checkbox contains
+      **no block-level element** (`label.querySelector('div, p') === null`)
+      and the input's next sibling is the text. This is the regression test
+      for the reported bug; it fails today with the CommentBlock `<div>`.
+- [x] Same file: new test with the reporter's nested/mixed fixture
+      (`* \[Elliot\]` / nested bullets / one `[x]` item). Asserts: the inner
+      `<ul>` has no `task-list` class (writer parity, all-items rule), and the
+      one checkbox's label passes the same no-block-descendant check.
+- [x] Same file: new test that any block-level wrapper is an **ancestor** of
+      the label, i.e. `input.closest('li') > * … > label` — the comment
+      wrapper `<div>` (present in `show` mode) now sits between `<li>` and
+      `<label>`; documents the intended DOM shape.
+- [x] Same file: loose task items (`- [ ] a\n\n- [x] b\n`) render
+      `li > p > label > input` and no ballot glyph in `textContent`
+      (bd-tvtknbhx item 2; fails today — glyph renders as text).
+- [x] Same file: toggle tests keep passing unchanged (they fire `click` on the
+      input and inspect the subtree commit) — they are the guard that the
+      context plumbing delivers `onToggle` correctly. Add one for a loose
+      item toggle.
+- [x] `OrderedList` coverage: one test with `1. [ ] a` / `2. [x] b` asserting
+      `ol` has no `task-list` class and labels are block-free.
+
+### Phase 2 — implementation
+
+- [x] `taskList.tsx`: add `TaskItemContext` and `TaskLabel`; remove
+      `TaskItemBody` / `strippedTaskHead`; update the module comment (the
+      "tight items only … until Para grows a slot" paragraph is obsolete).
+- [x] `Plain.tsx`, `Para.tsx`: consume the context; render `TaskLabel` when the
+      head-marker check passes.
+- [x] `BulletList.tsx`, `OrderedList.tsx`: provide the context around
+      `item[0]` in both branches; drop the `TaskItemBody` fork.
+- [x] `npx vitest run` in `ts-packages/preview-renderer` green; then
+      `cargo xtask verify` (hub-client build + `test:ci` cover the consumer;
+      no Rust change expected, but the TS package is bundled by hub-client and
+      q2-preview-spa). Ran `fnm exec --using=24 cargo xtask verify
+      --skip-rust-tests` (no Rust source changed): all steps passed
+      2026-09-10 — lints, workspace build, ts-packages builds + tests,
+      hub-client `build:all` and `test:ci`, q2-preview-spa build.
+
+### Phase 3 — end-to-end verification (required before declaring done)
+
+- [x] Rebuild the embedded SPA so `q2 preview` picks up the TS change:
+      `cargo xtask build-q2-preview-spa && cargo build --bin q2`.
+- [x] `target/debug/q2 preview tasklist.qmd --no-browser` + the Playwright
+      inspect script: the input and the text now share one line
+      (label height ≈ one line box; input rect and label rect on the same y),
+      `li` outerHTML shows `<li><div …><label><input …>text</label></div></li>`.
+      Record the invocation and the observed DOM in this plan.
+- [x] Same for the all-task fixture and a loose-item fixture
+      (`li > p > label`).
+- [x] hub-client: verified on the reported surface with a permanent e2e spec,
+      `hub-client/e2e/q2-preview-task-list.spec.ts` (real hub on :3031, real
+      q2-preview iframe, headless Chromium). One document with the reporter's
+      nested list + a tight and a loose all-task list; per checkbox it asserts
+      no block element inside the label, `label` is the input's parent, and
+      the text's first client rect starts within the checkbox's height of the
+      checkbox (same line box) — plus `task-list` class parity and
+      `li > p > label` for loose items. Run:
+      `VITE_E2E=1 npm run build && npx playwright test e2e/q2-preview-task-list.spec.ts --project=chromium --workers=1`
+      → 1 passed (3.1s). Red-check: with the renderer changes stashed and the
+      client rebuilt, the same spec fails (`toHaveCount(5)` received 3 — the
+      loose items had no checkbox; the two retries agree), so it guards the
+      fix. Toggle write-back was exercised through `q2 preview --allow-edit`
+      (above); the hub-client path shares `makeTaskToggle` unchanged, and the
+      integration tests cover its commit payload for tight, loose and ordered
+      items.
+- [x] Optional parity check: skipped. The `/preview-parity` harness mounts
+      read-only without `PreviewContext` (bd-q2wqj24c), so it never sees the
+      CommentBlock wrapper and cannot reproduce this bug; the e2e spec above
+      is the browser-level guard instead.
+
+#### q2 preview evidence (2026-09-10, after `cargo xtask build-q2-preview-spa && cargo build --bin q2`)
+
+`target/debug/q2 preview <fixture> --no-browser`, inspected with the headless
+Playwright script (`inspect.mjs`: finds the checkbox in the preview frame,
+dumps its `<li>` outerHTML and rects). Output was read, not inferred:
+
+| fixture | `<li>` outerHTML (abridged) | input top / label top / label height |
+|---|---|---|
+| nested (reporter's) | `<li><div style="position: relative; …"><label><input disabled type="checkbox" checked>working with Julia …</label></div></li>` | 180.8 / 175.8 / **25.5px** (was 51px) |
+| tight all-task | `<li><div …><label><input … checked>done item</label></div></li>`, `ul.task-list` | 22 / 17 / 25.5px |
+| loose all-task | `<li><div …><p data-loc="0:1:7-2:1"><label><input …>todo</label></p></div></li>`, `ul.task-list` | 22 / 17 / 25.5px |
+
+Before the fix the same nested item measured label height 51px with the
+`<div>` inside the label; screenshots `out-*/li.png` show checkbox and text
+on one line.
+
+Toggle write-back, `q2 preview toggle.qmd --no-browser --allow-edit` on a copy
+of the loose fixture, clicking the first checkbox from Playwright: the file on
+disk went from `- [ ] todo` to `* [x] todo` (bullet canonicalisation is
+bd-tvtknbhx item 4, pre-existing); the second item stayed `[x]`. Loose items
+had no checkbox at all before this change.
+
+### Phase 4 — wrap-up
+
+- [x] `braid comment` the strand with the e2e evidence; close it.
+- [x] Comment on bd-tvtknbhx that polish item (2) (loose task items) is done
+      here; items (3) and (4) remain.
+- [x] hub-client changelog entry: needed after all — the e2e spec lives under
+      `hub-client/e2e/`, and the fix is user-visible in hub-client; added in
+      the follow-up changelog commit per the two-commit workflow.
+
+## Decisions (reviewed 2026-09-10)
+
+1. **Scope: tight and loose items both.** The `Para` slot is in scope; loose
+   task items must render `li > p > label > input` like the writer.
+2. **Reveal/incremental branch stays inert.** Provide `onToggle: undefined`
+   in the incremental branch; revealjs task-list behaviour is left for later.
+3. **No guard for a leading comment span** (`[>> note] [x] item`). The reader
+   does not recognise a task marker there, so nothing changes; the simpler
+   implementation is the accepted trade-off and that configuration is
+   unsupported.
diff --git a/hub-client/changelog.md b/hub-client/changelog.md
index 092f37d4d..5575eb2bd 100644
--- a/hub-client/changelog.md
+++ b/hub-client/changelog.md
@@ -23,6 +23,10 @@ WASM rebuild is needed for a changelog-only edit.
 
 -->
 
+### 2026-09-10
+
+- [`0f17a8b2c`](https://github.com/quarto-dev/q2/commits/0f17a8b2c): q2-preview task lists: the checkbox and its item text render on one line again, and loose (blank-line-separated) task items now get checkboxes too
+
 ### 2026-09-09
 
 - [`93b146c`](https://github.com/quarto-dev/q2/commits/93b146c): Edit pill in the document bottom bar turns q2-preview block editing on/off (off makes links plain links); the choice persists
diff --git a/hub-client/e2e/q2-preview-task-list.spec.ts b/hub-client/e2e/q2-preview-task-list.spec.ts
new file mode 100644
index 000000000..c9f395f78
--- /dev/null
+++ b/hub-client/e2e/q2-preview-task-list.spec.ts
@@ -0,0 +1,162 @@
+/**
+ * q2-preview task-list layout (bd-qif9l4cx).
+ *
+ * Reported 2026-09-10 on quarto-hub.com: a `- [x] item` rendered its
+ * checkbox alone on one line with the item text on the next. The cause was
+ * DOM shape, not CSS — the `<li>` built the `<label>` around
+ * `<Node node={Plain}>`, and CommentBlock's positioned `<div>` wrapper (a
+ * block box) landed inside the inline label after the `<input>`. The
+ * preview-renderer integration tests now assert the label holds no block
+ * descendants, but jsdom has no layout: only a real browser can prove the
+ * checkbox and its text share a line box. This spec is that proof, on the
+ * surface the bug was reported on (hub-client's q2-preview iframe).
+ *
+ * One document carries the three list shapes the fix covers:
+ *   - the reporter's nested list mixing plain items with one `[x]` item;
+ *   - a tight all-task list (`<ul class="task-list">`);
+ *   - a loose all-task list (Para-leading items, `li > p > label`).
+ *
+ * Run via:
+ *   cd hub-client && npx playwright test e2e/q2-preview-task-list.spec.ts \
+ *     --project=chromium --workers=1
+ */
+
+import { test, expect, type Page } from '@playwright/test';
+import type {} from './helpers/testHooks';
+import {
+    bootstrapProjectSet,
+    createProjectOnServer,
+    seedProjectInBrowser,
+    getServerUrl,
+} from './helpers/projectFactory';
+import { waitForPreviewRender } from './helpers/previewExtraction';
+
+const Q2_IFRAME = 'iframe[src*="q2-preview.html"]';
+
+const DOC = [
+    '---',
+    'title: Task lists',
+    'format: q2-preview',
+    '---',
+    '',
+    '## Nested',
+    '',
+    '* \\[Elliot\\]',
+    '  * looking into QH file sync bug a bit',
+    '  * part-way thru getting sandboxed-preview up to feature parity with q2-preview',
+    '    - once it is we should (consider) replace q2-preview with it',
+    '  * [x] working with Julia on getting her work on replacing vdocs in Positron merged',
+    '',
+    '## Tight',
+    '',
+    '- [ ] tight todo',
+    '- [x] tight done',
+    '',
+    '## Loose',
+    '',
+    '- [ ] loose todo',
+    '',
+    '- [x] loose done',
+    '',
+].join('\n');
+
+/** Per-checkbox geometry + DOM facts, measured inside the iframe. */
+interface CheckboxFacts {
+    text: string;
+    checked: boolean;
+    /** Tag chain from the label up to (excluding) the <li>. */
+    ancestors: string[];
+    ulClass: string | null;
+    blockInsideLabel: boolean;
+    /** Vertical distance between the input's top and the top of the first
+     * client rect of the text that follows it (both viewport-relative). */
+    textOffsetY: number;
+    inputHeight: number;
+}
+
+async function openDoc(page: Page): Promise<void> {
+    const serverUrl = getServerUrl();
+    const docId = await createProjectOnServer(serverUrl, [
+        { path: '_quarto.yml', content: 'project:\n  type: default\n', contentType: 'text' },
+        { path: 'doc.qmd', content: DOC, contentType: 'text' },
+    ]);
+    await bootstrapProjectSet(page, serverUrl);
+    const localId = await seedProjectInBrowser(page, docId, serverUrl);
+    await page.goto(`/#/p/${localId}/file/doc.qmd`);
+    await waitForPreviewRender(page, { kind: 'q2-preview', timeout: 30000 });
+}
+
+async function collectCheckboxFacts(page: Page): Promise<CheckboxFacts[]> {
+    const frame = page.frameLocator(Q2_IFRAME);
+    const inputs = frame.locator('input[type="checkbox"]');
+    await expect(inputs).toHaveCount(5, { timeout: 30000 });
+    return inputs.evaluateAll((els) =>
+        els.map((el) => {
+            const input = el as HTMLInputElement;
+            const label = input.parentElement as HTMLElement;
+            const li = input.closest('li') as HTMLElement;
+            const ancestors: string[] = [];
+            for (let e = label; e && e !== li; e = e.parentElement as HTMLElement) {
+                ancestors.push(e.tagName.toLowerCase());
+            }
+            // First rect of the text node right after the input.
+            const textNode = Array.from(label.childNodes).find(
+                (n) => n.nodeType === Node.TEXT_NODE && (n.textContent ?? '').trim() !== '',
+            );
+            const range = document.createRange();
+            range.selectNodeContents(textNode ?? label);
+            const textRect = range.getClientRects()[0] ?? range.getBoundingClientRect();
+            const inputRect = input.getBoundingClientRect();
+            return {
+                text: label.textContent ?? '',
+                checked: input.checked,
+                ancestors,
+                ulClass: input.closest('ul')?.getAttribute('class') ?? null,
+                blockInsideLabel: label.querySelector('div, p, ul, ol') !== null,
+                textOffsetY: Math.abs(textRect.top - inputRect.top),
+                inputHeight: inputRect.height,
+            };
+        }),
+    );
+}
+
+test.describe('q2-preview task lists', () => {
+    test('checkbox and item text share one line for nested, tight and loose items', async ({
+        page,
+    }) => {
+        await openDoc(page);
+        const facts = await collectCheckboxFacts(page);
+
+        expect(facts.map((f) => f.text)).toEqual([
+            'working with Julia on getting her work on replacing vdocs in Positron merged',
+            'tight todo',
+            'tight done',
+            'loose todo',
+            'loose done',
+        ]);
+        expect(facts.map((f) => f.checked)).toEqual([true, false, true, false, true]);
+
+        for (const f of facts) {
+            // The regression: a block box inside the label pushed the text
+            // onto its own line. Now every wrapper is an ancestor of the
+            // label, and the text's first rect starts within the checkbox's
+            // own height of the checkbox (same line box).
+            expect(f.blockInsideLabel, `${f.text}: block inside label`).toBe(false);
+            expect(f.ancestors[0], `${f.text}: input parent`).toBe('label');
+            // (The label's own height is deliberately not asserted: a long
+            // item may wrap in a narrow preview pane, which is fine.)
+            expect(f.textOffsetY, `${f.text}: text/checkbox vertical offset`).toBeLessThan(
+                f.inputHeight,
+            );
+        }
+
+        // Writer parity: `class="task-list"` iff every item is a task item.
+        expect(facts[0].ulClass).toBeNull();
+        expect(facts[1].ulClass).toBe('task-list');
+        expect(facts[3].ulClass).toBe('task-list');
+        // Loose items keep the writer's `li > p > label` shape.
+        expect(facts[3].ancestors).toContain('p');
+        expect(facts[4].ancestors).toContain('p');
+        expect(facts[1].ancestors).not.toContain('p');
+    });
+});
diff --git a/ts-packages/preview-renderer/src/q2-preview/__fixtures__/task-list-loose.ast.json b/ts-packages/preview-renderer/src/q2-preview/__fixtures__/task-list-loose.ast.json
new file mode 100644
index 000000000..005fe8133
--- /dev/null
+++ b/ts-packages/preview-renderer/src/q2-preview/__fixtures__/task-list-loose.ast.json
@@ -0,0 +1,147 @@
+{
+  "blocks": [
+    {
+      "c": [
+        [
+          {
+            "c": [
+              {
+                "c": "☐",
+                "s": 2,
+                "t": "Str"
+              },
+              {
+                "s": 3,
+                "t": "Space"
+              },
+              {
+                "c": "todo",
+                "s": 4,
+                "t": "Str"
+              }
+            ],
+            "s": 1,
+            "t": "Para"
+          }
+        ],
+        [
+          {
+            "c": [
+              {
+                "c": "☒",
+                "s": 6,
+                "t": "Str"
+              },
+              {
+                "s": 7,
+                "t": "Space"
+              },
+              {
+                "c": "done",
+                "s": 8,
+                "t": "Str"
+              }
+            ],
+            "s": 5,
+            "t": "Para"
+          }
+        ]
+      ],
+      "s": 0,
+      "t": "BulletList"
+    }
+  ],
+  "meta": {},
+  "pandoc-api-version": [
+    1,
+    23,
+    1
+  ],
+  "astContext": {
+    "files": [
+      {
+        "line_breaks": [
+          10,
+          11,
+          22
+        ],
+        "name": "/task-list-loose.qmd",
+        "total_length": 23
+      }
+    ],
+    "p": [
+      {
+        "d": 0,
+        "r": [
+          0,
+          23
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          6,
+          11
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          2,
+          5
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          5,
+          6
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          6,
+          10
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          18,
+          23
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          14,
+          17
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          17,
+          18
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          18,
+          22
+        ],
+        "t": 0
+      }
+    ]
+  }
+}
diff --git a/ts-packages/preview-renderer/src/q2-preview/__fixtures__/task-list-loose.qmd b/ts-packages/preview-renderer/src/q2-preview/__fixtures__/task-list-loose.qmd
new file mode 100644
index 000000000..e1bfdcf1e
--- /dev/null
+++ b/ts-packages/preview-renderer/src/q2-preview/__fixtures__/task-list-loose.qmd
@@ -0,0 +1,3 @@
+- [ ] todo
+
+- [x] done
diff --git a/ts-packages/preview-renderer/src/q2-preview/__fixtures__/task-list-nested.ast.json b/ts-packages/preview-renderer/src/q2-preview/__fixtures__/task-list-nested.ast.json
new file mode 100644
index 000000000..74ff96f8d
--- /dev/null
+++ b/ts-packages/preview-renderer/src/q2-preview/__fixtures__/task-list-nested.ast.json
@@ -0,0 +1,694 @@
+{
+  "blocks": [
+    {
+      "c": [
+        [
+          {
+            "c": [
+              {
+                "c": "[Elliot]",
+                "s": 6,
+                "t": "Str"
+              }
+            ],
+            "s": 1,
+            "t": "Plain"
+          },
+          {
+            "c": [
+              [
+                {
+                  "c": [
+                    {
+                      "c": "looking",
+                      "s": 9,
+                      "t": "Str"
+                    },
+                    {
+                      "s": 10,
+                      "t": "Space"
+                    },
+                    {
+                      "c": "into",
+                      "s": 11,
+                      "t": "Str"
+                    },
+                    {
+                      "s": 12,
+                      "t": "Space"
+                    },
+                    {
+                      "c": "QH",
+                      "s": 13,
+                      "t": "Str"
+                    },
+                    {
+                      "s": 14,
+                      "t": "Space"
+                    },
+                    {
+                      "c": "file",
+                      "s": 15,
+                      "t": "Str"
+                    },
+                    {
+                      "s": 16,
+                      "t": "Space"
+                    },
+                    {
+                      "c": "sync",
+                      "s": 17,
+                      "t": "Str"
+                    },
+                    {
+                      "s": 18,
+                      "t": "Space"
+                    },
+                    {
+                      "c": "bug",
+                      "s": 19,
+                      "t": "Str"
+                    },
+                    {
+                      "s": 20,
+                      "t": "Space"
+                    },
+                    {
+                      "c": "a",
+                      "s": 21,
+                      "t": "Str"
+                    },
+                    {
+                      "s": 22,
+                      "t": "Space"
+                    },
+                    {
+                      "c": "bit",
+                      "s": 23,
+                      "t": "Str"
+                    }
+                  ],
+                  "s": 8,
+                  "t": "Plain"
+                }
+              ],
+              [
+                {
+                  "c": [
+                    {
+                      "c": "☒",
+                      "s": 25,
+                      "t": "Str"
+                    },
+                    {
+                      "s": 26,
+                      "t": "Space"
+                    },
+                    {
+                      "c": "working",
+                      "s": 27,
+                      "t": "Str"
+                    },
+                    {
+                      "s": 28,
+                      "t": "Space"
+                    },
+                    {
+                      "c": "with",
+                      "s": 29,
+                      "t": "Str"
+                    },
+                    {
+                      "s": 30,
+                      "t": "Space"
+                    },
+                    {
+                      "c": "Julia",
+                      "s": 31,
+                      "t": "Str"
+                    },
+                    {
+                      "s": 32,
+                      "t": "Space"
+                    },
+                    {
+                      "c": "on",
+                      "s": 33,
+                      "t": "Str"
+                    },
+                    {
+                      "s": 34,
+                      "t": "Space"
+                    },
+                    {
+                      "c": "getting",
+                      "s": 35,
+                      "t": "Str"
+                    },
+                    {
+                      "s": 36,
+                      "t": "Space"
+                    },
+                    {
+                      "c": "her",
+                      "s": 37,
+                      "t": "Str"
+                    },
+                    {
+                      "s": 38,
+                      "t": "Space"
+                    },
+                    {
+                      "c": "work",
+                      "s": 39,
+                      "t": "Str"
+                    },
+                    {
+                      "s": 40,
+                      "t": "Space"
+                    },
+                    {
+                      "c": "on",
+                      "s": 41,
+                      "t": "Str"
+                    },
+                    {
+                      "s": 42,
+                      "t": "Space"
+                    },
+                    {
+                      "c": "replacing",
+                      "s": 43,
+                      "t": "Str"
+                    },
+                    {
+                      "s": 44,
+                      "t": "Space"
+                    },
+                    {
+                      "c": "vdocs",
+                      "s": 45,
+                      "t": "Str"
+                    },
+                    {
+                      "s": 46,
+                      "t": "Space"
+                    },
+                    {
+                      "c": "in",
+                      "s": 47,
+                      "t": "Str"
+                    },
+                    {
+                      "s": 48,
+                      "t": "Space"
+                    },
+                    {
+                      "c": "Positron",
+                      "s": 49,
+                      "t": "Str"
+                    },
+                    {
+                      "s": 50,
+                      "t": "Space"
+                    },
+                    {
+                      "c": "merged",
+                      "s": 51,
+                      "t": "Str"
+                    }
+                  ],
+                  "s": 24,
+                  "t": "Plain"
+                }
+              ]
+            ],
+            "s": 7,
+            "t": "BulletList"
+          }
+        ]
+      ],
+      "s": 0,
+      "t": "BulletList"
+    }
+  ],
+  "meta": {},
+  "pandoc-api-version": [
+    1,
+    23,
+    1
+  ],
+  "astContext": {
+    "files": [
+      {
+        "line_breaks": [
+          12,
+          52,
+          137
+        ],
+        "name": "/task-list-nested.qmd",
+        "total_length": 138
+      }
+    ],
+    "p": [
+      {
+        "d": 0,
+        "r": [
+          0,
+          138
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          2,
+          15
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          2,
+          4
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          4,
+          10
+        ],
+        "t": 0
+      },
+      {
+        "d": [
+          [
+            2,
+            0,
+            2
+          ],
+          [
+            3,
+            2,
+            6
+          ]
+        ],
+        "r": [
+          0,
+          8
+        ],
+        "t": 2
+      },
+      {
+        "d": 0,
+        "r": [
+          10,
+          12
+        ],
+        "t": 0
+      },
+      {
+        "d": [
+          [
+            4,
+            0,
+            8
+          ],
+          [
+            5,
+            8,
+            2
+          ]
+        ],
+        "r": [
+          0,
+          10
+        ],
+        "t": 2
+      },
+      {
+        "d": 0,
+        "r": [
+          15,
+          138
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          17,
+          55
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          17,
+          24
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          24,
+          25
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          25,
+          29
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          29,
+          30
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          30,
+          32
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          32,
+          33
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          33,
+          37
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          37,
+          38
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          38,
+          42
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          42,
+          43
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          43,
+          46
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          46,
+          47
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          47,
+          48
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          48,
+          49
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          49,
+          52
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          61,
+          138
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          57,
+          60
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          60,
+          61
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          61,
+          68
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          68,
+          69
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          69,
+          73
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          73,
+          74
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          74,
+          79
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          79,
+          80
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          80,
+          82
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          82,
+          83
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          83,
+          90
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          90,
+          91
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          91,
+          94
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          94,
+          95
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          95,
+          99
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          99,
+          100
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          100,
+          102
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          102,
+          103
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          103,
+          112
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          112,
+          113
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          113,
+          118
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          118,
+          119
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          119,
+          121
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          121,
+          122
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          122,
+          130
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          130,
+          131
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          131,
+          137
+        ],
+        "t": 0
+      }
+    ]
+  }
+}
diff --git a/ts-packages/preview-renderer/src/q2-preview/__fixtures__/task-list-nested.qmd b/ts-packages/preview-renderer/src/q2-preview/__fixtures__/task-list-nested.qmd
new file mode 100644
index 000000000..c93f8ea62
--- /dev/null
+++ b/ts-packages/preview-renderer/src/q2-preview/__fixtures__/task-list-nested.qmd
@@ -0,0 +1,3 @@
+* \[Elliot\]
+  * looking into QH file sync bug a bit
+  * [x] working with Julia on getting her work on replacing vdocs in Positron merged
diff --git a/ts-packages/preview-renderer/src/q2-preview/__fixtures__/task-list-ordered.ast.json b/ts-packages/preview-renderer/src/q2-preview/__fixtures__/task-list-ordered.ast.json
new file mode 100644
index 000000000..0da88f4b5
--- /dev/null
+++ b/ts-packages/preview-renderer/src/q2-preview/__fixtures__/task-list-ordered.ast.json
@@ -0,0 +1,157 @@
+{
+  "blocks": [
+    {
+      "c": [
+        [
+          1,
+          {
+            "t": "Decimal"
+          },
+          {
+            "t": "Period"
+          }
+        ],
+        [
+          [
+            {
+              "c": [
+                {
+                  "c": "☐",
+                  "s": 2,
+                  "t": "Str"
+                },
+                {
+                  "s": 3,
+                  "t": "Space"
+                },
+                {
+                  "c": "todo",
+                  "s": 4,
+                  "t": "Str"
+                }
+              ],
+              "s": 1,
+              "t": "Plain"
+            }
+          ],
+          [
+            {
+              "c": [
+                {
+                  "c": "☒",
+                  "s": 6,
+                  "t": "Str"
+                },
+                {
+                  "s": 7,
+                  "t": "Space"
+                },
+                {
+                  "c": "done",
+                  "s": 8,
+                  "t": "Str"
+                }
+              ],
+              "s": 5,
+              "t": "Plain"
+            }
+          ]
+        ]
+      ],
+      "s": 0,
+      "t": "OrderedList"
+    }
+  ],
+  "meta": {},
+  "pandoc-api-version": [
+    1,
+    23,
+    1
+  ],
+  "astContext": {
+    "files": [
+      {
+        "line_breaks": [
+          11,
+          23
+        ],
+        "name": "/task-list-ordered.qmd",
+        "total_length": 24
+      }
+    ],
+    "p": [
+      {
+        "d": 0,
+        "r": [
+          0,
+          24
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          7,
+          12
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          3,
+          6
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          6,
+          7
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          7,
+          11
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          19,
+          24
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          15,
+          18
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          18,
+          19
+        ],
+        "t": 0
+      },
+      {
+        "d": 0,
+        "r": [
+          19,
+          23
+        ],
+        "t": 0
+      }
+    ]
+  }
+}
diff --git a/ts-packages/preview-renderer/src/q2-preview/__fixtures__/task-list-ordered.qmd b/ts-packages/preview-renderer/src/q2-preview/__fixtures__/task-list-ordered.qmd
new file mode 100644
index 000000000..cbda8a19d
--- /dev/null
+++ b/ts-packages/preview-renderer/src/q2-preview/__fixtures__/task-list-ordered.qmd
@@ -0,0 +1,2 @@
+1. [ ] todo
+2. [x] done
diff --git a/ts-packages/preview-renderer/src/q2-preview/blocks/BulletList.tsx b/ts-packages/preview-renderer/src/q2-preview/blocks/BulletList.tsx
index e8c4fe7d6..b506ef528 100644
--- a/ts-packages/preview-renderer/src/q2-preview/blocks/BulletList.tsx
+++ b/ts-packages/preview-renderer/src/q2-preview/blocks/BulletList.tsx
@@ -4,7 +4,7 @@ import type { BulletListBlock, NodeArgs } from '../../framework';
 import { IncrementalContext } from '../IncrementalContext';
 import { PreviewContext } from '../PreviewContext';
 import { isLeadingBlockBorrowable } from './listBorrow';
-import { allTaskItems, makeTaskToggle, TaskItemBody, taskItemChecked } from './taskList';
+import { allTaskItems, makeTaskToggle, TaskItemBlocks, taskItemChecked } from './taskList';
 
 const NOOP = () => {};
 
@@ -39,7 +39,7 @@ export const BulletList = (args: NodeArgs<BulletListBlock>) => {
                             {checked !== null ? (
                                 // Incremental (reveal) surfaces are never edit-enabled:
                                 // render the checkbox, but inert.
-                                <TaskItemBody
+                                <TaskItemBlocks
                                     item={item}
                                     checked={checked}
                                     onNavigateToDocument={args.onNavigateToDocument}
@@ -86,7 +86,7 @@ export const BulletList = (args: NodeArgs<BulletListBlock>) => {
                 return (
                     <li key={i} {...itemAttrProps} {...liProps}>
                         {checked !== null ? (
-                            <TaskItemBody
+                            <TaskItemBlocks
                                 item={item}
                                 checked={checked}
                                 onToggle={makeTaskToggle(ctx, resolved, i)}
diff --git a/ts-packages/preview-renderer/src/q2-preview/blocks/OrderedList.tsx b/ts-packages/preview-renderer/src/q2-preview/blocks/OrderedList.tsx
index 28a2b3dc0..1feb80944 100644
--- a/ts-packages/preview-renderer/src/q2-preview/blocks/OrderedList.tsx
+++ b/ts-packages/preview-renderer/src/q2-preview/blocks/OrderedList.tsx
@@ -4,7 +4,7 @@ import type { NodeArgs, OrderedListBlock } from '../../framework';
 import { IncrementalContext } from '../IncrementalContext';
 import { PreviewContext } from '../PreviewContext';
 import { isLeadingBlockBorrowable } from './listBorrow';
-import { makeTaskToggle, TaskItemBody, taskItemChecked } from './taskList';
+import { makeTaskToggle, TaskItemBlocks, taskItemChecked } from './taskList';
 
 const NOOP = () => {};
 
@@ -93,7 +93,7 @@ export const OrderedList = (args: NodeArgs<OrderedListBlock>) => {
                 if (checked !== null) {
                     return (
                         <li key={i} {...itemAttrProps} {...liProps}>
-                            <TaskItemBody
+                            <TaskItemBlocks
                                 item={item}
                                 checked={checked}
                                 onToggle={makeTaskToggle(ctx, resolved, i)}
diff --git a/ts-packages/preview-renderer/src/q2-preview/blocks/Para.tsx b/ts-packages/preview-renderer/src/q2-preview/blocks/Para.tsx
index 8c14fd272..5393f52d9 100644
--- a/ts-packages/preview-renderer/src/q2-preview/blocks/Para.tsx
+++ b/ts-packages/preview-renderer/src/q2-preview/blocks/Para.tsx
@@ -2,9 +2,11 @@ import { useContext } from 'react';
 import { renderChildren, dataLocProps } from '../../framework';
 import type { NodeArgs, ParaBlock } from '../../framework';
 import { PreviewContext } from '../PreviewContext';
+import { stripTaskMarker, TaskLabel, useTaskItem } from './taskList';
 
 export const Para = (args: NodeArgs<ParaBlock>) => {
     const ctx = useContext(PreviewContext);
+    const task = useTaskItem();
     const poolId = (args.node as any).s as string | number | undefined;
     const resolved = ctx?.resolveSource ? ctx.resolveSource(args.node) : null;
 
@@ -33,5 +35,17 @@ export const Para = (args: NodeArgs<ParaBlock>) => {
         domProps.tabIndex = -1;
     }
 
-    return <p {...domProps} {...dataLocProps(args.node)}>{renderChildren(args)}</p>;
+    // Head of a loose task item: the writer renders `<p><label><input…/>…</label></p>`;
+    // the label goes INSIDE the <p> so block-level wrappers stay outside it
+    // (bd-qif9l4cx).
+    const body = task ? stripTaskMarker(args.node.c) : null;
+    const children = task && body ? (
+        <TaskLabel state={task}>
+            {renderChildren({ ...args, node: { ...args.node, c: body } })}
+        </TaskLabel>
+    ) : (
+        renderChildren(args)
+    );
+
+    return <p {...domProps} {...dataLocProps(args.node)}>{children}</p>;
 };
diff --git a/ts-packages/preview-renderer/src/q2-preview/blocks/Plain.tsx b/ts-packages/preview-renderer/src/q2-preview/blocks/Plain.tsx
index 8751609ad..50353bd11 100644
--- a/ts-packages/preview-renderer/src/q2-preview/blocks/Plain.tsx
+++ b/ts-packages/preview-renderer/src/q2-preview/blocks/Plain.tsx
@@ -1,6 +1,23 @@
 import { renderChildren } from '../../framework';
 import type { NodeArgs, PlainBlock } from '../../framework';
+import { stripTaskMarker, TaskLabel, useTaskItem } from './taskList';
 
 /** Plain renders no wrapper element — its inlines flow into the
- * surrounding context (table cells, list items, etc.). */
-export const Plain = (args: NodeArgs<PlainBlock>) => <>{renderChildren(args)}</>;
+ * surrounding context (table cells, list items, etc.).
+ *
+ * As the head block of a task item (`TaskItemContext` set by the `<li>`,
+ * inlines starting with the ballot-box marker) it renders the writer's
+ * `<label><input type="checkbox"…/>…</label>` itself, so any block-level
+ * wrapper the dispatcher adds stays outside the label (bd-qif9l4cx). */
+export const Plain = (args: NodeArgs<PlainBlock>) => {
+    const task = useTaskItem();
+    const body = task ? stripTaskMarker(args.node.c) : null;
+    if (task && body) {
+        return (
+            <TaskLabel state={task}>
+                {renderChildren({ ...args, node: { ...args.node, c: body } })}
+            </TaskLabel>
+        );
+    }
+    return <>{renderChildren(args)}</>;
+};
diff --git a/ts-packages/preview-renderer/src/q2-preview/blocks/taskList.tsx b/ts-packages/preview-renderer/src/q2-preview/blocks/taskList.tsx
index 1df4b7fee..df22221d6 100644
--- a/ts-packages/preview-renderer/src/q2-preview/blocks/taskList.tsx
+++ b/ts-packages/preview-renderer/src/q2-preview/blocks/taskList.tsx
@@ -1,34 +1,62 @@
+import { createContext, useContext } from 'react';
+import type { ReactNode } from 'react';
 import { Node } from '../../framework';
-import type { BlockNode } from '../../framework';
+import type { BlockNode, InlineNode } from '../../framework';
 import type { PreviewContextValue } from '../PreviewContext';
 import type { ResolvedSource } from '../sourceIndex';
 
 /**
- * Task-list support (bd-obkvhlam / bd-tvtknbhx).
+ * Task-list support (bd-obkvhlam / bd-tvtknbhx / bd-qif9l4cx).
  *
  * The reader parses `- [ ] todo` into Pandoc's convention: the item's first
  * inline is `Str "☐"` (unchecked) / `Str "☒"` (checked) followed by `Space`.
- * The native HTML writer renders `<ul class="task-list">` with
- * `<label><input type="checkbox" …/>…</label>` per item; this module gives
- * the q2-preview React renderer the same DOM, plus the interactive half: in
- * an edit-enabled surface, toggling a checkbox flips the ballot-box `Str` in
- * the list's *untransformed* source node and commits it through the subtree
- * edit channel — `apply_node_edit` + the qmd writer's task-marker round-trip
- * turn that into a `[ ]` ↔ `[x]` splice in the source file.
+ * The native HTML writer rewrites the item's head `Plain`/`Para` inlines to
+ * `<label><input type="checkbox" …/>…</label>`, so a tight item renders
+ * `<li><label>…</label></li>` and a loose one `<li><p><label>…</label></p></li>`.
+ * This module gives the q2-preview React renderer the same DOM, plus the
+ * interactive half: in an edit-enabled surface, toggling a checkbox flips the
+ * ballot-box `Str` in the list's *untransformed* source node and commits it
+ * through the subtree edit channel — `apply_node_edit` + the qmd writer's
+ * task-marker round-trip turn that into a `[ ]` ↔ `[x]` splice in the source.
  *
- * Tight (`Plain`-leading) items only: the writer nests the `<label>` inside
- * the loose item's `<p>`, which a wrapper around `<Node node={Para}>` cannot
- * reproduce without invalid HTML (`<p>` is not phrasing content, so it cannot
- * go inside `<label>`). Loose task items keep the default text rendering
- * until Para grows a slot for it.
+ * ## Where the `<label>` is built (bd-qif9l4cx)
+ *
+ * The `<label>` is rendered by the head block itself (`Plain`/`Para`), not
+ * by the `<li>` around `<Node node={head}>`. A block dispatched through
+ * `<Node>` picks up block-level decorations on the way — CommentBlock's
+ * positioned wrapper, the attribution wrapper, the measured edit surface —
+ * and any of those landing *inside* an inline `<label>` after the `<input>`
+ * pushes the item text onto its own line (the reported bug). Building the
+ * label inside the block keeps every wrapper an ancestor of the label, so
+ * checkbox and text always share one inline formatting context. The `<li>`
+ * hands the checked state and toggle handler to its head block through
+ * `TaskItemContext`; the head block strips the marker and wraps the rest.
  */
 
-/** `true`/`false` = task item with that checked state; `null` = not a task item. */
+/** What the `<li>` tells its head block: checked state, and the toggle
+ * handler (absent = render a disabled checkbox). */
+export interface TaskItemState {
+    checked: boolean;
+    onToggle?: () => void;
+}
+
+/** Provided by `BulletList`/`OrderedList` around a task item's head block
+ * only. `null` everywhere else, including inside the label's own content. */
+export const TaskItemContext = createContext<TaskItemState | null>(null);
+
+function isTaskMarker(inline: InlineNode | undefined): inline is InlineNode & { t: 'Str'; c: '☐' | '☒' } {
+    return !!inline && inline.t === 'Str' && (inline.c === '☐' || inline.c === '☒');
+}
+
+/** `true`/`false` = task item with that checked state; `null` = not a task
+ * item. Mirrors the writer's `task_item_checked`: the head block is a
+ * `Plain` (tight) or `Para` (loose) whose inlines start with the marker
+ * `Str` followed by `Space`. */
 export function taskItemChecked(item: BlockNode[]): boolean | null {
     const head = item[0] as any;
-    if (!head || head.t !== 'Plain' || !Array.isArray(head.c)) return null;
+    if (!head || (head.t !== 'Plain' && head.t !== 'Para') || !Array.isArray(head.c)) return null;
     const first = head.c[0];
-    if (!first || first.t !== 'Str' || (first.c !== '☐' && first.c !== '☒')) return null;
+    if (!isTaskMarker(first)) return null;
     if (head.c[1]?.t !== 'Space') return null;
     return first.c === '☒';
 }
@@ -39,12 +67,12 @@ export function allTaskItems(items: BlockNode[][]): boolean {
     return items.length > 0 && items.every((item) => taskItemChecked(item) !== null);
 }
 
-/** The item's head block with the marker `Str` + `Space` stripped, so the
- * remaining inlines render inside the `<label>`. Keeps the pool-id (`s`) so
- * the `<li>` borrow behaves exactly as for a non-task tight item. */
-export function strippedTaskHead(head: BlockNode): BlockNode {
-    const h = head as any;
-    return { ...h, c: h.c.slice(2) };
+/** The inlines after the marker `Str` + `Space`, or `null` when `inlines`
+ * does not start with a task marker. Used by the head block to decide
+ * whether it is the task head and what goes inside the `<label>`. */
+export function stripTaskMarker(inlines: InlineNode[]): InlineNode[] | null {
+    if (!isTaskMarker(inlines[0]) || inlines[1]?.t !== 'Space') return null;
+    return inlines.slice(2);
 }
 
 /**
@@ -68,7 +96,7 @@ export function makeTaskToggle(
         const clone = JSON.parse(JSON.stringify(resolved.sourceNode)) as any;
         const items = clone.t === 'OrderedList' ? clone.c?.[1] : clone.c;
         const marker = items?.[itemIndex]?.[0]?.c?.[0];
-        if (!marker || marker.t !== 'Str' || (marker.c !== '☐' && marker.c !== '☒')) {
+        if (!isTaskMarker(marker)) {
             // The transformed and source lists disagree (transform reshaped
             // the list) — refuse a blind edit rather than corrupt the doc.
             return;
@@ -78,9 +106,12 @@ export function makeTaskToggle(
     };
 }
 
-/** The `<label><input type="checkbox"…/>{stripped head inlines}</label>` body
- * of a task `<li>`. Rest-of-item blocks render after the label (writer parity). */
-export function TaskItemBody(props: {
+/**
+ * The blocks of a task `<li>`: the head block under a `TaskItemContext`
+ * provider (so `Plain`/`Para` render the `<label>`), then the rest of the
+ * item's blocks outside it (a nested list must not inherit the state).
+ */
+export function TaskItemBlocks(props: {
     item: BlockNode[];
     checked: boolean;
     onToggle?: () => void;
@@ -88,6 +119,27 @@ export function TaskItemBody(props: {
 }) {
     const { item, checked, onToggle, onNavigateToDocument } = props;
     const noop = () => {};
+    return (
+        <>
+            <TaskItemContext.Provider value={{ checked, onToggle }}>
+                <Node node={item[0]} onNavigateToDocument={onNavigateToDocument} setLocalAst={noop} />
+            </TaskItemContext.Provider>
+            {item.slice(1).map((block, j) => (
+                <Node key={j} node={block} onNavigateToDocument={onNavigateToDocument} setLocalAst={noop} />
+            ))}
+        </>
+    );
+}
+
+/**
+ * `<label><input type="checkbox"…/>{children}</label>` — the writer's task
+ * markup, rendered by the head block with the marker already stripped.
+ * Re-provides `TaskItemContext` as `null` so nothing inside the label
+ * (a footnote's blocks, a custom inline) can mistake itself for the head.
+ */
+export function TaskLabel(props: { state: TaskItemState; children: ReactNode }) {
+    const { checked, onToggle } = props.state;
+    const noop = () => {};
     // Pointer events must not escape the checkbox: the block-edit surface
     // activates on the host's React onPointerUp (useBlockEditHover), so a
     // toggle click would otherwise ALSO open the item's editor. Text clicks
@@ -96,35 +148,26 @@ export function TaskItemBody(props: {
     // any click that isn't on the input itself.
     const stop = (e: { stopPropagation: () => void }) => e.stopPropagation();
     return (
-        <>
-            <label
-                onClick={(e) => {
-                    if ((e.target as HTMLElement).tagName !== 'INPUT') e.preventDefault();
-                }}
-            >
-                <input
-                    type="checkbox"
-                    checked={checked}
-                    disabled={onToggle === undefined}
-                    onChange={onToggle ?? noop}
-                    onClick={stop}
-                    onPointerDown={stop}
-                    onPointerUp={stop}
-                />
-                <Node
-                    node={strippedTaskHead(item[0])}
-                    onNavigateToDocument={onNavigateToDocument}
-                    setLocalAst={noop}
-                />
-            </label>
-            {item.slice(1).map((block, j) => (
-                <Node
-                    key={j}
-                    node={block}
-                    onNavigateToDocument={onNavigateToDocument}
-                    setLocalAst={noop}
-                />
-            ))}
-        </>
+        <label
+            onClick={(e) => {
+                if ((e.target as HTMLElement).tagName !== 'INPUT') e.preventDefault();
+            }}
+        >
+            <input
+                type="checkbox"
+                checked={checked}
+                disabled={onToggle === undefined}
+                onChange={onToggle ?? noop}
+                onClick={stop}
+                onPointerDown={stop}
+                onPointerUp={stop}
+            />
+            <TaskItemContext.Provider value={null}>{props.children}</TaskItemContext.Provider>
+        </label>
     );
 }
+
+/** The current task-item state, or `null` outside a task head block. */
+export function useTaskItem(): TaskItemState | null {
+    return useContext(TaskItemContext);
+}
diff --git a/ts-packages/preview-renderer/src/q2-preview/task-list.integration.test.tsx b/ts-packages/preview-renderer/src/q2-preview/task-list.integration.test.tsx
index 28b90f4ad..f18e84f2f 100644
--- a/ts-packages/preview-renderer/src/q2-preview/task-list.integration.test.tsx
+++ b/ts-packages/preview-renderer/src/q2-preview/task-list.integration.test.tsx
@@ -16,9 +16,14 @@
 
 import { describe, it, expect, afterEach, vi } from 'vitest';
 import { render, cleanup, fireEvent } from '@testing-library/react';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
 import { PreviewRoot } from './PreviewRoot';
 import type { PreviewRootProps } from './PreviewRoot';
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
 afterEach(() => {
     cleanup();
     vi.restoreAllMocks();
@@ -93,15 +98,54 @@ function mountPreviewRoot(overrides: Partial<PreviewRootProps> = {}) {
     return { setAst, ...render(<PreviewRoot {...props} />) };
 }
 
+/**
+ * Larger fixtures live in `__fixtures__/task-list-<name>.{qmd,ast.json}`;
+ * the JSON is verbatim `pampa <name>.qmd -t json` with the file name in
+ * `astContext.files[0].name` rewritten to `/task-list-<name>.qmd`.
+ */
+function mountFixture(name: string, overrides: Partial<PreviewRootProps> = {}) {
+    const dir = join(__dirname, '__fixtures__');
+    const astJson = readFileSync(join(dir, `task-list-${name}.ast.json`), 'utf8');
+    const content = readFileSync(join(dir, `task-list-${name}.qmd`), 'utf8');
+    return mountPreviewRoot({
+        astJson,
+        untransformedAstJson: astJson,
+        renderedContent: content,
+        currentFilePath: `/task-list-${name}.qmd`,
+        ...overrides,
+    });
+}
+
+/**
+ * The regression this file guards (bd-qif9l4cx): the checkbox and the
+ * item text must share one inline formatting context. Block-level
+ * decorations the dispatcher stack adds (CommentBlock's positioned
+ * wrapper, the attribution wrapper, the edit surface) must be ANCESTORS
+ * of the `<label>`, never descendants — a `<div>` after the `<input>`
+ * inside the label pushes the text onto its own line.
+ */
+function expectInlineLabel(input: Element, text: string) {
+    const label = input.parentElement!;
+    expect(label.tagName).toBe('LABEL');
+    expect(label.firstElementChild).toBe(input);
+    expect(label.querySelector('div, p, ul, ol, pre, table, section')).toBeNull();
+    expect(label.textContent).toBe(text);
+    // Wrappers may sit between the <li> and the label, never inside it.
+    expect(label.closest('li')).not.toBeNull();
+}
+
 describe('task-list rendering', () => {
     it('renders ul.task-list with label-wrapped checkboxes (writer parity)', () => {
         const { container } = mountPreviewRoot();
         const ul = container.querySelector('ul.task-list');
         expect(ul).not.toBeNull();
-        const inputs = ul!.querySelectorAll('li > label > input[type="checkbox"]');
+        const inputs = ul!.querySelectorAll('li label > input[type="checkbox"]');
         expect(inputs.length).toBe(2);
         expect((inputs[0] as HTMLInputElement).checked).toBe(false);
         expect((inputs[1] as HTMLInputElement).checked).toBe(true);
+        // Checkbox and text on one line: no block box inside the label.
+        expectInlineLabel(inputs[0], 'todo');
+        expectInlineLabel(inputs[1], 'done');
         // The ballot-box characters must not leak into the visible text.
         expect(container.textContent).not.toContain('☐');
         expect(container.textContent).not.toContain('☒');
@@ -174,3 +218,71 @@ describe('task-list rendering', () => {
         expect(setAst).not.toHaveBeenCalled();
     });
 });
+
+describe('task-list DOM shape across list kinds (bd-qif9l4cx)', () => {
+    it('nested mixed list: the one task item keeps its checkbox inline', () => {
+        // The reporter's document: an outer bullet whose nested list mixes
+        // plain items with a single `[x]` item.
+        const { container } = mountFixture('nested');
+        const inputs = container.querySelectorAll('input[type="checkbox"]');
+        expect(inputs.length).toBe(1);
+        expect((inputs[0] as HTMLInputElement).checked).toBe(true);
+        expectInlineLabel(
+            inputs[0],
+            'working with Julia on getting her work on replacing vdocs in Positron merged',
+        );
+        // Writer parity: `class="task-list"` only when EVERY item is a task.
+        const innerUl = inputs[0].closest('ul')!;
+        expect(innerUl.classList.contains('task-list')).toBe(false);
+        expect(innerUl.querySelectorAll(':scope > li').length).toBe(2);
+        expect(container.querySelector('ul.task-list')).toBeNull();
+        expect(container.textContent).not.toContain('☒');
+    });
+
+    it('loose (Para-leading) items render li > p > label > input (writer parity)', () => {
+        const { container } = mountFixture('loose');
+        const inputs = container.querySelectorAll('li p > label > input[type="checkbox"]');
+        expect(inputs.length).toBe(2);
+        expect((inputs[0] as HTMLInputElement).checked).toBe(false);
+        expect((inputs[1] as HTMLInputElement).checked).toBe(true);
+        expectInlineLabel(inputs[0], 'todo');
+        expectInlineLabel(inputs[1], 'done');
+        expect(container.querySelector('ul.task-list')).not.toBeNull();
+        expect(container.textContent).not.toContain('☐');
+        expect(container.textContent).not.toContain('☒');
+    });
+
+    it('toggling a loose item flips its Para marker through the subtree channel', () => {
+        const { container, setAst } = mountFixture('loose');
+        const inputs = container.querySelectorAll('input[type="checkbox"]');
+        fireEvent.click(inputs[0]);
+
+        expect(setAst).toHaveBeenCalledTimes(1);
+        const payload = setAst.mock.calls[0][0];
+        expect(payload.channel).toBe('subtree');
+        const list = JSON.parse(payload.modifiedSubtreeJson).blocks[0];
+        expect(list.t).toBe('BulletList');
+        expect(list.c[0][0].t).toBe('Para');
+        expect(list.c[0][0].c[0]).toMatchObject({ t: 'Str', c: '☒' });
+        expect(list.c[1][0].c[0]).toMatchObject({ t: 'Str', c: '☒' });
+    });
+
+    it('ordered lists render inline checkboxes and never carry the task-list class', () => {
+        const { container, setAst } = mountFixture('ordered');
+        const ol = container.querySelector('ol')!;
+        expect(ol.classList.contains('task-list')).toBe(false);
+        const inputs = ol.querySelectorAll('li label > input[type="checkbox"]');
+        expect(inputs.length).toBe(2);
+        expect((inputs[0] as HTMLInputElement).checked).toBe(false);
+        expect((inputs[1] as HTMLInputElement).checked).toBe(true);
+        expectInlineLabel(inputs[0], 'todo');
+        expectInlineLabel(inputs[1], 'done');
+
+        fireEvent.click(inputs[1]);
+        expect(setAst).toHaveBeenCalledTimes(1);
+        const list = JSON.parse(setAst.mock.calls[0][0].modifiedSubtreeJson).blocks[0];
+        expect(list.t).toBe('OrderedList');
+        expect(list.c[1][0][0].c[0]).toMatchObject({ t: 'Str', c: '☐' });
+        expect(list.c[1][1][0].c[0]).toMatchObject({ t: 'Str', c: '☐' });
+    });
+});