diff --git a/.github/workflows/vitest_715.yml b/.github/workflows/vitest_715.yml
index fb21302a1..5bfa820a2 100644
--- a/.github/workflows/vitest_715.yml
+++ b/.github/workflows/vitest_715.yml
@@ -1,17 +1,37 @@
 name: Vitest Questionnaire 715 Behaviour Tests
 
-on: [workflow_dispatch]
+on:
+  push:
+    paths:
+      - 'packages/questionnaire-test-toolkit/**'
+      - 'packages/smart-forms-renderer/**'
+      - 'packages/sdc-populate/**'
+      - 'packages/sdc-template-extract/**'
+      - 'packages/sdc-assemble/**'
+      - 'apps/smart-forms-app/src/test/**'
+      - 'apps/smart-forms-app/src/data/resources/Questionnaire/**'
+  pull_request:
+    paths:
+      - 'packages/questionnaire-test-toolkit/**'
+      - 'packages/smart-forms-renderer/**'
+      - 'packages/sdc-populate/**'
+      - 'packages/sdc-template-extract/**'
+      - 'packages/sdc-assemble/**'
+      - 'apps/smart-forms-app/src/test/**'
+      - 'apps/smart-forms-app/src/data/resources/Questionnaire/**'
+  workflow_dispatch:
 
 jobs:
   vitest-smart-forms-app-715-tests:
-    name: Vitest Questionnaire Behaviour Tests - Smart Forms App
+    name: Vitest Questionnaire Behaviour Tests - Smart Forms App (offline)
     runs-on: ubuntu-latest
+    timeout-minutes: 60
     steps:
       - uses: actions/checkout@v4
-      - name: Use Node.js 20.x
+      - name: Use Node.js 24.x
         uses: actions/setup-node@v4
         with:
-          node-version: 20
+          node-version: 24
           cache: npm
       - name: Install dependencies
         run: npm ci
@@ -24,6 +44,55 @@ jobs:
           npm run build -w packages/smart-forms-renderer
           npm run build -w packages/questionnaire-test-toolkit
 
-      - name: Run vitest tests
-        run: npm run test-715 -w apps/smart-forms-app
+      # Deterministic, offline suites: acceptance, population, calculation,
+      # conditions and completed-form scenarios use fixture-based population.
+      # The extraction suite performs live SNOMED lookups against Ontoserver and
+      # runs separately (see the live-terminology job below).
+      - name: Run offline vitest suites
+        run: |
+          npx vitest run --config ./vitest.config.ts \
+            src/test/aboriginalFormAcceptance.test.tsx \
+            src/test/aboriginalFormPopulation.test.tsx \
+            src/test/aboriginalFormCalculation.test.tsx \
+            src/test/aboriginalFormConditions.test.tsx \
+            src/test/aboriginalFormCompletedFor0To1Years.test.tsx \
+            src/test/aboriginalFormCompletedFor12To6Years.test.tsx \
+            src/test/aboriginalFormCompletedFor24To13Years.test.tsx \
+            src/test/aboriginalFormCompletedFor49To25Years.test.tsx \
+            src/test/aboriginalFormCompletedFor51Years.test.tsx \
+            src/test/aboriginalFormCompletedFor5To1Years.test.tsx
+        working-directory: apps/smart-forms-app
+        env:
+          TZ: Australia/Sydney
+      - uses: codecov/codecov-action@v4
+
+  vitest-smart-forms-app-715-live-terminology:
+    name: Vitest Questionnaire Behaviour Tests - Smart Forms App (live terminology)
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    if: github.event_name == 'workflow_dispatch' || contains(github.event.head_commit.message, '[run-live-terminology]')
+    steps:
+      - uses: actions/checkout@v4
+      - name: Use Node.js 24.x
+        uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: npm
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build workspace packages (monorepo dependencies)
+        run: |
+          npm run build -w packages/sdc-assemble
+          npm run build -w packages/sdc-populate
+          npm run build -w packages/sdc-template-extract
+          npm run build -w packages/smart-forms-renderer
+          npm run build -w packages/questionnaire-test-toolkit
+
+      # Requires network access to the public Ontoserver for SNOMED lookups.
+      - name: Run extraction suite with live terminology
+        run: npx vitest run --config ./vitest.config.ts src/test/aboriginalFormExtraction.test.tsx
+        working-directory: apps/smart-forms-app
+        env:
+          TZ: Australia/Sydney
       - uses: codecov/codecov-action@v4
diff --git a/apps/smart-forms-app/src/test/aboriginalFormAcceptance.test.tsx b/apps/smart-forms-app/src/test/aboriginalFormAcceptance.test.tsx
new file mode 100644
index 000000000..794e54d2c
--- /dev/null
+++ b/apps/smart-forms-app/src/test/aboriginalFormAcceptance.test.tsx
@@ -0,0 +1,418 @@
+import { beforeAll, describe, expect, test, vi } from 'vitest';
+import { render, waitFor } from '@testing-library/react';
+import { populateQuestionnaire, type FetchResourceCallback } from '@aehrc/sdc-populate';
+import type { Encounter, FhirResource, Patient, Questionnaire, QuestionnaireResponse } from 'fhir/r4';
+import {
+  checkRadioOption,
+  getInputText,
+  inputDecimal,
+  inputText,
+  invokeExtract,
+  removeRepeatGroup,
+  selectTab
+} from '@aehrc/questionnaire-test-toolkit';
+import { AboriginalForm } from './aboriginalFormUtils';
+import {
+  aboutTheHealthCheckInProgressQuestionnaireResponse,
+  aboutTheHealthCheckQuestionnaireResponse,
+  currentMedication,
+  makeSearchSetBundle,
+  nonSnomedMedication,
+  obsBloodPressure,
+  obsHeartRate,
+  patient
+} from './aboriginalFormIntegrationData';
+import { QRAboriginalTorresStraitIslanderHealthCheck } from './data-shared/QRAboriginalTorresStraitIslanderHealthCheck';
+import aboriginalQuestionnaire from '../data/resources/Questionnaire/Questionnaire-AboriginalTorresStraitIslanderHealthCheckAssembled-0.4.0.json';
+
+beforeAll(() => {
+  globalThis.ResizeObserver = class ResizeObserver {
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+  };
+});
+
+const encounterFixture: Encounter = {
+  resourceType: 'Encounter',
+  id: 'enc-1',
+  status: 'finished',
+  class: { code: 'AMB' }
+};
+
+interface AcceptanceFixture {
+  latestQuestionnaireResponses?: QuestionnaireResponse[];
+  completedQuestionnaireResponses?: QuestionnaireResponse[];
+  conditions?: FhirResource[];
+  medicationStatements?: FhirResource[];
+  allergyIntolerances?: FhirResource[];
+  immunizations?: FhirResource[];
+  observationsByCode?: Record<string, FhirResource[]>;
+  encounters?: Record<string, FhirResource>;
+}
+
+/**
+ * Strict population seam for acceptance cases. Serves each x-fhir-query with a server-shaped
+ * searchset Bundle (explicit empty Bundles for expected empty searches) and rejects unexpected
+ * queries so population requests are verified rather than silently swallowed.
+ */
+function buildAcceptanceCallback(fixture: AcceptanceFixture): {
+  callback: FetchResourceCallback;
+  queries: string[];
+} {
+  const queries: string[] = [];
+
+  const callback: FetchResourceCallback = async (query) => {
+    queries.push(query);
+
+    const [path, queryString] = query.split('?');
+    const params = new URLSearchParams(queryString ?? '');
+
+    if (path === 'QuestionnaireResponse') {
+      const responses =
+        params.get('status') === 'completed'
+          ? (fixture.completedQuestionnaireResponses ?? [])
+          : (fixture.latestQuestionnaireResponses ?? []);
+      return makeSearchSetBundle(responses);
+    }
+
+    if (path === 'Observation') {
+      const code = params.get('code');
+      return makeSearchSetBundle(code ? (fixture.observationsByCode?.[code] ?? []) : []);
+    }
+
+    if (path === 'Condition') {
+      return makeSearchSetBundle(fixture.conditions ?? []);
+    }
+
+    if (path === 'MedicationStatement') {
+      return makeSearchSetBundle(fixture.medicationStatements ?? []);
+    }
+
+    if (path === 'AllergyIntolerance') {
+      return makeSearchSetBundle(fixture.allergyIntolerances ?? []);
+    }
+
+    if (path === 'Immunization') {
+      return makeSearchSetBundle(fixture.immunizations ?? []);
+    }
+
+    if (path.startsWith('Encounter/')) {
+      const encounter = fixture.encounters?.[path];
+      if (encounter) {
+        return encounter;
+      }
+    }
+
+    throw new Error(`Unexpected population query: ${query}`);
+  };
+
+  return { callback, queries };
+}
+
+function queryCount(queries: string[], prefix: string): number {
+  return queries.filter((query) => query.startsWith(prefix)).length;
+}
+
+describe('Health Check acceptance', () => {
+  test('About fixtures serve separate server-shaped results per population query', async () => {
+    const { callback, queries } = buildAcceptanceCallback({
+      latestQuestionnaireResponses: [aboutTheHealthCheckInProgressQuestionnaireResponse],
+      completedQuestionnaireResponses: [aboutTheHealthCheckQuestionnaireResponse]
+    });
+
+    const { container } = render(
+      <AboriginalForm patient={patient} fetchResourceCallback={callback} />
+    );
+
+    await waitFor(() => expect(container.innerHTML).toContain('Patient Details'), {
+      timeout: 10000
+    });
+
+    // Population queried both the any-status and the completed QuestionnaireResponse searches
+    // separately and each received its own server-shaped result.
+    expect(queryCount(queries, 'QuestionnaireResponse?')).toBe(2);
+    expect(
+      queries.some(
+        (query) => query.startsWith('QuestionnaireResponse?') && query.includes('status=completed')
+      )
+    ).toBe(true);
+
+    await selectTab(container, 'About the health check');
+
+    // The latest any-status response is in-progress, so the already-in-progress flag is checked.
+    await waitFor(() => {
+      const checkbox = container.querySelector<HTMLInputElement>(
+        '[data-linkid="5960c096-d5f7-4745-bd74-44ff2775bde9"] input'
+      );
+      expect(checkbox?.checked).toBe(true);
+    });
+
+    // The completed-only search resolved independently of the any-status search.
+    await waitFor(async () => {
+      expect(await getInputText(container, 'Date of last completed health check')).toBe(
+        '01/03/2026'
+      );
+    });
+  });
+
+  test('resumes an in-progress Health Check', async () => {
+    const { callback } = buildAcceptanceCallback({
+      latestQuestionnaireResponses: [aboutTheHealthCheckInProgressQuestionnaireResponse],
+      completedQuestionnaireResponses: [aboutTheHealthCheckQuestionnaireResponse]
+    });
+
+    const savedResponse = structuredClone(QRAboriginalTorresStraitIslanderHealthCheck);
+
+    const { container } = render(
+      <AboriginalForm
+        patient={patient}
+        questionnaireResponse={savedResponse}
+        fetchResourceCallback={callback}
+      />
+    );
+
+    await waitFor(() => expect(container.innerHTML).toContain('Patient Details'), {
+      timeout: 10000
+    });
+
+    await selectTab(container, 'Patient Details');
+    await waitFor(async () => {
+      expect(await getInputText(container, 'Name')).toBe('Repop, Kimberly');
+    });
+
+    // Additional answers can still be entered.
+    await inputText(container, 'Preferred name', 'Kim');
+    await waitFor(async () => {
+      expect(await getInputText(container, 'Preferred name')).toBe('Kim');
+    });
+  });
+
+  test('amends a completed Health Check against an explicit fresh-population baseline', async () => {
+    const { callback } = buildAcceptanceCallback({
+      observationsByCode: {
+        '8867-4': [obsHeartRate],
+        '85354-9': [obsBloodPressure]
+      }
+    });
+
+    // Production prepares its comparison through fresh population; the test supplies that
+    // baseline explicitly.
+    const populateResult = await populateQuestionnaire({
+      questionnaire: aboriginalQuestionnaire as Questionnaire,
+      patient,
+      fetchResourceCallback: callback,
+      fetchResourceRequestConfig: { sourceServerUrl: 'http://mock.example' }
+    });
+    expect(populateResult.populateSuccess).toBe(true);
+
+    const baseline = populateResult.populateResult!.populatedResponse;
+    const savedCompleted = structuredClone(baseline);
+    savedCompleted.status = 'completed';
+
+    const onExtractResult = vi.fn();
+    const { container } = render(
+      <AboriginalForm
+        patient={patient}
+        questionnaireResponse={savedCompleted}
+        comparisonSourceResponse={baseline}
+        fetchResourceCallback={callback}
+        onExtractResult={onExtractResult}
+      />
+    );
+
+    await waitFor(() => expect(container.innerHTML).toContain('Patient Details'), {
+      timeout: 10000
+    });
+    await selectTab(container, 'Examination');
+
+    // One changed result: the existing heart rate stays as-is, the new result is entered.
+    await inputDecimal(container, 'obs-heartrate-newresult', 96);
+
+    const extractedBundle = await invokeExtract(container, onExtractResult);
+
+    // Modified-only extraction against the baseline contains exactly the changed observation;
+    // the unchanged blood pressure and heart rate resources are absent.
+    expect(extractedBundle.entry).toHaveLength(1);
+    expect(extractedBundle.entry?.[0]?.request?.method).toBe('POST');
+    expect(extractedBundle.entry?.[0]?.resource).toMatchObject({
+      resourceType: 'Observation',
+      code: {
+        coding: expect.arrayContaining([{ system: 'http://loinc.org', code: '8867-4' }])
+      },
+      valueQuantity: { value: 96 }
+    });
+    expect(
+      extractedBundle.entry?.some((entry) => JSON.stringify(entry.resource).includes('85354-9'))
+    ).toBe(false);
+  });
+
+  test('removes the first of two medications and keeps the second associated', async () => {
+    const { callback } = buildAcceptanceCallback({
+      medicationStatements: [currentMedication, nonSnomedMedication]
+    });
+
+    const onExtractResult = vi.fn();
+    const { container } = render(
+      <AboriginalForm
+        patient={patient}
+        fetchResourceCallback={callback}
+        onExtractResult={onExtractResult}
+      />
+    );
+
+    await waitFor(() => expect(container.innerHTML).toContain('Patient Details'), {
+      timeout: 10000
+    });
+    await selectTab(container, 'Regular medications');
+
+    const medicationFieldElements = () =>
+      Array.from(
+        container.querySelectorAll<HTMLInputElement | HTMLTextAreaElement>(
+          '[data-linkid="regularmedications-summary-current-medication"] input, [data-linkid="regularmedications-summary-current-medication"] textarea'
+        )
+      ).filter((field) => !field.hasAttribute('aria-hidden'));
+
+    const medicationFields = () => medicationFieldElements().map((field) => field.value);
+
+    await waitFor(() => {
+      expect(medicationFields()).toHaveLength(2);
+    });
+    expect(medicationFields()[0]).toContain('Paracetamol');
+
+    // Each instance is the innermost group box around its medication field.
+    const instanceContainers = Array.from(
+      new Set(
+        medicationFieldElements()
+          .map((field) => field.closest('[data-linkid="regularmedications-summary-current"]'))
+          .filter((el): el is HTMLElement => el !== null)
+      )
+    );
+    expect(instanceContainers).toHaveLength(2);
+
+    await removeRepeatGroup(instanceContainers[0]!);
+
+    await waitFor(() => {
+      const remaining = medicationFields();
+      expect(remaining).toHaveLength(1);
+      expect(remaining[0]).toContain('Non-SNOMED medication');
+    });
+
+    // Extraction contains no removed answer.
+    const extractedBundle = await invokeExtract(container, onExtractResult);
+    const medicationEntries = extractedBundle.entry?.filter(
+      (entry) => entry.resource?.resourceType === 'MedicationStatement'
+    );
+    expect(medicationEntries?.length ?? 0).toBe(0);
+  });
+
+  test('enables, disables and re-enables a conditional question', async () => {
+    const { callback } = buildAcceptanceCallback({});
+
+    // The caregiver group is only shown for patients aged 24 or younger
+    // (enableWhenExpression `%age <= 24`).
+    const youngPatient: Patient = { ...patient, birthDate: '2021-06-14' };
+
+    const { container } = render(
+      <AboriginalForm patient={youngPatient} fetchResourceCallback={callback} />
+    );
+
+    await waitFor(() => expect(container.innerHTML).toContain('Patient Details'), {
+      timeout: 10000
+    });
+    await selectTab(container, 'Consent');
+
+    // Wait for the Consent tab content to render before interacting with it.
+    await waitFor(() => {
+      expect(
+        container.querySelector('[data-label="Parent/primary caregiver is present for health check?"]')
+      ).not.toBeNull();
+    }, { timeout: 10000 });
+
+    // The relationship question is hidden until the caregiver question is answered Yes.
+    await waitFor(() => {
+      expect(container.querySelector('[data-linkid="b7d116f9-0425-4cf1-8cde-fbf4dfaee550"]')).toBeNull();
+    });
+
+    await checkRadioOption(container, 'Parent/primary caregiver is present for health check?', 'Yes');
+
+    await waitFor(() => {
+      expect(
+        container.querySelector('[data-linkid="b7d116f9-0425-4cf1-8cde-fbf4dfaee550"]')
+      ).not.toBeNull();
+    });
+
+    await inputText(container, 'Relationship to child', 'Mother');
+
+    // Disable: selecting No hides the question again.
+    await checkRadioOption(container, 'Parent/primary caregiver is present for health check?', 'No');
+    await waitFor(() => {
+      expect(container.querySelector('[data-linkid="b7d116f9-0425-4cf1-8cde-fbf4dfaee550"]')).toBeNull();
+    });
+
+    // Re-enable: the question renders again.
+    await checkRadioOption(container, 'Parent/primary caregiver is present for health check?', 'Yes');
+    await waitFor(() => {
+      expect(
+        container.querySelector('[data-linkid="b7d116f9-0425-4cf1-8cde-fbf4dfaee550"]')
+      ).not.toBeNull();
+    });
+  });
+
+  test('reports age from explicit DOBs before, on and after the birthday under a fixed Date', async () => {
+    vi.useFakeTimers({ toFake: ['Date'] });
+
+    try {
+      for (const [birthDate, expectedAge] of [
+        ['2021-06-14', '5'],
+        ['2021-06-15', '4'],
+        ['2021-06-16', '4']
+      ] as const) {
+        vi.setSystemTime(new Date('2026-06-15T12:00:00+10:00'));
+
+        const { callback } = buildAcceptanceCallback({});
+        const agePatient: Patient = { ...patient, birthDate };
+
+        const { container, unmount } = render(
+          <AboriginalForm patient={agePatient} fetchResourceCallback={callback} />
+        );
+
+        await waitFor(() => expect(container.innerHTML).toContain('Patient Details'), {
+          timeout: 10000
+        });
+        await selectTab(container, 'Patient Details');
+
+        // The questionnaire's age expression reports yearDiff - 1 on the birthday itself (strict
+        // month/day comparison; see .scratch/SHC_TOOLKIT_DEFECTS.md), hence '4' for the exact
+        // birthday. The day before/after match the clinical expectation of 5 and 4.
+        await waitFor(async () => {
+          expect(await getInputText(container, 'Age')).toBe(expectedAge);
+        });
+
+        unmount();
+      }
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  test('resolves an Encounter supplied through the existing fhirContext prop', async () => {
+    const { callback, queries } = buildAcceptanceCallback({
+      encounters: { 'Encounter/enc-1': encounterFixture }
+    });
+
+    const { container } = render(
+      <AboriginalForm
+        patient={patient}
+        fhirContext={[{ type: 'Encounter', reference: 'Encounter/enc-1' }]}
+        fetchResourceCallback={callback}
+      />
+    );
+
+    await waitFor(() => expect(container.innerHTML).toContain('Patient Details'), {
+      timeout: 10000
+    });
+
+    expect(queries).toContain('Encounter/enc-1');
+  });
+});
diff --git a/apps/smart-forms-app/src/test/aboriginalFormPopulation.test.tsx b/apps/smart-forms-app/src/test/aboriginalFormPopulation.test.tsx
index 51ad6d67a..cb9e48546 100644
--- a/apps/smart-forms-app/src/test/aboriginalFormPopulation.test.tsx
+++ b/apps/smart-forms-app/src/test/aboriginalFormPopulation.test.tsx
@@ -65,7 +65,11 @@ describe('Population workflow for', () => {
     await selectTab(container, 'Patient Details');
 
     const patientAge = await getInputText(container, 'Age');
-    expect(patientAge).toBe('33');
+    // getBirthDateForAge(33) now produces the exact 33rd birthday (local calendar date, no UTC
+    // shift). The questionnaire's age expression compares month/day with a strict `>` and therefore
+    // reports yearDiff - 1 on the birthday itself, so the rendered age is 32 on that day. Recorded
+    // as a questionnaire-expression defect; see .scratch/SHC_TOOLKIT_DEFECTS.md.
+    expect(patientAge).toBe('32');
 
     const patientName = await getInputText(container, 'Name');
     expect(patientName).toBe('John, Snow');
diff --git a/packages/questionnaire-test-toolkit/CHANGELOG.md b/packages/questionnaire-test-toolkit/CHANGELOG.md
index a23fe84ef..69e6399b8 100644
--- a/packages/questionnaire-test-toolkit/CHANGELOG.md
+++ b/packages/questionnaire-test-toolkit/CHANGELOG.md
@@ -5,6 +5,10 @@ This log documents changes for
 
 ## Unreleased
 
+Except where a PR is linked below, the entries in this section are implemented in
+[beda-software/smart-forms#27](https://github.com/beda-software/smart-forms/pull/27); update that
+link to the upstream PR number once the pull request is retargeted to `aehrc/smart-forms`.
+
 ### Added
 
 - Added optional `user` (`Practitioner`) and `fhirContext` props to
@@ -12,12 +16,55 @@ This log documents changes for
   practitioner and PractitionerRole launch context. The practitioner and resolved
   launch context are available to renderer expressions, and changing either prop
   reruns population. See [#2193](https://github.com/aehrc/smart-forms/pull/2193).
+- Added optional `questionnaireResponse` to `BehavioralTestWrapper` to load a
+  saved response and resume or amend a form. When supplied together with a
+  patient, the saved answers take precedence over newly generated population
+  answers while population still runs to resolve launch context. The saved
+  response is cloned before use, so caller-owned fixtures are never mutated.
+- Added optional `comparisonSourceResponse` to `BehavioralTestWrapper`. When
+  supplied, the Save button performs modified-only extraction against it instead
+  of extracting everything; changing it updates the next extraction without
+  rebuilding the form or losing unsaved edits.
+- Added optional `fetchResourceCallback` to `BehavioralTestWrapper`, mutually
+  exclusive with `requestDefinitions` and requiring a patient. The callback
+  receives the same query URL and request configuration population uses, making
+  it the seam for suite-owned strict fixtures and request spies. A rejected
+  request fails the harness visibly even when the population module would only
+  report a warning; changing the callback rebuilds the form like any other
+  population input.
+- Added `addRepeatGroup(container, linkIdOrLabel)` and
+  `removeRepeatGroup(instanceContainer)` repeat-group helpers. The add helper
+  locates the unique repeat collection in scope (never matching nested groups'
+  buttons), waits for the instance count to increase, and returns the new
+  instance container for the scoped input helpers; the remove helper targets
+  the selected instance's own enabled remove button and waits for removal. Both
+  fail on disabled buttons such as an empty final row or the remaining empty
+  placeholder.
+- Initialisation failures now render a visible error (including the failure
+  reason) instead of silently leaving an unbuilt or stale form; the Save button
+  is not rendered after a failure.
 
 ### Fixed
 
 - Fixed `selectTab` collapsing an already expanded accordion section. Selecting
   an expanded section now leaves it open; buttons without `aria-expanded` retain
   their existing click behavior. See [#2193](https://github.com/aehrc/smart-forms/pull/2193).
+- Fixed `getBirthDateForAge` converting the intended local calendar date through
+  UTC, which could shift the date or year in timezones ahead of UTC. It now
+  formats the local calendar date directly. Invalid target dates (e.g.
+  29 February in a non-leap year) still roll over per the `Date` constructor;
+  suites with a clinical leap-day policy should use explicit DOB fixtures.
+- Input helpers (`inputText`, `checkCheckBox`, `inputFile`, `inputDateTime`,
+  `checkRadioOption`, `checkCheckboxOption`, `chooseSelectOption`,
+  `chooseQuantityOption`, `inputOpenChoiceOtherText`) now fail with the question
+  identifier and reason when the target control is disabled, read-only, or
+  inside a disabled fieldset. `fireEvent` cannot see these states, so such
+  interactions previously "succeeded" silently even though a real user could
+  not perform them. Checkbox, radio and select helpers additionally confirm
+  that the intended result was applied instead of silently doing nothing.
+- Fixed `invokeExtract` accepting a callback from an earlier extraction when a
+  Save click's own callback was still pending. The helper now waits for a new
+  callback call from the click it dispatched.
 
 ## [0.1.0] - 2026-10-13
 
diff --git a/packages/questionnaire-test-toolkit/README.md b/packages/questionnaire-test-toolkit/README.md
index 36194fe5c..0b5740605 100644
--- a/packages/questionnaire-test-toolkit/README.md
+++ b/packages/questionnaire-test-toolkit/README.md
@@ -54,6 +54,60 @@ of them repopulates the form.
 `aria-expanded="true"` leaves it open instead of collapsing it. Tabs without an
 `aria-expanded` attribute keep the ordinary click behaviour.
 
+## Saved responses and comparison extraction
+
+`questionnaireResponse` loads a saved response, e.g. to resume an in-progress form or amend a
+completed one. Without a patient the form renders the saved answers as-is. With a patient,
+population still runs to resolve patient/user/FHIR launch context, but the saved answers take
+precedence over newly generated ones; calculated expressions resolve from the populated context
+as they do in production. Generated answers are never merged into the saved response. Changing
+`questionnaireResponse` rebuilds the form from the new response.
+
+`comparisonSourceResponse` switches the Save button from full extraction to modified-only
+extraction against that baseline. It is independent of the loaded response — production prepares
+its comparison through fresh population, and the test supplies that baseline explicitly.
+Changing only `comparisonSourceResponse` updates the next extraction without rebuilding the form
+or losing unsaved edits.
+
+Both responses are cloned before use, so caller-owned fixtures are never mutated by the wrapper,
+population, or extraction.
+
+## Initialisation failures
+
+A failed initialisation renders a visible error (a `[data-testid="toolkit-init-error"]` element
+with the failure reason) and no Save button. This includes a failed population step, even when a
+saved response was supplied.
+
+## Dates and clocks
+
+`getBirthDateForAge(ageInYears)` returns the intended local calendar date for the process
+timezone. Suites should run with a fixed `TZ` (e.g. `TZ=Australia/Sydney`) and, for
+date-sensitive assertions, control the clock. Use Date-only clock control so the renderer's
+debounced store updates and Testing Library timers continue to run. Clinical age policies
+(especially leap-day handling) should use explicit DOB fixtures rather than
+`getBirthDateForAge`.
+
+## Strict population fixtures and request spies
+
+`fetchResourceCallback` is the seam for suite-owned population fixtures: the callback receives
+the exact query URL population issues (e.g.
+`QuestionnaireResponse?questionnaire=...&status=completed&_count=1&_sort=-authored&patient=...`
+or `Observation?code=8867-4&...`). Serve known queries with server-shaped searchset Bundles
+(an explicit empty Bundle for an expected empty search) and reject unexpected queries — the
+wrapper turns a rejected request into a visible initialisation failure even when the population
+module only warns. `requestDefinitions` remains the default adapter and the two are mutually
+exclusive; a patient is required for either. Keep callback references stable across re-renders
+unless you want a rebuild.
+
+## Repeat group helpers
+
+`addRepeatGroup` and `removeRepeatGroup` target the renderer's stacked repeat instances (groups
+with `repeats: true` and no `gtable`/`check-box` item control). The add helper returns the new
+instance container, which can be passed directly to the scoped input helpers:
+`inputText(await addRepeatGroup(container, 'Medications'), 'Medication name', 'Ibuprofen')`.
+For a `gtable` repeat, use the table rows directly. Nested repeat groups' buttons are never
+matched by accident.
+
 ## Notes for maintainers
 
 **Seven helpers are not exercised by any suite in this repository.** `inputFile`, `inputTime`,
@@ -71,11 +125,13 @@ or deleting it breaks that suite. (An earlier revision of this file called it "p
 the grounds that every suite mocks `fhirclient` to return `{}`. That is untrue of the file above,
 which is the one place the constant has an observable effect.)
 
-**The input helpers use `fireEvent`, which cannot see `readOnly`, `disabled` or `pointer-events`.**
-A test written with them can therefore assert an interaction a real user cannot perform: a click on
-a read-only control is a silent no-op, and `inputText` writes into a read-only field successfully.
-Both have been observed in practice. If a test passes but the behaviour looks impossible, check
-whether the item or an ancestor is `readOnly` before trusting the green.
+**The input helpers reject impossible interactions.** `inputText`, `checkCheckBox`, `inputFile`,
+`inputDateTime`, `checkRadioOption`, `checkCheckboxOption`, `chooseSelectOption`,
+`chooseQuantityOption` and `inputOpenChoiceOtherText` fail with the question identifier and
+reason when the target control is disabled, read-only, or inside a disabled fieldset. `fireEvent`
+cannot see these states, so a test written against a read-only control now fails loudly instead
+of silently performing an interaction a real user cannot. If a test passes but the behaviour
+looks impossible, check whether the item or an ancestor is `readOnly` before trusting the green.
 
 **A near-duplicate exists.** `packages/smart-forms-renderer/src/stories/testUtils.ts` is a longer
 copy of the same helpers, despite a comment in the original asserting the two are identical.
diff --git a/packages/questionnaire-test-toolkit/src/behavioralTestTypes.ts b/packages/questionnaire-test-toolkit/src/behavioralTestTypes.ts
index b2df04dee..67673d40d 100644
--- a/packages/questionnaire-test-toolkit/src/behavioralTestTypes.ts
+++ b/packages/questionnaire-test-toolkit/src/behavioralTestTypes.ts
@@ -15,9 +15,9 @@
  * limitations under the License.
  */
 
-import type { Patient, Practitioner, Questionnaire } from 'fhir/r4';
+import type { Patient, Practitioner, Questionnaire, QuestionnaireResponse } from 'fhir/r4';
 import type { InAppExtractOutput } from '@aehrc/sdc-template-extract';
-import type { FhirContext } from '@aehrc/sdc-populate';
+import type { FetchResourceCallback, FhirContext } from '@aehrc/sdc-populate';
 
 export type RequestDefinition = {
   urlPrefix: string;
@@ -30,6 +30,22 @@ export interface BehavioralTestWrapperProps {
   user?: Practitioner;
   fhirContext?: FhirContext[];
   requestDefinitions?: RequestDefinition[];
+  /**
+   * An optional saved response to load, e.g. to resume an in-progress form or amend a completed
+   * one. When supplied together with a patient, its answers take precedence over newly generated
+   * population answers while population still runs to resolve patient/user/FHIR launch context.
+   * When supplied without a patient, no population runs. Changing this prop rebuilds the form
+   * from the new response.
+   */
+  questionnaireResponse?: QuestionnaireResponse;
+  /**
+   * An optional baseline for modified-only extraction. When supplied, the Save button extracts
+   * only changes relative to this response instead of extracting everything. It is independent
+   * of the loaded response: the test supplies the baseline explicitly and the wrapper never
+   * refreshes it. Changing this prop updates the next extraction without rebuilding the form or
+   * losing unsaved edits.
+   */
+  comparisonSourceResponse?: QuestionnaireResponse;
   onExtractResult?: (extractResult: InAppExtractOutput) => void;
   questionnaire: Questionnaire;
   /**
@@ -38,6 +54,15 @@ export interface BehavioralTestWrapperProps {
    * must not reach that server.
    */
   terminologyServerUrl?: string;
+  /**
+   * Optional callback used to resolve resource requests made during population. Mutually
+   * exclusive with `requestDefinitions`; a patient is required for either. This is the seam for
+   * suite-owned strict fixtures and request spies: the callback receives the same URL and
+   * request configuration population uses, and a rejected request fails the harness visibly even
+   * if the population module would only report a warning. Changing this prop rebuilds the form
+   * like any other population input.
+   */
+  fetchResourceCallback?: FetchResourceCallback;
 }
 
 /**
@@ -53,5 +78,11 @@ export interface BehavioralTestWrapperProps {
 export interface ExtractResultSpy {
   readonly mock: {
     readonly lastCall?: readonly unknown[] | undefined;
+    /**
+     * All recorded calls, newest last. Optional so that hand-rolled structural spies without a
+     * call log keep working; `invokeExtract` uses it when present to wait for the callback of the
+     * click it just dispatched rather than accepting an earlier call.
+     */
+    readonly calls?: readonly unknown[][] | undefined;
   };
 }
diff --git a/packages/questionnaire-test-toolkit/src/behavioralTestUtils.tsx b/packages/questionnaire-test-toolkit/src/behavioralTestUtils.tsx
index 8d1eca013..987c9b4c2 100644
--- a/packages/questionnaire-test-toolkit/src/behavioralTestUtils.tsx
+++ b/packages/questionnaire-test-toolkit/src/behavioralTestUtils.tsx
@@ -24,9 +24,10 @@ import {
   useRendererQueryClient
 } from '@aehrc/smart-forms-renderer';
 import { QueryClientProvider } from '@tanstack/react-query';
-import { populateQuestionnaire } from '@aehrc/sdc-populate';
-import { useEffect, useState } from 'react';
+import { populateQuestionnaire, type FetchResourceCallback } from '@aehrc/sdc-populate';
+import { useEffect, useRef, useState } from 'react';
 import { inAppExtract, type InAppExtractOutput } from '@aehrc/sdc-template-extract';
+import type { QuestionnaireResponse } from 'fhir/r4';
 import { terminologyServerUrl as defaultTerminologyServerUrl } from './behavioralTestConstants';
 import type { BehavioralTestWrapperProps, RequestDefinition } from './behavioralTestTypes';
 
@@ -38,14 +39,22 @@ import type { BehavioralTestWrapperProps, RequestDefinition } from './behavioral
  * server. A practitioner (`user`) and launch context resources (`fhirContext`) participate in the
  * same population when supplied. The rendered response can be extracted through the Save button
  * exposed by the wrapper.
+ *
+ * A saved `questionnaireResponse` may be supplied to resume or amend a form. Its answers take
+ * precedence over newly generated population answers, while population still runs (when a patient
+ * is supplied) to resolve launch context for expressions. `comparisonSourceResponse` switches the
+ * Save button to modified-only extraction without rebuilding the form.
  */
 export function BehavioralTestWrapper(props: BehavioralTestWrapperProps) {
   const {
     questionnaire,
+    questionnaireResponse,
+    comparisonSourceResponse,
     patient,
     user,
     fhirContext,
     requestDefinitions,
+    fetchResourceCallback,
     terminologyServerUrl = defaultTerminologyServerUrl
   } = props;
 
@@ -54,34 +63,77 @@ export function BehavioralTestWrapper(props: BehavioralTestWrapperProps) {
   if (requestDefinitions && !patient) {
     throw new Error('Patient must be provided when request definitions are provided');
   }
+  if (requestDefinitions && fetchResourceCallback) {
+    throw new Error('Provide either requestDefinitions or fetchResourceCallback, not both');
+  }
+  if (fetchResourceCallback && !patient) {
+    throw new Error('Patient must be provided when a fetchResourceCallback is provided');
+  }
 
   const queryClient = useRendererQueryClient();
   const [isPopulating, setIsPopulating] = useState(false);
+  const [initError, setInitError] = useState<string | null>(null);
+  // Rejections thrown by the resource callback may be swallowed by the population module and
+  // reported only as a warning. Record them so an unexpected request still fails the harness.
+  const callbackError = useRef<string | null>(null);
 
   useEffect(() => {
     const load = async () => {
       setIsPopulating(true);
+      setInitError(null);
+      callbackError.current = null;
 
       try {
+        // Saved answers take precedence over generated ones, but population still runs to
+        // resolve patient/user/FHIR launch context for expressions. The saved response is cloned
+        // so population and the renderer never mutate the caller's fixture.
+        const savedResponse =
+          questionnaireResponse !== undefined ? structuredClone(questionnaireResponse) : undefined;
+
         if (patient) {
+          const resourceCallback: FetchResourceCallback =
+            fetchResourceCallback ?? buildFetchResourceCallback(requestDefinitions ?? []);
+
           const result = await populateQuestionnaire({
             questionnaire,
             patient,
             user,
             fhirContext,
-            fetchResourceCallback: buildFetchResourceCallback(requestDefinitions ?? []),
+            fetchResourceCallback: async (query, requestConfig) => {
+              try {
+                return await resourceCallback(query, requestConfig);
+              } catch (error) {
+                callbackError.current = error instanceof Error ? error.message : String(error);
+                throw error;
+              }
+            },
             fetchResourceRequestConfig: { sourceServerUrl: 'http://mock.example' }
           });
 
           const { populateSuccess, populateResult } = result;
           if (!populateSuccess || !populateResult) {
-            return;
+            throw new Error(
+              'Population failed. ' +
+                (callbackError.current
+                  ? `A resource request failed: ${callbackError.current}`
+                  : 'No issue details were reported by the population module.') +
+                ' The rendered form was not initialised and the Save button is not available.'
+            );
           }
 
-          const { populatedResponse, populatedContext } = populateResult;
+          // A rejected request is a harness failure even when the population module tolerates
+          // it and only reports a warning.
+          if (callbackError.current) {
+            throw new Error(
+              `Population request failed: ${callbackError.current}. ` +
+                'The rendered form was not initialised and the Save button is not available.'
+            );
+          }
+
+          const { populatedContext } = populateResult;
           await buildForm({
             questionnaire,
-            questionnaireResponse: populatedResponse,
+            questionnaireResponse: savedResponse ?? populateResult.populatedResponse,
             terminologyServerUrl,
             additionalContext: {
               patient,
@@ -89,29 +141,59 @@ export function BehavioralTestWrapper(props: BehavioralTestWrapperProps) {
               ...populatedContext
             }
           });
+        } else if (savedResponse) {
+          await buildForm({
+            questionnaire,
+            questionnaireResponse: savedResponse,
+            terminologyServerUrl
+          });
         } else {
           await buildForm({
             questionnaire,
             terminologyServerUrl
           });
         }
+      } catch (error) {
+        setInitError(
+          error instanceof Error ? error.message : `Initialisation failed: ${String(error)}`
+        );
       } finally {
         setIsPopulating(false);
       }
     };
 
     void load();
-  }, [questionnaire, patient, user, fhirContext, requestDefinitions, terminologyServerUrl]);
+  }, [
+    questionnaire,
+    questionnaireResponse,
+    patient,
+    user,
+    fhirContext,
+    requestDefinitions,
+    fetchResourceCallback,
+    terminologyServerUrl
+  ]);
 
   if (isPopulating) {
     return <div>Loading...</div>;
   }
 
+  if (initError !== null) {
+    return (
+      <div data-testid="toolkit-init-error" role="alert">
+        {initError}
+      </div>
+    );
+  }
+
   return (
     <RendererThemeProvider>
       <QueryClientProvider client={queryClient}>
         <BaseRenderer />
-        <SaveControl onExtractResult={props.onExtractResult} />
+        <SaveControl
+          onExtractResult={props.onExtractResult}
+          comparisonSourceResponse={comparisonSourceResponse}
+        />
       </QueryClientProvider>
     </RendererThemeProvider>
   );
@@ -147,9 +229,11 @@ function buildFetchResourceCallback(requestDefinitions: RequestDefinition[]) {
 }
 
 function SaveControl({
-  onExtractResult
+  onExtractResult,
+  comparisonSourceResponse
 }: {
   onExtractResult?: (extractResult: InAppExtractOutput) => void;
+  comparisonSourceResponse?: QuestionnaireResponse;
 }) {
   const qr = useQuestionnaireResponseStore.use.updatableResponse();
   const q = useQuestionnaireStore.use.sourceQuestionnaire();
@@ -159,7 +243,12 @@ function SaveControl({
       data-testid="save-button"
       type="button"
       onClick={async () => {
-        const result = await inAppExtract(qr, q, null);
+        // The comparison response is cloned so extraction never mutates the caller's fixture.
+        const result = await inAppExtract(
+          qr,
+          q,
+          comparisonSourceResponse !== undefined ? structuredClone(comparisonSourceResponse) : null
+        );
         onExtractResult?.(result);
       }}>
       Save
diff --git a/packages/questionnaire-test-toolkit/src/index.ts b/packages/questionnaire-test-toolkit/src/index.ts
index 488ade0fe..ce4dd3f29 100644
--- a/packages/questionnaire-test-toolkit/src/index.ts
+++ b/packages/questionnaire-test-toolkit/src/index.ts
@@ -73,6 +73,10 @@ export {
 
 export { findByLinkIdOrLabel, findAllByLinkIdOrLabel, selectTab } from './testUtils';
 
+// -- Repeating groups ----------------------------------------------------------------------
+
+export { addRepeatGroup, removeRepeatGroup } from './testUtils';
+
 // -- Extraction and misc --------------------------------------------------------------------
 
 export { invokeExtract, getBirthDateForAge } from './testUtils';
diff --git a/packages/questionnaire-test-toolkit/src/test/birthDate.test.tsx b/packages/questionnaire-test-toolkit/src/test/birthDate.test.tsx
new file mode 100644
index 000000000..c295c8b22
--- /dev/null
+++ b/packages/questionnaire-test-toolkit/src/test/birthDate.test.tsx
@@ -0,0 +1,57 @@
+import { afterEach, describe, expect, test, vi } from 'vitest';
+import { getBirthDateForAge } from '@aehrc/questionnaire-test-toolkit';
+
+const originalTz = process.env.TZ;
+
+afterEach(() => {
+  vi.useRealTimers();
+  process.env.TZ = originalTz;
+});
+
+function freezeAt(localIsoDate: string, tz: string) {
+  process.env.TZ = tz;
+  vi.useFakeTimers();
+  vi.setSystemTime(new Date(`${localIsoDate}T12:00:00`));
+}
+
+describe('getBirthDateForAge', () => {
+  test('returns the intended local calendar date in Australia/Sydney', () => {
+    freezeAt('2026-03-15', 'Australia/Sydney');
+    expect(getBirthDateForAge(1)).toBe('2025-03-15');
+  });
+
+  test('returns the intended local calendar date in UTC', () => {
+    freezeAt('2026-03-15', 'UTC');
+    expect(getBirthDateForAge(1)).toBe('2025-03-15');
+  });
+
+  test('does not shift the year near the New Year boundary in a timezone ahead of UTC', () => {
+    // 1 January in Australia/Sydney is 31 December in UTC. Converting through toISOString() would
+    // have returned the previous year's date.
+    freezeAt('2026-01-01', 'Australia/Sydney');
+    expect(getBirthDateForAge(0)).toBe('2026-01-01');
+  });
+
+  test('does not shift the date just after midnight in a timezone ahead of UTC', () => {
+    freezeAt('2026-01-02', 'Australia/Sydney');
+    expect(getBirthDateForAge(0)).toBe('2026-01-02');
+  });
+
+  test('rolls 29 February over to 1 March in a non-leap target year', () => {
+    // Today is 29 February 2028 (leap year); the target year 2027 is not a leap year, so the Date
+    // constructor rolls the birthday over to 1 March. Documented behavior; clinical leap-day
+    // policies should use explicit DOB fixtures.
+    freezeAt('2028-02-29', 'Australia/Sydney');
+    expect(getBirthDateForAge(1)).toBe('2027-03-01');
+  });
+
+  test('keeps 29 February when the target year is a leap year', () => {
+    freezeAt('2028-02-29', 'UTC');
+    expect(getBirthDateForAge(4)).toBe('2024-02-29');
+  });
+
+  test('formats single-digit months and days with leading zeros', () => {
+    freezeAt('2026-01-05', 'UTC');
+    expect(getBirthDateForAge(0)).toBe('2026-01-05');
+  });
+});
diff --git a/packages/questionnaire-test-toolkit/src/test/extractSync.test.tsx b/packages/questionnaire-test-toolkit/src/test/extractSync.test.tsx
new file mode 100644
index 000000000..946d67926
--- /dev/null
+++ b/packages/questionnaire-test-toolkit/src/test/extractSync.test.tsx
@@ -0,0 +1,95 @@
+import { describe, expect, test, vi } from 'vitest';
+import { render, waitFor } from '@testing-library/react';
+import { inAppExtract } from '@aehrc/sdc-template-extract';
+import type { InAppExtractOutput } from '@aehrc/sdc-template-extract';
+import type { Observation, Questionnaire, QuestionnaireResponse } from 'fhir/r4';
+import {
+  BehavioralTestWrapper,
+  getInputText,
+  inputText,
+  invokeExtract
+} from '@aehrc/questionnaire-test-toolkit';
+import { repeatQuestionnaire, savedResponseA } from './fixtures/repeatQuestionnaire';
+
+const { originalInAppExtract } = vi.hoisted(() => {
+  const originalInAppExtract: {
+    current:
+      | ((
+          questionnaireResponse: QuestionnaireResponse,
+          questionnaireOrCallback: Questionnaire,
+          comparisonSourceResponse: QuestionnaireResponse | null
+        ) => Promise<InAppExtractOutput>)
+      | undefined;
+  } = { current: undefined };
+  return { originalInAppExtract };
+});
+
+vi.mock('@aehrc/sdc-template-extract', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@aehrc/sdc-template-extract')>();
+  originalInAppExtract.current = actual.inAppExtract;
+  return {
+    ...actual,
+    inAppExtract: vi.fn(actual.inAppExtract)
+  };
+});
+
+describe('invokeExtract synchronisation', () => {
+  test('waits for the callback of the Save click it dispatched', async () => {
+    const onExtractResult = vi.fn();
+    const { container } = render(
+      <BehavioralTestWrapper
+        questionnaire={repeatQuestionnaire}
+        questionnaireResponse={savedResponseA}
+        onExtractResult={onExtractResult}
+      />
+    );
+
+    await waitFor(async () => {
+      expect(await getInputText(container, 'Notes')).toBe('Baseline notes');
+    });
+
+    await inputText(container, 'Notes', 'First edit');
+    const firstBundle = await invokeExtract(container, onExtractResult);
+    const firstNotes = firstBundle.entry
+      ?.map((entry) => entry.resource)
+      .find((resource) => (resource as Observation | undefined)?.code?.text === 'Notes');
+    expect(firstNotes).toMatchObject({ valueString: 'First edit' });
+
+    await inputText(container, 'Notes', 'Second edit');
+
+    // Delay the second extraction so that the previous onExtractResult call is still the most
+    // recent one while the new extraction is pending.
+    let releaseDelay: (() => void) | undefined;
+    const inAppExtractMock = vi.mocked(inAppExtract);
+    inAppExtractMock.mockImplementationOnce(async (qr, q, comparison) => {
+      await new Promise<void>((resolve) => {
+        releaseDelay = resolve;
+      });
+      return originalInAppExtract.current!(qr, q as Questionnaire, comparison);
+    });
+
+    let secondExtractResolved = false;
+    const secondExtractPromise = invokeExtract(container, onExtractResult);
+    void secondExtractPromise.then(() => {
+      secondExtractResolved = true;
+    });
+
+    // The delayed second extraction is now in flight. The helper must not accept the previous
+    // callback as this click's result.
+    await waitFor(() => {
+      expect(releaseDelay).toBeDefined();
+    });
+    await new Promise((resolve) => setTimeout(resolve, 150));
+    expect(secondExtractResolved).toBe(false);
+
+    releaseDelay!();
+
+    const secondBundle = await secondExtractPromise;
+    expect(secondExtractResolved).toBe(true);
+    const secondNotes = secondBundle.entry
+      ?.map((entry) => entry.resource)
+      .find((resource) => (resource as Observation | undefined)?.code?.text === 'Notes');
+    expect(secondNotes).toMatchObject({ valueString: 'Second edit' });
+    expect(onExtractResult).toHaveBeenCalledTimes(2);
+  });
+});
diff --git a/packages/questionnaire-test-toolkit/src/test/fetchResourceCallback.test.tsx b/packages/questionnaire-test-toolkit/src/test/fetchResourceCallback.test.tsx
new file mode 100644
index 000000000..63ff13891
--- /dev/null
+++ b/packages/questionnaire-test-toolkit/src/test/fetchResourceCallback.test.tsx
@@ -0,0 +1,182 @@
+import { describe, expect, test, vi } from 'vitest';
+import { render, waitFor } from '@testing-library/react';
+import type { FetchResourceCallback } from '@aehrc/sdc-populate';
+import type { Patient, Practitioner } from 'fhir/r4';
+import { BehavioralTestWrapper, getInputText } from '@aehrc/questionnaire-test-toolkit';
+import type { BehavioralTestWrapperProps, RequestDefinition } from '@aehrc/questionnaire-test-toolkit';
+import { contextQuestionnaire } from './fixtures/contextQuestionnaire';
+
+const patient: Patient = { resourceType: 'Patient', id: 'patient-1' };
+const jane: Practitioner = {
+  resourceType: 'Practitioner',
+  id: 'practitioner-1',
+  name: [{ family: 'Smith' }]
+};
+const fhirContext: BehavioralTestWrapperProps['fhirContext'] = [
+  { type: 'PractitionerRole', reference: 'PractitionerRole/role-1' }
+];
+const roleOne = {
+  resourceType: 'PractitionerRole',
+  id: 'role-1',
+  location: [{ reference: 'Location/clinic-1' }]
+};
+
+describe('fetchResourceCallback seam', () => {
+  test('observes the population queries and resolves launch context from the callback', async () => {
+    const queries: string[] = [];
+    const callback: FetchResourceCallback = async (query, requestConfig) => {
+      queries.push(query);
+      expect(requestConfig.sourceServerUrl).toBe('http://mock.example');
+      if (query === 'PractitionerRole/role-1') {
+        return roleOne;
+      }
+      throw new Error(`Unexpected population query: ${query}`);
+    };
+
+    const { container } = render(
+      <BehavioralTestWrapper
+        questionnaire={contextQuestionnaire}
+        patient={patient}
+        user={jane}
+        fhirContext={fhirContext}
+        fetchResourceCallback={callback}
+      />
+    );
+
+    await waitFor(async () => {
+      expect(await getInputText(container, 'User calc')).toBe('Smith');
+    });
+    await waitFor(async () => {
+      expect(await getInputText(container, 'Role calc')).toBe('Location/clinic-1');
+    });
+
+    expect(queries).toContain('PractitionerRole/role-1');
+  });
+
+  test('an unexpected or rejected population request fails the harness visibly', async () => {
+    const callback: FetchResourceCallback = async (query) => {
+      throw new Error(`Unexpected population query: ${query}`);
+    };
+
+    const { container } = render(
+      <BehavioralTestWrapper
+        questionnaire={contextQuestionnaire}
+        patient={patient}
+        fhirContext={fhirContext}
+        fetchResourceCallback={callback}
+      />
+    );
+
+    const errorElement = await waitFor(() => {
+      const element = container.querySelector('[data-testid="toolkit-init-error"]');
+      expect(element).not.toBeNull();
+      return element as HTMLElement;
+    });
+
+    expect(errorElement.textContent).toContain('Unexpected population query');
+    expect(container.querySelector('button[data-testid="save-button"]')).toBeNull();
+  });
+
+  test('changing the callback rebuilds the population context', async () => {
+    const roleTwo = {
+      resourceType: 'PractitionerRole',
+      id: 'role-2',
+      location: [{ reference: 'Location/clinic-2' }]
+    };
+
+    const callbackOne: FetchResourceCallback = async (query) => {
+      if (query === 'PractitionerRole/role-1') {
+        return roleOne;
+      }
+      throw new Error(`Unexpected population query: ${query}`);
+    };
+    const callbackTwo: FetchResourceCallback = async (query) => {
+      if (query === 'PractitionerRole/role-1') {
+        return roleTwo;
+      }
+      throw new Error(`Unexpected population query: ${query}`);
+    };
+
+    const { container, rerender } = render(
+      <BehavioralTestWrapper
+        questionnaire={contextQuestionnaire}
+        patient={patient}
+        user={jane}
+        fhirContext={fhirContext}
+        fetchResourceCallback={callbackOne}
+      />
+    );
+
+    await waitFor(async () => {
+      expect(await getInputText(container, 'Role calc')).toBe('Location/clinic-1');
+    });
+
+    rerender(
+      <BehavioralTestWrapper
+        questionnaire={contextQuestionnaire}
+        patient={patient}
+        user={jane}
+        fhirContext={fhirContext}
+        fetchResourceCallback={callbackTwo}
+      />
+    );
+
+    await waitFor(async () => {
+      expect(await getInputText(container, 'Role calc')).toBe('Location/clinic-2');
+    });
+  });
+
+  test('rejects supplying both adapters synchronously', () => {
+    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {});
+    try {
+      expect(() =>
+        render(
+          <BehavioralTestWrapper
+            questionnaire={contextQuestionnaire}
+            patient={patient}
+            requestDefinitions={[]}
+            fetchResourceCallback={async () => ({})}
+          />
+        )
+      ).toThrow('Provide either requestDefinitions or fetchResourceCallback, not both');
+    } finally {
+      consoleError.mockRestore();
+    }
+  });
+
+  test('rejects a callback without a patient synchronously', () => {
+    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {});
+    try {
+      expect(() =>
+        render(
+          <BehavioralTestWrapper
+            questionnaire={contextQuestionnaire}
+            fetchResourceCallback={async () => ({})}
+          />
+        )
+      ).toThrow('Patient must be provided when a fetchResourceCallback is provided');
+    } finally {
+      consoleError.mockRestore();
+    }
+  });
+
+  test('request definitions remain the default adapter for existing callers', async () => {
+    const requestDefinitions: RequestDefinition[] = [
+      { urlPrefix: 'PractitionerRole/role-1', responseBody: roleOne }
+    ];
+
+    const { container } = render(
+      <BehavioralTestWrapper
+        questionnaire={contextQuestionnaire}
+        patient={patient}
+        user={jane}
+        fhirContext={fhirContext}
+        requestDefinitions={requestDefinitions}
+      />
+    );
+
+    await waitFor(async () => {
+      expect(await getInputText(container, 'Role calc')).toBe('Location/clinic-1');
+    });
+  });
+});
diff --git a/packages/questionnaire-test-toolkit/src/test/fixtures/contextQuestionnaire.ts b/packages/questionnaire-test-toolkit/src/test/fixtures/contextQuestionnaire.ts
new file mode 100644
index 000000000..e9c81e457
--- /dev/null
+++ b/packages/questionnaire-test-toolkit/src/test/fixtures/contextQuestionnaire.ts
@@ -0,0 +1,52 @@
+import type { Questionnaire } from 'fhir/r4';
+
+const launchContext = (name: string, type: string) => ({
+  url: 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-launchContext',
+  extension: [
+    { url: 'name', valueCoding: { code: name } },
+    { url: 'type', valueCode: type }
+  ]
+});
+
+const calculatedExpression = (expression: string) => ({
+  url: 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-calculatedExpression',
+  valueExpression: { language: 'text/fhirpath', expression }
+});
+
+const initialExpression = (expression: string) => ({
+  url: 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-initialExpression',
+  valueExpression: { language: 'text/fhirpath', expression }
+});
+
+// Population fills initialExpression items; the renderer evaluates calculatedExpression items from
+// the launch context on every build. Used to check that saved answers win over generated ones
+// while context-dependent calculations still resolve.
+export const contextQuestionnaire: Questionnaire = {
+  resourceType: 'Questionnaire',
+  id: 'toolkit-context',
+  status: 'draft',
+  extension: [
+    launchContext('user', 'Practitioner'),
+    launchContext('practitionerrole', 'PractitionerRole')
+  ],
+  item: [
+    {
+      linkId: 'user-initial',
+      text: 'User initial',
+      type: 'string',
+      extension: [initialExpression('%user.name.family')]
+    },
+    {
+      linkId: 'user-calc',
+      text: 'User calc',
+      type: 'string',
+      extension: [calculatedExpression('%user.name.family')]
+    },
+    {
+      linkId: 'role-calc',
+      text: 'Role calc',
+      type: 'string',
+      extension: [calculatedExpression('%practitionerrole.location.reference')]
+    }
+  ]
+};
diff --git a/packages/questionnaire-test-toolkit/src/test/fixtures/interactionQuestionnaire.ts b/packages/questionnaire-test-toolkit/src/test/fixtures/interactionQuestionnaire.ts
new file mode 100644
index 000000000..25f4638cf
--- /dev/null
+++ b/packages/questionnaire-test-toolkit/src/test/fixtures/interactionQuestionnaire.ts
@@ -0,0 +1,72 @@
+import type { Questionnaire } from 'fhir/r4';
+
+const answerOption = (code: string, display: string) => ({
+  valueCoding: { system: 'http://example.org/options', code, display }
+});
+
+const itemControl = (code: string) => ({
+  url: 'http://hl7.org/fhir/StructureDefinition/questionnaire-itemControl',
+  valueCodeableConcept: {
+    coding: [{ system: 'http://hl7.org/fhir/questionnaire-item-control', code }]
+  }
+});
+
+// Small generic questionnaire exercising writable, read-only and choice controls through the real
+// renderer. Used for interaction-guard checks.
+export const interactionQuestionnaire: Questionnaire = {
+  resourceType: 'Questionnaire',
+  id: 'toolkit-interaction',
+  status: 'draft',
+  item: [
+    { linkId: 'plain-text', text: 'Plain text', type: 'string' },
+    { linkId: 'locked-text', text: 'Locked text', type: 'string', readOnly: true },
+    {
+      linkId: 'locked-group',
+      text: 'Locked group',
+      type: 'group',
+      readOnly: true,
+      item: [{ linkId: 'nested-text', text: 'Nested text', type: 'string' }]
+    },
+    { linkId: 'plain-check', text: 'Plain check', type: 'boolean' },
+    { linkId: 'locked-check', text: 'Locked check', type: 'boolean', readOnly: true },
+    {
+      linkId: 'plain-pet',
+      text: 'Plain pet',
+      type: 'choice',
+      extension: [itemControl('radio-button')],
+      answerOption: [answerOption('cat', 'Cat'), answerOption('dog', 'Dog')]
+    },
+    {
+      linkId: 'locked-pet',
+      text: 'Locked pet',
+      type: 'choice',
+      readOnly: true,
+      extension: [itemControl('radio-button')],
+      answerOption: [answerOption('cat', 'Cat'), answerOption('dog', 'Dog')]
+    },
+    {
+      linkId: 'plain-toppings',
+      text: 'Plain toppings',
+      type: 'choice',
+      extension: [itemControl('check-box')],
+      answerOption: [answerOption('cheese', 'Cheese'), answerOption('olives', 'Olives')]
+    },
+    {
+      linkId: 'plain-colour',
+      text: 'Plain colour',
+      type: 'choice',
+      answerOption: [
+        answerOption('red', 'Red'),
+        answerOption('green', 'Green'),
+        answerOption('blue', 'Blue')
+      ]
+    },
+    {
+      linkId: 'locked-colour',
+      text: 'Locked colour',
+      type: 'choice',
+      readOnly: true,
+      answerOption: [answerOption('red', 'Red'), answerOption('green', 'Green')]
+    }
+  ]
+};
diff --git a/packages/questionnaire-test-toolkit/src/test/fixtures/repeatQuestionnaire.ts b/packages/questionnaire-test-toolkit/src/test/fixtures/repeatQuestionnaire.ts
new file mode 100644
index 000000000..0e5e3c565
--- /dev/null
+++ b/packages/questionnaire-test-toolkit/src/test/fixtures/repeatQuestionnaire.ts
@@ -0,0 +1,112 @@
+import type { Questionnaire, QuestionnaireResponse } from 'fhir/r4';
+
+const templateExtractValue = (valueString: string) => ({
+  url: 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-templateExtractValue',
+  valueString
+});
+
+const templateExtract = (reference: string) => ({
+  url: 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-templateExtract',
+  extension: [{ url: 'template', valueReference: { reference } }]
+});
+
+// A minimal questionnaire with a repeating group and a plain string, each extracted into its own
+// contained Observation template. Used for saved-response, repeat-survival and modified-only
+// extraction checks.
+export const repeatQuestionnaire: Questionnaire = {
+  resourceType: 'Questionnaire',
+  id: 'toolkit-repeat',
+  status: 'draft',
+  item: [
+    {
+      linkId: 'root',
+      text: 'Root',
+      type: 'group',
+      extension: [templateExtract('#notes-observation-template')],
+      item: [
+        {
+          linkId: 'medications',
+          text: 'Medications',
+          type: 'group',
+          repeats: true,
+          extension: [templateExtract('#med-observation-template')],
+          item: [
+            { linkId: 'med-name', text: 'Medication name', type: 'string' },
+            { linkId: 'med-dose', text: 'Dose', type: 'string' }
+          ]
+        },
+        { linkId: 'notes', text: 'Notes', type: 'string' }
+      ]
+    }
+  ],
+  contained: [
+    {
+      resourceType: 'Observation',
+      id: 'med-observation-template',
+      status: 'final',
+      code: { text: 'Medication' },
+      valueString: '',
+      _valueString: {
+        extension: [templateExtractValue("item.where(linkId='med-name').answer.value")]
+      }
+    },
+    {
+      resourceType: 'Observation',
+      id: 'notes-observation-template',
+      status: 'final',
+      code: { text: 'Notes' },
+      valueString: '',
+      _valueString: {
+        extension: [templateExtractValue("item.where(linkId='notes').answer.value")]
+      }
+    }
+  ]
+};
+
+function buildSavedResponse(
+  notes: string,
+  medications: Array<[string, string]>
+): QuestionnaireResponse {
+  return {
+    resourceType: 'QuestionnaireResponse',
+    status: 'in-progress',
+    item: [
+      {
+        linkId: 'root',
+        text: 'Root',
+        item: [
+          ...medications.map(([name, dose]) => ({
+            linkId: 'medications',
+            text: 'Medications',
+            item: [
+              {
+                linkId: 'med-name',
+                text: 'Medication name',
+                answer: [{ valueString: name }]
+              },
+              {
+                linkId: 'med-dose',
+                text: 'Dose',
+                answer: [{ valueString: dose }]
+              }
+            ]
+          })),
+          {
+            linkId: 'notes',
+            text: 'Notes',
+            answer: [{ valueString: notes }]
+          }
+        ]
+      }
+    ]
+  };
+}
+
+export const savedResponseA: QuestionnaireResponse = buildSavedResponse('Baseline notes', [
+  ['Paracetamol', '500mg'],
+  ['Ibuprofen', '200mg']
+]);
+
+export const savedResponseB: QuestionnaireResponse = buildSavedResponse('Second notes', [
+  ['Aspirin', '100mg']
+]);
diff --git a/packages/questionnaire-test-toolkit/src/test/initFailure.test.tsx b/packages/questionnaire-test-toolkit/src/test/initFailure.test.tsx
new file mode 100644
index 000000000..216167d14
--- /dev/null
+++ b/packages/questionnaire-test-toolkit/src/test/initFailure.test.tsx
@@ -0,0 +1,90 @@
+import { describe, expect, test, vi } from 'vitest';
+import { render, waitFor } from '@testing-library/react';
+import { populateQuestionnaire } from '@aehrc/sdc-populate';
+import { BehavioralTestWrapper } from '@aehrc/questionnaire-test-toolkit';
+import type { Patient } from 'fhir/r4';
+import { questionnaire } from './fixtures/questionnaire';
+
+vi.mock('@aehrc/sdc-populate', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@aehrc/sdc-populate')>();
+  return {
+    ...actual,
+    populateQuestionnaire: vi.fn(actual.populateQuestionnaire)
+  };
+});
+
+const patient: Patient = { resourceType: 'Patient', id: 'patient-1' };
+
+describe('visible initialisation failures', () => {
+  test('surfaces a failed population and exposes no Save button', async () => {
+    vi.mocked(populateQuestionnaire).mockReturnValueOnce(
+      Promise.resolve({ populateSuccess: false, populateResult: null })
+    );
+
+    const { container } = render(<BehavioralTestWrapper questionnaire={questionnaire} patient={patient} />);
+
+    const errorElement = await waitFor(() => {
+      const element = container.querySelector('[data-testid="toolkit-init-error"]');
+      expect(element).not.toBeNull();
+      return element as HTMLElement;
+    });
+
+    expect(errorElement.textContent).toContain('Population failed');
+    expect(container.querySelector('button[data-testid="save-button"]')).toBeNull();
+  });
+
+  test('surfaces a rejected population when a saved response was supplied', async () => {
+    vi.mocked(populateQuestionnaire).mockRejectedValueOnce(new Error('boom'));
+
+    const { container } = render(
+      <BehavioralTestWrapper
+        questionnaire={questionnaire}
+        patient={patient}
+        questionnaireResponse={{
+          resourceType: 'QuestionnaireResponse',
+          status: 'in-progress',
+          item: [{ linkId: 'tabs' }]
+        }}
+      />
+    );
+
+    const errorElement = await waitFor(() => {
+      const element = container.querySelector('[data-testid="toolkit-init-error"]');
+      expect(element).not.toBeNull();
+      return element as HTMLElement;
+    });
+
+    expect(errorElement.textContent).toContain('boom');
+    expect(container.querySelector('button[data-testid="save-button"]')).toBeNull();
+  });
+
+  test('keeps working after a failed initialisation is replaced by valid inputs', async () => {
+    vi.mocked(populateQuestionnaire)
+      .mockReturnValueOnce(Promise.resolve({ populateSuccess: false, populateResult: null }))
+      .mockReturnValueOnce(
+        Promise.resolve({
+          populateSuccess: true,
+          populateResult: {
+            populatedResponse: {
+              resourceType: 'QuestionnaireResponse',
+              status: 'in-progress'
+            }
+          }
+        })
+      );
+
+    const { container, rerender } = render(
+      <BehavioralTestWrapper questionnaire={questionnaire} patient={patient} />
+    );
+
+    await waitFor(() => {
+      expect(container.querySelector('[data-testid="toolkit-init-error"]')).not.toBeNull();
+    });
+
+    rerender(<BehavioralTestWrapper questionnaire={questionnaire} />);
+
+    await waitFor(() => {
+      expect(container.querySelector('button[data-testid="save-button"]')).not.toBeNull();
+    });
+  });
+});
diff --git a/packages/questionnaire-test-toolkit/src/test/interactionGuards.test.tsx b/packages/questionnaire-test-toolkit/src/test/interactionGuards.test.tsx
new file mode 100644
index 000000000..aacf6f87d
--- /dev/null
+++ b/packages/questionnaire-test-toolkit/src/test/interactionGuards.test.tsx
@@ -0,0 +1,127 @@
+import { describe, expect, test } from 'vitest';
+import { render, waitFor } from '@testing-library/react';
+import { questionnaireResponseStore } from '@aehrc/smart-forms-renderer';
+import {
+  BehavioralTestWrapper,
+  checkCheckBox,
+  checkCheckboxOption,
+  checkRadioOption,
+  chooseSelectOption,
+  getInputText,
+  inputText
+} from '@aehrc/questionnaire-test-toolkit';
+import { interactionQuestionnaire } from './fixtures/interactionQuestionnaire';
+
+function renderForm() {
+  return render(<BehavioralTestWrapper questionnaire={interactionQuestionnaire} />);
+}
+
+describe('interaction guards', () => {
+  test('writable controls accept input', async () => {
+    const { container } = renderForm();
+
+    await inputText(container, 'Plain text', 'hello');
+    expect(await getInputText(container, 'Plain text')).toBe('hello');
+
+    await checkCheckBox(container, 'Plain check');
+    expect(container.querySelector<HTMLInputElement>('[data-linkid="plain-check"] input')?.checked).toBe(true);
+
+    await checkRadioOption(container, 'Plain pet', 'Cat');
+    expect(
+      container.querySelector<HTMLInputElement>('[data-linkid="plain-pet"] input:checked')
+    ).not.toBeNull();
+
+    await checkCheckboxOption(container, 'Plain toppings', 'Cheese');
+    expect(
+      container.querySelector<HTMLInputElement>(
+        '[data-linkid="plain-toppings"] span[data-test="checkbox-single-Cheese"] input'
+      )?.checked
+    ).toBe(true);
+  });
+
+  test('rejects writes to a read-only text field with the question identifier', async () => {
+    const { container } = renderForm();
+    await waitFor(() => {
+      expect(container.querySelector('[data-linkid="locked-text"]')).not.toBeNull();
+    });
+
+    await expect(inputText(container, 'Locked text', 'nope')).rejects.toThrow(
+      'Question "Locked text" cannot be interacted with'
+    );
+  });
+
+  test('rejects writes to a field under a read-only ancestor', async () => {
+    const { container } = renderForm();
+    await waitFor(() => {
+      expect(container.querySelector('[data-linkid="nested-text"]')).not.toBeNull();
+    });
+
+    await expect(inputText(container, 'Nested text', 'nope')).rejects.toThrow(
+      'Question "Nested text" cannot be interacted with'
+    );
+  });
+
+  test('rejects checking a read-only checkbox', async () => {
+    const { container } = renderForm();
+    await waitFor(() => {
+      expect(container.querySelector('[data-linkid="locked-check"]')).not.toBeNull();
+    });
+
+    await expect(checkCheckBox(container, 'Locked check')).rejects.toThrow(
+      'Question "Locked check" cannot be interacted with'
+    );
+  });
+
+  test('rejects selecting a read-only radio option', async () => {
+    const { container } = renderForm();
+    await waitFor(() => {
+      expect(container.querySelector('[data-linkid="locked-pet"]')).not.toBeNull();
+    });
+
+    await expect(checkRadioOption(container, 'Locked pet', 'Cat')).rejects.toThrow(
+      'Question "Locked pet" cannot be interacted with'
+    );
+  });
+
+  test('rejects choosing a read-only select option', async () => {
+    const { container } = renderForm();
+    await waitFor(() => {
+      expect(container.querySelector('[data-linkid="locked-colour"]')).not.toBeNull();
+    });
+
+    await expect(chooseSelectOption(container, 'Locked colour', 'Red')).rejects.toThrow(
+      'Question "Locked colour" cannot be interacted with'
+    );
+  });
+
+  test('rejected edits leave the response unchanged', async () => {
+    const { container } = renderForm();
+    await waitFor(() => {
+      expect(container.querySelector('[data-linkid="locked-text"]')).not.toBeNull();
+    });
+
+    await expect(inputText(container, 'Locked text', 'nope')).rejects.toThrow();
+    await expect(checkCheckBox(container, 'Locked check')).rejects.toThrow();
+
+    const qr = questionnaireResponseStore.getState().updatableResponse;
+    const hasLockedAnswers = qr?.item?.some(
+      (item) => (item.linkId === 'locked-text' || item.linkId === 'locked-check') && item.answer
+    );
+    expect(hasLockedAnswers).toBe(false);
+  });
+
+  test('selecting a writable option records the answer', async () => {
+    const { container } = renderForm();
+    await waitFor(() => {
+      expect(container.querySelector('[data-linkid="plain-colour"]')).not.toBeNull();
+    });
+
+    await chooseSelectOption(container, 'Plain colour', 'Green');
+
+    await waitFor(() => {
+      const qr = questionnaireResponseStore.getState().updatableResponse;
+      const colour = qr?.item?.find((item) => item.linkId === 'plain-colour');
+      expect(colour?.answer?.[0].valueCoding?.display).toBe('Green');
+    });
+  });
+});
diff --git a/packages/questionnaire-test-toolkit/src/test/repeatHelpers.test.tsx b/packages/questionnaire-test-toolkit/src/test/repeatHelpers.test.tsx
new file mode 100644
index 000000000..dd9cd5134
--- /dev/null
+++ b/packages/questionnaire-test-toolkit/src/test/repeatHelpers.test.tsx
@@ -0,0 +1,108 @@
+import { describe, expect, test } from 'vitest';
+import { render, waitFor } from '@testing-library/react';
+import {
+  BehavioralTestWrapper,
+  addRepeatGroup,
+  getInputText,
+  inputText,
+  removeRepeatGroup
+} from '@aehrc/questionnaire-test-toolkit';
+import { repeatQuestionnaire, savedResponseA } from './fixtures/repeatQuestionnaire';
+
+function fieldValues(container: HTMLElement, linkId: string): string[] {
+  return Array.from(
+    container.querySelectorAll<HTMLInputElement | HTMLTextAreaElement>(
+      `[data-linkid="${linkId}"] input, [data-linkid="${linkId}"] textarea`
+    )
+  )
+    .filter((field) => !field.hasAttribute('aria-hidden'))
+    .map((field) => field.value);
+}
+
+describe('repeat group helpers', () => {
+  test('adds an instance and fills it through the returned container', async () => {
+    const { container } = render(
+      <BehavioralTestWrapper questionnaire={repeatQuestionnaire} questionnaireResponse={savedResponseA} />
+    );
+
+    await waitFor(async () => {
+      expect(await getInputText(container, 'Notes')).toBe('Baseline notes');
+    });
+    expect(fieldValues(container, 'med-name')).toHaveLength(2);
+
+    const newInstance = await addRepeatGroup(container, 'Medications');
+    expect(fieldValues(container, 'med-name')).toHaveLength(3);
+
+    await inputText(newInstance, 'Medication name', 'Codeine');
+    await inputText(newInstance, 'Dose', '30mg');
+
+    expect(fieldValues(container, 'med-name')).toEqual(['Paracetamol', 'Ibuprofen', 'Codeine']);
+    expect(fieldValues(container, 'med-dose')).toEqual(['500mg', '200mg', '30mg']);
+  });
+
+  test('rejects adding when the final row is empty', async () => {
+    const { container } = render(<BehavioralTestWrapper questionnaire={repeatQuestionnaire} />);
+
+    await waitFor(() => {
+      expect(container.querySelector('[data-linkid="med-name"]')).not.toBeNull();
+    });
+
+    await expect(addRepeatGroup(container, 'Medications')).rejects.toThrow(
+      'Question "Medications" cannot be interacted with'
+    );
+  });
+
+  test('adds again after the first instance has been filled', async () => {
+    const { container } = render(<BehavioralTestWrapper questionnaire={repeatQuestionnaire} />);
+
+    await waitFor(() => {
+      expect(container.querySelector('[data-linkid="med-name"]')).not.toBeNull();
+    });
+
+    const firstInstance = container.querySelector('[data-linkid="medications"]') as HTMLElement;
+    await inputText(firstInstance, 'Medication name', 'Paracetamol');
+
+    const secondInstance = await addRepeatGroup(container, 'Medications');
+    await inputText(secondInstance, 'Medication name', 'Ibuprofen');
+
+    expect(fieldValues(container, 'med-name')).toEqual(['Paracetamol', 'Ibuprofen']);
+  });
+
+  test('removes a selected instance and keeps the other instance values associated', async () => {
+    const { container } = render(
+      <BehavioralTestWrapper questionnaire={repeatQuestionnaire} questionnaireResponse={savedResponseA} />
+    );
+
+    await waitFor(async () => {
+      expect(await getInputText(container, 'Notes')).toBe('Baseline notes');
+    });
+
+    const instances = Array.from(
+      container.querySelectorAll<HTMLElement>('[data-linkid="medications"]')
+    );
+    expect(instances).toHaveLength(2);
+
+    await removeRepeatGroup(instances[0]!);
+
+    await waitFor(() => {
+      expect(fieldValues(container, 'med-name')).toEqual(['Ibuprofen']);
+    });
+    expect(fieldValues(container, 'med-dose')).toEqual(['200mg']);
+  });
+
+  test('rejects removing the remaining empty placeholder', async () => {
+    const { container } = render(<BehavioralTestWrapper questionnaire={repeatQuestionnaire} />);
+
+    await waitFor(() => {
+      expect(container.querySelector('[data-linkid="medications"]')).not.toBeNull();
+    });
+
+    const placeholder = container.querySelector(
+      '[data-linkid="medications"]'
+    ) as HTMLElement;
+
+    await expect(removeRepeatGroup(placeholder)).rejects.toThrow(
+      'Question "medications" cannot be interacted with'
+    );
+  });
+});
diff --git a/packages/questionnaire-test-toolkit/src/test/savedResponse.test.tsx b/packages/questionnaire-test-toolkit/src/test/savedResponse.test.tsx
new file mode 100644
index 000000000..bb19b433d
--- /dev/null
+++ b/packages/questionnaire-test-toolkit/src/test/savedResponse.test.tsx
@@ -0,0 +1,265 @@
+import { describe, expect, test, vi } from 'vitest';
+import { render, waitFor } from '@testing-library/react';
+import { questionnaireResponseStore } from '@aehrc/smart-forms-renderer';
+import type { Patient, Practitioner, QuestionnaireResponse } from 'fhir/r4';
+import {
+  BehavioralTestWrapper,
+  getInputText,
+  inputText,
+  invokeExtract
+} from '@aehrc/questionnaire-test-toolkit';
+import type {
+  BehavioralTestWrapperProps,
+  RequestDefinition
+} from '@aehrc/questionnaire-test-toolkit';
+import { contextQuestionnaire } from './fixtures/contextQuestionnaire';
+import {
+  repeatQuestionnaire,
+  savedResponseA,
+  savedResponseB
+} from './fixtures/repeatQuestionnaire';
+
+const patient: Patient = { resourceType: 'Patient', id: 'patient-1' };
+const jane: Practitioner = {
+  resourceType: 'Practitioner',
+  id: 'practitioner-1',
+  name: [{ family: 'Smith' }]
+};
+const roleOne = {
+  resourceType: 'PractitionerRole',
+  id: 'role-1',
+  location: [{ reference: 'Location/clinic-1' }]
+} as const;
+const requestDefinitions: RequestDefinition[] = [
+  { urlPrefix: 'PractitionerRole/role-1', responseBody: roleOne }
+];
+const fhirContext = [
+  { type: 'PractitionerRole', reference: 'PractitionerRole/role-1' }
+] as BehavioralTestWrapperProps['fhirContext'];
+
+const savedContextResponse: QuestionnaireResponse = {
+  resourceType: 'QuestionnaireResponse',
+  status: 'in-progress',
+  item: [
+    {
+      linkId: 'user-initial',
+      answer: [{ valueString: 'Saved Name' }]
+    }
+  ]
+};
+
+// String fields render as textareas; capture both input and textarea descendants. MUI renders a
+// hidden mirror textarea (aria-hidden) for autosizing — exclude it.
+function fieldValues(container: HTMLElement, linkId: string): string[] {
+  return Array.from(
+    container.querySelectorAll<HTMLInputElement | HTMLTextAreaElement>(
+      `[data-linkid="${linkId}"] input, [data-linkid="${linkId}"] textarea`
+    )
+  )
+    .filter((field) => !field.hasAttribute('aria-hidden'))
+    .map((field) => field.value);
+}
+
+describe('BehavioralTestWrapper saved responses', () => {
+  test('loads saved answers and repeated groups without a patient', async () => {
+    const { container } = render(
+      <BehavioralTestWrapper questionnaire={repeatQuestionnaire} questionnaireResponse={savedResponseA} />
+    );
+
+    await waitFor(async () => {
+      expect(await getInputText(container, 'Notes')).toBe('Baseline notes');
+    });
+
+    const medNames = fieldValues(container, 'med-name');
+    const medDoses = fieldValues(container, 'med-dose');
+
+    expect(medNames).toHaveLength(2);
+    expect(medNames[0]).toBe('Paracetamol');
+    expect(medNames[1]).toBe('Ibuprofen');
+
+    // Doses stay associated with their own repeat instance.
+    expect(medDoses).toHaveLength(2);
+    expect(medDoses[0]).toBe('500mg');
+    expect(medDoses[1]).toBe('200mg');
+  });
+
+  test('saved answers win over population while launch context still resolves', async () => {
+    const { container } = render(
+      <BehavioralTestWrapper
+        questionnaire={contextQuestionnaire}
+        questionnaireResponse={savedContextResponse}
+        patient={patient}
+        user={jane}
+        fhirContext={fhirContext}
+        requestDefinitions={requestDefinitions}
+      />
+    );
+
+    // The saved answer takes precedence over the %user initial expression that population would
+    // have generated.
+    await waitFor(async () => {
+      expect(await getInputText(container, 'User initial')).toBe('Saved Name');
+    });
+
+    // Calculated expressions still resolve from the populated launch context.
+    await waitFor(async () => {
+      expect(await getInputText(container, 'User calc')).toBe('Smith');
+    });
+    await waitFor(async () => {
+      expect(await getInputText(container, 'Role calc')).toBe('Location/clinic-1');
+    });
+  });
+
+  test('rerendering with a different saved response rebuilds the form', async () => {
+    const { container, rerender } = render(
+      <BehavioralTestWrapper questionnaire={repeatQuestionnaire} questionnaireResponse={savedResponseA} />
+    );
+
+    await waitFor(async () => {
+      expect(await getInputText(container, 'Notes')).toBe('Baseline notes');
+    });
+
+    rerender(
+      <BehavioralTestWrapper questionnaire={repeatQuestionnaire} questionnaireResponse={savedResponseB} />
+    );
+
+    await waitFor(async () => {
+      expect(await getInputText(container, 'Notes')).toBe('Second notes');
+    });
+
+    const medNames = fieldValues(container, 'med-name');
+    expect(medNames).toHaveLength(1);
+    expect(medNames[0]).toBe('Aspirin');
+  });
+
+  test('a later mount does not leak the previous saved response', async () => {
+    const first = render(
+      <BehavioralTestWrapper questionnaire={repeatQuestionnaire} questionnaireResponse={savedResponseA} />
+    );
+    await waitFor(async () => {
+      expect(await getInputText(first.container, 'Notes')).toBe('Baseline notes');
+    });
+    first.unmount();
+
+    const second = render(<BehavioralTestWrapper questionnaire={repeatQuestionnaire} />);
+    await waitFor(async () => {
+      expect(await getInputText(second.container, 'Notes')).toBe('');
+    });
+    // A fresh form renders a single empty repeat placeholder with no answers.
+    expect(fieldValues(second.container, 'med-name')).toEqual(['']);
+  });
+
+  test('changing only the comparison response keeps unsaved edits and uses the new baseline', async () => {
+    const onExtractResult = vi.fn();
+    const { container, rerender } = render(
+      <BehavioralTestWrapper
+        questionnaire={repeatQuestionnaire}
+        questionnaireResponse={savedResponseA}
+        comparisonSourceResponse={savedResponseA}
+        onExtractResult={onExtractResult}
+      />
+    );
+
+    await waitFor(async () => {
+      expect(await getInputText(container, 'Notes')).toBe('Baseline notes');
+    });
+
+    await inputText(container, 'Notes', 'Edited notes');
+
+    // Modified-only extraction against the original saved response: only the edited answer is
+    // extracted; the unchanged repeat answers produce no resources.
+    const editedBundle = await invokeExtract(container, onExtractResult);
+    expect(editedBundle.entry).toHaveLength(1);
+    expect(editedBundle.entry?.[0].resource).toMatchObject({
+      resourceType: 'Observation',
+      code: { text: 'Notes' },
+      valueString: 'Edited notes'
+    });
+
+    // Switch the baseline without rebuilding: the unsaved edit must survive...
+    const newBaseline = structuredClone(savedResponseA);
+    const notesItem = newBaseline.item?.[0]?.item?.find((item) => item.linkId === 'notes');
+    notesItem!.answer = [{ valueString: 'Edited notes' }];
+
+    rerender(
+      <BehavioralTestWrapper
+        questionnaire={repeatQuestionnaire}
+        questionnaireResponse={savedResponseA}
+        comparisonSourceResponse={newBaseline}
+        onExtractResult={onExtractResult}
+      />
+    );
+
+    await waitFor(async () => {
+      expect(await getInputText(container, 'Notes')).toBe('Edited notes');
+    });
+
+    // ...and the next extraction must use the new baseline, finding no changes.
+    const unchangedBundle = await invokeExtract(container, onExtractResult);
+    expect(unchangedBundle.entry ?? []).toHaveLength(0);
+  });
+
+  test('full extraction is retained when the comparison response is omitted', async () => {
+    const onExtractResult = vi.fn();
+    const { container } = render(
+      <BehavioralTestWrapper
+        questionnaire={repeatQuestionnaire}
+        questionnaireResponse={savedResponseA}
+        onExtractResult={onExtractResult}
+      />
+    );
+
+    await waitFor(async () => {
+      expect(await getInputText(container, 'Notes')).toBe('Baseline notes');
+    });
+
+    // No comparison source means full extraction: both repeat instances plus the notes.
+    const bundle = await invokeExtract(container, onExtractResult);
+    expect(bundle.entry).toHaveLength(3);
+  });
+
+  test('does not mutate the saved or comparison responses supplied by the caller', async () => {
+    const savedFixture = structuredClone(savedResponseA);
+    const comparisonFixture = structuredClone(savedResponseA);
+
+    const onExtractResult = vi.fn();
+    const { container } = render(
+      <BehavioralTestWrapper
+        questionnaire={repeatQuestionnaire}
+        questionnaireResponse={savedFixture}
+        comparisonSourceResponse={comparisonFixture}
+        onExtractResult={onExtractResult}
+      />
+    );
+
+    await waitFor(async () => {
+      expect(await getInputText(container, 'Notes')).toBe('Baseline notes');
+    });
+
+    await inputText(container, 'Notes', 'Edited notes');
+    await invokeExtract(container, onExtractResult);
+
+    const notesItem = savedFixture.item?.[0]?.item?.find((item) => item.linkId === 'notes');
+    expect(notesItem?.answer?.[0].valueString).toBe('Baseline notes');
+    expect(savedFixture.questionnaire).toBeUndefined();
+    expect(comparisonFixture).toEqual(savedResponseA);
+  });
+
+  test('an edit is recorded in the renderer response after saved-response loading', async () => {
+    const { container } = render(
+      <BehavioralTestWrapper questionnaire={repeatQuestionnaire} questionnaireResponse={savedResponseA} />
+    );
+
+    await waitFor(async () => {
+      expect(await getInputText(container, 'Notes')).toBe('Baseline notes');
+    });
+
+    await inputText(container, 'Notes', 'Changed');
+
+    await waitFor(() => {
+      const qr = questionnaireResponseStore.getState().updatableResponse;
+      const notesItem = qr?.item?.[0]?.item?.find((item) => item.linkId === 'notes');
+      expect(notesItem?.answer?.[0].valueString).toBe('Changed');
+    });
+  });
+});
diff --git a/packages/questionnaire-test-toolkit/src/testUtils.ts b/packages/questionnaire-test-toolkit/src/testUtils.ts
index 5fde3d9dd..693ea1357 100644
--- a/packages/questionnaire-test-toolkit/src/testUtils.ts
+++ b/packages/questionnaire-test-toolkit/src/testUtils.ts
@@ -29,6 +29,35 @@ import type { ExtractResult, InAppExtractOutput } from '@aehrc/sdc-template-extr
 import { extractResultIsOperationOutcome } from '@aehrc/sdc-template-extract';
 import type { ExtractResultSpy } from './behavioralTestTypes';
 
+/**
+ * Fails with the question identifier and the reason when the supplied control cannot be
+ * interacted with. `fireEvent` cannot see `readOnly`, `disabled` or disabled fieldsets, so
+ * without this check helpers would silently "succeed" at interactions a real user cannot
+ * perform.
+ */
+function assertInteractive(element: Element, linkId: string): void {
+  const reason = describeNonInteractiveReason(element);
+  if (reason) {
+    throw new Error(`Question "${linkId}" cannot be interacted with: ${reason}`);
+  }
+}
+
+function describeNonInteractiveReason(element: Element): string | null {
+  const input = element as HTMLInputElement;
+
+  if (input.disabled) {
+    return 'the control is disabled';
+  }
+  if (input.readOnly) {
+    return 'the control is read-only';
+  }
+  if (element.closest('fieldset:disabled')) {
+    return 'the control is inside a disabled fieldset';
+  }
+
+  return null;
+}
+
 export async function inputText(
   canvasElement: HTMLElement,
   linkId: string,
@@ -43,6 +72,8 @@ export async function inputText(
     throw new Error(`Input or textarea was not found inside ${`[data-linkid=${linkId}] block`}`);
   }
 
+  assertInteractive(input, linkId);
+
   await act(async () => {
     fireEvent.change(input, { target: { value: text } });
   });
@@ -62,8 +93,20 @@ export async function checkCheckBox(canvasElement: HTMLElement, linkId: string)
     throw new Error(`Input or textarea was not found inside ${`[data-linkid=${linkId}] block`}`);
   }
 
-  await act(async () => {
-    fireEvent.click(input);
+  assertInteractive(input, linkId);
+
+  const checkbox = input as HTMLInputElement;
+  if (!checkbox.checked) {
+    await act(async () => {
+      fireEvent.click(checkbox);
+    });
+  }
+
+  // Confirm the click actually checked the box instead of silently doing nothing.
+  await waitFor(() => {
+    if (!checkbox.checked) {
+      throw new Error(`Checkbox "${linkId}" was not checked after interaction`);
+    }
   });
 
   // Here we await for debounced store update
@@ -97,6 +140,10 @@ export async function inputFile(
     throw new Error(`File input was not found inside [data-linkid="File name (optional)"] block`);
   }
 
+  assertInteractive(input, linkId);
+  assertInteractive(textareaUrl, linkId);
+  assertInteractive(textareaName, linkId);
+
   const fileList = Array.isArray(files) ? files : [files];
   await userEvent.upload(input, fileList);
 
@@ -146,6 +193,121 @@ export async function inputInteger(canvasElement: HTMLElement, linkId: string, t
   return await inputText(canvasElement, linkId, text);
 }
 
+/**
+ * Adds an instance to the unique repeat collection identified by `linkIdOrLabel` and waits for
+ * the rendered instance count to increase. Returns the new instance container, which can be
+ * passed directly to the scoped input helpers (e.g. `inputText(newInstance, 'name', 'value')`).
+ *
+ * The collection's own add button is used; add buttons of nested repeat groups inside an
+ * existing instance are never matched. Fails when the add button is disabled (e.g. the final
+ * row is empty).
+ */
+export async function addRepeatGroup(
+  canvasElement: HTMLElement,
+  linkIdOrLabel: string
+): Promise<HTMLElement> {
+  const instance = await findByLinkIdOrLabel(canvasElement, linkIdOrLabel);
+  const linkId = instance.getAttribute('data-linkid') ?? linkIdOrLabel;
+
+  // The add button belongs to the nearest ancestor of the instance that has one outside the
+  // instance itself; buttons inside instances belong to nested repeat groups.
+  let scope: HTMLElement | null = instance;
+  let collection: HTMLElement | null = null;
+  let addButton: HTMLButtonElement | null = null;
+  while (scope && !addButton) {
+    addButton =
+      Array.from(
+        scope.querySelectorAll<HTMLButtonElement>('[data-test="button-add-repeat-item"]')
+      ).find((button) => !instance.contains(button)) ?? null;
+    if (addButton) {
+      collection = scope;
+    }
+    scope = scope.parentElement;
+  }
+
+  if (!addButton || !collection) {
+    throw new Error(`Add button for repeat group "${linkIdOrLabel}" was not found`);
+  }
+
+  assertInteractive(addButton, linkIdOrLabel);
+
+  const repeatCollection = collection;
+  const repeatAddButton = addButton;
+  const instanceSelector = `[data-linkid="${linkId}"]`;
+  const instanceCountBefore =
+    repeatCollection.querySelectorAll<HTMLElement>(instanceSelector).length;
+
+  await act(async () => {
+    fireEvent.click(repeatAddButton);
+  });
+
+  await waitFor(
+    () => {
+      const countAfter = repeatCollection.querySelectorAll<HTMLElement>(instanceSelector).length;
+      if (countAfter <= instanceCountBefore) {
+        throw new Error(`Repeat group "${linkIdOrLabel}" did not add an instance`);
+      }
+    },
+    { timeout: 5000 }
+  );
+
+  const instancesAfter = Array.from(collection.querySelectorAll<HTMLElement>(instanceSelector));
+  const newInstance = instancesAfter[instancesAfter.length - 1];
+  if (!newInstance) {
+    throw new Error(`Repeat group "${linkIdOrLabel}" did not add an instance`);
+  }
+
+  return newInstance;
+}
+
+/**
+ * Removes the repeat instance identified by `instanceContainer` (as returned by
+ * `addRepeatGroup` or `findByLinkIdOrLabel`) using that instance's own remove button, and waits
+ * for the removal to complete. Fails when the instance has no enabled remove button (e.g. the
+ * remaining empty placeholder of a repeat group).
+ */
+export async function removeRepeatGroup(instanceContainer: HTMLElement) {
+  const linkId = instanceContainer.getAttribute('data-linkid') ?? 'repeat group';
+
+  // The instance's remove button is a sibling of the instance wrapper in the repeat collection
+  // stack. Walk up from the instance and pick the first remove button outside the instance
+  // itself; remove buttons inside the instance belong to nested repeat groups.
+  let scope: HTMLElement | null = instanceContainer;
+  let removeButton: HTMLButtonElement | null = null;
+  while (scope && !removeButton) {
+    removeButton =
+      Array.from(scope.querySelectorAll<HTMLButtonElement>('span[role="button"] button')).find(
+        (button) => !instanceContainer.contains(button)
+      ) ?? null;
+    scope = scope.parentElement;
+  }
+
+  if (!removeButton) {
+    throw new Error(`Remove button for repeat instance "${linkId}" was not found`);
+  }
+
+  assertInteractive(removeButton, linkId);
+
+  await act(async () => {
+    fireEvent.click(removeButton);
+  });
+
+  // The instance's Collapse closes; MUI marks the collapsed section hidden once the transition
+  // completes. The generous timeout covers slow removal transitions under load.
+  await waitFor(
+    () => {
+      const collapse = instanceContainer.closest('.MuiCollapse-root') as HTMLElement | null;
+      const isRemoved =
+        !instanceContainer.isConnected ||
+        (collapse !== null && collapse.style.visibility.includes('hidden'));
+      if (!isRemoved) {
+        throw new Error(`Repeat instance "${linkId}" was not removed`);
+      }
+    },
+    { timeout: 10000 }
+  );
+}
+
 export async function selectTab(canvasElement: HTMLElement, linkId: string) {
   const questionElement = await findByLinkIdOrLabel(canvasElement, linkId);
   const button =
@@ -187,6 +349,10 @@ export async function inputDateTime(
     throw new Error(`Input or textarea was not found inside ${`[data-linkid=${linkId}] block`}`);
   }
 
+  assertInteractive(inputDate, linkId);
+  assertInteractive(inputTime, linkId);
+  assertInteractive(inputAmPm, linkId);
+
   await act(async () => {
     fireEvent.change(inputDate, { target: { value: date } });
     fireEvent.change(inputTime, { target: { value: time } });
@@ -207,9 +373,19 @@ export async function checkRadioOption(canvasElement: HTMLElement, linkId: strin
     throw new Error(`Input or textarea was not found inside ${`[data-linkid=${linkId}] block`}`);
   }
 
+  assertInteractive(radio, linkId);
+
   await act(async () => {
     fireEvent.click(radio);
   });
+
+  // Confirm the click actually selected the option instead of silently doing nothing.
+  await waitFor(() => {
+    if (!(radio as HTMLInputElement).checked) {
+      throw new Error(`Radio option "${text}" for "${linkId}" was not selected after interaction`);
+    }
+  });
+
   // Here we await for debounced store update
   await act(async () => {
     await new Promise((resolve) => setTimeout(resolve, 500));
@@ -230,9 +406,24 @@ export async function checkCheckboxOption(
     throw new Error(`Input or textarea was not found inside ${`[data-linkid=${linkId}] block`}`);
   }
 
-  await act(async () => {
-    fireEvent.click(checkbox);
+  assertInteractive(checkbox, linkId);
+
+  const checkboxInput = checkbox as HTMLInputElement;
+  if (!checkboxInput.checked) {
+    await act(async () => {
+      fireEvent.click(checkboxInput);
+    });
+  }
+
+  // Confirm the click actually checked the option instead of silently doing nothing.
+  await waitFor(() => {
+    if (!checkboxInput.checked) {
+      throw new Error(
+        `Checkbox option "${text}" for "${linkId}" was not checked after interaction`
+      );
+    }
   });
+
   // Here we await for debounced store update
   await act(async () => {
     await new Promise((resolve) => setTimeout(resolve, 500));
@@ -299,6 +490,8 @@ export async function chooseSelectOption(
     throw new Error(`There is no input inside ${linkId}`);
   }
 
+  assertInteractive(input, linkId);
+
   await act(async () => {
     fireEvent.focus(input);
     fireEvent.keyDown(input, { key: 'ArrowDown', code: 'ArrowDown' });
@@ -310,6 +503,19 @@ export async function chooseSelectOption(
   await act(async () => {
     fireEvent.click(option);
   });
+
+  // Confirm the click actually recorded the selection instead of silently doing nothing. A
+  // successful selection closes the options list; a silent no-op (e.g. a click that a real user
+  // could not perform) leaves the clicked option in the DOM. The selected display text is not
+  // checked because terminology-sourced options do not always round-trip their display label.
+  await waitFor(
+    () => {
+      if (screen.queryByRole('option', { name: optionLabel })) {
+        throw new Error(`Select "${linkId}" did not record option "${optionLabel}"`);
+      }
+    },
+    { timeout: 5000 }
+  );
 }
 
 export async function chooseQuantityOption(
@@ -332,6 +538,9 @@ export async function chooseQuantityOption(
     throw new Error(`There is no input inside ${linkId}`);
   }
 
+  assertInteractive(inputComaparator, linkId);
+  assertInteractive(inputWeight, linkId);
+
   await act(async () => {
     fireEvent.focus(inputComaparator);
     fireEvent.keyDown(inputComaparator, { key: 'ArrowDown', code: 'ArrowDown' });
@@ -413,6 +622,8 @@ export async function inputOpenChoiceOtherText(
     throw new Error(`Input or textarea was not found inside ${`[data-test=${linkId}] block`}`);
   }
 
+  assertInteractive(textarea, linkId);
+
   await act(async () => {
     fireEvent.change(textarea, { target: { value: text } });
   });
@@ -453,7 +664,17 @@ export async function getVisibleTab(canvasElement: HTMLElement): Promise<HTMLEle
 export function getBirthDateForAge(ageInYears: number): string {
   const today = new Date();
   const birthDate = new Date(today.getFullYear() - ageInYears, today.getMonth(), today.getDate());
-  return birthDate.toISOString().slice(0, 10);
+
+  // Format the intended local calendar date directly. Converting through toISOString() shifts the
+  // date in timezones ahead of UTC (e.g. Australia/Sydney) and can even move the year when the
+  // birthday is near the New Year boundary. Invalid target dates roll over per the Date
+  // constructor: a 29 February birthday in a non-leap target year resolves to 1 March. Suites with
+  // a clinical leap-day policy should use explicit DOB fixtures instead.
+  const year = birthDate.getFullYear();
+  const month = String(birthDate.getMonth() + 1).padStart(2, '0');
+  const day = String(birthDate.getDate()).padStart(2, '0');
+
+  return `${year}-${month}-${day}`;
 }
 
 export async function invokeExtract(
@@ -464,20 +685,37 @@ export async function invokeExtract(
   if (!button) {
     throw new Error('Save button not found');
   }
+
+  const callsBefore = onExtractResultMock.mock.calls?.length ?? 0;
+
   await act(async () => {
     fireEvent.click(button);
   });
 
   await waitFor(
     () => {
-      if (!onExtractResultMock.mock.lastCall) {
-        throw new Error('Expected onExtractResult to be called');
+      const calls = onExtractResultMock.mock.calls;
+
+      // Spies without a call log keep the lastCall-based wait.
+      if (calls === undefined) {
+        if (!onExtractResultMock.mock.lastCall) {
+          throw new Error('Expected onExtractResult to be called');
+        }
+        return;
+      }
+
+      // Wait for the callback of the click just dispatched, rather than accepting a callback from
+      // an earlier extraction.
+      if (calls.length <= callsBefore) {
+        throw new Error('Expected onExtractResult to be called for this extraction');
       }
     },
     { timeout: 5000 }
   );
 
-  const lastCall = onExtractResultMock.mock.lastCall;
+  const calls = onExtractResultMock.mock.calls;
+  const lastCall =
+    calls !== undefined ? calls[calls.length - 1] : onExtractResultMock.mock.lastCall;
   if (!lastCall) {
     throw new Error('Expected onExtractResult to be called');
   }