@cat-factory/app 0.280.1 → 0.280.2

package/app/components/humanTest/HumanTestWindow.vue

@@ -89,6 +89,18 @@ const ROUND_OUTCOME_LABEL: Record<HumanTestRoundOutcome, string> = {
 const findings = ref('')
 const showFindings = ref(false)
 
+/**
+ * Confirm before discarding typed findings (UX-79). This box is what a human tester saw go wrong —
+ * the one record of it anywhere — held here until Request fix is pressed, on a window Escape and a
+ * backdrop click both close. Sending it on close would resolve the gate and dispatch a fixer.
+ */
+const { requestClose } = useUnsavedGuard({
+  open,
+  close: () => close(),
+  saving: () => busy.value,
+  snapshot: () => findings.value.trim(),
+})
+
 async function confirm() {
   if (!blockId.value) return
   await humanTest.confirm(blockId.value)
@@ -142,7 +154,7 @@ const canDestroy = computed(
     :title="headerTitle"
     :subtitle="phase ? t(PHASE_LABEL[phase]) : t('humanTest.subtitle')"
     width="3xl"
-    @close="close"
+    @close="requestClose"
   >
     <div class="flex min-h-0 flex-1 flex-col gap-4 overflow-y-auto px-5 py-4">
       <div

package/app/components/initiative/InitiativePlanDecision.vue

@@ -13,7 +13,7 @@
 // an edit typed over it would reach nothing, and the engine refuses it outright
 // (`outputIsRendered` → 422). Requesting changes is the route for a correction, which is why an
 // anchored comment is worth having: it quotes the planner's own text back to it on the re-plan.
-import { computed, ref, watch } from 'vue'
+import { computed, onUnmounted, ref, watch } from 'vue'
 import type { RequestStepChangesInput } from '@cat-factory/contracts'
 
 const props = defineProps<{
@@ -30,8 +30,16 @@ const props = defineProps<{
   comments?: RequestStepChangesInput['comments']
 }>()
 
-/** A send-back succeeded: the surface drops its anchored drafts (the feedback is cleared here). */
-const emit = defineEmits<{ sent: [] }>()
+const emit = defineEmits<{
+  /** A send-back succeeded: the surface drops its anchored drafts (the feedback is cleared here). */
+  sent: []
+  /**
+   * Whether unsent feedback is typed here right now. Reported UPWARD because the field lives two
+   * components below the window that owns closing, and the window is what Escape and a backdrop
+   * click reach (UX-79) — without this the host has no way to know a review is in progress.
+   */
+  'update:dirty': [boolean]
+}>()
 
 const execution = useExecutionStore()
 const { t } = useI18n()
@@ -39,6 +47,11 @@ const { t } = useI18n()
 const feedback = ref('')
 const submitting = ref(false)
 
+watch(feedback, (value) => emit('update:dirty', value.trim().length > 0))
+// The gate resolving unmounts this surface; retract the claim rather than leaving the host holding
+// a dirty flag for a field that no longer exists.
+onUnmounted(() => emit('update:dirty', false))
+
 /** Changes can only be requested with something to act on — an empty send would re-plan blind. */
 const canRequestChanges = computed(
   () => !!feedback.value.trim() || (props.comments?.length ?? 0) > 0,

package/app/components/initiative/InitiativePlanReview.vue

@@ -25,7 +25,7 @@
 // for the outline/collapse/scroll-spy, `useProseComments` for the anchoring, `InitiativePlanDecision`
 // for the two commands, and the global `.reader-prose` sheet for the presentation — so the surfaces
 // cannot drift.
-import { ref, watch } from 'vue'
+import { onUnmounted, ref, watch } from 'vue'
 import type { StepApproval } from '~/types/execution'
 import { useStepProse } from '~/composables/useStepProse'
 import { useProseComments } from '~/composables/useProseComments'
@@ -97,6 +97,20 @@ watch(
   },
 )
 
+/**
+ * Whether this review holds work that is not on the server yet, relayed to the window that owns
+ * closing (UX-79). Three things count and all three are lost on a stray Escape: anchored comments
+ * already placed, a comment being typed, and the decision's overall feedback. They are reported
+ * rather than auto-sent, because sending them RESOLVES the gate and re-plans the initiative.
+ */
+const emit = defineEmits<{ 'update:dirty': [boolean] }>()
+const decisionDirty = ref(false)
+watch(
+  () => decisionDirty.value || planComments.value.length > 0 || draftBody.value.trim().length > 0,
+  (dirty) => emit('update:dirty', dirty),
+)
+onUnmounted(() => emit('update:dirty', false))
+
 /** Whether the sidebar's run-details stack is expanded (it is, until a reviewer wants the outline). */
 const runDetailsOpen = ref(true)
 
@@ -386,6 +400,7 @@ async function copyPlan() {
         :can-execute="canExecute"
         :comments="wireComments"
         @sent="resetComments"
+        @update:dirty="decisionDirty = $event"
       />
     </aside>
   </div>

package/app/components/initiative/InitiativePlanningWindow.vue

@@ -22,7 +22,7 @@
 // identically before and after the click, which reads as the button having done nothing. The
 // phase below folds the planning RUN's status in, so the wait is visible and a failed pass says
 // so instead of leaving the human staring at questions they already submitted.
-import { computed, reactive, ref, watch } from 'vue'
+import { computed, ref, watch } from 'vue'
 import ClarificationItem from '~/components/common/ClarificationItem.vue'
 import InterviewGateNotice from '~/components/common/InterviewGateNotice.vue'
 import {
@@ -44,6 +44,11 @@ const { t } = useI18n()
 
 const { open, blockId, instanceId, stepIndex, close } = useResultView('initiative-planning', {
   onOpen: ({ blockId }) => void initiatives.load(blockId),
+  // Persist any typed-but-unsubmitted answer before the view tears down (X, backdrop, Escape), so
+  // closing the window never silently drops it (UX-79). A flush rather than a discard prompt because
+  // saving ONE answer is a plain save: it records the reply without resuming the interview, which is
+  // what this window's own two commands do.
+  onClose: () => flushOnClose(),
 })
 
 const block = computed(() => (blockId.value ? board.getBlock(blockId.value) : undefined))
@@ -76,18 +81,32 @@ const questions = computed(() =>
 /** Questions still needing an answer: not dismissed, and not yet answered (mirrors backend). */
 const pending = computed(() => questions.value.filter(isPendingQuestion))
 
-// Per-question answer drafts, seeded from the entity and refreshed as new rounds arrive
-// without clobbering an answer the human is mid-edit on.
-const drafts = reactive<Record<string, string>>({})
-watch(
-  questions,
-  (list) => {
-    for (const q of list) {
-      if (!(q.key in drafts)) drafts[q.key] = q.answer ?? ''
-    }
+// Per-question answer drafts, plus the two ways they leave the browser: one on blur, all of them on
+// the way out. The shared seam with the doc-authoring interviewer, which holds the same kind of draft
+// for the same reason; `useInterviewDrafts` records what a per-window copy kept getting wrong.
+//
+// `writable` is this window's own rule: a question set aside as not-relevant had its recorded answer
+// CLEARED, so writing a stale local draft back would silently re-answer it and leak it into the
+// converged digest.
+const { drafts, addressable, unanswered, saveAnswer, flushDrafts, flushThen } = useInterviewDrafts({
+  blockId: () => blockId.value,
+  questions: () => questions.value,
+  pending: () => pending.value,
+  write: (block, questionId, answer) => initiatives.answerQuestion(block, questionId, answer),
+  writable: (q) => q.status !== 'dismissed',
+  failureTitleKeys: {
+    one: 'initiative.planning.saveFailed',
+    many: 'initiative.planning.saveFailedCount',
   },
-  { immediate: true },
-)
+})
+
+/**
+ * A hoisted indirection for the close hook above. The seam that owns `flushDrafts` needs the
+ * `blockId` this very `useResultView` call produces, so the hook cannot name the const directly.
+ */
+function flushOnClose(): void {
+  flushDrafts()
+}
 
 /**
  * Render order (pending first — see `orderInterviewQuestions`), re-snapshotted ONLY when the
@@ -129,33 +148,6 @@ const phase = computed(() =>
       ),
 )
 
-/**
- * Questions still missing a drafted answer. Continue is only meaningful once this is empty — but a
- * disabled button with no stated reason is itself a "nothing happened", so the count is rendered.
- * A dismissed question doesn't count (it was set aside), so an all-dismissed round is trivially
- * answered.
- */
-const unanswered = computed(() => pending.value.filter((q) => !drafts[q.key]?.trim()).length)
-
-/**
- * Persist one answer if its draft differs from what's recorded. A `dismissed` question is skipped:
- * it was set aside (its server answer cleared), and the `flushThen` sweep on continue/proceed must
- * NOT write a stale local draft back to it — that would silently re-answer a not-relevant question
- * and leak it into the converged digest.
- */
-async function persist(q: {
-  id?: string
-  key: string
-  answer?: string
-  status?: 'open' | 'dismissed'
-}) {
-  const id = q.id
-  if (!id || !blockId.value || q.status === 'dismissed') return
-  const next = (drafts[q.key] ?? '').trim()
-  if (!next || next === (q.answer ?? '').trim()) return
-  await initiatives.answerQuestion(blockId.value, id, next)
-}
-
 /** Mark a question not-relevant / reopen it. */
 async function setStatus(q: { id?: string }, status: 'open' | 'dismissed') {
   if (!q.id || !blockId.value) return
@@ -168,22 +160,17 @@ async function recommend(q: { id?: string }) {
   await initiatives.recommendAnswer(blockId.value, q.id)
 }
 
-/** Adopt a suggested answer into the draft, then persist it. */
-async function useRecommendation(q: { id?: string; key: string; recommendation?: string | null }) {
+/** Adopt a suggested answer into the draft, then record it. */
+function useRecommendation(q: (typeof questions.value)[number]) {
   if (!q.recommendation) return
   drafts[q.key] = q.recommendation
-  await persist(q)
-}
-
-/** Flush all dirty drafts, then run a window action (continue / proceed). */
-async function flushThen(action: (id: string) => Promise<unknown>) {
-  if (!blockId.value) return
-  for (const q of questions.value) await persist(q)
-  await action(blockId.value)
+  saveAnswer(q)
 }
 
-const onContinue = () => flushThen((id) => initiatives.continuePlanning(id))
-const onProceed = () => flushThen((id) => initiatives.proceedPlanning(id))
+const onContinue = () =>
+  flushThen((id) => initiatives.continuePlanning(id), 'initiative.planning.continueFailed')
+const onProceed = () =>
+  flushThen((id) => initiatives.proceedPlanning(id), 'initiative.planning.proceedFailed')
 
 /**
  * The escape hatch for a planning run that stalled. It belongs HERE, not only in the inspector's
@@ -301,13 +288,24 @@ async function onDiscard() {
                 :dismissed="q.status === 'dismissed'"
                 :recommendation="q.recommendation"
                 :recommending="!!q.id && initiatives.recommending.has(q.id)"
+                :disabled="!addressable(q)"
                 :answer-placeholder="t('initiative.planning.answerPlaceholder')"
-                @persist="persist(q)"
+                @persist="saveAnswer(q)"
                 @dismiss="setStatus(q, 'dismissed')"
                 @reopen="setStatus(q, 'open')"
                 @recommend="recommend(q)"
                 @use-recommendation="useRecommendation(q)"
               />
+              <!-- Every action here addresses a question by id, so an exchange without one has
+                   nowhere for an answer (or a dismissal) to go. Saying so beats taking text the
+                   flush could only drop. -->
+              <p
+                v-if="!addressable(q)"
+                class="mt-1 text-[11px] text-amber-300"
+                data-testid="initiative-planning-unanswerable"
+              >
+                {{ t('initiative.planning.unanswerable') }}
+              </p>
             </li>
           </ul>
         </template>

package/app/components/initiative/InitiativeTrackerWindow.vue

@@ -136,6 +136,20 @@ const { planApproval } = useInitiativePlanning(() => blockId.value ?? '')
  */
 const planDocument = computed(() => planReviewDocument(planApproval.value))
 
+/**
+ * Confirm before discarding an in-progress plan review (UX-79). While a plan gate is parked this
+ * window hands its whole body to `InitiativePlanReview`, which holds anchored per-block comments
+ * and the overall feedback — the reviewer's actual work, held only in the browser until Send back
+ * is pressed, on a surface Escape and a backdrop click both close. The review reports its own
+ * dirtiness upward (it lives two components down); this is the only place that can act on it.
+ *
+ * The tracker body has two drafts of its own, and both are typed values held here until their OWN
+ * Save: the follow-up promotion form's item title, and the policy form's two knobs (see
+ * `promoteState` / `policyState` below for why each is measured against what it was SEEDED with).
+ * The guard itself is registered at the bottom of this block, where all three are in scope.
+ */
+const planReviewDirty = ref(false)
+
 const policyRules = computed(() => initiative.value?.policy?.rules ?? [])
 function ruleAxes(rule: { minComplexity?: number; minRisk?: number; minImpact?: number }): string {
   const axes = [
@@ -161,6 +175,22 @@ function reportError(error: unknown) {
 // Follow-up promotion: an inline per-follow-up form (phase + optional title override).
 const promotingId = ref<string | null>(null)
 const promoteForm = reactive<{ phaseId: string; title: string }>({ phaseId: '', title: '' })
+/**
+ * What the promote form held the moment it opened.
+ *
+ * The unsaved guard below reports the form's DIVERGENCE from this rather than its contents, because
+ * both of this window's inline forms are seeded from what is already stored: an opened-but-untouched
+ * form is not unsaved work, and prompting over one would train the reader to dismiss the prompt.
+ */
+let promoteSeed = ''
+function promoteState(): string {
+  return JSON.stringify([promoteForm.phaseId, promoteForm.title])
+}
+/** The promote form's unsaved edit, or `''` when it is closed or untouched. */
+function promoteDraft(): string {
+  if (promotingId.value === null) return ''
+  return promoteState() === promoteSeed ? '' : promoteState()
+}
 
 function startPromote(followUp: InitiativeFollowUp) {
   const sourcePhase = (initiative.value?.items ?? []).find(
@@ -168,6 +198,7 @@ function startPromote(followUp: InitiativeFollowUp) {
   )?.phaseId
   promoteForm.phaseId = sourcePhase ?? phases.value[0]?.id ?? ''
   promoteForm.title = followUp.title
+  promoteSeed = promoteState()
   promotingId.value = followUp.id
 }
 
@@ -212,12 +243,23 @@ const policyForm = reactive<{ maxConcurrent: number; defaultPipelineId: string }
   maxConcurrent: 1,
   defaultPipelineId: '',
 })
+/** What the policy form held when it opened; see `promoteSeed` for why the guard compares to it. */
+let policySeed = ''
+function policyState(): string {
+  return JSON.stringify([policyForm.maxConcurrent, policyForm.defaultPipelineId])
+}
+/** The policy form's unsaved edit, or `''` when it is closed or untouched. */
+function policyDraft(): string {
+  if (!editingPolicy.value) return ''
+  return policyState() === policySeed ? '' : policyState()
+}
 
 function startEditPolicy() {
   const policy = initiative.value?.policy
   if (!policy) return
   policyForm.maxConcurrent = policy.maxConcurrent
   policyForm.defaultPipelineId = policy.defaultPipelineId
+  policySeed = policyState()
   editingPolicy.value = true
 }
 
@@ -235,6 +277,21 @@ async function savePolicy() {
     reportError(error)
   }
 }
+
+// Registered last on purpose: the snapshot reads the two inline forms above, and
+// `useUnsavedGuard` takes its baseline synchronously, so a `ref` declared further down would still
+// be in its temporal dead zone.
+const { requestClose } = useUnsavedGuard({
+  open,
+  close: () => close(),
+  snapshot: () => ({
+    // Only meaningful while the review is the thing on screen; with no parked gate the body below
+    // is what is rendered, and its own two forms are the drafts that count.
+    planReview: planApproval.value && planDocument.value ? planReviewDirty.value : false,
+    promote: promoteDraft(),
+    policy: policyDraft(),
+  }),
+})
 </script>
 
 <template>
@@ -246,7 +303,7 @@ async function savePolicy() {
     :subtitle="t('initiative.tracker.subtitle')"
     width="full"
     testid="initiative-tracker-window"
-    @close="close"
+    @close="requestClose"
   >
     <template #header-extras>
       <div v-if="progress" class="flex items-center gap-2" data-testid="initiative-progress">
@@ -277,6 +334,7 @@ async function savePolicy() {
       :instance-id="planApproval.instanceId"
       :can-execute="access.canExecuteRuns.value"
       :plan-document="planDocument"
+      @update:dirty="planReviewDirty = $event"
     >
       <template v-if="runMeta" #run-details>
         <StepRunMeta v-bind="runMeta" />

package/app/components/judge/JudgeResultView.vue

@@ -101,6 +101,19 @@ const DISPOSITION_LABELS = computed<
 
 const feedback = ref('')
 const busy = computed(() => judgeStore.resolving)
+
+/**
+ * Confirm before discarding typed guidance (UX-79). The feedback box is what a bounced producer is
+ * handed as its rework brief, it is held here until one of the three commands is pressed, and this
+ * window closes on Escape and on a backdrop click. Flushing it is not an option: every command that
+ * would carry it also RESOLVES the parked verdict.
+ */
+const { requestClose } = useUnsavedGuard({
+  open,
+  close: () => close(),
+  saving: () => busy.value,
+  snapshot: () => feedback.value.trim(),
+})
 const canAct = computed(() => awaiting.value && access.canExecuteRuns.value && !busy.value)
 
 async function act(choice: 'proceed' | 'bounce' | 'stop') {
@@ -120,7 +133,7 @@ async function act(choice: 'proceed' | 'bounce' | 'stop') {
     :subtitle="t('judge.subtitle')"
     :step-ref="{ instanceId, stepIndex }"
     width="3xl"
-    @close="close"
+    @close="requestClose"
   >
     <template #header-extras>
       <UBadge

package/app/components/panels/ResultWindowDrafts.logic.spec.ts

@@ -0,0 +1,233 @@
+import { readFileSync, readdirSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { describe, expect, it } from 'vitest'
+
+// UX-79: a result window that holds typed-but-unsubmitted input must not discard it when the user
+// dismisses the window. `ResultWindowShell` closes on the X, on Escape and on a backdrop click, and
+// a window wired `@close="close"` goes straight through all three — so a reviewer who tabbed away
+// mid-sentence lost the sentence, with nothing on screen having said so.
+//
+// The seams to fix it already existed and were used by exactly two of the fourteen windows that
+// needed them. That is the shape this file guards against: not a missing primitive, but a primitive the
+// next window silently doesn't reach for (the re-audit's cross-cutting theme 8). Nothing in the type
+// system can ask "does this window hold a draft?", so the table below is the answer, asserted
+// against what the components actually do.
+//
+// The two sanctioned dispositions, and the rule for picking:
+//
+//   'flush'   — `useResultView({ onClose })`, then `useInterviewDrafts` or the review windows' own
+//               flush. For a draft whose save is a PLAIN SAVE: recording it changes nothing else, so
+//               writing it on the way out is what the user meant. The review windows and the two
+//               interview windows persist one answer at a time.
+//   'confirm' — `useUnsavedGuard` in front of the shell's close. For a draft whose only submit
+//               button also DECIDES something — resolves a gate, spends a bounded chat turn, keeps
+//               an artifact, re-runs an agent. A stray Escape may not do that on the user's behalf,
+//               so the only honest options are to keep the draft or to ask.
+//
+// A window with no draft state is 'none' and closes straight through, as it always did.
+
+/** Anchored on the vitest root (`frontend/app`) — see the sibling width spec for why not `import.meta.url`. */
+const componentsDir = resolve(process.cwd(), 'app/components')
+
+type Disposition = 'none' | 'flush' | 'confirm'
+
+/**
+ * Every `ResultWindowShell` consumer and how it treats unsubmitted input. The `why` is the point for
+ * anything other than 'none': it has to name the draft, because "this window has no draft" is the
+ * claim that gets silently falsified when someone adds an input to it.
+ */
+const WINDOWS: Record<string, { drafts: Disposition; why: string }> = {
+  'binaryCandidates/BinaryCandidatesWindow.vue': {
+    drafts: 'confirm',
+    why: 'the keep rationale + per-candidate store-as aliases; Keep commits the artifacts',
+  },
+  'brainstorm/BrainstormWindow.vue': {
+    drafts: 'confirm',
+    why: 'per-item replies + the redo comment; a reply resolves an item and the redo starts a pass',
+  },
+  'clarity/ClarityReviewWindow.vue': {
+    drafts: 'flush',
+    why: 'per-finding answers, each recorded on its own',
+  },
+  'consensus/ConsensusSessionWindow.vue': { drafts: 'none', why: 'a read-only transcript' },
+  'docs/DocInterviewWindow.vue': {
+    drafts: 'flush',
+    why: 'per-question answers, each recorded on its own (Submit is a separate command)',
+  },
+  'followUp/FollowUpWindow.vue': {
+    drafts: 'confirm',
+    why: 'per-question answers; sending one decides the item and re-arms the run',
+  },
+  'forkDecision/ForkDecisionWindow.vue': {
+    drafts: 'confirm',
+    why: 'the custom approach, the steering note and the chat box; chat spends a bounded turn budget',
+  },
+  'gates/GateResultView.vue': {
+    drafts: 'confirm',
+    why: 'the human-review fix instructions; Request fix resolves the gate and dispatches a fixer',
+  },
+  'humanTest/HumanTestWindow.vue': {
+    drafts: 'confirm',
+    why: 'the tester findings, the only record of what went wrong; Request fix resolves the gate',
+  },
+  'initiative/InitiativePlanningWindow.vue': {
+    drafts: 'flush',
+    why: 'per-question answers, each recorded on its own (Submit / Plan now are separate commands)',
+  },
+  'initiative/InitiativeTrackerWindow.vue': {
+    drafts: 'confirm',
+    why: 'the plan review it hands its body to (anchored comments + feedback send back a re-plan), plus its own follow-up promotion and execution-policy forms',
+  },
+  'judge/JudgeResultView.vue': {
+    drafts: 'confirm',
+    why: 'the guidance box; every command carrying it also resolves the parked verdict',
+  },
+  'outcome/OutcomeSummaryWindow.vue': { drafts: 'none', why: 'a read-only run summary' },
+  'panels/GenericStructuredResultView.vue': {
+    drafts: 'none',
+    why: 'a read-only structured reader',
+  },
+  'panels/MergerResultView.vue': { drafts: 'none', why: 'a read-only merge verdict' },
+  'prReview/PrReviewWindow.vue': {
+    drafts: 'confirm',
+    why: 'the per-finding challenge box; sending it spends a reviewer turn',
+  },
+  'ralph/RalphLoopResultView.vue': { drafts: 'none', why: 'a loop status readout' },
+  'requirements/RequirementsReviewWindow.vue': {
+    drafts: 'flush',
+    why: 'per-finding answers, each recorded on its own',
+  },
+  'spec/ServiceSpecWindow.vue': { drafts: 'none', why: 'a read-only spec reader' },
+  'testing/TestReportWindow.vue': { drafts: 'none', why: 'a read-only test report' },
+  'visualConfirm/VisualConfirmationWindow.vue': {
+    drafts: 'confirm',
+    why: 'per-view notes anchored to a screenshot + the overall findings box; Request fix resolves the gate',
+  },
+}
+
+/**
+ * `v-model` bindings that are VIEW state rather than a draft, and may therefore appear in a window
+ * declared draft-free. Listed as EXACT bindings rather than matched by shape, because the point of
+ * the inverse assertion below is that a new binding is unknown until someone classifies it: the
+ * planning window's `v-model:answer="drafts[q.key]"` sat unnoticed in a 'none' row precisely because
+ * it looked enough like the lightbox pair to pass a shape test.
+ */
+const VIEW_STATE_BINDINGS = ['v-model:open="lightboxOpen"', 'v-model:index="lightboxIndex"']
+
+/** Every component that mounts the shell, keyed by its path relative to `app/components`. */
+function findConsumers(): Map<string, string> {
+  const found = new Map<string, string>()
+  for (const entry of readdirSync(componentsDir, { recursive: true, encoding: 'utf8' })) {
+    const rel = entry.replace(/\\/g, '/')
+    if (!rel.endsWith('.vue') || rel.endsWith('panels/ResultWindowShell.vue')) continue
+    const source = readFileSync(`${componentsDir}/${rel}`, 'utf8')
+    if (source.includes('<ResultWindowShell')) found.set(rel, source)
+  }
+  return found
+}
+
+/**
+ * The shell's OWN opening tag. Quote-aware, so a `>` inside an attribute value can't end it early,
+ * and bounded, so `@close` on a nested component further down the template can't be read as the
+ * shell's: an unbounded scan would let a window bypass the guard by binding its own close deeper in.
+ */
+function shellTag(source: string): string {
+  const start = source.indexOf('<ResultWindowShell')
+  if (start < 0) return ''
+  let quote: string | null = null
+  for (let i = start; i < source.length; i += 1) {
+    const char = source[i]!
+    if (quote) {
+      if (char === quote) quote = null
+      continue
+    }
+    if (char === '"' || char === "'") quote = char
+    else if (char === '>') return source.slice(start, i + 1)
+  }
+  return ''
+}
+
+/** What the component's `<ResultWindowShell>` binds its close to. */
+function closeBinding(source: string): string | null {
+  return /@close="([^"]+)"/.exec(shellTag(source))?.[1] ?? null
+}
+
+/** Whether the window registers the flush hook on its `useResultView` seam. */
+function registersFlushHook(source: string): boolean {
+  return /useResultView\([\s\S]*?onClose:/.test(source)
+}
+
+/**
+ * Every state binding in the source: `v-model` with or without an argument, plus the explicit
+ * `:model-value` + `@update:model-value` pair that a per-row control inside a `v-for` has to use
+ * (which is the shape `BinaryCandidatesWindow`'s store-as aliases already have).
+ */
+function stateBindings(source: string): string[] {
+  const pattern = /(?:v-model(?::[\w-]+)?|:?model-value|@update:model-value)="[^"]*"/g
+  return [...source.matchAll(pattern)].map((match) => match[0])
+}
+
+/** A native form control, which holds typed input whether or not it carries a `v-model`. */
+function hasNativeControl(source: string): boolean {
+  return /<(?:input|textarea|select)\b/.test(source)
+}
+
+/** What makes this window suspect for a 'none' row, or `null` when nothing does. */
+function draftEvidence(source: string): string | null {
+  const bound = stateBindings(source).filter((binding) => !VIEW_STATE_BINDINGS.includes(binding))
+  if (bound.length > 0) return bound[0]!
+  return hasNativeControl(source) ? 'a native input/textarea/select' : null
+}
+
+describe('result-window draft handling', () => {
+  const consumers = findConsumers()
+
+  it('covers every shell consumer, with no stale rows', () => {
+    expect(consumers.size).toBeGreaterThan(10)
+    expect([...consumers.keys()].sort()).toEqual(Object.keys(WINDOWS).sort())
+  })
+
+  // Every assertion below reads its row through this, so an UNLISTED consumer fails the coverage
+  // test above with a message that names it, instead of crashing the rest of the file on a
+  // `Cannot read properties of undefined` that names nothing.
+  const rows = () =>
+    [...consumers.entries()].flatMap(([file, source]) => {
+      const row = WINDOWS[file]
+      return row ? [{ file, source, row }] : []
+    })
+
+  // The defect UX-79 named: a window holding a draft whose close goes straight to `ui.closeResultView`.
+  // Asserted POSITIVELY — the disposition's own seam has to be present AND wired to the shell's own
+  // close. Merely checking that the binding is not the literal `close` passes a window that renamed
+  // its handler and still closed straight through.
+  it('wires every draft-holding window to the seam its disposition names', () => {
+    const offenders = rows().filter(({ source, row }) => {
+      if (row.drafts === 'flush') {
+        return !registersFlushHook(source) || closeBinding(source) !== 'close'
+      }
+      if (row.drafts === 'confirm') {
+        return !source.includes('useUnsavedGuard(') || closeBinding(source) !== 'requestClose'
+      }
+      return closeBinding(source) !== 'close'
+    })
+    expect(offenders.map(({ file }) => file)).toEqual([])
+  })
+
+  // The inverse, and the one that actually rots: a window declared draft-free that grew an input.
+  // Without this the table degrades into a list of what someone once believed. It reports WHAT it
+  // found, because "this file is suspect" alone sends the reader hunting.
+  it('finds no unsubmitted input in a window declared draft-free', () => {
+    const suspects = rows()
+      .filter(({ row }) => row.drafts === 'none')
+      .map(({ file, source }) => ({ file, evidence: draftEvidence(source) }))
+      .filter(({ evidence }) => evidence !== null)
+    expect(suspects).toEqual([])
+  })
+
+  // A row that says 'confirm'/'flush' but names no draft is a row nobody thought about.
+  it('makes every non-trivial row say what the draft is', () => {
+    for (const [file, row] of Object.entries(WINDOWS)) {
+      if (row.drafts !== 'none') expect(row.why.length, file).toBeGreaterThan(20)
+    }
+  })
+})