rcf-lite 0.26.0 → 0.28.0

package/blueprints/application-forms-wizard/contributions/probes/probe-utils.mjs

@@ -0,0 +1,177 @@
+// Shared helpers for application-forms-wizard probes.
+//
+// The engine under probe is the sample-app fixture at
+// packages/rcf-lite/test/fixtures/probe-pack-application-forms-wizard/server.js. The
+// fixture stamps an x-fixture-request-id header on every response as
+// part of its own request pipeline (no probe-side monkey-patch), so
+// the identifier the probe records is the identifier the engine
+// itself issued. Probes call the fixture over real HTTP via node's
+// fetch, vary inputs, assert derived outputs, and record the
+// request-id, status, body excerpt, the varied input and the derived
+// output as evidence on every result row.
+// No account-bound branch: the engine is a local fixture, not a
+// third-party account, so no CI_HAS_* gate is invented. Every env
+// var this pack reads is declared on the fixture README.
+
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+export const PROJECT_ROOT = resolve(HERE, '..', '..', '..', '..');
+export const FIXTURE_DIR = resolve(PROJECT_ROOT, 'packages/rcf-lite/test/fixtures/probe-pack-application-forms-wizard');
+export const REPORT_DIR = resolve(PROJECT_ROOT, '.rcf/reports/blueprints/application-forms-wizard');
+
+export const DEFAULT_PORT = 0;
+
+export function aggregate(results) {
+  if (!Array.isArray(results) || results.length === 0) return 'fail';
+  if (results.some((r) => r.verdict === 'fail')) return 'fail';
+  if (results.some((r) => r.verdict === 'warn')) return 'warn';
+  return 'pass';
+}
+
+// Empty results never pass: a synthesised row is emitted with an actionable detail and its
+// own evidence object recording the empty condition so the row is
+// not a naked verdict scalar.
+export function normaliseResults(results) {
+  if (!Array.isArray(results) || results.length === 0) {
+    return [{
+      anchorReqId: 'unknown',
+      verdict: 'fail',
+      detail: 'no checks ran',
+      evidence: {
+        reason: 'empty-results',
+        route: 'n/a',
+        status: 0,
+        xFixtureRequestId: null,
+        bodyExcerpt: '',
+      },
+    }];
+  }
+  return results;
+}
+
+export async function writeReport({ probeName, engine, results, extra }) {
+  await mkdir(REPORT_DIR, { recursive: true });
+  const report = {
+    slug: 'application-forms-wizard',
+    probeName,
+    runAt: new Date().toISOString(),
+    engine,
+    results,
+    aggregateVerdict: aggregate(results),
+    ...(extra ?? {}),
+  };
+  const path = resolve(REPORT_DIR, `${probeName}.json`);
+  await writeFile(path, JSON.stringify(report, null, 2) + '\n', 'utf8');
+  return { report, path };
+}
+
+// Starts the fixture on an ephemeral port (or PROBE_PORT when set)
+// and returns { server, port, baseUrl, close }. The close helper
+// rejects when the underlying close callback carries an error;
+// swallowing a teardown error would hide a boundary failure.
+export async function startFixture({ startServer, port } = {}) {
+  const resolvedPort = typeof port === 'number'
+    ? port
+    : Number(process.env.PROBE_PORT ?? DEFAULT_PORT);
+  const started = await startServer({ port: resolvedPort });
+  return {
+    server: started.server,
+    port: started.port,
+    baseUrl: `http://127.0.0.1:${started.port}`,
+    close: () => new Promise((res, rej) => started.server.close((err) => {
+      if (err) rej(err);
+      else res();
+    })),
+  };
+}
+
+// Reads a distinctive slice of a response body: the first N chars
+// so the report carries a body excerpt alongside the header id.
+export function bodyExcerpt(text, max = 240) {
+  if (text == null) return '';
+  const s = typeof text === 'string' ? text : String(text);
+  return s.length > max ? s.slice(0, max) + '...' : s;
+}
+
+// Records the positive-evidence shape on a probe result. Every row
+// carries route, status, the request id the fixture stamped, and a
+// body excerpt; the caller may extend the object with the varied
+// input and the derived output for that row.
+export function evidenceFromResponse({ route, response, bodyText, extraFields }) {
+  return {
+    route,
+    status: response.status,
+    xFixtureRequestId: response.headers.get('x-fixture-request-id') || null,
+    bodyExcerpt: bodyExcerpt(bodyText),
+    ...(extraFields ?? {}),
+  };
+}
+
+export async function runShim(probeName, engine, mainFn) {
+  try {
+    const outcome = (await mainFn()) ?? { results: [] };
+    const { results, extra } = outcome;
+    const { report, path } = await writeReport({ probeName, engine, results: normaliseResults(results), extra });
+    process.stdout.write(JSON.stringify(report, null, 2) + '\n');
+    process.stdout.write(`report written to ${path}\n`);
+    if (report.aggregateVerdict !== 'pass') process.exitCode = 1;
+  } catch (err) {
+    const results = [{
+      anchorReqId: 'unknown',
+      verdict: 'fail',
+      detail: `probe threw: ${err && err.message ? err.message : String(err)}`,
+      evidence: {
+        reason: 'probe-threw',
+        route: 'n/a',
+        status: 0,
+        xFixtureRequestId: null,
+        bodyExcerpt: err && err.stack ? String(err.stack).slice(0, 240) : '',
+      },
+    }];
+    const { report, path } = await writeReport({ probeName, engine, results });
+    process.stdout.write(JSON.stringify(report, null, 2) + '\n');
+    process.stderr.write(`probe error: ${err && err.stack ? err.stack : String(err)}\n`);
+    process.stderr.write(`report written to ${path}\n`);
+    process.exitCode = 1;
+  }
+}
+
+// Browser-observable properties are AMBER on the shelf by ruling.
+// A row that names such a property is recorded as notObservableHere
+// carrying an object with the AC id and a reason; the tally script
+// reads notObservableHere.ac to accept the row.
+export function notObservableHereResult({ ac, anchorAcId, detail, reason, evidence } = {}) {
+  // A notObservableHere row anchors nothing else: no anchorAcId,
+  // no anchorReqId - only notObservableHere.ac.
+  const acId = ac || anchorAcId;
+  return {
+    verdict: 'pass',
+    notObservableHere: {
+      ac: acId,
+      reason: reason || 'not observable on server-side probe pack; needs a browser-driven runner',
+    },
+    detail: detail || 'not observable on server-side probe pack',
+    evidence: {
+      reason: reason || 'not observable here; needs a browser-driven probe runner',
+      ...(evidence || {}),
+    },
+  };
+}
+
+// A row that keeps a real observation but records that the
+// observation only covers part of an AC uses conformanceOnly +
+// limitation carrying the AC id and the property not observed.
+export function conformanceOnlyResult({ anchorAcId, anchorReqId, verdict, detail, evidence, limitation }) {
+  return {
+    ...(anchorAcId ? { anchorAcId } : {}),
+    ...(anchorReqId ? { anchorReqId } : {}),
+    verdict: verdict || 'pass',
+    conformanceOnly: true,
+    limitation: limitation || 'browser-observable property not asserted from the server-side probe',
+    detail,
+    evidence,
+  };
+}

package/blueprints/application-forms-wizard/contributions/probes/run-draft-persistence-round-trip.mjs

@@ -0,0 +1,4 @@
+import runProbe from './draft-persistence-round-trip.mjs';
+import { runShim } from './probe-utils.mjs';
+const engine = { kind: 'application-forms-wizard-fixture', server: 'packages/rcf-lite/test/fixtures/probe-pack-application-forms-wizard/server.js' };
+runShim('draft-persistence-round-trip', engine, runProbe);

package/blueprints/application-forms-wizard/contributions/probes/run-step-page-shape.mjs

@@ -0,0 +1,4 @@
+import runProbe from './step-page-shape.mjs';
+import { runShim } from './probe-utils.mjs';
+const engine = { kind: 'application-forms-wizard-fixture', server: 'packages/rcf-lite/test/fixtures/probe-pack-application-forms-wizard/server.js' };
+runShim('step-page-shape', engine, runProbe);

package/blueprints/application-forms-wizard/contributions/probes/run-task-list-surface.mjs

@@ -0,0 +1,4 @@
+import runProbe from './task-list-surface.mjs';
+import { runShim } from './probe-utils.mjs';
+const engine = { kind: 'application-forms-wizard-fixture', server: 'packages/rcf-lite/test/fixtures/probe-pack-application-forms-wizard/server.js' };
+runShim('task-list-surface', engine, runProbe);

package/blueprints/application-forms-wizard/contributions/probes/step-page-shape.mjs

@@ -0,0 +1,61 @@
+// step-page-shape probe for application-forms-wizard v1.2.6.
+//
+// AC-24102-1 describes blur/change/submit browser events on the
+// wizard step. The full AC is browser-only; the /validate rebuild
+// count is a slice the fixture can observe honestly, but only as
+// PART of AC-24102-1. This probe records ONE conformanceOnly row
+// carrying that observation with a limitation citing the AC id.
+//
+// anchorAcId: application-forms-wizard-AC-24102-1.
+
+import { startFixture, evidenceFromResponse, conformanceOnlyResult } from './probe-utils.mjs';
+
+export const anchorReqId = 'application-forms-wizard-REQ-002';
+export const accountBound = false;
+
+export default async function runProbe() {
+  const { startServer } = await import('../../../../packages/rcf-lite/test/fixtures/probe-pack-application-forms-wizard/server.js');
+  const fixture = await startFixture({ startServer, port: 0 });
+  try {
+    const results = [];
+
+    // /validate rebuild derivation.
+    const failRes = await fetch(`${fixture.baseUrl}/validate`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ step: 'contact-details', fullName: '' }),
+    });
+    const failBody = await failRes.text();
+    const failParsed = JSON.parse(failBody);
+    const okRes = await fetch(`${fixture.baseUrl}/validate`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ step: 'contact-details', fullName: 'Alex Example', previousErrorCount: failParsed.errorCount }),
+    });
+    const okBody = await okRes.text();
+    const okParsed = JSON.parse(okBody);
+    const rebuildOk = failRes.status === 200 && failParsed.errorCount === 1 && !!failParsed.errors.fullName
+      && okRes.status === 200 && okParsed.errorCount === 0 && okParsed.rebuildOf === 1;
+    results.push(conformanceOnlyResult({
+      anchorAcId: 'application-forms-wizard-AC-24102-1',
+      anchorReqId: 'application-forms-wizard-REQ-002',
+      verdict: rebuildOk ? 'pass' : 'fail',
+      detail: `On the wizard step route, focusing a field - server-observable slice: /validate {fullName:""} -> errorCount=${failParsed.errorCount}, {fullName:"Alex Example"} -> errorCount=${okParsed.errorCount} rebuildOf=${okParsed.rebuildOf}`,
+      evidence: evidenceFromResponse({
+        route: '/validate',
+        response: okRes,
+        bodyText: okBody,
+        extraFields: {
+          input: { firstSubmit: { fullName: '' }, secondSubmit: { fullName: 'Alex Example' } },
+          derived: { failErrorCount: failParsed.errorCount, okErrorCount: okParsed.errorCount, rebuildOf: okParsed.rebuildOf },
+          altBodyExcerpt: failBody.slice(0, 240),
+        },
+      }),
+      limitation: 'application-forms-wizard-AC-24102-1: the AC requires observing blur, change and submit browser events on the DOM; only the /validate rebuild count is server-observable',
+    }));
+
+    return { results };
+  } finally {
+    await fixture.close();
+  }
+}

package/blueprints/application-forms-wizard/contributions/probes/task-list-surface.mjs

@@ -0,0 +1,109 @@
+// task-list-surface probe for application-forms-wizard v1.2.6.
+//
+// AC-24101-1 (server-observable): the task-list surface exposes
+// data-surface="task-list" carrying a role="progressbar" and one
+// child element per step whose data-step-state is drawn from the
+// four-state GOV.UK enum. The probe DRIVES a varied manifest via
+// `?manifest=slug1|slug2|slug3|slug4` so the rendered rows AND
+// /__task-manifest both derive from the same varied input rather
+// than duplicating the fixture's module constant.
+//
+// Row 2 (AC-24101-1, browser-only half): the AC's contract names
+// driving the REAL BROWSER to /task-list and reading the state
+// string per step, the progressbar values and the enumerated step
+// order from the rendered DOM. A server-side probe pack cannot
+// drive a browser, so that half is recorded as notObservableHere
+// against the same AC alongside the server counting row.
+//
+// anchorAcId: application-forms-wizard-AC-24101-1.
+
+import { startFixture, evidenceFromResponse, conformanceOnlyResult, notObservableHereResult } from './probe-utils.mjs';
+
+export const anchorReqId = 'application-forms-wizard-REQ-001';
+export const accountBound = false;
+
+function extractRows(body) {
+ const rowRe = /data-step-slug="([^"]+)"[^>]*data-step-state="([^"]+)"/g;
+ const rows = [];
+ let m;
+ while ((m = rowRe.exec(body)) !== null) rows.push({ slug: m[1], state: m[2] });
+ return rows;
+}
+
+async function driveOne(fixture, variedSlugs) {
+ const q = variedSlugs.join('|');
+ const manifestRes = await fetch(`${fixture.baseUrl}/__task-manifest?manifest=${encodeURIComponent(q)}`);
+ const manifestBody = await manifestRes.text();
+ const manifest = JSON.parse(manifestBody);
+ const expectedSlugs = (manifest.steps || []).map((s) => s.slug);
+ const allowedStates = new Set(manifest.allowedStates || []);
+
+ const shellRes = await fetch(`${fixture.baseUrl}/task-list?manifest=${encodeURIComponent(q)}`);
+ const shellBody = await shellRes.text();
+ const rows = extractRows(shellBody);
+ const slugsInOrder = rows.map((r) => r.slug);
+ const progressbar = /role="progressbar"[^>]*aria-valuenow="(\d+)"[^>]*aria-valuemax="(\d+)"[^>]*aria-valuetext="([^"]+)"/.exec(shellBody);
+ const statesValid = rows.every((r) => allowedStates.has(r.state));
+ const orderMatchesManifest = slugsInOrder.length === expectedSlugs.length && slugsInOrder.every((s, i) => s === expectedSlugs[i]);
+ const manifestFollowsInput = expectedSlugs.length === variedSlugs.length && expectedSlugs.every((s, i) => s === variedSlugs[i]);
+ const progressOk = !!progressbar && Number(progressbar[2]) === variedSlugs.length;
+ const passOne = shellRes.status === 200 && rows.length === variedSlugs.length && statesValid && orderMatchesManifest && manifestFollowsInput && progressOk;
+ return { manifestBody, manifestRes, manifest, expectedSlugs, allowedStates: [...allowedStates], rows, slugsInOrder, orderMatchesManifest, manifestFollowsInput, progressOk, statesValid, passOne, shellRes, shellBody };
+}
+
+export default async function runProbe() {
+ const { startServer } = await import('../../../../packages/rcf-lite/test/fixtures/probe-pack-application-forms-wizard/server.js');
+ const fixture = await startFixture({ startServer, port: 0 });
+ try {
+ const results = [];
+
+ // Drive TWO distinct manifests so the varied input demonstrably
+ // changes the rendered output; a fixture that echoed the module
+ // constant would fail both.
+ const runA = await driveOne(fixture, ['alpha-step', 'bravo-step', 'charlie-step']);
+ const runB = await driveOne(fixture, ['delta-step', 'echo-step', 'foxtrot-step', 'golf-step']);
+ const pass = runA.passOne && runB.passOne
+ && JSON.stringify(runA.slugsInOrder) !== JSON.stringify(runB.slugsInOrder);
+ results.push(conformanceOnlyResult({
+ anchorAcId: 'application-forms-wizard-AC-24101-1',
+ verdict: pass ? 'pass' : 'fail',
+ detail: `Given the wizard task-list route, the rendered surface - drove two distinct manifests; runA rows=[${runA.slugsInOrder.join(',')}] runB rows=[${runB.slugsInOrder.join(',')}]; both align with /__task-manifest (${runA.manifestFollowsInput && runB.manifestFollowsInput}) and progressbar valuemax follows the varied input (${runA.progressOk && runB.progressOk})`,
+ evidence: evidenceFromResponse({
+ route: '/task-list?manifest=delta-step|echo-step|foxtrot-step|golf-step',
+ response: runB.shellRes,
+ bodyText: runB.shellBody,
+ extraFields: {
+ input: { runA: ['alpha-step', 'bravo-step', 'charlie-step'], runB: ['delta-step', 'echo-step', 'foxtrot-step', 'golf-step'] },
+ derived: {
+ runARows: runA.slugsInOrder,
+ runBRows: runB.slugsInOrder,
+ runAManifestFollowsInput: runA.manifestFollowsInput,
+ runBManifestFollowsInput: runB.manifestFollowsInput,
+ runAOrderMatchesManifest: runA.orderMatchesManifest,
+ runBOrderMatchesManifest: runB.orderMatchesManifest,
+ runAStatesValid: runA.statesValid,
+ runBStatesValid: runB.statesValid,
+ },
+ altBodyExcerpt: runA.manifestBody.slice(0, 240),
+ },
+ }),
+ limitation: 'application-forms-wizard-AC-24101-1: the closed enum owned by TAC-2501.interfaces.statesEnum is validated against /__task-manifest.allowedStates on this pack; a server-side probe pack cannot import the applying project\'s statesEnum. The rendered per-step [data-step-state] and progressbar values are asserted directly.',
+ }));
+
+ // Row 2: notObservableHere for AC-24101-1's browser-only half -
+ // the AC contract names driving the real browser to /task-list
+ // and reading per-step state, progressbar values and enumerated
+ // step order from the rendered DOM. A server-side probe pack
+ // cannot drive a browser, so the row represents that half on the
+ // shelf so it is not carried by the server row's limitation alone.
+ results.push(notObservableHereResult({
+ ac: 'application-forms-wizard-AC-24101-1',
+ detail: 'Given the wizard task-list route, the rendered surface - the pack drives the real browser to /task-list and reads state per step, progressbar values and step order from the rendered DOM',
+ reason: 'AC-24101-1 requires driving a real browser to /task-list and reading data-step-state, aria-valuenow/valuemax/valuetext and the enumerated step order from the rendered DOM; a server-side probe pack cannot drive a browser or observe DOM read-back',
+ evidence: { requires: 'real-browser observation of /task-list rendered DOM', ac: 'application-forms-wizard-AC-24101-1' },
+ }));
+ return { results };
+ } finally {
+ await fixture.close();
+ }
+}

package/blueprints/application-forms-wizard/contributions/requirements/application-forms-wizard-req-001.json

@@ -3,10 +3,14 @@
   "prdId": "PRD-001",
   "title": "Task-list contract: per-step completion state announced through the GOV.UK vocabulary Cannot start yet, Not started, In progress, Completed",
   "description": "The wizard renders a task-list surface listing every step in a stable order. Each step exposes one of four completion states from the closed GOV.UK vocabulary: Cannot start yet (a prerequisite step is unfinished), Not started (the step is reachable but has no answers), In progress (the step has partial answers), Completed (the step is fully valid). The task-list carries an ARIA progressbar shape naming the total step count and the number completed. The four state strings are a closed enum at v1.0.0; a fifth state is a v1.1.0 minor bump. The surface anchors on TAC-2501 (task-list shell) and is vendor-neutral: the blueprint contributes WHAT strings under WHAT condition, not the visual token set.",
+  "deliveredBy": {
+    "tacId": "TAC-2501-application-forms-wizard-task-list",
+    "field": "interfaces.renderTaskList"
+  },
   "category": "functional",
   "domain": "application",
   "priority": "must",
-  "rationale": "Per visual round 4 spec section 5.3, REQ 1.",
+  "rationale": "Per the application-core specification section 5.3, REQ 1.",
   "tags": [
     "blueprint:application-forms-wizard",
     "category:01-task-list-contract"

package/blueprints/application-forms-wizard/contributions/requirements/application-forms-wizard-req-002.json

@@ -3,16 +3,20 @@
   "prdId": "PRD-001",
   "title": "Per-step validation timing: on-blur before first submit, then on-change after the first failure, and a full pass on submit reusing the SPA forms-engine",
   "description": "Every step validates its own answers before advancing. Validation timing is on-blur before the first submit attempt on a step (a field validates when the operator leaves it), then on-change after the first submit failure on that field (so the operator sees the message clear as they correct it), and a full pass on submit that rebuilds the error set from scratch. Validation delegates to the SPA blueprint's forms-engine TAC-205 so a project already applying application-spa does not compose two overlapping engines. On refusal the engine surfaces the failed fields to the error-summary contract (REQ-003). The timing rule is a closed set at v1.0.0; different projects can elicit stricter (validate on every change from the start) via a project-level ADR but the shipped default is the three-mode rule above.",
+  "deliveredBy": {
+    "tacId": "TAC-2502-application-forms-wizard-error-summary",
+    "field": "responsibilities.validationTimingGate"
+  },
   "category": "functional",
   "domain": "application",
   "priority": "must",
-  "rationale": "Per visual round 4 spec section 5.3, REQ 2.",
+  "rationale": "Per the application-core specification section 5.3, REQ 2.",
   "tags": [
     "blueprint:application-forms-wizard",
     "category:02-validation-timing"
   ],
-  "version": "1.0.0",
+  "version": "1.0.1",
   "status": "approved",
   "createdAt": "2026-09-06T18:00:00Z",
-  "updatedAt": "2026-09-06T18:00:00Z"
+  "updatedAt": "2026-09-10T00:00:00Z"
 }

package/blueprints/application-forms-wizard/contributions/requirements/application-forms-wizard-req-003.json

@@ -3,16 +3,20 @@
   "prdId": "PRD-001",
   "title": "Error-summary contract: top-of-page summary with skip links per failed field, aria-invalid on the field, and focus moved to the summary heading on submit failure",
   "description": "On submit refusal the step renders a top-of-page error summary region carrying a heading and one skip link per failed field. Each skip link's target is a focusable field element; the field carries aria-invalid=\"true\" while unresolved and aria-describedby pointing at the field-level error message. On submit failure the client moves focus to the summary heading so a screen-reader user hears the error class and can walk the skip links; visual users see the heading anchor scroll into view. The summary and per-field bindings anchor on TAC-2502 (error-summary contract). Per WCAG 2.2 SC 3.3.1 Error Identification and SC 3.3.3 Error Suggestion.",
+  "deliveredBy": {
+    "tacId": "TAC-2502-application-forms-wizard-error-summary",
+    "field": "interfaces.renderSummary"
+  },
   "category": "functional",
   "domain": "application",
   "priority": "must",
-  "rationale": "Per visual round 4 spec section 5.3, REQ 3.",
+  "rationale": "Per the application-core specification section 5.3, REQ 3.",
   "tags": [
     "blueprint:application-forms-wizard",
     "category:03-error-summary"
   ],
-  "version": "1.0.0",
+  "version": "1.0.1",
   "status": "approved",
   "createdAt": "2026-09-06T18:00:00Z",
-  "updatedAt": "2026-09-06T18:00:00Z"
+  "updatedAt": "2026-09-10T00:00:00Z"
 }

package/blueprints/application-forms-wizard/contributions/requirements/application-forms-wizard-req-004.json

@@ -3,16 +3,20 @@
   "prdId": "PRD-001",
   "title": "Summary-review contract: a summary-list rendering per step with Change links returning to each step and retaining every other answer on save",
   "description": "After every step is Completed (per REQ-001) the wizard renders a summary-review surface: one summary-list section per step, each row a definition-list entry naming the field label and the operator's answer, and a Change link per row that navigates to the step with the field focused. Editing on the target step and saving returns to the summary-review surface with every other answer retained; only the edited answer is updated. The summary-list shape follows the GOV.UK Design System summary-list pattern. Per WCAG 2.2 SC 3.3.4 Error Prevention (Legal, Financial, Data): the summary-review is the last checkpoint before submission and every answer is reversible up to submit.",
+  "deliveredBy": {
+    "tacId": "TAC-2501-application-forms-wizard-task-list",
+    "field": "responsibilities.renderSummaryReview"
+  },
   "category": "functional",
   "domain": "application",
   "priority": "must",
-  "rationale": "Per visual round 4 spec section 5.3, REQ 4.",
+  "rationale": "Per the application-core specification section 5.3, REQ 4.",
   "tags": [
     "blueprint:application-forms-wizard",
     "category:04-summary-review"
   ],
-  "version": "1.0.0",
+  "version": "1.0.1",
   "status": "approved",
   "createdAt": "2026-09-06T18:00:00Z",
-  "updatedAt": "2026-09-06T18:00:00Z"
+  "updatedAt": "2026-09-10T00:00:00Z"
 }

package/blueprints/application-forms-wizard/contributions/requirements/application-forms-wizard-req-005.json

@@ -3,10 +3,14 @@
   "prdId": "PRD-001",
   "title": "Save-and-return contract: a server-side draft table or a client-side local buffer with a sync tick; refuses to ship if neither is wired",
   "description": "The wizard commits partial answers between steps to a draft store so an operator can leave the surface and return without losing progress. Two transports ship: a server-side draft table (POST /drafts persists per-operator per-wizard rows, GET /drafts hydrates on return) and a client-side local buffer (localStorage keyed by operator identifier and wizard slug with a per-write sync tick). ADR-2502 commits to no recommendedDefault because the abandoned-draft loss class is genuinely per-project. A wizard that ships without either transport is refused at build gate: the draft-store TAC is a required companion. Per WCAG 2.2 SC 3.3.7 Redundant Entry: information the operator has already entered is preserved across sessions and not re-solicited.",
+  "deliveredBy": {
+    "tacId": "TAC-2503-application-forms-wizard-draft-store",
+    "field": "interfaces.resolveTransport"
+  },
   "category": "functional",
   "domain": "application",
   "priority": "must",
-  "rationale": "Per visual round 4 spec section 5.3, REQ 5.",
+  "rationale": "Per the application-core specification section 5.3, REQ 5.",
   "tags": [
     "blueprint:application-forms-wizard",
     "category:05-save-and-return"

package/blueprints/application-forms-wizard/contributions/requirements/application-forms-wizard-req-006.json

@@ -0,0 +1,21 @@
+{
+  "reqId": "application-forms-wizard-REQ-006",
+  "prdId": "PRD-001",
+  "title": "Apply-time answer families bind the five elicits to the wizard contract",
+  "description": "When the applying project answers the five apply-time elicits, the wizard honours each with a runtime clause per family: `blueprint.json.elicits[id=step-manifest]` populates the step order the task-list enumerates; `blueprint.json.elicits[id=navigation]` picks the linear-vs-free branch on TAC-2501 (linear gates rows by prerequisites; free allows anchor navigation to every row); `blueprint.json.elicits[id=step-indicator]` picks the indicator surface owned by `ADR-2503.decision`; `blueprint.json.elicits[id=draft-transport]` picks the draft-store backend on TAC-2503 (spa-local-storage default; server-scoped delegates to the applied persistence blueprint; none disables draft persistence); `blueprint.json.elicits[id=validation-policy]` sets the on-blur/on-change/on-submit gate on TAC-2502.",
+  "deliveredBy": {
+    "tacId": "TAC-2501-application-forms-wizard-task-list",
+    "field": "responsibilities.applyElicits"
+  },
+  "category": "functional",
+  "domain": "application",
+  "priority": "must",
+  "rationale": "The five apply-time answer families named in the guide needed one must REQ per family so a project cannot elicit a value and see it ignored silently.",
+  "tags": [
+    "blueprint:application-forms-wizard"
+  ],
+  "version": "1.0.0",
+  "status": "approved",
+  "createdAt": "2026-09-10T00:00:00Z",
+  "updatedAt": "2026-09-10T00:00:00Z"
+}

package/blueprints/application-forms-wizard/contributions/tacs/tac-2501-application-forms-wizard-task-list.json

@@ -2,7 +2,7 @@
   "tacId": "TAC-2501-application-forms-wizard-task-list",
   "prdId": "PRD-001",
   "tadId": "TAD-001",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "status": "approved",
   "name": "Wizard task-list shell",
   "purpose": "Owns the task-list surface of the wizard: the ordered enumeration of steps, the per-step completion-state slot from the closed GOV.UK vocabulary, the ARIA progressbar wrapper, and the linear-or-free navigation gate. Every AC on REQ-001 anchors on this TAC, and every AC that reads step order anchors here.",
@@ -11,7 +11,9 @@
     "Render [data-step-state] on every row from the closed enum {Cannot start yet, Not started, In progress, Completed} (AC-24101-1).",
     "Render an ARIA progressbar wrapper on the surface with aria-valuenow (completed count), aria-valuemax (total step count) and aria-valuetext naming the completion in words (AC-24101-1).",
     "Honour the ADR-2501 linear-vs-free branch by rendering rows whose prerequisites are unfinished as non-anchor spans on linear and as anchors on free (AC-24106-1).",
-    "Delegate to TAC-2503 to hydrate step states from the draft store on entry and to persist step completion transitions on advance."
+    "Delegate to TAC-2503 to hydrate step states from the draft store on entry and to persist step completion transitions on advance.",
+    "renderSummaryReview: render the per-step summary-list at review time with Change links returning to each step and retaining every other answer on save (REQ-004).",
+    "applyElicits: at apply time, dispatch each of the five answer families to its owner interface: `step-manifest` populates the step order enumerated by the task-list; `navigation` picks the linear-or-free branch on the task-list; `step-indicator` selects the indicator surface owned by `ADR-2503.decision`; `draft-transport` binds the draft-store backend on `TAC-2503`; `validation-policy` sets the timing gate on `TAC-2502.validationTimingGate`. Per REQ-006."
   ],
   "internalStructure": "One task-list module the shell mounts on the /task-list route. On mount it reads the step manifest, reads the draft store for the operator's per-step answers, computes the per-step completion state from the answers, renders the enumeration, and wires the row-click handler to the linear-vs-free branch. On step advance the module recomputes the state for the just-completed step and updates the progressbar aria-valuenow. Framework is not prescribed; the module's interfaces are what the project realises against React, Vue, Svelte or vanilla DOM.",
   "interfaces": [
@@ -42,5 +44,5 @@
   "tradeoffs": "One task-list module keeps the enumeration deterministic and lint-checkable but ties every step to a manifest entry the project supplies. A project rendering the wizard without a task-list (a single-flow submit surface with no completion overview) does not apply this TAC; the wizard-shell TACs still hold. Known mechanism-reach gap: the pack asserts row order and state strings but does not additionally probe that focus moves to the task-list on route entry; a v1.1.0 minor bump can drive the accessibility tree.",
   "notes": "See README Known mechanism-reach gaps.",
   "createdAt": "2026-09-06T18:00:00Z",
-  "updatedAt": "2026-09-06T18:00:00Z"
-}
+  "updatedAt": "2026-09-10T00:00:00Z"
+}

package/blueprints/application-forms-wizard/contributions/tacs/tac-2502-application-forms-wizard-error-summary.json

@@ -2,7 +2,7 @@
   "tacId": "TAC-2502-application-forms-wizard-error-summary",
   "prdId": "PRD-001",
   "tadId": "TAD-001",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "status": "approved",
   "name": "Wizard error-summary contract",
   "purpose": "Owns the top-of-page error-summary contract on submit refusal: the summary region, the skip-link binding per failed field, the aria-invalid and aria-describedby marking on the fields themselves, the focus move to the summary heading, and the validation-timing gate the SPA forms-engine drives per REQ-002. Every AC on REQ-002 and REQ-003 anchors on this TAC.",
@@ -11,7 +11,8 @@
     "Mark every failed field with aria-invalid=\"true\" and aria-describedby pointing at its per-field error message id (AC-24103-1).",
     "Move focus to the summary heading on submit failure (AC-24103-1).",
     "Delegate validation to the SPA forms-engine TAC-205 on the on-blur, on-change and on-submit triggers per REQ-002 (AC-24102-1); this TAC does not re-implement validation, it consumes the engine.",
-    "Clear aria-invalid on a field when its message clears and remove the anchor from the summary on the next successful submit."
+    "Clear aria-invalid on a field when its message clears and remove the anchor from the summary on the next successful submit.",
+    "validationTimingGate: honour the elicited validation-policy (on-blur-then-on-change default, on-change-always, on-submit-only) by wiring the SPA forms-engine triggers accordingly (REQ-002)."
   ],
   "internalStructure": "One error-summary module the shell mounts inside the step surface. On submit refusal the module reads the engine's error set, renders the anchor list, moves focus, and wires the anchor click to focus the corresponding field. On subsequent input events after the first failure the module re-runs the engine per-field and updates the message; on the next submit the module rebuilds the error set from scratch. Framework is not prescribed; the interfaces are what the project realises.",
   "interfaces": [
@@ -36,5 +37,5 @@
   "tradeoffs": "Consuming the SPA forms-engine keeps a project on the shelf free from a second overlapping engine but ties this TAC to the SPA blueprint's validation shape. Known mechanism-reach gap: the pack asserts the summary and the aria bindings but does not additionally probe the focus-order sweep across every field in the DOM after focus moves to the heading; a v1.1.0 minor bump can walk the tab order and diff.",
   "notes": "See README Known mechanism-reach gaps.",
   "createdAt": "2026-09-06T18:00:00Z",
-  "updatedAt": "2026-09-06T18:00:00Z"
+  "updatedAt": "2026-09-10T00:00:00Z"
 }

package/blueprints/application-forms-wizard/contributions/user-stories/application-forms-wizard-us-24101.json

@@ -13,7 +13,40 @@
       "id": "AC-24101-1",
       "testable": true,
       "scope": "runtime",
-      "description": "Given the wizard task-list route, the rendered surface exposes [data-surface=\"task-list\"] carrying a [role=\"progressbar\"] with aria-valuenow, aria-valuemax and aria-valuetext, and one child element per step carrying [data-step-slug] and [data-step-state] whose value is one of the closed set {Cannot start yet, Not started, In progress, Completed}. The pack drives the real browser to /task-list and reads the state string per step, the progressbar values, and the enumerated step order."
+      "description": "Given the wizard task-list route, the rendered surface exposes [data-surface=\"task-list\"] carrying a [role=\"progressbar\"] with aria-valuenow, aria-valuemax and aria-valuetext, and one child element per step carrying [data-step-slug] and [data-step-state] whose value is drawn from the closed enum owned by `TAC-2501.interfaces.statesEnum`. The pack drives the real browser to /task-list and reads the state string per step, the progressbar values, and the enumerated step order. (Progressbar ARIA role verified against https://www.w3.org/TR/wai-aria-1.2/#progressbar, 2026-09-10.)",
+      "disposition": "fixed",
+      "ownerRef": {
+        "tacId": "TAC-2501-application-forms-wizard-task-list",
+        "field": "interfaces.statesEnum"
+      },
+      "vendorCitation": {
+        "url": "https://design-system.service.gov.uk/patterns/task-list-pages/",
+        "verifiedOn": "2026-09-10"
+      }
+    },
+    {
+      "id": "AC-24101-2",
+      "description": "Every step row carries exactly one of the four GOV.UK completion states (Not started, In progress, Cannot start yet, Completed) as data-step-state; an unknown value refuses to render (data-error=STEP_STATE_UNKNOWN is emitted and the row is suppressed).",
+      "given": "a task-list with a step whose state is outside the four-state enum",
+      "when": "the surface renders",
+      "then": "the row is suppressed, data-error=STEP_STATE_UNKNOWN is emitted and no fallback state renders",
+      "testable": true,
+      "scope": "runtime",
+      "disposition": "fixed",
+      "vendorCitation": {
+        "url": "https://design-system.service.gov.uk/patterns/task-list-pages/",
+        "verifiedOn": "2026-09-10"
+      }
+    },
+    {
+      "id": "AC-24101-3",
+      "description": "A Cannot-start-yet step lists its blocking dependencies in an aria-describedby-bound description; activating a blocked step is refused with focus preserved on the row and a polite live-region announcement of the block.",
+      "given": "a step in Cannot start yet state with named blockers",
+      "when": "the principal activates the row",
+      "then": "the row does not navigate, focus stays and the polite live region announces the block",
+      "testable": true,
+      "scope": "runtime",
+      "disposition": "fixed"
     }
   ],
   "tacIds": [
@@ -24,5 +57,5 @@
     "contract:task-list"
   ],
   "createdAt": "2026-09-06T18:00:00Z",
-  "updatedAt": "2026-09-06T18:00:00Z"
+  "updatedAt": "2026-09-10T00:00:00Z"
 }