From ddf486298ab21b260d9af5a4322563dd8afbe75e Mon Sep 17 00:00:00 2001
From: Chris0Jeky <jeky.tck@gmail.com>
Date: Sat, 5 Sep 2026 08:04:02 +0100
Subject: [PATCH 1/4] test(guards): scan wrapper button call sites for dead
 affordances

PaperHLBtn, TdButton and TdIconButton each render a native <button> root and
declare click as an emit, so the component file passes the native-button scan
while an unbound call site ships an enabled control that does nothing. Nothing
scanned the ~150 call sites, and ESLint's click-events-have-key-events cannot
fire on markup with no click handler at all.

findDeadWrapperButtons reports a call site unless it binds a click, uses v-on
object syntax, carries a static type=submit with a proven form owner, is
permanently disabled, or is a marked visual specimen. Form ownership reuses
formIds and hasFormOwner rather than restating the proof.

The submit clause is deliberately not a copy of the native one: all three
components default the type prop to 'button', so an untyped wrapper inside a
form submits nothing, unlike a native button.

directiveOnlyMarkup now keeps a bare v-on alongside v-on:x so object syntax is
read through the same attribute-boundary parse that rejects an inert
data-note='v-on="{ click: run }"'. No existing finding changes.

The repo-wide assertion is red at this commit with the seven style-guide
specimens the next commit marks.
---
 .../src/tests/guards/deadAnchors.spec.ts      | 277 +++++++++++++++++-
 1 file changed, 268 insertions(+), 9 deletions(-)

diff --git a/frontend/taskdeck-web/src/tests/guards/deadAnchors.spec.ts b/frontend/taskdeck-web/src/tests/guards/deadAnchors.spec.ts
index 73db1c037..bc04530a6 100644
--- a/frontend/taskdeck-web/src/tests/guards/deadAnchors.spec.ts
+++ b/frontend/taskdeck-web/src/tests/guards/deadAnchors.spec.ts
@@ -4,12 +4,14 @@ import { baseParse, ElementTypes, NodeTypes, parserOptions } from '@vue/compiler
 /**
  * Dead-affordance source guard.
  *
- * WHAT THIS MECHANIZES: two source shapes that look interactive and do nothing:
+ * WHAT THIS MECHANIZES: source shapes that look interactive and do nothing:
  * an `<a>` tag whose href is a placeholder destination — the bare `#`, the
- * empty string, or a `javascript:` scheme — and an enabled-looking
+ * empty string, or a `javascript:` scheme — an enabled-looking
  * native `<button>` with no detectable action binding or native form semantics,
- * plus interactive `aria-label` semantics that are not native or keyboard
- * reachable. Labelled custom buttons must expose both Enter and Space
+ * an enabled-looking CALL SITE of a wrapper button component (`<PaperHLBtn>`,
+ * `<TdButton>`, `<TdIconButton>`) that binds no click and has no native submit
+ * semantics, plus interactive `aria-label` semantics that are not native or
+ * keyboard reachable. Labelled custom buttons must expose both Enter and Space
  * activation rather than merely listening for an arbitrary key.
  * The GH-1941 defect was the BOUND anchor form, `:href="tuneHref ?? '#'"`, so
  * both static and bound placeholder hrefs are detected.
@@ -26,9 +28,19 @@ import { baseParse, ElementTypes, NodeTypes, parserOptions } from '@vue/compiler
  *    compiler-backed guard below, but remain unproven action evidence.
  *  - A static `draggable="true"` is treated as native drag activation; the
  *    guard cannot prove which ancestor receives the drag event.
- *  - Component tags (for example `<PaperHLBtn>`) are not compiler-expanded;
- *    this guard only checks their explicit role/action source shape. Their
- *    rendered root still needs component tests for the final DOM contract.
+ *  - Component tags are not compiler-expanded. The three wrapper BUTTON
+ *    components are now scanned at their call sites (see
+ *    `WRAPPER_BUTTON_COMPONENTS`), but only for the source shapes listed there:
+ *    their rendered root still needs component tests for the final DOM
+ *    contract, and every other component tag is checked for nothing beyond its
+ *    explicit role/action source shape.
+ *  - A wrapper call site is redeemed by a click binding, `v-on` object syntax,
+ *    a static `type="submit"` with a proven form owner, a permanent disabled,
+ *    or the specimen marker — and by nothing else. A fallthrough pointer
+ *    listener (`@mousedown`) IS live at runtime and is still reported, because
+ *    a button reachable only by pointer is not operable from the keyboard;
+ *    `@[dynamicEvent]` is reported because source text cannot say which event
+ *    it resolves to. Neither shape exists today.
  *  - `v-on="{ click: fn }"` object syntax and `@[dynamicEvent]` are reported
  *    on native controls by the compiler-backed guard below. No such tag exists
  *    today; do not delete that finding without proving the runtime event.
@@ -37,7 +49,8 @@ import { baseParse, ElementTypes, NodeTypes, parserOptions } from '@vue/compiler
  *  - An expression that concatenates onto the literal (`:href="'#' + id"`)
  *    resolves to a real fragment but IS reported. The guard prefers that false
  *    positive to missing the GH-1941 shape; no such expression exists today.
- *  - The four intentionally inert Paper style-guide specimens carry a narrow
+ *  - The eleven intentionally inert Paper style-guide specimens — four native
+ *    `.pbtn` buttons and seven `<PaperHLBtn>` call sites — carry a narrow
  *    `data-dead-affordance-exempt="visual-specimen"` marker. A new product
  *    control must not copy that marker; the rest of the view is scanned.
  *
@@ -161,6 +174,54 @@ const NATIVE_INTERACTIVE_COMPONENTS = new Set([
   'tdiconbutton',
 ])
 
+/**
+ * The button-shaped subset of `NATIVE_INTERACTIVE_COMPONENTS`, scanned at every
+ * call site (GH-1949).
+ *
+ * Each of these renders a single native `<button>` root and declares `click` as
+ * an emit, so the component FILE always passes the native-button scan above —
+ * its own root carries `@click="onClick"`. What ships dead is the CALL SITE: an
+ * `<PaperHLBtn label="Apply" />` with no `@click` renders an enabled, focusable
+ * button that does nothing, and because the markup contains no click handler at
+ * all, `vuejs-accessibility/click-events-have-key-events` never fires either.
+ * That is the GH-1941 defect wearing component clothing, and until this slice
+ * nothing scanned the ~150 call sites.
+ *
+ * `router-link` and `InputAssistField` are deliberately NOT here: a router link
+ * is actionable through `to`, not a click binding, and the assist field is an
+ * input rather than a command control. Both stay in the shared native list
+ * because that list answers a different question (keyboard reachability for the
+ * aria-label scan). A test below pins this set as a subset of that one.
+ */
+const WRAPPER_BUTTON_COMPONENTS = new Set(['paperhlbtn', 'tdbutton', 'tdiconbutton'])
+
+/**
+ * Opening/closing form and wrapper-button tags, with quoted values consumed
+ * whole. Built from the set above so the two cannot drift; the `i` flag is what
+ * makes the lower-cased names match the PascalCase source spelling.
+ */
+const FORM_OR_WRAPPER_BUTTON_TAG = new RegExp(
+  `<\\/?(?:form|${[...WRAPPER_BUTTON_COMPONENTS].join('|')})(?=[\\s>/])(?:"[^"]*"|'[^']*'|[^>'"])*>`,
+  'gi',
+)
+
+/**
+ * A `type` attribute with its NAME captured, so a bound `:type` can be rejected
+ * without resolving it — the same trade the native scan makes. Shaped like
+ * `TABINDEX_ATTR` rather than `BUTTON_TYPE_ATTR`, which discards the prefix.
+ */
+const WRAPPER_TYPE_ATTR = /\s((?::|v-bind:)?type)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/i
+
+/** A leading binding prefix on an attribute name, in either spelling. */
+const BINDING_PREFIX = /^(?::|v-bind:)/i
+
+/**
+ * `v-on="{ click: fn }"` object syntax. On a component whose declared emit is
+ * `click` this really does wire activation, so it redeems a call site — unlike
+ * on a native control, where the compiler-backed scan reports it as unproven.
+ */
+const VON_OBJECT_BINDING = /(?:^|\s)v-on\s*=\s*(?:"([^"]*)"|'([^']*)')/i
+
 /** Opening tags for native or custom elements. Quoted values are consumed whole. */
 const OPENING_TAG = /<([A-Za-z][\w.-]*)(?=[\s>/])(?:"[^"]*"|'[^']*'|[^>'"])*>/g
 
@@ -245,7 +306,11 @@ function directiveOnlyMarkup(tag: string): string {
 
   for (const match of body.matchAll(OPENING_ATTRIBUTE)) {
     const name = match[1]
-    if (!name.startsWith('@') && !/^v-on:/i.test(name)) continue
+    // `v-on` with no argument is kept as well as `v-on:x`, so the wrapper scan
+    // can read object syntax through the same attribute-boundary parse that
+    // keeps an inert `data-note='v-on="{ click: run }"'` out. Nothing else keys
+    // off a bare `v-on`, so no existing finding changes.
+    if (!name.startsWith('@') && !/^v-on(?::|$)/i.test(name)) continue
 
     directives.push(match[0])
   }
@@ -427,6 +492,74 @@ function findDeadButtons(source: string): string[] {
   return dead
 }
 
+/** True when the call site wires the component's declared `click` emit through `v-on` object syntax. */
+function hasVOnObjectBinding(tag: string): boolean {
+  const match = VON_OBJECT_BINDING.exec(directiveOnlyMarkup(tag))
+  if (!match) return false
+  return (match[1] ?? match[2] ?? '').trim().length > 0
+}
+
+/**
+ * Native submit semantics for a wrapper call site: a STATIC `type="submit"`
+ * plus a form owner the source can prove.
+ *
+ * The asymmetry with a native button matters and is the reason this is not a
+ * copy of that clause. `<button>` inside a form defaults to `type="submit"`, so
+ * the native scan treats a missing type as submit. All three wrapper components
+ * declare `type` with a `'button'` DEFAULT, so a `<PaperHLBtn>` inside a form
+ * with no type renders `type="button"` and submits nothing. Only the explicit
+ * static value counts here. `type="reset"` is not accepted: no call site uses
+ * it, and `TdIconButton` hard-codes `type="button"` on its root, so the claim
+ * would rest on attribute-fallthrough precedence rather than a declared prop.
+ */
+function hasStaticSubmitWithFormOwner(
+  tag: string,
+  formDepth: number,
+  knownFormIds: Set<string>,
+): boolean {
+  const match = WRAPPER_TYPE_ATTR.exec(tag)
+  if (!match || BINDING_PREFIX.test(match[1])) return false
+  const type = (match[2] ?? match[3] ?? match[4] ?? '').trim().toLowerCase()
+  if (type !== 'submit') return false
+  return hasFormOwner(tag, formDepth, knownFormIds)
+}
+
+/**
+ * Wrapper-component call sites that look like an enabled button and do nothing.
+ *
+ * Form depth is tracked across the same match stream as the wrapper tags so a
+ * `type="submit"` inside a `<form>` is recognised in document order, exactly as
+ * `findDeadButtons` does for native controls. `formIds` and `hasFormOwner` are
+ * reused rather than reimplemented: the form-ownership proof is one rule.
+ */
+function findDeadWrapperButtons(source: string): string[] {
+  const dead: string[] = []
+  const markup = markupOnly(source)
+  const knownFormIds = formIds(markup)
+  let formDepth = 0
+
+  for (const [tag] of markup.matchAll(FORM_OR_WRAPPER_BUTTON_TAG)) {
+    if (/^<form\b/i.test(tag)) {
+      if (!/\/\s*>$/.test(tag)) formDepth += 1
+      continue
+    }
+    if (/^<\/form\b/i.test(tag)) {
+      formDepth = Math.max(0, formDepth - 1)
+      continue
+    }
+    if (/^<\//.test(tag)) continue
+
+    if (BUTTON_SPECIMEN_MARKER.test(tag)) continue
+    if (hasNonEmptyBinding(tag, CLICK_BINDING)) continue
+    if (hasVOnObjectBinding(tag)) continue
+    if (isPermanentlyDisabled(tag)) continue
+    if (hasStaticSubmitWithFormOwner(tag, formDepth, knownFormIds)) continue
+
+    dead.push(tag.replace(/\s+/g, ' '))
+  }
+  return dead
+}
+
 /** Extract the opening tag name without depending on Vue compiler expansion. */
 function openingTagName(tag: string): string {
   return /^<([A-Za-z][\w.-]*)/.exec(tag)?.[1]?.toLowerCase() ?? ''
@@ -522,6 +655,14 @@ const DEAD_ANCHOR_FIXTURE = `<template><a :href="tuneHref ?? '#'" class="tune">T
 
 /** The GH-1932 avatar shape: a labelled generic element with no focus or action semantics. */
 const DEAD_ARIA_LABEL_FIXTURE = `<template><div class="paper-topbar__avatar" aria-label="Profile: D">D</div></template>`
+
+/**
+ * The GH-1949 wrapper shape: an enabled, labelled `<PaperHLBtn>` call site with
+ * nothing bound. Synthetic for the same reason as `DEAD_ANCHOR_FIXTURE` — the
+ * correct fix for a real offender deletes the string and would silently redden
+ * a canary pinned to it.
+ */
+const DEAD_WRAPPER_BUTTON_FIXTURE = `<template><PaperHLBtn label="Apply" variant="ember" /></template>`
 const COMPILER_DYNAMIC_LISTENER_FIXTURE =
   '<template><button @[eventName]="run">Dynamic</button><button v-on="{ click: run }">Object</button></template>'
 
@@ -537,6 +678,14 @@ describe('dead affordances', () => {
     // The third way: a regex typo turns the repo-wide assertion into a green
     // no-op. The fixture is synthetic on purpose — see DEAD_ANCHOR_FIXTURE.
     expect(findDeadAnchors(DEAD_ANCHOR_FIXTURE)).toHaveLength(1)
+    expect(findDeadWrapperButtons(DEAD_WRAPPER_BUTTON_FIXTURE)).toHaveLength(1)
+
+    // The wrapper scan must be looking at real call sites, not at nothing: the
+    // components are used ~150 times across the SFCs this glob returns.
+    const wrapperCallSites = Object.values(VUE_SOURCES).filter((source) =>
+      /<(?:PaperHLBtn|TdButton|TdIconButton)(?=[\s>/])/.test(markupOnly(source)),
+    )
+    expect(wrapperCallSites.length).toBeGreaterThan(20)
   })
 
   it('detects the shapes it claims to detect', () => {
@@ -656,6 +805,104 @@ describe('dead affordances', () => {
     expect(findDeadButtons('<template><button data-dead-affordance-exempt="other">Not exempt</button></template>')).toHaveLength(1)
   })
 
+  it('scans only wrapper tags the shared native-component list already knows', () => {
+    // The two sets answer different questions but must not disagree about what
+    // a native-rooted interactive component IS. If a tag is added to one, this
+    // fails until the relationship is restated deliberately.
+    for (const tag of WRAPPER_BUTTON_COMPONENTS) {
+      expect(NATIVE_INTERACTIVE_COMPONENTS.has(tag), `${tag} missing from the native list`).toBe(true)
+    }
+  })
+
+  it('detects wrapper button call sites that bind no action', () => {
+    expect(findDeadWrapperButtons(DEAD_WRAPPER_BUTTON_FIXTURE)).toEqual([
+      '<PaperHLBtn label="Apply" variant="ember" />',
+    ])
+    expect(findDeadWrapperButtons('<template><TdButton>Save</TdButton></template>')).toHaveLength(1)
+    expect(findDeadWrapperButtons('<template><TdIconButton label="Close" /></template>')).toHaveLength(1)
+    // A multi-line call site is still one tag.
+    expect(
+      findDeadWrapperButtons('<template>\n<PaperHLBtn\n  label="Apply"\n  variant="ember"\n/>\n</template>'),
+    ).toHaveLength(1)
+    // An empty or modifier-only handler binds nothing, exactly as for a native button.
+    expect(findDeadWrapperButtons('<template><PaperHLBtn @click="" label="Apply" /></template>')).toHaveLength(1)
+    expect(findDeadWrapperButtons('<template><PaperHLBtn @click.stop label="Apply" /></template>')).toHaveLength(1)
+    // Handler text quoted inside an inert attribute is not a binding.
+    expect(
+      findDeadWrapperButtons(`<template><PaperHLBtn data-note='@click="run"' label="Apply" /></template>`),
+    ).toHaveLength(1)
+    expect(
+      findDeadWrapperButtons(`<template><PaperHLBtn data-note='v-on="{ click: run }"' label="Apply" /></template>`),
+    ).toHaveLength(1)
+  })
+
+  it('accepts wrapper call sites with a click binding or v-on object syntax', () => {
+    expect(findDeadWrapperButtons('<template><PaperHLBtn label="Apply" @click="apply" /></template>')).toEqual([])
+    expect(findDeadWrapperButtons('<template><PaperHLBtn label="Apply" @click.stop="apply" /></template>')).toEqual([])
+    expect(findDeadWrapperButtons('<template><PaperHLBtn label="Apply" v-on:click="apply" /></template>')).toEqual([])
+    expect(findDeadWrapperButtons('<template><TdButton @click="save">Save</TdButton></template>')).toEqual([])
+    expect(findDeadWrapperButtons('<template><TdIconButton label="Close" @click="close" /></template>')).toEqual([])
+    // `click` is the declared emit on all three, so object syntax really does
+    // wire activation here — unlike on a native control, where the compiler
+    // scan reports it as unproven.
+    expect(findDeadWrapperButtons('<template><PaperHLBtn label="Apply" v-on="{ click: apply }" /></template>')).toEqual([])
+    expect(findDeadWrapperButtons(`<template><PaperHLBtn label="Apply" v-on='listeners' /></template>`)).toEqual([])
+    expect(findDeadWrapperButtons('<template><PaperHLBtn label="Apply" v-on="" /></template>')).toHaveLength(1)
+    // A dynamic event argument resolves to an unknown event: still reported.
+    expect(findDeadWrapperButtons('<template><PaperHLBtn label="Apply" @[eventName]="apply" /></template>')).toHaveLength(1)
+  })
+
+  it('accepts a wrapper submit only with a static type and a proven form owner', () => {
+    expect(findDeadWrapperButtons('<template><form><PaperHLBtn type="submit" label="Save" /></form></template>')).toEqual([])
+    expect(
+      findDeadWrapperButtons('<template><form id="new-board"></form><PaperHLBtn form="new-board" type="submit" label="Save" /></template>'),
+    ).toEqual([])
+    expect(findDeadWrapperButtons('<template><PaperHLBtn type="submit" label="Save" /></template>')).toHaveLength(1)
+    expect(
+      findDeadWrapperButtons('<template><PaperHLBtn form="missing" type="submit" label="Save" /></template>'),
+    ).toHaveLength(1)
+    expect(
+      findDeadWrapperButtons('<template><form><PaperHLBtn :type="mode" label="Save" /></form></template>'),
+    ).toHaveLength(1)
+    // The asymmetry with a native button: `type` defaults to `'button'` on all
+    // three components, so an untyped call site inside a form submits nothing.
+    expect(findDeadWrapperButtons('<template><form><PaperHLBtn label="Save" /></form></template>')).toHaveLength(1)
+    expect(findDeadWrapperButtons('<template><form><PaperHLBtn type="button" label="Save" /></form></template>')).toHaveLength(1)
+    // A closed form no longer owns what follows it.
+    expect(
+      findDeadWrapperButtons('<template><form><input></form><PaperHLBtn type="submit" label="Save" /></template>'),
+    ).toHaveLength(1)
+  })
+
+  it('exempts a wrapper call site only when it is permanently off or a marked specimen', () => {
+    expect(findDeadWrapperButtons('<template><PaperHLBtn disabled label="Apply" /></template>')).toEqual([])
+    expect(findDeadWrapperButtons('<template><PaperHLBtn :disabled="true" label="Apply" /></template>')).toEqual([])
+    expect(findDeadWrapperButtons('<template><PaperHLBtn :disabled="busy" label="Apply" /></template>')).toHaveLength(1)
+    expect(
+      findDeadWrapperButtons('<template><PaperHLBtn data-dead-affordance-exempt="visual-specimen" label="Apply" /></template>'),
+    ).toEqual([])
+    expect(
+      findDeadWrapperButtons('<template><PaperHLBtn data-dead-affordance-exempt="other" label="Apply" /></template>'),
+    ).toHaveLength(1)
+  })
+
+  it('scans wrapper markup only, and only the wrapper tags', () => {
+    // Prose about a call site is prose.
+    expect(
+      findDeadWrapperButtons('<script>/* was <PaperHLBtn label="Apply" /> */</script><template><p>ok</p></template>'),
+    ).toEqual([])
+    expect(findDeadWrapperButtons('<template><!-- <PaperHLBtn label="Apply" /> --><p>ok</p></template>')).toEqual([])
+    // Components that are not in the set are not this scan's business.
+    expect(findDeadWrapperButtons('<template><PaperCard variant="flat">Inert</PaperCard></template>')).toEqual([])
+    expect(findDeadWrapperButtons('<template><RouterLink to="/boards">Boards</RouterLink></template>')).toEqual([])
+    // A longer tag name that merely starts with a wrapper name is a different tag.
+    expect(findDeadWrapperButtons('<template><TdButtonGroup>Group</TdButtonGroup></template>')).toEqual([])
+    // A `>` inside a bound expression does not end the tag early.
+    expect(
+      findDeadWrapperButtons('<template><PaperHLBtn :disabled="count > 0" label="Apply" /></template>'),
+    ).toHaveLength(1)
+  })
+
   it('documents source-only limits for dynamic Vue bindings', () => {
     // Dynamic listeners remain unproven for the source-level action guard;
     // compiler-backed coverage below reports their exact AST shape.
@@ -761,6 +1008,18 @@ describe('dead affordances', () => {
     expect(offenders).toEqual([])
   })
 
+  it('never ships a wrapper button call site without an action', () => {
+    const offenders: string[] = []
+
+    for (const [file, source] of Object.entries(VUE_SOURCES)) {
+      for (const tag of findDeadWrapperButtons(source)) {
+        offenders.push(`${file.replace('../../', 'src/')}: ${tag}`)
+      }
+    }
+
+    expect(offenders).toEqual([])
+  })
+
   it('never ships native controls with unproven compiler-expanded listeners', () => {
     const offenders: string[] = []
 

From d4ec44c66d736663e89c08765b534ddce12e979d Mon Sep 17 00:00:00 2001
From: Chris0Jeky <jeky.tck@gmail.com>
Date: Sat, 5 Sep 2026 08:05:10 +0100
Subject: [PATCH 2/4] test(guards): mark the seven inert PaperHLBtn style-guide
 specimens

The wrapper scan's repo-wide red output named exactly seven offenders, all in
PaperStyleGuideView.vue: the five PaperHLBtn variant specimens and the two
opposite-theme preview specimens. Both rows exist to show what a variant looks
like, so there is no intended handler to restore and no product control is
affected. They carry the same narrow data-dead-affordance-exempt marker the
four native .pbtn specimens in the same view already use.

No product offender was reported, so nothing outside the style guide changed.

The attribute lands on PaperHLBtn's rendered <button> root as an ordinary
fallthrough data attribute; there is no behaviour change.
---
 .../src/views/PaperStyleGuideView.vue         | 22 +++++++++++++------
 1 file changed, 15 insertions(+), 7 deletions(-)

diff --git a/frontend/taskdeck-web/src/views/PaperStyleGuideView.vue b/frontend/taskdeck-web/src/views/PaperStyleGuideView.vue
index c20775cd5..d596bcb7a 100644
--- a/frontend/taskdeck-web/src/views/PaperStyleGuideView.vue
+++ b/frontend/taskdeck-web/src/views/PaperStyleGuideView.vue
@@ -221,12 +221,18 @@ const stampKind = ref<'applied' | 'proposed' | 'captured' | 'overdue' | 'draft'>
         </div>
 
         <h3 class="tk-eyebrow sg-section-eyebrow">PaperHLBtn</h3>
+        <!-- Variant specimens, inert on purpose: this row exists to show what
+             each variant LOOKS like. The marker is the same narrow opt-out the
+             native `.pbtn` specimens above already carry, and it is scanned by
+             `src/tests/guards/deadAnchors.spec.ts` (GH-1949). A product control
+             must not copy it. It lands on the rendered <button> as an ordinary
+             fallthrough data attribute; nothing about behaviour changes. -->
         <div class="sg-row">
-          <PaperHLBtn label="Default" kbd="⌫" />
-          <PaperHLBtn variant="primary" label="Primary" kbd="P" />
-          <PaperHLBtn variant="ember" label="Apply" kbd="⏎" />
-          <PaperHLBtn variant="ghost" label="Ghost" />
-          <PaperHLBtn label="Capture" kbd="space">
+          <PaperHLBtn label="Default" kbd="⌫" data-dead-affordance-exempt="visual-specimen" />
+          <PaperHLBtn variant="primary" label="Primary" kbd="P" data-dead-affordance-exempt="visual-specimen" />
+          <PaperHLBtn variant="ember" label="Apply" kbd="⏎" data-dead-affordance-exempt="visual-specimen" />
+          <PaperHLBtn variant="ghost" label="Ghost" data-dead-affordance-exempt="visual-specimen" />
+          <PaperHLBtn label="Capture" kbd="space" data-dead-affordance-exempt="visual-specimen">
             <template #icon><PaperIcon name="plus" /></template>
           </PaperHLBtn>
         </div>
@@ -332,9 +338,11 @@ const stampKind = ref<'applied' | 'proposed' | 'captured' | 'overdue' | 'draft'>
           <PaperStamp kind="proposed" date="Apr 25" time="11:50" num="015" />
           <PaperStamp kind="overdue" date="3d" time="past" num="007" />
         </div>
+        <!-- Opposite-theme specimens: same inert row, rendered in the other
+             substrate. Marked for the same reason as the row above. -->
         <div class="sg-row">
-          <PaperHLBtn label="Default" kbd="⌫" />
-          <PaperHLBtn variant="ember" label="Apply" kbd="⏎" />
+          <PaperHLBtn label="Default" kbd="⌫" data-dead-affordance-exempt="visual-specimen" />
+          <PaperHLBtn variant="ember" label="Apply" kbd="⏎" data-dead-affordance-exempt="visual-specimen" />
           <PaperTagstamp tone="ember">PROPOSED</PaperTagstamp>
           <PaperStatusPill kind="live">LIVE</PaperStatusPill>
         </div>

From b3484f06e399904fecb25c7c5dbd53d0311e550e Mon Sep 17 00:00:00 2001
From: Chris0Jeky <jeky.tck@gmail.com>
Date: Sat, 5 Sep 2026 08:09:32 +0100
Subject: [PATCH 3/4] test(guards): state the AC3 primary-action inventory and
 register six preconditions

The registry proved two controls and said nothing about its own scope, so a
reader could not tell whether an absent control was safe or merely unexamined.
The header now defines a primary action as one whose activation writes or
enqueues, lists every covered surface with the preconditions each can be
blocked by, and names what is deliberately out: PaperReviewView's approve,
reject and execute while GH-2629 holds those files, the native form submits,
and every other writing control.

Six registrations back the inventory:
  PaperTriageRowEdit save - empty, unchanged, busyElsewhere (its three
  saveBlock states, so a change that keeps the button enabled for one cannot
  pass by satisfying the others).
  PaperCaptureNib submit - empty draft.
  PaperTriageTable accept-on-board - loadFailed and viewOnly, joining the
  noBoard registration already here.

Each keeps the branch-pinning disabled assertion and adds a data-reason
assertion, so a test cannot silently drift onto a different blocked state:
saveBlock reports busyElsewhere before empty, and boardPickBlock reports
noBoard before viewOnly.

The viewOnly path models write access being revoked on an already picked
board, because the picker disables a read-only option and the state is
otherwise unreachable from the UI.

No production file changes.
---
 .../tests/guards/primaryActionGuards.spec.ts  | 198 +++++++++++++++++-
 1 file changed, 194 insertions(+), 4 deletions(-)

diff --git a/frontend/taskdeck-web/src/tests/guards/primaryActionGuards.spec.ts b/frontend/taskdeck-web/src/tests/guards/primaryActionGuards.spec.ts
index 3bf3edceb..4d2925f81 100644
--- a/frontend/taskdeck-web/src/tests/guards/primaryActionGuards.spec.ts
+++ b/frontend/taskdeck-web/src/tests/guards/primaryActionGuards.spec.ts
@@ -1,9 +1,11 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { mount } from '@vue/test-utils'
-import { reactive } from 'vue'
+import { flushPromises, mount } from '@vue/test-utils'
+import { nextTick, reactive } from 'vue'
 import PaperTriageTable from '../../views/paper/inbox/PaperTriageTable.vue'
 import PaperCaptureComposer from '../../views/paper/inbox/PaperCaptureComposer.vue'
-import type { CaptureItemSummary } from '../../types/capture'
+import PaperCaptureNib from '../../views/paper/inbox/PaperCaptureNib.vue'
+import PaperTriageRowEdit from '../../views/paper/inbox/PaperTriageRowEdit.vue'
+import type { CaptureItem, CaptureItemSummary } from '../../types/capture'
 import { expectGuardedPrimaryAction } from '../utils/guardedPrimaryAction'
 
 /**
@@ -28,9 +30,44 @@ import { expectGuardedPrimaryAction } from '../utils/guardedPrimaryAction'
  * The helper passes on EITHER branch — disabled, or enabled-with-feedback — so
  * registering a control does not dictate which of the two designs it uses.
  *
+ * THE INVENTORY THIS FILE CLAIMS.
+ *
+ * A primary action, for AC3, is a control whose activation WRITES or ENQUEUES:
+ * it mutates server state, or it queues work that will. A navigation, a
+ * disclosure toggle, a filter, a cancel and a re-read are not primary actions
+ * and are deliberately absent — they have nothing to be silent about.
+ *
+ * COVERED, with every precondition each control can be blocked by:
+ *  - `PaperTriageTable` accept-on-board (`data-action="accept-on-board"`),
+ *    which enqueues triage for a capture. Its `boardPickBlock` states are
+ *    `loading` / `loadFailed` / `noBoards` / `noBoard` / `viewOnly`; `noBoard`,
+ *    `loadFailed` and `viewOnly` are registered below. `loading` and `noBoards`
+ *    are the same disabled binding reached through the same computed and are
+ *    not separately registered.
+ *  - `PaperTriageRowEdit` save (`data-action="edit-save"`), which writes the
+ *    capture suggestion. All three `saveBlock` states — `busyElsewhere`,
+ *    `empty`, `unchanged` — are registered below.
+ *  - `PaperCaptureNib` submit, which enqueues a capture. Its one precondition
+ *    is `canSubmit`.
+ *  - `PaperCaptureComposer` submit, which enqueues a capture. Its one
+ *    precondition is a non-blank body.
+ *
+ * DELIBERATELY OUT, and why:
+ *  - `PaperReviewView` approve / reject / execute — the review surface's
+ *    primary actions. GH-2629 holds those files; registering them from here
+ *    would conflict with that PR's markup. They are the first thing to add
+ *    once it lands, and this file makes NO claim about them today.
+ *  - Board and card mutations (`PaperBoardView`, `PaperCardComposer`) and the
+ *    settings forms. Their submits are native `type="submit"` inside a real
+ *    `<form>`, a shape the sibling source guard already scans; whether their
+ *    preconditions are honestly reported is unproven and unclaimed.
+ *  - Every other writing control in the app. Absence from this list is not
+ *    evidence of a guarded action; it is the absence of evidence.
+ *
  * NOT COVERED: whether the validation text is correct, whether a disabled
  * reason is announced to assistive tech, and every primary action absent from
- * this list. Route-walking runtime coverage (AC4) remains open on GH-1949.
+ * the inventory above. Route-walking runtime coverage (AC4) remains open on
+ * GH-1949.
  */
 
 type MockBoard = { id: string; name: string; canWrite?: boolean }
@@ -58,6 +95,39 @@ vi.mock('../../store/captureStore', () => ({
   useCaptureStore: () => mockCaptureStore,
 }))
 
+/**
+ * A capture detail the row editor will actually offer for editing:
+ * `canEditSuggestion` must be exactly `true` or the editor renders its
+ * "not editable" explanation instead of a textarea and a Save button.
+ */
+function editableDetail(overrides: Partial<CaptureItem> = {}): CaptureItem {
+  return {
+    id: 'capture-1',
+    userId: 'user-1',
+    boardId: 'board-alpha',
+    status: 'New',
+    source: 'Typed',
+    textExcerpt: 'Ship the release notes…',
+    rawText: 'Ship the release notes before Friday',
+    createdAt: new Date('2026-04-25T09:42:00Z').toISOString(),
+    processedAt: null,
+    retryCount: 0,
+    provenance: null,
+    canEditSuggestion: true,
+    ...overrides,
+  } as CaptureItem
+}
+
+/** Mount the row editor with its detail fetch already settled. */
+async function mountRowEditor(mutationInFlight = false) {
+  mockCaptureStore.fetchDetail.mockResolvedValue(editableDetail())
+  const wrapper = mount(PaperTriageRowEdit, {
+    props: { itemId: 'capture-1', mutationInFlight },
+  })
+  await flushPromises()
+  return wrapper
+}
+
 function boardlessItems(): CaptureItemSummary[] {
   return [
     {
@@ -181,4 +251,124 @@ describe('primary action guards (GH-1949 AC3)', () => {
       unmetPreconditions: 'composer body is whitespace only',
     })
   })
+
+  /**
+   * `PaperTriageRowEdit` save writes the capture suggestion, and one computed
+   * (`saveBlock`) drives the disabled binding, the guard inside `save()` and
+   * the visible reason. All three of its states are registered so a future
+   * change that keeps the button enabled for one of them cannot pass by
+   * satisfying the other two.
+   */
+  it('Inbox capture-edit Save is guarded with an empty draft', async () => {
+    const wrapper = await mountRowEditor()
+    await wrapper.get('[data-testid="capture-edit-textarea"]').setValue('   ')
+
+    const save = wrapper.get('button[data-action="edit-save"]')
+    // Pin the branch AND the reason: the helper accepts either design, and
+    // `saveBlock` reports `busyElsewhere` before `empty`, so without the
+    // reason assertion this test could be silently exercising a different state.
+    expect(save.attributes('disabled')).toBeDefined()
+    expect(wrapper.get('[data-testid="capture-edit-save-reason"]').attributes('data-reason')).toBe('empty')
+
+    await expectGuardedPrimaryAction(wrapper, save, {
+      unmetPreconditions: 'capture edit draft is whitespace only',
+    })
+  })
+
+  it('Inbox capture-edit Save is guarded with an unchanged draft', async () => {
+    // Straight off the load: the draft IS the fetched text and no metadata
+    // changed, so the write would be a no-op.
+    const wrapper = await mountRowEditor()
+
+    const save = wrapper.get('button[data-action="edit-save"]')
+    expect(save.attributes('disabled')).toBeDefined()
+    expect(wrapper.get('[data-testid="capture-edit-save-reason"]').attributes('data-reason')).toBe('unchanged')
+
+    await expectGuardedPrimaryAction(wrapper, save, {
+      unmetPreconditions: 'capture edit draft is identical to the loaded text',
+    })
+  })
+
+  it('Inbox capture-edit Save is guarded while another mutation owns the busy slot', async () => {
+    // The one block the user cannot clear from the textarea: another row's
+    // Accept or Reject holds the capture store's single busy slot, and saving
+    // through it would steal that write's in-flight state.
+    const wrapper = await mountRowEditor(true)
+    await wrapper.get('[data-testid="capture-edit-textarea"]').setValue('Ship the release notes on Thursday')
+
+    const save = wrapper.get('button[data-action="edit-save"]')
+    expect(save.attributes('disabled')).toBeDefined()
+    expect(wrapper.get('[data-testid="capture-edit-save-reason"]').attributes('data-reason')).toBe('busyElsewhere')
+
+    await expectGuardedPrimaryAction(wrapper, save, {
+      unmetPreconditions: 'another capture mutation holds the shared busy slot',
+    })
+  })
+
+  it('Inbox capture nib submit is guarded with an empty draft', async () => {
+    const wrapper = mount(PaperCaptureNib)
+
+    // The nib footer has exactly one button. Asserting that before selecting it
+    // means a markup change that adds another fails loudly here rather than
+    // silently registering the wrong control.
+    const buttons = wrapper.findAll('button')
+    expect(buttons, 'nib should render exactly one button').toHaveLength(1)
+    const submit = buttons[0]
+    expect(submit.attributes('disabled')).toBeDefined()
+
+    await expectGuardedPrimaryAction(wrapper, submit, {
+      unmetPreconditions: 'nib draft is empty',
+    })
+  })
+
+  // ---- PaperTriageTable registrations (see the boundaries note in the PR) ----
+
+  it('Inbox "Accept on board" is guarded when the board list failed to load', async () => {
+    mockBoardStore.boards = []
+    mockBoardStore.fetchBoards.mockRejectedValue(new Error('boards unavailable'))
+    const wrapper = mount(PaperTriageTable, { props: { items: boardlessItems() } })
+
+    // Opening the picker with no boards cached triggers the load that fails.
+    await wrapper.findAll('button[data-action="accept"]')[0].trigger('click')
+    await flushPromises()
+
+    expect(wrapper.get('[data-testid="board-pick-reason"]').attributes('data-reason')).toBe('loadFailed')
+    // The failure is recoverable and says so: the retry control is the reason
+    // this state is not simply a dead end.
+    expect(wrapper.find('button[data-action="retry-board-load"]').exists()).toBe(true)
+
+    const confirm = wrapper.get('button[data-action="accept-on-board"]')
+    expect(confirm.attributes('disabled')).toBeDefined()
+
+    await expectGuardedPrimaryAction(wrapper, confirm, {
+      unmetPreconditions: 'board picker open, board list load failed',
+    })
+  })
+
+  it('Inbox "Accept on board" is guarded when the picked board turns read-only', async () => {
+    // `viewOnly` is defence in depth: the picker disables a read-only option,
+    // so this state is reached when write access to an ALREADY picked board is
+    // revoked and a board-list refresh brings that back (`BoardDto.CanWrite`,
+    // #1836). Accepting onto it would 403 at the server.
+    mockBoardStore.boards = [{ id: 'board-alpha', name: 'Alpha', canWrite: true }]
+    const wrapper = mount(PaperTriageTable, { props: { items: boardlessItems() } })
+
+    await wrapper.findAll('button[data-action="accept"]')[0].trigger('click')
+    await wrapper.get('select').setValue('board-alpha')
+    // Nothing is blocking yet — the pick is live. That is what makes the flip
+    // below the thing under test rather than a state that was always off.
+    expect(wrapper.find('[data-testid="board-pick-reason"]').exists()).toBe(false)
+
+    mockBoardStore.boards = [{ id: 'board-alpha', name: 'Alpha', canWrite: false }]
+    await nextTick()
+
+    expect(wrapper.get('[data-testid="board-pick-reason"]').attributes('data-reason')).toBe('viewOnly')
+
+    const confirm = wrapper.get('button[data-action="accept-on-board"]')
+    expect(confirm.attributes('disabled')).toBeDefined()
+
+    await expectGuardedPrimaryAction(wrapper, confirm, {
+      unmetPreconditions: 'board picker open, picked board is read-only',
+    })
+  })
 })

From 4ad6519f0434849849a7db5c54d52b297e58e9aa Mon Sep 17 00:00:00 2001
From: Chris0Jeky <jeky.tck@gmail.com>
Date: Sat, 5 Sep 2026 08:28:43 +0100
Subject: [PATCH 4/4] test(guards): address round-2 review on the wrapper scan
 and AC3 inventory

MEDIUM 1. The AC3 header claimed to list every precondition each control can
be blocked by, but three controls have more than the registrations cover:
composer submit is a four-conjunct canSubmit, row-edit save is saveBlock ||
saving, and accept-on-board is boardPickBlock plus a six-way isActionDisabled.
Each bullet now enumerates every disjunct or conjunct the binding reads and
marks it REGISTERED or not-registered with a reason, and the header states that
an unmarked entry means unexamined rather than safe.

MEDIUM 2. hasVOnObjectBinding accepted any non-empty v-on object, so
v-on="{ mouseenter: showHint }" was redeemed while @mouseenter on the same tag
was reported. It now requires a spelled-out click key in any of the four JS
spellings, including the { click } shorthand. An expression that never spells
the key - v-on="listeners", or a spread-only object - is REPORTED rather than
accepted: source text cannot say what it resolves to, and the compiler-backed
scan already treats that shape on a native control as unproven. The former
listeners pin is inverted and a new block covers mouseenter-only, dblclick,
clickOutside and onclick as reported shapes.

LOW 3. TdIconButton declares no type prop and hard-codes type=button on its
root, so the old comment was wrong for it. Corrected, and TdIconButton is now
excluded from the submit clause via SUBMIT_CAPABLE_WRAPPERS rather than resting
the exemption on unverified fallthrough merge precedence.

LOW 4. Added the kebab spellings paper-h-l-btn, td-button and td-icon-button,
matching how the shared native list already carries router-link beside
routerlink. The subset test compares on the de-hyphenated name, and a second
loop pins SUBMIT_CAPABLE_WRAPPERS as a subset of the scanned set.

LOW 5. The vacuity canary counted FILES while being named and described as call
sites, so it would have passed with one call site left per file. It now counts
tag matches through WRAPPER_CALL_SITE, with the threshold raised from 20 to 100
against a real 156.

LOW 6. The loadFailed registration's comment said the accept click triggers the
failing load. onMounted primes it and onAccept re-triggers only from idle, so
the load has already failed by then. Comment corrected and an explicit flush
added after mount so the described sequence is the one that runs.

No production file changes in this commit.
---
 .../src/tests/guards/deadAnchors.spec.ts      | 184 +++++++++++++++---
 .../tests/guards/primaryActionGuards.spec.ts  |  63 ++++--
 2 files changed, 201 insertions(+), 46 deletions(-)

diff --git a/frontend/taskdeck-web/src/tests/guards/deadAnchors.spec.ts b/frontend/taskdeck-web/src/tests/guards/deadAnchors.spec.ts
index bc04530a6..1cb218dc9 100644
--- a/frontend/taskdeck-web/src/tests/guards/deadAnchors.spec.ts
+++ b/frontend/taskdeck-web/src/tests/guards/deadAnchors.spec.ts
@@ -34,13 +34,15 @@ import { baseParse, ElementTypes, NodeTypes, parserOptions } from '@vue/compiler
  *    their rendered root still needs component tests for the final DOM
  *    contract, and every other component tag is checked for nothing beyond its
  *    explicit role/action source shape.
- *  - A wrapper call site is redeemed by a click binding, `v-on` object syntax,
- *    a static `type="submit"` with a proven form owner, a permanent disabled,
- *    or the specimen marker — and by nothing else. A fallthrough pointer
- *    listener (`@mousedown`) IS live at runtime and is still reported, because
- *    a button reachable only by pointer is not operable from the keyboard;
- *    `@[dynamicEvent]` is reported because source text cannot say which event
- *    it resolves to. Neither shape exists today.
+ *  - A wrapper call site is redeemed by a click binding, a `v-on` object that
+ *    spells out a `click` key, a static `type="submit"` with a proven form
+ *    owner on a component that declares a `type` prop, a permanent disabled, or
+ *    the specimen marker — and by nothing else. Three live-at-runtime shapes
+ *    are still reported: a fallthrough pointer listener (`@mousedown`), because
+ *    a button reachable only by pointer is not operable from the keyboard; a
+ *    `v-on` expression that never spells the key (`v-on="listeners"`), because
+ *    source text cannot say what it resolves to; and `@[dynamicEvent]`, for the
+ *    same reason. None of these shapes exists today.
  *  - `v-on="{ click: fn }"` object syntax and `@[dynamicEvent]` are reported
  *    on native controls by the compiler-backed guard below. No such tag exists
  *    today; do not delete that finding without proving the runtime event.
@@ -187,13 +189,40 @@ const NATIVE_INTERACTIVE_COMPONENTS = new Set([
  * That is the GH-1941 defect wearing component clothing, and until this slice
  * nothing scanned the ~150 call sites.
  *
+ * Both spellings of each tag are listed. Vue resolves `<td-button>` and
+ * `<TdButton>` to the same component, and the shared native list already
+ * carries `router-link` alongside `routerlink` for that reason. No kebab call
+ * site exists today; the entry is here so that writing one does not silently
+ * leave the scan. A test below pins each entry against the shared list on its
+ * de-hyphenated name.
+ *
  * `router-link` and `InputAssistField` are deliberately NOT here: a router link
  * is actionable through `to`, not a click binding, and the assist field is an
  * input rather than a command control. Both stay in the shared native list
  * because that list answers a different question (keyboard reachability for the
- * aria-label scan). A test below pins this set as a subset of that one.
+ * aria-label scan).
+ */
+const WRAPPER_BUTTON_COMPONENTS = new Set([
+  'paperhlbtn',
+  'paper-h-l-btn',
+  'tdbutton',
+  'td-button',
+  'tdiconbutton',
+  'td-icon-button',
+])
+
+/**
+ * The subset that can carry native submit semantics.
+ *
+ * `PaperHLBtn` and `TdButton` both DECLARE a `type` prop and pass it to their
+ * root, so `type="submit"` at a call site is a prop the component honours.
+ * `TdIconButton` declares no such prop and hard-codes `type="button"` on its
+ * root, so a `type="submit"` there would be a fallthrough attribute whose
+ * effect depends on Vue's merge precedence over an explicit root attribute.
+ * That precedence is not verified here, so the claim is not made: a
+ * `<TdIconButton type="submit">` is reported like any other unbound call site.
  */
-const WRAPPER_BUTTON_COMPONENTS = new Set(['paperhlbtn', 'tdbutton', 'tdiconbutton'])
+const SUBMIT_CAPABLE_WRAPPERS = new Set(['paperhlbtn', 'paper-h-l-btn', 'tdbutton', 'td-button'])
 
 /**
  * Opening/closing form and wrapper-button tags, with quoted values consumed
@@ -216,12 +245,46 @@ const WRAPPER_TYPE_ATTR = /\s((?::|v-bind:)?type)\s*=\s*(?:"([^"]*)"|'([^']*)'|(
 const BINDING_PREFIX = /^(?::|v-bind:)/i
 
 /**
- * `v-on="{ click: fn }"` object syntax. On a component whose declared emit is
- * `click` this really does wire activation, so it redeems a call site — unlike
- * on a native control, where the compiler-backed scan reports it as unproven.
+ * `v-on="…"` object syntax, with the object expression captured.
+ *
+ * On a component whose declared emit is `click` this really can wire
+ * activation, so it redeems a call site — unlike on a native control, where the
+ * compiler-backed scan reports it as unproven.
  */
 const VON_OBJECT_BINDING = /(?:^|\s)v-on\s*=\s*(?:"([^"]*)"|'([^']*)')/i
 
+/**
+ * A literal `click` KEY inside a `v-on` object expression, in any of the four
+ * spellings JS allows: `{ click: fn }`, `{ 'click': fn }`, `{ "click": fn }`
+ * and the shorthand `{ click }`. The trailing `[:,}]` is what stops
+ * `{ dblclick: … }`, `{ clickOutside: … }` and `{ onclick: … }` from matching.
+ *
+ * Requiring the key is the point. A `v-on` object that binds only
+ * `{ mouseenter: showHint }` is no more of a click handler than an
+ * `@mouseenter` attribute, and this guard reports that one — accepting the
+ * object form of the same non-binding would have been an inconsistency a future
+ * dead control could hide behind.
+ *
+ * An expression that does not spell the key out — `v-on="listeners"`, or an
+ * object built only from a spread — is REPORTED, not accepted. Source text
+ * cannot say what such an expression resolves to, and this file's standing
+ * answer to an unprovable listener is to report it: the compiler-backed scan
+ * treats the same shape on a native control as unproven action evidence. No
+ * `v-on` call site of any kind exists today, so the strictness costs nothing
+ * now; a future one is expected to spell the key or take the false positive.
+ */
+const VON_CLICK_KEY = /[{,]\s*(?:'click'|"click"|click)\s*[:,}]/
+
+/**
+ * Every wrapper call site, for the scan's own vacuity canary. Same tag set and
+ * same lookahead as the scan, without the attribute tail: this counts openings,
+ * not whole tags.
+ */
+const WRAPPER_CALL_SITE = new RegExp(
+  `<(?:${[...WRAPPER_BUTTON_COMPONENTS].join('|')})(?=[\\s>/])`,
+  'gi',
+)
+
 /** Opening tags for native or custom elements. Quoted values are consumed whole. */
 const OPENING_TAG = /<([A-Za-z][\w.-]*)(?=[\s>/])(?:"[^"]*"|'[^']*'|[^>'"])*>/g
 
@@ -496,7 +559,10 @@ function findDeadButtons(source: string): string[] {
 function hasVOnObjectBinding(tag: string): boolean {
   const match = VON_OBJECT_BINDING.exec(directiveOnlyMarkup(tag))
   if (!match) return false
-  return (match[1] ?? match[2] ?? '').trim().length > 0
+  const expression = (match[1] ?? match[2] ?? '').trim()
+  if (expression.length === 0) return false
+  // Only a spelled-out `click` key counts — see VON_CLICK_KEY.
+  return VON_CLICK_KEY.test(expression)
 }
 
 /**
@@ -505,18 +571,22 @@ function hasVOnObjectBinding(tag: string): boolean {
  *
  * The asymmetry with a native button matters and is the reason this is not a
  * copy of that clause. `<button>` inside a form defaults to `type="submit"`, so
- * the native scan treats a missing type as submit. All three wrapper components
- * declare `type` with a `'button'` DEFAULT, so a `<PaperHLBtn>` inside a form
- * with no type renders `type="button"` and submits nothing. Only the explicit
- * static value counts here. `type="reset"` is not accepted: no call site uses
- * it, and `TdIconButton` hard-codes `type="button"` on its root, so the claim
- * would rest on attribute-fallthrough precedence rather than a declared prop.
+ * the native scan treats a missing type as submit. `PaperHLBtn` and `TdButton`
+ * declare a `type` prop whose DEFAULT is `'button'`, so either of them inside a
+ * form with no type renders `type="button"` and submits nothing. Only the
+ * explicit static value counts here.
+ *
+ * `TdIconButton` is excluded entirely (see `SUBMIT_CAPABLE_WRAPPERS`): it
+ * declares no `type` prop at all and hard-codes `type="button"` on its root, so
+ * accepting `type="submit"` there would rest on unverified fallthrough merge
+ * precedence. `type="reset"` is accepted for nobody: no call site uses it.
  */
 function hasStaticSubmitWithFormOwner(
   tag: string,
   formDepth: number,
   knownFormIds: Set<string>,
 ): boolean {
+  if (!SUBMIT_CAPABLE_WRAPPERS.has(openingTagName(tag))) return false
   const match = WRAPPER_TYPE_ATTR.exec(tag)
   if (!match || BINDING_PREFIX.test(match[1])) return false
   const type = (match[2] ?? match[3] ?? match[4] ?? '').trim().toLowerCase()
@@ -680,12 +750,15 @@ describe('dead affordances', () => {
     expect(findDeadAnchors(DEAD_ANCHOR_FIXTURE)).toHaveLength(1)
     expect(findDeadWrapperButtons(DEAD_WRAPPER_BUTTON_FIXTURE)).toHaveLength(1)
 
-    // The wrapper scan must be looking at real call sites, not at nothing: the
-    // components are used ~150 times across the SFCs this glob returns.
-    const wrapperCallSites = Object.values(VUE_SOURCES).filter((source) =>
-      /<(?:PaperHLBtn|TdButton|TdIconButton)(?=[\s>/])/.test(markupOnly(source)),
+    // The wrapper scan must be looking at real call sites, not at nothing.
+    // CALL SITES, not files: the components are used ~156 times across ~35
+    // SFCs, and a threshold counting files would still pass if all but one
+    // call site vanished from a file that kept one.
+    const wrapperCallSites = Object.values(VUE_SOURCES).reduce(
+      (total, source) => total + [...markupOnly(source).matchAll(WRAPPER_CALL_SITE)].length,
+      0,
     )
-    expect(wrapperCallSites.length).toBeGreaterThan(20)
+    expect(wrapperCallSites).toBeGreaterThan(100)
   })
 
   it('detects the shapes it claims to detect', () => {
@@ -808,9 +881,18 @@ describe('dead affordances', () => {
   it('scans only wrapper tags the shared native-component list already knows', () => {
     // The two sets answer different questions but must not disagree about what
     // a native-rooted interactive component IS. If a tag is added to one, this
-    // fails until the relationship is restated deliberately.
+    // fails until the relationship is restated deliberately. The comparison is
+    // on the de-hyphenated name because the shared list spells these components
+    // without hyphens while this set carries both spellings.
     for (const tag of WRAPPER_BUTTON_COMPONENTS) {
-      expect(NATIVE_INTERACTIVE_COMPONENTS.has(tag), `${tag} missing from the native list`).toBe(true)
+      expect(
+        NATIVE_INTERACTIVE_COMPONENTS.has(tag.replace(/-/g, '')),
+        `${tag} missing from the native list`,
+      ).toBe(true)
+    }
+    // Every submit-capable tag is a wrapper tag; the reverse does not hold.
+    for (const tag of SUBMIT_CAPABLE_WRAPPERS) {
+      expect(WRAPPER_BUTTON_COMPONENTS.has(tag), `${tag} is not a scanned wrapper`).toBe(true)
     }
   })
 
@@ -842,12 +924,34 @@ describe('dead affordances', () => {
     expect(findDeadWrapperButtons('<template><PaperHLBtn label="Apply" v-on:click="apply" /></template>')).toEqual([])
     expect(findDeadWrapperButtons('<template><TdButton @click="save">Save</TdButton></template>')).toEqual([])
     expect(findDeadWrapperButtons('<template><TdIconButton label="Close" @click="close" /></template>')).toEqual([])
-    // `click` is the declared emit on all three, so object syntax really does
-    // wire activation here — unlike on a native control, where the compiler
-    // scan reports it as unproven.
+    // `click` is the declared emit on all three, so object syntax with a
+    // spelled-out click key really does wire activation here — unlike on a
+    // native control, where the compiler scan reports it as unproven.
     expect(findDeadWrapperButtons('<template><PaperHLBtn label="Apply" v-on="{ click: apply }" /></template>')).toEqual([])
-    expect(findDeadWrapperButtons(`<template><PaperHLBtn label="Apply" v-on='listeners' /></template>`)).toEqual([])
+    expect(findDeadWrapperButtons(`<template><PaperHLBtn label="Apply" v-on="{ 'click': apply }" /></template>`)).toEqual([])
+    expect(findDeadWrapperButtons('<template><PaperHLBtn label="Apply" v-on="{ click }" /></template>')).toEqual([])
+    expect(findDeadWrapperButtons('<template><PaperHLBtn label="Apply" v-on="{ mouseenter: hint, click: apply }" /></template>')).toEqual([])
+    expect(findDeadWrapperButtons('<template><PaperHLBtn label="Apply" v-on="{ ...base, click: apply }" /></template>')).toEqual([])
+  })
+
+  it('requires a v-on object to spell out the click key', () => {
+    // The reason this rule exists: an object binding only `mouseenter` is no
+    // more of a click handler than the `@mouseenter` attribute beside it, and
+    // that attribute is reported. Accepting the object form of the same
+    // non-binding would be a hole a dead control could hide in.
+    expect(
+      findDeadWrapperButtons('<template><PaperHLBtn label="Apply" v-on="{ mouseenter: showHint }" /></template>'),
+    ).toHaveLength(1)
+    expect(findDeadWrapperButtons('<template><PaperHLBtn label="Apply" @mouseenter="showHint" /></template>')).toHaveLength(1)
+    // An expression that never spells the key is unprovable from source, and
+    // this guard's standing answer to an unprovable listener is to report it.
+    expect(findDeadWrapperButtons(`<template><PaperHLBtn label="Apply" v-on='listeners' /></template>`)).toHaveLength(1)
+    expect(findDeadWrapperButtons('<template><PaperHLBtn label="Apply" v-on="{ ...listeners }" /></template>')).toHaveLength(1)
     expect(findDeadWrapperButtons('<template><PaperHLBtn label="Apply" v-on="" /></template>')).toHaveLength(1)
+    // Keys that merely contain "click" are not the click key.
+    expect(findDeadWrapperButtons('<template><PaperHLBtn label="Apply" v-on="{ dblclick: apply }" /></template>')).toHaveLength(1)
+    expect(findDeadWrapperButtons('<template><PaperHLBtn label="Apply" v-on="{ clickOutside: apply }" /></template>')).toHaveLength(1)
+    expect(findDeadWrapperButtons('<template><PaperHLBtn label="Apply" v-on="{ onclick: apply }" /></template>')).toHaveLength(1)
     // A dynamic event argument resolves to an unknown event: still reported.
     expect(findDeadWrapperButtons('<template><PaperHLBtn label="Apply" @[eventName]="apply" /></template>')).toHaveLength(1)
   })
@@ -872,6 +976,26 @@ describe('dead affordances', () => {
     expect(
       findDeadWrapperButtons('<template><form><input></form><PaperHLBtn type="submit" label="Save" /></template>'),
     ).toHaveLength(1)
+    // TdButton declares the prop too, so it submits on the same terms.
+    expect(findDeadWrapperButtons('<template><form><TdButton type="submit">Save</TdButton></form></template>')).toEqual([])
+    // TdIconButton does NOT: it declares no type prop and hard-codes
+    // type="button" on its root, so this would rest on fallthrough merge
+    // precedence that is not verified here.
+    expect(
+      findDeadWrapperButtons('<template><form><TdIconButton type="submit" label="Save" /></form></template>'),
+    ).toHaveLength(1)
+  })
+
+  it('scans both the PascalCase and the kebab spelling of each wrapper', () => {
+    // Vue resolves the two spellings to the same component, so a call site
+    // written either way has to reach the same verdict.
+    expect(findDeadWrapperButtons('<template><td-button>Save</td-button></template>')).toHaveLength(1)
+    expect(findDeadWrapperButtons('<template><td-icon-button label="Close" /></template>')).toHaveLength(1)
+    expect(findDeadWrapperButtons('<template><paper-h-l-btn label="Apply" /></template>')).toHaveLength(1)
+    expect(findDeadWrapperButtons('<template><td-button @click="save">Save</td-button></template>')).toEqual([])
+    expect(findDeadWrapperButtons('<template><form><td-button type="submit">Save</td-button></form></template>')).toEqual([])
+    // Still not a prefix match: the lookahead ends the tag name.
+    expect(findDeadWrapperButtons('<template><td-button-group>Group</td-button-group></template>')).toEqual([])
   })
 
   it('exempts a wrapper call site only when it is permanently off or a marked specimen', () => {
diff --git a/frontend/taskdeck-web/src/tests/guards/primaryActionGuards.spec.ts b/frontend/taskdeck-web/src/tests/guards/primaryActionGuards.spec.ts
index 4d2925f81..246915675 100644
--- a/frontend/taskdeck-web/src/tests/guards/primaryActionGuards.spec.ts
+++ b/frontend/taskdeck-web/src/tests/guards/primaryActionGuards.spec.ts
@@ -37,20 +37,48 @@ import { expectGuardedPrimaryAction } from '../utils/guardedPrimaryAction'
  * disclosure toggle, a filter, a cancel and a re-read are not primary actions
  * and are deliberately absent — they have nothing to be silent about.
  *
- * COVERED, with every precondition each control can be blocked by:
+ * COVERED CONTROLS, and for each one EVERY precondition its `disabled` binding
+ * reads, marked registered or not. A precondition that is not marked
+ * "registered" is NOT proven by this file: read an unmarked entry as unexamined,
+ * never as safe. Registering one precondition of a control proves that the
+ * control honours its binding at all; it says nothing about the others.
+ *
  *  - `PaperTriageTable` accept-on-board (`data-action="accept-on-board"`),
- *    which enqueues triage for a capture. Its `boardPickBlock` states are
- *    `loading` / `loadFailed` / `noBoards` / `noBoard` / `viewOnly`; `noBoard`,
- *    `loadFailed` and `viewOnly` are registered below. `loading` and `noBoards`
- *    are the same disabled binding reached through the same computed and are
- *    not separately registered.
+ *    which enqueues triage for a capture.
+ *    Binding: `isActionDisabled(item) || boardPickBlock !== null`.
+ *      `boardPickBlock === 'noBoard'` — REGISTERED.
+ *      `boardPickBlock === 'loadFailed'` — REGISTERED.
+ *      `boardPickBlock === 'viewOnly'` — REGISTERED.
+ *      `boardPickBlock === 'loading'` — not registered: a transient state
+ *        between the picker opening and the board fetch settling, not a
+ *        standing condition a user acts against.
+ *      `boardPickBlock === 'noBoards'` — not registered: out of this slice.
+ *      `isActionDisabled`: `readOnly`, `hasMutationInFlight`,
+ *        `triagePollingItemId === item.id`, `!canMutate(item)`,
+ *        `isEditing(item)`, `isEditingElsewhere(item)` — six further
+ *        disjuncts, none registered, all out of this slice.
  *  - `PaperTriageRowEdit` save (`data-action="edit-save"`), which writes the
- *    capture suggestion. All three `saveBlock` states — `busyElsewhere`,
- *    `empty`, `unchanged` — are registered below.
- *  - `PaperCaptureNib` submit, which enqueues a capture. Its one precondition
- *    is `canSubmit`.
- *  - `PaperCaptureComposer` submit, which enqueues a capture. Its one
- *    precondition is a non-blank body.
+ *    capture suggestion.
+ *    Binding: `saveBlock !== null || saving`.
+ *      `saveBlock === 'busyElsewhere'` — REGISTERED.
+ *      `saveBlock === 'empty'` — REGISTERED.
+ *      `saveBlock === 'unchanged'` — REGISTERED.
+ *      `saving` — not registered: it is the in-flight state of a write the
+ *        user already started, not a precondition for starting one.
+ *    This is the only control here whose every standing precondition is
+ *    registered.
+ *  - `PaperCaptureNib` submit, which enqueues a capture.
+ *    Binding: `!canSubmit`, two conjuncts.
+ *      draft is non-blank — REGISTERED.
+ *      `!props.submitting` — not registered: parent-owned in-flight state.
+ *  - `PaperCaptureComposer` submit, which enqueues a capture.
+ *    Binding: `!canSubmit`, FOUR conjuncts.
+ *      body is non-blank — REGISTERED.
+ *      `!props.submitting` — not registered: parent-owned in-flight state.
+ *      `selectedBoardIsWritable` — not registered, out of this slice. It is
+ *        the composer's analogue of the table's `viewOnly`, and worth adding.
+ *      `!transcriptTooLong` — not registered, out of this slice. It is the one
+ *        conjunct here that is a content-length rule rather than a state flag.
  *
  * DELIBERATELY OUT, and why:
  *  - `PaperReviewView` approve / reject / execute — the review surface's
@@ -65,9 +93,9 @@ import { expectGuardedPrimaryAction } from '../utils/guardedPrimaryAction'
  *    evidence of a guarded action; it is the absence of evidence.
  *
  * NOT COVERED: whether the validation text is correct, whether a disabled
- * reason is announced to assistive tech, and every primary action absent from
- * the inventory above. Route-walking runtime coverage (AC4) remains open on
- * GH-1949.
+ * reason is announced to assistive tech, every precondition marked "not
+ * registered" above, and every primary action absent from the inventory
+ * entirely. Route-walking runtime coverage (AC4) remains open on GH-1949.
  */
 
 type MockBoard = { id: string; name: string; canWrite?: boolean }
@@ -327,8 +355,11 @@ describe('primary action guards (GH-1949 AC3)', () => {
     mockBoardStore.boards = []
     mockBoardStore.fetchBoards.mockRejectedValue(new Error('boards unavailable'))
     const wrapper = mount(PaperTriageTable, { props: { items: boardlessItems() } })
+    // The failing load is the one `onMounted` primes, not one the click starts:
+    // by the time the picker opens, `boardListLoadState` is already `failed`,
+    // and `onAccept` re-triggers a load only from `idle`.
+    await flushPromises()
 
-    // Opening the picker with no boards cached triggers the load that fails.
     await wrapper.findAll('button[data-action="accept"]')[0].trigger('click')
     await flushPromises()