diff --git a/.agents/skills/ln-build/SKILL.md b/.agents/skills/ln-build/SKILL.md
index 9055e9a7..d069732e 100644
--- a/.agents/skills/ln-build/SKILL.md
+++ b/.agents/skills/ln-build/SKILL.md
@@ -98,6 +98,10 @@ Use these to decide whether a candidate fact is already covered by an existing l
 
 When uncertain between merge and add → add. When uncertain between update and no-op → update.
 
+## Temporary-document retirement
+
+If this build used a card from `memory/CARDS.md` or a step from `memory/REFACTOR.md`, check whether all items in that document are now complete. If so, confirm with the user that the document should be deleted — these are temporary working documents that should not outlive their purpose.
+
 ## Routing
 
 After traceability is complete, present these options to the user (use `tool-ask-question`):
diff --git a/.agents/skills/ln-scope/SKILL.md b/.agents/skills/ln-scope/SKILL.md
index e32a6762..6daf2da6 100644
--- a/.agents/skills/ln-scope/SKILL.md
+++ b/.agents/skills/ln-scope/SKILL.md
@@ -65,6 +65,18 @@ Name the oracle strategy for this slice. If `memory/SPEC.md` §Oracle Strategy b
 
 A slice without a verification approach is not fully scoped. At minimum, inner-loop oracles must be named. Middle/outer are required when the slice touches LLM boundaries, visual rendering, or compositional behavior. Those slices should run through `ln-oracles` before `ln-build`.
 
+## Batch pre-scoping (optional)
+
+When several near-term slices follow a **proven structural pattern** with linear dependencies, scope them together into `memory/CARDS.md` instead of one at a time. This compresses planning without separate scope→build→scope context switches.
+
+**Use when:** slices mirror a pattern already validated by earlier work, dependencies are linear and well-understood, and risk is in execution rather than discovery.
+
+**Avoid when:** slices are exploratory, the design space has genuine uncertainty, or building slice N could fundamentally change what slice N+1 should be.
+
+`memory/CARDS.md` is a **temporary derivative document** — no authority, derivative of `memory/PLAN.md` for active implementation convenience. Delete it once all cards are built or superseded. Same convention as `memory/REFACTOR.md`.
+
+**Escape valve:** if a build invalidates a downstream card's assumptions, revise the card before building it — never build against stale scope.
+
 ## Traceability (mandatory — do before routing)
 
 After the scope card is complete, do these before presenting routing options:
diff --git a/memory/CARDS.md b/memory/CARDS.md
deleted file mode 100644
index 4cb1f785..00000000
--- a/memory/CARDS.md
+++ /dev/null
@@ -1,161 +0,0 @@
-<!-- CARDS.md — temporary scoped-card working document.
-     Authority: none. Derivative of PLAN.md for active implementation convenience.
-     Create when pre-scoping several near-term slices saves time; retire once these cards are built or superseded.
-     Current intent: pre-scope Slice 10 tracer bullets without introducing a permanent third planning document. -->
-
-# Cards
-
-## Scope Card — `10.1` Criteria grounding + first synthesis/review loop
-
-### Target Behavior
-After requirements closes, the first prepared criteria turn is grounded in the approved requirement set and can round-trip one initial criterion through the existing seams without dropping out of `criteria` mode.
-
-### Boundary Crossings
-```text
-→ requirements phase is confirmed closed from slice 9.5, with criteria now the active phase
-→ next prepared turn / /chat invocation selects `phase: 'criteria'`
-→ interviewer context injects the approved requirement inventory (and any existing criterion inventory)
-→ criteria-mode interviewer emits a criteria-shaped question rather than a generic follow-up
-→ user replies through the existing turn-response seam
-→ observer persists one criterion through the generic knowledge seam
-→ workflow remains `criteria` / `in_progress` and entities projection exposes the new criterion
-```
-
-### Risks and Assumptions
-- **RISK:** Criteria mode may technically activate but still receive weak or stale grounding, producing a generic follow-up instead of a verification-oriented question.
-  - **MITIGATION:** Lock both artifacts independently: approved-requirement inventory reaching the interviewer seam and the emitted turn remaining criteria-shaped.
-
-- **RISK:** The first criterion round-trip could accidentally widen into explicit criterion review-state or closeability work.
-  - **MITIGATION:** Keep this slice synthesis-thin: prove one first criterion can emerge and persist; defer approve/reject/closeability to `10.2`.
-
-- **RISK:** Criteria grounding may include rejected or otherwise out-of-scope requirements rather than the reviewed active set.
-  - **MITIGATION:** Assert approved-requirement grounding specifically, not just generic requirement inventory presence.
-
-- **ASSUMPTION:** The criteria interviewer can be usefully grounded by the approved requirement inventory plus any earlier criterion-like signals without first introducing a dedicated criteria workspace.
-  - **VALIDATE:** criteria context/prompt tests and one criterion persistence round-trip stay coherent.
-  - → existing `SPEC.md` assumptions/decisions already cover this (`A28`, `A40`, `D25`, `D55`, `D56`, `D71`)
-
-### Acceptance Criteria
-```text
-✓ src/server/context.test.ts or src/server/interview.test.ts — criteria-mode interviewer context includes the approved requirement inventory (not just prior chat history)
-✓ src/server/app.test.ts — the first post-9.5 /chat turn runs the interviewer and observer with `phase: 'criteria'` and emits a criteria-shaped question rather than a generic follow-up
-✓ src/server/app.test.ts or src/server/db.test.ts — one initial criterion can round-trip through criteria-mode reply → observer persistence → entities projection while criteria remains `in_progress`
-```
-
-### Verification Approach
-- **Inner:** fast unit tests — proves criteria context/prompt grounding and criteria-mode phase selection.
-- **Middle:** round-trip oracle (criteria synthesis) — approved requirements → criteria turn → observer-created criterion → entities projection with no drift.
-- **Outer:** manual walkthrough — finish requirements, enter criteria, verify the first criteria question feels tied to the reviewed requirement set.
-
-### Traceability
-- **PLAN:** Slice `10.1`
-- **SPEC requirements:** `#6`, `#8`, `#12`
-- **SPEC assumptions:** `A28`, `A40`
-- **SPEC decisions:** `D25`, `D55`, `D56`, `D71`
-- **Invariants to respect:** `I18`, `I19`, `I21`, `I24`, `I95`, `I96`
-- **Deferred to later cards:** explicit per-criterion review state, criteria closeability, final criteria closure
-
----
-
-## Scope Card — `10.2` Explicit criterion review state + minimal closeability
-
-### Target Behavior
-Criteria review can persist explicit per-criterion positive/non-positive review state, project `approved` / `rejected` / `pending` status from the active path, and mark criteria closeable only when no current criterion remains pending.
-
-### Boundary Crossings
-```text
-→ criteria mode has a current criterion set on the active path
-→ interviewer emits a targeted criteria-review turn carrying explicit criterion review metadata
-→ user responds through the existing turn-response seam
-→ response handling records durable active-path criterion review linkage
-→ entities / sidebar read model projects `approved` / `rejected` / `pending` criterion state from the latest explicit review action
-→ workflow projection computes criteria `closeability: true` only when every current criterion has non-pending review state
-```
-
-### Risks and Assumptions
-- **RISK:** Repeating the slice-9 pattern too literally could split criterion approval, rejection, and closeability into separate tracer bullets that do not unblock the app.
-  - **MITIGATION:** Bundle the minimum useful criterion lifecycle into one slice: explicit positive action, explicit non-positive action, latest-action projection, and deterministic closeability.
-
-- **RISK:** Criterion review semantics may diverge from requirement review enough that reusing the same metadata/linkage seam becomes awkward.
-  - **MITIGATION:** Keep the first seam narrow and structural; defer edit/merge/split/stale semantics to `13a`.
-
-- **RISK:** Criteria closeability could accidentally widen into richer coverage logic such as "every approved requirement must have N criteria" before the thin end-to-end path is working.
-  - **MITIGATION:** Start with the same deterministic minimum-bar approach as earlier phases: current criterion set has no pending explicit review state.
-
-- **ASSUMPTION:** The first explicit criterion review seam can reuse the same targeted-review + active-path link pattern already proven for requirements.
-  - **VALIDATE:** targeted criterion review round-trip and latest-action projection pass without introducing a separate mutation path.
-  - → likely SPEC follow-on from existing seams (`A15`, `A28`, `D24`, `D61`, `D65`, `D66`, `D70`)
-
-### Acceptance Criteria
-```text
-✓ src/shared/chat.ts or src/server/interview.test.ts — criteria review metadata validates targeted criterion review actions through the existing structured question seam
-✓ src/server/app.test.ts — one explicit positive criterion review action and one explicit non-positive criterion review action persist through the response seam and project correctly in entities/sidebar state
-✓ src/server/db.test.ts — criterion review projection resolves `approved` / `rejected` / `pending` from the latest explicit active-path action
-✓ src/server/db.test.ts — criteria becomes closeable only when every current criterion has explicit non-pending review state
-```
-
-### Verification Approach
-- **Inner:** fast unit tests — proves criterion review metadata, read-model projection, and closeability rule.
-- **Middle:** round-trip oracle (criteria review) — targeted review metadata → response submit → durable review linkage → projected criterion state with no drift.
-- **Middle:** model-based lifecycle oracle (criteria review) — criteria remains `in_progress` until all current criteria are explicitly reviewed.
-- **Outer:** manual walkthrough — confirm the thin approve/reject semantics are legible enough to keep moving toward completed workflow.
-
-### Traceability
-- **PLAN:** Slice `10.2`
-- **SPEC requirements:** `#7`, `#8`, `#12`, `#13`
-- **SPEC assumptions:** `A15`, `A28`
-- **SPEC decisions:** `D24`, `D61`, `D65`, `D66`, `D70`
-- **Invariants to respect:** `I18`, `I21`, `I24`, `I62`, `I63`, `I96`
-- **Deferred to later cards:** criterion edit/add/merge/split flows, richer requirement↔criterion coverage logic, stale review invalidation
-
----
-
-## Scope Card — `10.3` Criteria closure + completed workflow state
-
-### Target Behavior
-Once criteria is closeable, the shared phase-close seam can propose and confirm final criteria closure, leaving workflow with all phases closed and no stale active interviewer phase before export.
-
-### Boundary Crossings
-```text
-→ criteria phase is active and closeable after 10.2
-→ interviewer emits `propose_phase_closure` for `criteria`
-→ `/chat` streams `data-phase-summary` and persists a proposed criteria `phase_outcome`
-→ user confirms the proposed criteria closure through `data-confirmation`
-→ `phase_outcome` persistence confirms the final criteria outcome with durable closure basis
-→ workflow projection marks criteria `closed` and projects no remaining active phase
-→ next app/project state reads as interview-complete rather than reopening stale criteria mode
-```
-
-### Risks and Assumptions
-- **RISK:** The current server-side "first unclosed phase or `criteria` fallback" behavior may fabricate an active criteria phase even after final closure.
-  - **MITIGATION:** Lock completed-workflow projection explicitly and treat "all phases closed" as its own tested structural state.
-
-- **RISK:** Final-phase closure could widen into export gating, dashboard polish, or force-close variants.
-  - **MITIGATION:** Keep this slice about closure mechanics only: proposed final close, confirmation, and completed workflow projection. Leave export/dashboard concerns to slices `11a` and `13`.
-
-- **RISK:** Criteria closure may be implemented correctly in persistence but fail to suppress stale interviewer activity on the next app interaction.
-  - **MITIGATION:** Add an app/core assertion that post-confirmation state has no remaining active interview phase before export.
-
-- **ASSUMPTION:** The shared phase-close transport used for scope, design, and requirements can close the terminal `criteria` phase without a criteria-specific mutation path.
-  - **VALIDATE:** proposal/confirmation round-trip persists and projects a completed workflow state through the same seam.
-  - → existing `SPEC.md` assumptions/decisions already cover this (`A15`, `A28`, `D65`, `D66`, `D71`)
-
-### Acceptance Criteria
-```text
-✓ src/server/app.test.ts — criteria can emit a shared `data-phase-summary` proposal and persist a proposed final `phase_outcome`
-✓ src/server/db.test.ts or src/server/app.test.ts — confirming the proposed criteria outcome closes criteria with durable closure provenance and leaves all workflow phases closed
-✓ src/server/core.test.ts or src/server/app.test.ts — post-confirmation app state projects no stale active interviewer phase before export rather than reopening `criteria`
-```
-
-### Verification Approach
-- **Inner:** fast unit/integration tests — proves final-phase proposal/confirmation persistence and completed-workflow projection.
-- **Middle:** round-trip oracle (phase outcome) — criteria proposal → confirmation → confirmed final `phase_outcome` → completed workflow state with no drift.
-- **Outer:** manual walkthrough — complete the interview, confirm final criteria closure, and verify the app feels done before export-specific polish lands.
-
-### Traceability
-- **PLAN:** Slice `10.3`
-- **SPEC requirements:** `#7`, `#8`, `#13`
-- **SPEC assumptions:** `A15`, `A28`
-- **SPEC decisions:** `D65`, `D66`, `D71`
-- **Invariants to respect:** `I18`, `I24`, `I96`
-- **Deferred to later cards:** export predicate details, dashboard summarization, low-readiness/forced-close variants if they prove necessary later
diff --git a/memory/PLAN.md b/memory/PLAN.md
index afcc37e2..817653b2 100644
--- a/memory/PLAN.md
+++ b/memory/PLAN.md
@@ -144,7 +144,7 @@
    - Result: interviewer grounded in requirement inventory; targeted approve/reject via review metadata + `turn_knowledge_item` links; closeability from full review coverage; shared phase-close seam reused for requirements → criteria handoff
    - Tracer bullets: 9.1 inventory grounding `done`, 9.2 targeted approval `done`, 9.3 targeted rejection `done`, 9.4 closeability + proposal `done`, 9.5 closure + criteria handoff `done`
 
-10.1 **Criteria grounding + first synthesis/review loop** — Prove the first post-requirements criteria turn is grounded in the approved requirement set and can round-trip one first criterion through the existing seams without widening into the full criteria lifecycle. `not-started`
+10.1 **Criteria grounding + first synthesis/review loop** `done`
      - Requirements: → SPEC.md §Requirements #6, #8, #12
      - Assumptions: → SPEC.md §Assumptions A28, A40
      - Decisions: → SPEC.md §Decisions D25, D55, D56, D71
@@ -153,7 +153,7 @@
      - Acceptance: after requirements closes, the first criteria turn includes the approved requirement inventory, asks a criteria-shaped question rather than a generic follow-up, and one initial criterion can round-trip through observer/entity persistence without dropping out of criteria mode
      - **Verification approach**: inner — criteria context/prompt seam tests plus criterion projection tests. Middle — round-trip oracle proving approved requirement inventory → criteria interviewer turn → criterion persistence/entities refresh. Outer — manual walkthrough judges whether the first criteria turn feels grounded in the reviewed requirement set.
 
-10.2 **Explicit criterion review state + minimal closeability** — Establish the first explicit per-criterion review seam and deterministic closeability rule in one slice rather than splitting approval, rejection, and closeability into separate tracer bullets. `not-started`
+10.2 **Explicit criterion review state + minimal closeability** — Establish the first explicit per-criterion review seam and deterministic closeability rule in one slice rather than splitting approval, rejection, and closeability into separate tracer bullets. `done`
      - Requirements: → SPEC.md §Requirements #7, #8, #12, #13
      - Assumptions: → SPEC.md §Assumptions A15, A28
      - Decisions: → SPEC.md §Decisions D24, D61, D65, D66, D70
@@ -162,7 +162,7 @@
      - Acceptance: a targeted criteria-review turn can persist one explicit positive review action and one explicit non-positive review action, read-side projection resolves latest review state per criterion, and workflow marks criteria closeable only when no criterion remains `pending`
      - **Verification approach**: inner — criterion review metadata/read-model/workflow-state tests. Middle — round-trip oracle proving explicit criterion review actions persist and project without drift, plus lifecycle oracle proving criteria stays `in_progress` until review coverage is complete. Outer — manual criteria review walkthrough judges whether the thin approve/reject semantics are legible enough to keep moving.
 
-10.3 **Criteria closure + completed workflow state** — Reuse the shared phase-close seam to close the final workflow phase and project a completed interview state once criteria review reaches the minimum bar. `not-started`
+10.3 **Criteria closure + completed workflow state** — Reuse the shared phase-close seam to close the final workflow phase and project a completed interview state once criteria review reaches the minimum bar. `done`
      - Requirements: → SPEC.md §Requirements #7, #8, #13
      - Assumptions: → SPEC.md §Assumptions A15, A28
      - Decisions: → SPEC.md §Decisions D65, D66, D71
@@ -293,10 +293,8 @@ Phase 8:  14 ──→ 15 (drizzle-kit audit remediation)
 
 ### Parallelism opportunities
 
-- With 7, 7a, 7b, 8, and 9 all done, the next primary slice is 10.1 (criteria grounding + first synthesis/review loop).
-- 10.2 and 10.3 should follow linearly; they are intentionally the minimum slices needed to unblock completed interview flow rather than separate variants of the same review seam.
-- 11a (project dashboard workflow state) can begin once 10.3 lands; it does not need the broader knowledge workspace.
-- 12 (knowledge workspace) and 13 (export) can proceed in parallel once 10.3 stabilizes the criteria artifacts and completed-workflow state.
+- 10.1–10.3 are done; the review seam has been unified (refactor landed between 10.3 and 11a).
+- 11a (project dashboard workflow state), 12 (knowledge workspace), and 13 (export) are all unblocked and can proceed in parallel.
 - 13a (review lifecycle refinement) is explicitly deferred; it should collect rarer review variants after 12 and 13 stabilize rather than fragmenting slices 9 and 10.
 - 14 (npx) can start early with a basic launcher, completing after slice 13 when the export predicate stabilizes.
 - 15 (drizzle-kit audit remediation) should wait until 14 lands.
diff --git a/memory/SPEC.md b/memory/SPEC.md
index 3afaedb7..cc9bbcf3 100644
--- a/memory/SPEC.md
+++ b/memory/SPEC.md
@@ -314,6 +314,14 @@ Detailed schema and mode-model rationale: `docs/design/INTERVIEW_MODE_MODEL.md`.
 | --- | ---------------------------------------------------------- | ------------------------- | ------------------------------------ | ----------- |
 | I87 | Requirements-review mode grounds the interviewer in the current requirement inventory, targeted approve/reject actions persist durable active-path review links with latest-action-wins projection, closeability derives from full review coverage, and the shared phase-close proposal/confirmation seam reuses for requirements → criteria handoff with correct mode advancement | Slices 9.1–9.5 | context.test.ts, interview.test.ts, db.test.ts, app.test.ts, core.test.ts, EntitySidebar.test.tsx | D24, D25, D51, D61, D65, D66, D70, D71, D77, D78, D79, A28, A44, A45, A46 |
 
+### Criteria-review seam
+
+| #   | Invariant                                                  | Established by            | Protected by                         | Proves      |
+| --- | ---------------------------------------------------------- | ------------------------- | ------------------------------------ | ----------- |
+| I97 | Criteria-mode interviewer context is grounded in the approved requirement inventory (not the full or pending set), and one initial criterion can round-trip through criteria-mode observer persistence → entities projection while criteria remains `in_progress` | Slice 10.1 | context.test.ts, app.test.ts | D25, D71, A28, A40 |
+| I98 | Targeted criterion approve/reject actions persist durable active-path review links with latest-action-wins projection (`approved` / `rejected` / `pending`), criteria closeability derives from full criterion review coverage, and the structured question seam carries criterion review metadata through the same response path as requirement reviews | Slice 10.2 | db.test.ts, app.test.ts | D24, D61, D65, D66, D70, A15, A28 |
+| I99 | The shared phase-close seam can propose and confirm criteria closure through the same transport used for scope/design/requirements, and confirming the final criteria outcome projects all four workflow phases as `closed` with no stale active interviewer phase | Slice 10.3 | app.test.ts | D65, D66, D71, A15, A28 |
+
 ## Lexicon
 
 <!-- Canonical terms. Code names must match.
@@ -532,13 +540,13 @@ This projection difference is a deliberate design choice, not an implementation
 
 | File                          | Tests | Protects                                              |
 | ----------------------------- | ----- | ----------------------------------------------------- |
-| db.test.ts                    | 41    | I5, I6, I9, I10, I11, I20, I48, I54, I72, I87        |
+| db.test.ts                    | 43    | I5, I6, I9, I10, I11, I20, I48, I54, I72, I87, I98   |
 | knowledge.test.ts             | 1     | I48                                                   |
-| app.test.ts                   | 26    | I1, I2, I3, I7, I14, I21, I23, I44, I48, I54, I72, I87 |
+| app.test.ts                   | 36    | I1, I2, I3, I7, I14, I21, I23, I44, I48, I54, I72, I87, I98, I99 |
 | core.test.ts                  | 10    | I12, I13, I18, I72, I87                               |
-| interview.test.ts             | 9     | I16, I72, I87                                         |
+| interview.test.ts             | 10    | I16, I72, I87                                         |
 | parts.test.ts                 | 15    | I17, I18, I44, I54, I72                               |
-| context.test.ts               | 14    | I19, I44, I48, I54, I87                               |
+| context.test.ts               | 15    | I19, I44, I48, I54, I87                               |
 | observer.test.ts              | 9     | I20, I21, I44, I48, I54                               |
 | phase-close.test.ts           | 13    | I72                                                   |
 | turn-response.test.ts         | 4     | I44                                                   |
diff --git a/src/server/app.test.ts b/src/server/app.test.ts
index 67611e46..a62502f4 100644
--- a/src/server/app.test.ts
+++ b/src/server/app.test.ts
@@ -103,7 +103,7 @@ async function makePhaseClosureInterviewer(
   dbArg: DB,
   projectId: number,
   turnId: number,
-  phase: 'scope' | 'design' | 'requirements' = 'scope',
+  phase: 'scope' | 'design' | 'requirements' | 'criteria' = 'scope',
   summary = 'Goals, terms, context, and constraints are sufficiently captured.',
 ) {
   const { createPhaseOutcome } = await import('./db.js');
@@ -223,6 +223,85 @@ async function seedActiveDesign(projectId: number) {
   return { ...seededScope, designTurn };
 }
 
+async function seedCriteriaReady(projectId: number) {
+  const {
+    advanceHead,
+    confirmPhaseOutcome,
+    createPhaseOutcome,
+    createTurn,
+    createKnowledgeItem,
+    linkKnowledgeItemToTurn,
+  } = await import('./db.js');
+  const seededRequirements = await seedRequirementsReady(projectId);
+
+  const approvedRequirement = createKnowledgeItem(
+    db,
+    projectId,
+    'requirement',
+    'Resume the interview from SQLite after restart',
+  );
+  const rejectedRequirement = createKnowledgeItem(
+    db,
+    projectId,
+    'requirement',
+    'Support exporting the spec as a PDF',
+  );
+
+  const reviewTurn = createTurn(db, projectId, {
+    phase: 'requirements',
+    parent_turn_id: seededRequirements.designConfirmationTurn.id,
+    question: 'Are these requirements all reviewed now?',
+    answer: 'Yes — approve resume and reject PDF export',
+  });
+  linkKnowledgeItemToTurn(db, approvedRequirement.id, reviewTurn.id, 'reviewed');
+  linkKnowledgeItemToTurn(db, rejectedRequirement.id, reviewTurn.id, 'rejected');
+  advanceHead(db, projectId, reviewTurn.id);
+
+  const requirementsProposalTurn = createTurn(db, projectId, {
+    phase: 'requirements',
+    parent_turn_id: reviewTurn.id,
+    question: '',
+    answer: 'The requirement set has explicit review coverage and is ready to move into criteria.',
+  });
+  advanceHead(db, projectId, requirementsProposalTurn.id);
+
+  const requirementsOutcome = createPhaseOutcome(db, {
+    projectId,
+    phase: 'requirements',
+    proposal_turn_id: requirementsProposalTurn.id,
+    summary: 'The requirement set has explicit review coverage and is ready to move into criteria.',
+  });
+
+  const requirementsConfirmationTurn = createTurn(db, projectId, {
+    phase: 'requirements',
+    parent_turn_id: requirementsProposalTurn.id,
+    question: '',
+    answer: 'Confirm requirements closure',
+    user_parts: JSON.stringify([
+      { type: 'text', text: 'Confirm requirements closure' },
+      {
+        type: 'data-confirmation',
+        data: {
+          kind: 'confirm-proposed-phase-closure',
+          proposalTurnId: requirementsProposalTurn.id,
+          phase: 'requirements',
+        },
+      },
+    ]),
+  });
+  confirmPhaseOutcome(db, requirementsOutcome.id, requirementsConfirmationTurn.id);
+  advanceHead(db, projectId, requirementsConfirmationTurn.id);
+
+  return {
+    ...seededRequirements,
+    approvedRequirement,
+    rejectedRequirement,
+    reviewTurn,
+    requirementsProposalTurn,
+    requirementsConfirmationTurn,
+  };
+}
+
 async function seedRequirementsReady(projectId: number) {
   const { advanceHead, confirmPhaseOutcome, createPhaseOutcome, createTurn } = await import('./db.js');
   const seededDesign = await seedActiveDesign(projectId);
@@ -707,6 +786,7 @@ describe('POST /api/projects/:id/chat', () => {
         subtype: null,
         content: 'Resuming restores the active path without data loss',
         rationale: 'This proves persistence worked for the branch the user was on',
+        reviewStatus: 'pending',
       },
     ]);
   });
@@ -1532,6 +1612,319 @@ describe('phase outcomes + scope closure', () => {
     expect(refreshedProjectRes.body.turns.at(-1).phase).toBe('criteria');
   });
 
+  it('grounds the first criteria turn in approved requirements and round-trips a criterion through observer persistence', async () => {
+    const projectId = await createTestProject();
+    await seedCriteriaReady(projectId);
+
+    mockStreamInterviewer.mockImplementation(async () =>
+      makeTextInterviewer('What would prove the resume flow is complete?'),
+    );
+    mockRunObserver.mockImplementation(async (dbArg, turnArg, observedProjectId) => {
+      const { createKnowledgeItem } = await import('./db.js');
+      const criterion = createKnowledgeItem(
+        dbArg as DB,
+        observedProjectId as number,
+        'criterion',
+        'Closing and reopening the browser restores the active path',
+      );
+      return {
+        goals: [],
+        terms: [],
+        contexts: [],
+        constraints: [],
+        requirements: [],
+        criteria: [criterion.id],
+        decisions: [],
+        assumptions: [],
+      };
+    });
+
+    await request(app)
+      .post(`/api/projects/${projectId}/chat`)
+      .send({
+        messages: [
+          {
+            id: 'u-criteria-grounding',
+            role: 'user',
+            parts: [{ type: 'text', text: 'Let us define the first acceptance criterion' }],
+          },
+        ],
+      })
+      .expect(200);
+
+    expect(mockStreamInterviewer).toHaveBeenLastCalledWith(
+      expect.anything(),
+      expect.objectContaining({ phase: 'criteria' }),
+      expect.any(Array),
+      expect.any(String),
+      'criteria',
+    );
+
+    expect(mockRunObserver).toHaveBeenLastCalledWith(
+      expect.anything(),
+      expect.objectContaining({ phase: 'criteria' }),
+      projectId,
+    );
+
+    const projectRes = await request(app).get(`/api/projects/${projectId}`).expect(200);
+    expect(projectRes.body.workflow.phases.criteria).toEqual(
+      expect.objectContaining({
+        status: 'in_progress',
+        closeability: false,
+      }),
+    );
+
+    const entitiesRes = await request(app).get(`/api/projects/${projectId}/entities`).expect(200);
+    expect(entitiesRes.body.criteria).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          content: 'Closing and reopening the browser restores the active path',
+        }),
+      ]),
+    );
+  });
+
+  it('emits a criteria phase-summary proposal once every criterion is explicitly reviewed', async () => {
+    const projectId = await createTestProject();
+    const seededCriteria = await seedCriteriaReady(projectId);
+    const { advanceHead, createKnowledgeItem, createTurn, linkKnowledgeItemToTurn } = await import('./db.js');
+
+    const approvedCriterion = createKnowledgeItem(
+      db,
+      projectId,
+      'criterion',
+      'Markdown preview renders the reviewed requirements',
+    );
+    const rejectedCriterion = createKnowledgeItem(
+      db,
+      projectId,
+      'criterion',
+      'PDF export renders the reviewed requirements',
+    );
+
+    const reviewTurn = createTurn(db, projectId, {
+      phase: 'criteria',
+      parent_turn_id: seededCriteria.requirementsConfirmationTurn.id,
+      question: 'Are these criteria all reviewed now?',
+      answer: 'Yes — approve markdown and reject PDF export',
+    });
+    linkKnowledgeItemToTurn(db, approvedCriterion.id, reviewTurn.id, 'reviewed');
+    linkKnowledgeItemToTurn(db, rejectedCriterion.id, reviewTurn.id, 'rejected');
+    advanceHead(db, projectId, reviewTurn.id);
+
+    mockStreamInterviewer.mockImplementation(async (dbArg, turn) =>
+      makePhaseClosureInterviewer(
+        dbArg as DB,
+        projectId,
+        (turn as { id: number }).id,
+        'criteria',
+        'All criteria have been explicitly reviewed and the criteria set is ready to close.',
+      ),
+    );
+
+    const chatRes = await request(app)
+      .post(`/api/projects/${projectId}/chat`)
+      .send({
+        messages: [
+          {
+            id: 'u-criteria-close',
+            role: 'user',
+            parts: [{ type: 'text', text: 'I think the criteria set is fully reviewed now' }],
+          },
+        ],
+      })
+      .expect(200);
+
+    const events = parseSSELines(collectSSE(chatRes)).filter((event) => event !== '[DONE]');
+    expect(events).toContainEqual({
+      type: 'data-phase-summary',
+      data: {
+        turnId: reviewTurn.id + 1,
+        phase: 'criteria',
+        summary: 'All criteria have been explicitly reviewed and the criteria set is ready to close.',
+      },
+    });
+
+    const projectRes = await request(app).get(`/api/projects/${projectId}`).expect(200);
+    expect(projectRes.body.workflow.phases.criteria).toEqual(
+      expect.objectContaining({
+        status: 'in_progress',
+        closeability: true,
+        proposalPending: true,
+        turnId: reviewTurn.id + 1,
+        summary: 'All criteria have been explicitly reviewed and the criteria set is ready to close.',
+      }),
+    );
+  });
+
+  it('confirms a proposed criteria outcome, closes criteria, and projects all workflow phases as closed', async () => {
+    const projectId = await createTestProject();
+    const seededCriteria = await seedCriteriaReady(projectId);
+    const { advanceHead, createKnowledgeItem, createPhaseOutcome, createTurn, linkKnowledgeItemToTurn } =
+      await import('./db.js');
+
+    const approvedCriterion = createKnowledgeItem(
+      db,
+      projectId,
+      'criterion',
+      'Markdown preview renders the reviewed requirements',
+    );
+    const rejectedCriterion = createKnowledgeItem(
+      db,
+      projectId,
+      'criterion',
+      'PDF export renders the reviewed requirements',
+    );
+
+    const reviewTurn = createTurn(db, projectId, {
+      phase: 'criteria',
+      parent_turn_id: seededCriteria.requirementsConfirmationTurn.id,
+      question: 'Are these criteria all reviewed now?',
+      answer: 'Yes — approve markdown and reject PDF export',
+    });
+    linkKnowledgeItemToTurn(db, approvedCriterion.id, reviewTurn.id, 'reviewed');
+    linkKnowledgeItemToTurn(db, rejectedCriterion.id, reviewTurn.id, 'rejected');
+    advanceHead(db, projectId, reviewTurn.id);
+
+    const proposalTurn = createTurn(db, projectId, {
+      phase: 'criteria',
+      parent_turn_id: reviewTurn.id,
+      question: '',
+      answer: 'All criteria have been explicitly reviewed and the criteria set is ready to close.',
+    });
+    advanceHead(db, projectId, proposalTurn.id);
+
+    createPhaseOutcome(db, {
+      projectId,
+      phase: 'criteria',
+      proposal_turn_id: proposalTurn.id,
+      summary: 'All criteria have been explicitly reviewed and the criteria set is ready to close.',
+    });
+
+    await request(app)
+      .post(`/api/projects/${projectId}/chat`)
+      .send({
+        messages: [
+          {
+            id: 'u-criteria-confirm',
+            role: 'user',
+            parts: [
+              { type: 'text', text: 'Confirm criteria closure' },
+              {
+                type: 'data-confirmation',
+                data: {
+                  kind: 'confirm-proposed-phase-closure',
+                  proposalTurnId: proposalTurn.id,
+                  phase: 'criteria',
+                },
+              },
+            ],
+          },
+        ],
+      })
+      .expect(200);
+
+    const projectRes = await request(app).get(`/api/projects/${projectId}`).expect(200);
+    expect(projectRes.body.workflow.phases.criteria).toEqual(
+      expect.objectContaining({
+        status: 'closed',
+        closeability: false,
+        readiness: 'high',
+        closureBasis: 'interviewer_recommended',
+        proposalPending: false,
+        turnId: proposalTurn.id,
+        summary: 'All criteria have been explicitly reviewed and the criteria set is ready to close.',
+      }),
+    );
+
+    for (const phase of ['scope', 'design', 'requirements', 'criteria'] as const) {
+      expect(projectRes.body.workflow.phases[phase].status).toBe('closed');
+    }
+
+    const phaseOutcomes = db.$client
+      .prepare(
+        'SELECT phase, closure_basis FROM phase_outcome WHERE project_id = ? AND status = ? ORDER BY id',
+      )
+      .all(projectId, 'confirmed') as Array<{ phase: string; closure_basis: string | null }>;
+    expect(phaseOutcomes.map((o) => o.phase)).toEqual(['scope', 'design', 'requirements', 'criteria']);
+    expect(phaseOutcomes.at(-1)).toEqual({
+      phase: 'criteria',
+      closure_basis: 'interviewer_recommended',
+    });
+  });
+
+  it('projects no stale active interviewer phase after criteria closure confirmation', async () => {
+    const projectId = await createTestProject();
+    const seededCriteria = await seedCriteriaReady(projectId);
+    const { advanceHead, createKnowledgeItem, createPhaseOutcome, createTurn, linkKnowledgeItemToTurn } =
+      await import('./db.js');
+
+    const criterion = createKnowledgeItem(
+      db,
+      projectId,
+      'criterion',
+      'Markdown preview renders the reviewed requirements',
+    );
+
+    const reviewTurn = createTurn(db, projectId, {
+      phase: 'criteria',
+      parent_turn_id: seededCriteria.requirementsConfirmationTurn.id,
+      question: 'Review this criterion?',
+      answer: 'Approve',
+    });
+    linkKnowledgeItemToTurn(db, criterion.id, reviewTurn.id, 'reviewed');
+    advanceHead(db, projectId, reviewTurn.id);
+
+    const proposalTurn = createTurn(db, projectId, {
+      phase: 'criteria',
+      parent_turn_id: reviewTurn.id,
+      question: '',
+      answer: 'Close criteria',
+    });
+    advanceHead(db, projectId, proposalTurn.id);
+
+    createPhaseOutcome(db, {
+      projectId,
+      phase: 'criteria',
+      proposal_turn_id: proposalTurn.id,
+      summary: 'Criteria reviewed.',
+    });
+
+    await request(app)
+      .post(`/api/projects/${projectId}/chat`)
+      .send({
+        messages: [
+          {
+            id: 'u-criteria-final-confirm',
+            role: 'user',
+            parts: [
+              { type: 'text', text: 'Confirm criteria closure' },
+              {
+                type: 'data-confirmation',
+                data: {
+                  kind: 'confirm-proposed-phase-closure',
+                  proposalTurnId: proposalTurn.id,
+                  phase: 'criteria',
+                },
+              },
+            ],
+          },
+        ],
+      })
+      .expect(200);
+
+    const projectRes = await request(app).get(`/api/projects/${projectId}`).expect(200);
+    const allClosed = (['scope', 'design', 'requirements', 'criteria'] as const).every(
+      (phase) => projectRes.body.workflow.phases[phase].status === 'closed',
+    );
+    expect(allClosed).toBe(true);
+
+    const activePhases = (['scope', 'design', 'requirements', 'criteria'] as const).filter(
+      (phase) => projectRes.body.workflow.phases[phase].status === 'in_progress',
+    );
+    expect(activePhases).toEqual([]);
+  });
+
   it('force-closes design through the shared confirmation seam and enters requirements mode on the next turn', async () => {
     const projectId = await createTestProject();
     mockStreamInterviewer.mockImplementation(async (dbArg, turn) =>
@@ -1909,7 +2302,7 @@ describe('POST /api/projects/:id/turns/:turnId/response', () => {
         { content: 'Approve this requirement', is_recommended: true },
         { content: 'This requirement needs correction', is_recommended: false },
       ],
-      review: {
+      requirementReview: {
         kind: 'requirement-approval' as const,
         requirementId: approvedRequirement.id,
         approveOptionPosition: 0,
@@ -2009,7 +2402,7 @@ describe('POST /api/projects/:id/turns/:turnId/response', () => {
         { content: 'Reject this requirement', is_recommended: true },
         { content: 'Keep this requirement for now', is_recommended: false },
       ],
-      review: {
+      requirementReview: {
         kind: 'requirement-rejection' as const,
         requirementId: rejectedRequirement.id,
         rejectOptionPosition: 0,
@@ -2083,6 +2476,197 @@ describe('POST /api/projects/:id/turns/:turnId/response', () => {
     );
   });
 
+  it('persists explicit approved review state for a targeted criterion through the response seam', async () => {
+    const projectId = await createTestProject();
+    const seededCriteria = await seedCriteriaReady(projectId);
+    const { advanceHead, createKnowledgeItem, createOption, createTurn, updateTurn } =
+      await import('./db.js');
+
+    const approvedCriterion = createKnowledgeItem(
+      db,
+      projectId,
+      'criterion',
+      'Markdown preview renders the reviewed requirements',
+    );
+    const pendingCriterion = createKnowledgeItem(
+      db,
+      projectId,
+      'criterion',
+      'Restarting the browser resumes the active path',
+    );
+    const reviewInput = {
+      question: `Should we approve criterion [${approvedCriterion.id}] Markdown preview renders the reviewed requirements?`,
+      why: 'Criteria review should record explicit approval state one item at a time.',
+      impact: 'high' as const,
+      options: [
+        { content: 'Approve this criterion', is_recommended: true },
+        { content: 'This criterion needs correction', is_recommended: false },
+      ],
+      criterionReview: {
+        kind: 'criterion-approval' as const,
+        criterionId: approvedCriterion.id,
+        approveOptionPosition: 0,
+      },
+    };
+
+    const reviewTurn = createTurn(db, projectId, {
+      phase: 'criteria',
+      parent_turn_id: seededCriteria.requirementsConfirmationTurn.id,
+      question: reviewInput.question,
+      why: reviewInput.why,
+      impact: reviewInput.impact,
+      answer: '',
+    });
+    createOption(db, reviewTurn.id, {
+      position: 0,
+      content: 'Approve this criterion',
+      is_recommended: true,
+    });
+    createOption(db, reviewTurn.id, {
+      position: 1,
+      content: 'This criterion needs correction',
+      is_recommended: false,
+    });
+    updateTurn(db, reviewTurn.id, {
+      assistant_parts: JSON.stringify([
+        {
+          type: 'tool-ask_question',
+          toolCallId: 'tool-criterion-review',
+          state: 'output-available',
+          input: reviewInput,
+          output: { ok: true, turnId: reviewTurn.id, optionCount: reviewInput.options.length },
+        },
+      ]),
+    });
+    advanceHead(db, projectId, reviewTurn.id);
+
+    await request(app)
+      .post(`/api/projects/${projectId}/turns/${reviewTurn.id}/response`)
+      .send({ positions: [0] })
+      .expect(200);
+
+    const reviewedRows = db.$client
+      .prepare(
+        `SELECT item_id, turn_id, relation FROM turn_knowledge_item WHERE item_id = ? AND relation = 'reviewed'`,
+      )
+      .all(approvedCriterion.id) as Array<{ item_id: number; turn_id: number; relation: string }>;
+    expect(reviewedRows).toEqual([
+      {
+        item_id: approvedCriterion.id,
+        turn_id: reviewTurn.id,
+        relation: 'reviewed',
+      },
+    ]);
+
+    const projectRes = await request(app).get(`/api/projects/${projectId}`).expect(200);
+    expect(projectRes.body.workflow.phases.criteria).toEqual(
+      expect.objectContaining({
+        status: 'in_progress',
+        closeability: false,
+        proposalPending: false,
+      }),
+    );
+
+    const entitiesRes = await request(app).get(`/api/projects/${projectId}/entities`).expect(200);
+    expect(entitiesRes.body.criteria).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: approvedCriterion.id, reviewStatus: 'approved' }),
+        expect.objectContaining({ id: pendingCriterion.id, reviewStatus: 'pending' }),
+      ]),
+    );
+  });
+
+  it('persists explicit rejected review state for a targeted criterion through the response seam', async () => {
+    const projectId = await createTestProject();
+    const seededCriteria = await seedCriteriaReady(projectId);
+    const { advanceHead, createKnowledgeItem, createOption, createTurn, updateTurn } =
+      await import('./db.js');
+
+    const rejectedCriterion = createKnowledgeItem(
+      db,
+      projectId,
+      'criterion',
+      'PDF export renders the reviewed requirements',
+    );
+    const pendingCriterion = createKnowledgeItem(
+      db,
+      projectId,
+      'criterion',
+      'Restarting the browser resumes the active path',
+    );
+    const reviewInput = {
+      question: `Should we reject criterion [${rejectedCriterion.id}] PDF export renders the reviewed requirements?`,
+      why: 'Criteria review should record explicit rejection state one item at a time.',
+      impact: 'high' as const,
+      options: [
+        { content: 'Reject this criterion', is_recommended: true },
+        { content: 'Keep this criterion for now', is_recommended: false },
+      ],
+      criterionReview: {
+        kind: 'criterion-rejection' as const,
+        criterionId: rejectedCriterion.id,
+        rejectOptionPosition: 0,
+      },
+    };
+
+    const reviewTurn = createTurn(db, projectId, {
+      phase: 'criteria',
+      parent_turn_id: seededCriteria.requirementsConfirmationTurn.id,
+      question: reviewInput.question,
+      why: reviewInput.why,
+      impact: reviewInput.impact,
+      answer: '',
+    });
+    createOption(db, reviewTurn.id, {
+      position: 0,
+      content: 'Reject this criterion',
+      is_recommended: true,
+    });
+    createOption(db, reviewTurn.id, {
+      position: 1,
+      content: 'Keep this criterion for now',
+      is_recommended: false,
+    });
+    updateTurn(db, reviewTurn.id, {
+      assistant_parts: JSON.stringify([
+        {
+          type: 'tool-ask_question',
+          toolCallId: 'tool-criterion-review-reject',
+          state: 'output-available',
+          input: reviewInput,
+          output: { ok: true, turnId: reviewTurn.id, optionCount: reviewInput.options.length },
+        },
+      ]),
+    });
+    advanceHead(db, projectId, reviewTurn.id);
+
+    await request(app)
+      .post(`/api/projects/${projectId}/turns/${reviewTurn.id}/response`)
+      .send({ positions: [0] })
+      .expect(200);
+
+    const rejectedRows = db.$client
+      .prepare(
+        `SELECT item_id, turn_id, relation FROM turn_knowledge_item WHERE item_id = ? AND relation = 'rejected'`,
+      )
+      .all(rejectedCriterion.id) as Array<{ item_id: number; turn_id: number; relation: string }>;
+    expect(rejectedRows).toEqual([
+      {
+        item_id: rejectedCriterion.id,
+        turn_id: reviewTurn.id,
+        relation: 'rejected',
+      },
+    ]);
+
+    const entitiesRes = await request(app).get(`/api/projects/${projectId}/entities`).expect(200);
+    expect(entitiesRes.body.criteria).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: rejectedCriterion.id, reviewStatus: 'rejected' }),
+        expect.objectContaining({ id: pendingCriterion.id, reviewStatus: 'pending' }),
+      ]),
+    );
+  });
+
   it('round-trips structured turn responses through project reload, transcript hydration, and interviewer history', async () => {
     const projectId = await createTestProject();
     mockStreamInterviewer.mockImplementation(async (dbArg, turn) =>
diff --git a/src/server/app.ts b/src/server/app.ts
index 70b67b04..cdd5a18e 100644
--- a/src/server/app.ts
+++ b/src/server/app.ts
@@ -39,7 +39,7 @@ import {
   getOptionsForTurn,
   updateTurn,
   getEntitiesForProject,
-  recordRequirementReviewFromTurnResponse,
+  recordReviewFromTurnResponse,
 } from './db.js';
 import { persistFallbackQuestionText, streamInterviewer } from './interview.js';
 import { runObserver } from './observer.js';
@@ -115,7 +115,8 @@ export function createApp(dbPath?: string) {
       return;
     }
     applyTurnResponseSelections(db, turnId, uniquePositions);
-    recordRequirementReviewFromTurnResponse(db, turn, uniquePositions);
+    recordReviewFromTurnResponse(db, turn, uniquePositions, 'requirementReview', 'requirement');
+    recordReviewFromTurnResponse(db, turn, uniquePositions, 'criterionReview', 'criterion');
 
     const selectedOptionIds = selectedOptions.map((option) => option.id);
     const selectedOptionContents = selectedOptions.map((option) => option.content);
diff --git a/src/server/context.test.ts b/src/server/context.test.ts
index 90af62d1..89a1b259 100644
--- a/src/server/context.test.ts
+++ b/src/server/context.test.ts
@@ -213,6 +213,40 @@ describe('buildInterviewerContext', () => {
     expect(result).toContain('User: Q3?');
   });
 
+  it('includes the approved requirement inventory when criteria review is active', () => {
+    const turns: TurnWithOptions[] = [
+      {
+        id: 10,
+        project_id: 1,
+        parent_turn_id: 9,
+        phase: 'criteria',
+        question: 'What would prove the resume flow is complete?',
+        answer: 'It should restore the active path after restart.',
+        why: null,
+        impact: null,
+        is_resolution: false,
+        user_parts: null,
+        assistant_parts: null,
+        created_at: '2026-01-04',
+      },
+    ];
+
+    const result = buildInterviewerContext(turns, 'Propose a first criterion', {
+      phase: 'criteria',
+      entities: {
+        approvedRequirements: [
+          { id: 5, content: 'Resume the interview from SQLite after restart' },
+          { id: 7, content: 'Export the reviewed spec as markdown' },
+        ],
+      },
+    });
+
+    expect(result).toContain('Approved requirements for criteria review:');
+    expect(result).toContain('- [5] Resume the interview from SQLite after restart');
+    expect(result).toContain('- [7] Export the reviewed spec as markdown');
+    expect(result).toContain('User: Propose a first criterion');
+  });
+
   it('includes the current requirement inventory when requirements review is active', () => {
     const turns: TurnWithOptions[] = [
       {
diff --git a/src/server/context.ts b/src/server/context.ts
index d9a0d92b..1c58272b 100644
--- a/src/server/context.ts
+++ b/src/server/context.ts
@@ -8,9 +8,22 @@ interface InterviewerContextOptions {
   phase?: TurnWithOptions['phase'];
   entities?: {
     requirements?: Array<{ id: number; content: string }>;
+    approvedRequirements?: Array<{ id: number; content: string }>;
   };
 }
 
+function formatApprovedRequirementInventory(
+  approvedRequirements: NonNullable<InterviewerContextOptions['entities']>['approvedRequirements'],
+): string | null {
+  if (!approvedRequirements || approvedRequirements.length === 0) {
+    return null;
+  }
+
+  return `Approved requirements for criteria review:\n${approvedRequirements
+    .map((requirement) => `- [${requirement.id}] ${requirement.content}`)
+    .join('\n')}`;
+}
+
 function formatRequirementReviewInventory(
   requirements: NonNullable<InterviewerContextOptions['entities']>['requirements'],
 ): string | null {
@@ -72,6 +85,14 @@ export function buildInterviewerContext(
     sections.push(requirementInventory);
   }
 
+  const approvedRequirementInventory =
+    options.phase === 'criteria'
+      ? formatApprovedRequirementInventory(options.entities?.approvedRequirements)
+      : null;
+  if (approvedRequirementInventory) {
+    sections.push(approvedRequirementInventory);
+  }
+
   if (sections.length === 0) {
     return currentPrompt;
   }
diff --git a/src/server/db.test.ts b/src/server/db.test.ts
index 953d1878..5232d3f1 100644
--- a/src/server/db.test.ts
+++ b/src/server/db.test.ts
@@ -566,6 +566,245 @@ describe('phase outcome lifecycle', () => {
     });
   });
 
+  it('projects criterion review status as approved, rejected, or pending from the latest active-path action', async () => {
+    const project = getOrCreateProject(db);
+
+    const scopeTurn = createTurn(db, project.id, { phase: 'scope', question: 'Goal?', answer: 'Spec tool' });
+    advanceHead(db, project.id, scopeTurn.id);
+
+    const { createPhaseOutcome, confirmPhaseOutcome } = await import('./db.js');
+
+    const scopeOutcome = createPhaseOutcome(db, {
+      projectId: project.id,
+      phase: 'scope',
+      proposal_turn_id: scopeTurn.id,
+      summary: 'Scope captured.',
+    });
+    const scopeConfirmationTurn = createTurn(db, project.id, {
+      phase: 'scope',
+      parent_turn_id: scopeTurn.id,
+      question: '',
+      answer: 'Confirm scope closure',
+    });
+    confirmPhaseOutcome(db, scopeOutcome.id, scopeConfirmationTurn.id);
+    advanceHead(db, project.id, scopeConfirmationTurn.id);
+
+    const designTurn = createTurn(db, project.id, {
+      phase: 'design',
+      parent_turn_id: scopeConfirmationTurn.id,
+      question: 'Tradeoff?',
+      answer: 'Keep it small',
+    });
+    advanceHead(db, project.id, designTurn.id);
+
+    const designOutcome = createPhaseOutcome(db, {
+      projectId: project.id,
+      phase: 'design',
+      proposal_turn_id: designTurn.id,
+      summary: 'Design captured.',
+    });
+    const designConfirmationTurn = createTurn(db, project.id, {
+      phase: 'design',
+      parent_turn_id: designTurn.id,
+      question: '',
+      answer: 'Confirm design closure',
+    });
+    confirmPhaseOutcome(db, designOutcome.id, designConfirmationTurn.id);
+    advanceHead(db, project.id, designConfirmationTurn.id);
+
+    const requirement = createKnowledgeItem(db, project.id, 'requirement', 'Export the spec');
+    const reqReviewTurn = createTurn(db, project.id, {
+      phase: 'requirements',
+      parent_turn_id: designConfirmationTurn.id,
+      question: 'Review?',
+      answer: 'Approve',
+    });
+    linkKnowledgeItemToTurn(db, requirement.id, reqReviewTurn.id, 'reviewed');
+    advanceHead(db, project.id, reqReviewTurn.id);
+
+    const reqProposalTurn = createTurn(db, project.id, {
+      phase: 'requirements',
+      parent_turn_id: reqReviewTurn.id,
+      question: '',
+      answer: 'Close requirements',
+    });
+    advanceHead(db, project.id, reqProposalTurn.id);
+    const reqOutcome = createPhaseOutcome(db, {
+      projectId: project.id,
+      phase: 'requirements',
+      proposal_turn_id: reqProposalTurn.id,
+      summary: 'Requirements reviewed.',
+    });
+    const reqConfirmationTurn = createTurn(db, project.id, {
+      phase: 'requirements',
+      parent_turn_id: reqProposalTurn.id,
+      question: '',
+      answer: 'Confirm requirements closure',
+    });
+    confirmPhaseOutcome(db, reqOutcome.id, reqConfirmationTurn.id);
+    advanceHead(db, project.id, reqConfirmationTurn.id);
+
+    const approvedCriterion = createKnowledgeItem(
+      db,
+      project.id,
+      'criterion',
+      'Markdown preview renders the reviewed requirements',
+    );
+    const rejectedCriterion = createKnowledgeItem(
+      db,
+      project.id,
+      'criterion',
+      'PDF export renders the reviewed requirements',
+    );
+    const pendingCriterion = createKnowledgeItem(
+      db,
+      project.id,
+      'criterion',
+      'Restarting the browser resumes the active path',
+    );
+
+    const criteriaReviewTurn = createTurn(db, project.id, {
+      phase: 'criteria',
+      parent_turn_id: reqConfirmationTurn.id,
+      question: 'Review these criteria?',
+      answer: 'Approve markdown, reject PDF',
+    });
+    linkKnowledgeItemToTurn(db, approvedCriterion.id, criteriaReviewTurn.id, 'reviewed');
+    linkKnowledgeItemToTurn(db, rejectedCriterion.id, criteriaReviewTurn.id, 'rejected');
+    advanceHead(db, project.id, criteriaReviewTurn.id);
+
+    const entities = getEntitiesForProject(db, project.id);
+    expect(entities.criteria).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: approvedCriterion.id, reviewStatus: 'approved' }),
+        expect.objectContaining({ id: rejectedCriterion.id, reviewStatus: 'rejected' }),
+        expect.objectContaining({ id: pendingCriterion.id, reviewStatus: 'pending' }),
+      ]),
+    );
+  });
+
+  it('makes criteria closeable only when every criterion has explicit non-pending review state', async () => {
+    const project = getOrCreateProject(db);
+
+    const scopeTurn = createTurn(db, project.id, { phase: 'scope', question: 'Goal?', answer: 'Spec tool' });
+    advanceHead(db, project.id, scopeTurn.id);
+
+    const { createPhaseOutcome, confirmPhaseOutcome } = await import('./db.js');
+
+    const scopeOutcome = createPhaseOutcome(db, {
+      projectId: project.id,
+      phase: 'scope',
+      proposal_turn_id: scopeTurn.id,
+      summary: 'Scope captured.',
+    });
+    const scopeConfirmationTurn = createTurn(db, project.id, {
+      phase: 'scope',
+      parent_turn_id: scopeTurn.id,
+      question: '',
+      answer: 'Confirm scope closure',
+    });
+    confirmPhaseOutcome(db, scopeOutcome.id, scopeConfirmationTurn.id);
+    advanceHead(db, project.id, scopeConfirmationTurn.id);
+
+    const designTurn = createTurn(db, project.id, {
+      phase: 'design',
+      parent_turn_id: scopeConfirmationTurn.id,
+      question: 'Tradeoff?',
+      answer: 'Keep it small',
+    });
+    advanceHead(db, project.id, designTurn.id);
+
+    const designOutcome = createPhaseOutcome(db, {
+      projectId: project.id,
+      phase: 'design',
+      proposal_turn_id: designTurn.id,
+      summary: 'Design captured.',
+    });
+    const designConfirmationTurn = createTurn(db, project.id, {
+      phase: 'design',
+      parent_turn_id: designTurn.id,
+      question: '',
+      answer: 'Confirm design closure',
+    });
+    confirmPhaseOutcome(db, designOutcome.id, designConfirmationTurn.id);
+    advanceHead(db, project.id, designConfirmationTurn.id);
+
+    const requirement = createKnowledgeItem(db, project.id, 'requirement', 'Export the spec');
+    const reqReviewTurn = createTurn(db, project.id, {
+      phase: 'requirements',
+      parent_turn_id: designConfirmationTurn.id,
+      question: 'Review?',
+      answer: 'Approve',
+    });
+    linkKnowledgeItemToTurn(db, requirement.id, reqReviewTurn.id, 'reviewed');
+    advanceHead(db, project.id, reqReviewTurn.id);
+
+    const reqProposalTurn = createTurn(db, project.id, {
+      phase: 'requirements',
+      parent_turn_id: reqReviewTurn.id,
+      question: '',
+      answer: 'Close requirements',
+    });
+    advanceHead(db, project.id, reqProposalTurn.id);
+    const reqOutcome = createPhaseOutcome(db, {
+      projectId: project.id,
+      phase: 'requirements',
+      proposal_turn_id: reqProposalTurn.id,
+      summary: 'Requirements reviewed.',
+    });
+    const reqConfirmationTurn = createTurn(db, project.id, {
+      phase: 'requirements',
+      parent_turn_id: reqProposalTurn.id,
+      question: '',
+      answer: 'Confirm requirements closure',
+    });
+    confirmPhaseOutcome(db, reqOutcome.id, reqConfirmationTurn.id);
+    advanceHead(db, project.id, reqConfirmationTurn.id);
+
+    const criterion1 = createKnowledgeItem(
+      db,
+      project.id,
+      'criterion',
+      'Markdown preview renders the reviewed requirements',
+    );
+    const criterion2 = createKnowledgeItem(
+      db,
+      project.id,
+      'criterion',
+      'Restarting the browser resumes the active path',
+    );
+
+    const partialReviewTurn = createTurn(db, project.id, {
+      phase: 'criteria',
+      parent_turn_id: reqConfirmationTurn.id,
+      question: 'Review this criterion?',
+      answer: 'Approve markdown preview',
+    });
+    linkKnowledgeItemToTurn(db, criterion1.id, partialReviewTurn.id, 'reviewed');
+    advanceHead(db, project.id, partialReviewTurn.id);
+
+    expect(getCurrentWorkflowState(db, project.id).phases.criteria).toMatchObject({
+      status: 'in_progress',
+      closeability: false,
+      proposalPending: false,
+    });
+
+    const finalReviewTurn = createTurn(db, project.id, {
+      phase: 'criteria',
+      parent_turn_id: partialReviewTurn.id,
+      question: 'Review the remaining criterion?',
+      answer: 'Approve browser resume',
+    });
+    linkKnowledgeItemToTurn(db, criterion2.id, finalReviewTurn.id, 'reviewed');
+    advanceHead(db, project.id, finalReviewTurn.id);
+
+    expect(getCurrentWorkflowState(db, project.id).phases.criteria).toMatchObject({
+      status: 'in_progress',
+      closeability: true,
+      proposalPending: false,
+    });
+  });
+
   it('confirms a proposed requirements outcome, clears the pending proposal, and keeps criteria active', async () => {
     const project = getOrCreateProject(db);
 
diff --git a/src/server/db.ts b/src/server/db.ts
index d6dc5c05..2a136110 100644
--- a/src/server/db.ts
+++ b/src/server/db.ts
@@ -3,7 +3,7 @@ import { and, desc, eq, inArray, sql, type InferSelectModel } from 'drizzle-orm'
 import { drizzle } from 'drizzle-orm/better-sqlite3';
 import { migrate } from 'drizzle-orm/better-sqlite3/migrator';
 
-import { isAskQuestionUIPart, structuredQuestionSchema, type RequirementReview } from '../shared/chat.js';
+import { isAskQuestionUIPart, structuredQuestionSchema, type StructuredQuestion } from '../shared/chat.js';
 import {
   genericKnowledgeKindRegistry,
   type GenericKnowledgeCollectionKey,
@@ -355,6 +355,11 @@ function hasRequirementsReviewCoverage(db: DB, projectId: number): boolean {
   );
 }
 
+function hasCriteriaReviewCoverage(db: DB, projectId: number): boolean {
+  const criteria = getCriterionEntitiesForProject(db, projectId);
+  return criteria.length > 0 && criteria.every((criterion) => criterion.reviewStatus !== 'pending');
+}
+
 function getPhaseCloseability(
   db: DB,
   projectId: number,
@@ -371,7 +376,7 @@ function getPhaseCloseability(
   }
 
   if (phase === 'criteria') {
-    return false;
+    return hasCriteriaReviewCoverage(db, projectId);
   }
 
   return hasTurnHistory;
@@ -502,10 +507,14 @@ export interface EntityRelationship {
   target: EntityReference;
 }
 
-export type RequirementReviewStatus = 'approved' | 'rejected' | 'pending';
+export type ReviewStatus = 'approved' | 'rejected' | 'pending';
 
 export type RequirementEntity = KnowledgeItem & {
-  reviewStatus?: RequirementReviewStatus;
+  reviewStatus?: ReviewStatus;
+};
+
+export type CriterionEntity = KnowledgeItem & {
+  reviewStatus?: ReviewStatus;
 };
 
 export interface EntitiesForProject {
@@ -514,7 +523,7 @@ export interface EntitiesForProject {
   contexts: KnowledgeItem[];
   constraints: KnowledgeItem[];
   requirements: RequirementEntity[];
-  criteria: KnowledgeItem[];
+  criteria: CriterionEntity[];
   decisions: Decision[];
   assumptions: Assumption[];
   relationships: EntityRelationship[];
@@ -661,10 +670,11 @@ function getEntityCollectionForKind(kind: KnowledgeKind): EntityCollection {
   return 'knowledge_item';
 }
 
-function getRequirementReviewStatusesOnActivePath(
+function getReviewStatusesOnActivePath(
   db: DB,
   projectId: number,
-): Map<number, RequirementReviewStatus> {
+  kind: 'requirement' | 'criterion',
+): Map<number, ReviewStatus> {
   const activePath = getActivePath(db, projectId);
   if (activePath.length === 0) {
     return new Map();
@@ -683,7 +693,7 @@ function getRequirementReviewStatusesOnActivePath(
     .where(
       and(
         eq(schema.knowledgeItem.project_id, projectId),
-        eq(schema.knowledgeItem.kind, 'requirement'),
+        eq(schema.knowledgeItem.kind, kind),
         inArray(schema.turnKnowledgeItem.relation, ['reviewed', 'rejected']),
         inArray(schema.turnKnowledgeItem.turn_id, activeTurnIds),
       ),
@@ -692,7 +702,7 @@ function getRequirementReviewStatusesOnActivePath(
 
   reviewRows.sort((left, right) => (turnOrder.get(left.turnId) ?? 0) - (turnOrder.get(right.turnId) ?? 0));
 
-  const statuses = new Map<number, RequirementReviewStatus>();
+  const statuses = new Map<number, ReviewStatus>();
   for (const row of reviewRows) {
     statuses.set(row.itemId, row.relation === 'reviewed' ? 'approved' : 'rejected');
   }
@@ -701,60 +711,75 @@ function getRequirementReviewStatusesOnActivePath(
 }
 
 function getRequirementEntitiesForProject(db: DB, projectId: number): RequirementEntity[] {
-  const requirementReviewStatuses = getRequirementReviewStatusesOnActivePath(db, projectId);
+  const reviewStatuses = getReviewStatusesOnActivePath(db, projectId, 'requirement');
   return getKnowledgeItemsForProjectByKind(db, projectId, 'requirement').map((item) => ({
     ...item,
-    reviewStatus: requirementReviewStatuses.get(item.id) ?? 'pending',
+    reviewStatus: reviewStatuses.get(item.id) ?? 'pending',
   }));
 }
 
-function getRequirementReview(turn: Pick<Turn, 'assistant_parts'>): RequirementReview | null {
+function getCriterionEntitiesForProject(db: DB, projectId: number): CriterionEntity[] {
+  const reviewStatuses = getReviewStatusesOnActivePath(db, projectId, 'criterion');
+  return getKnowledgeItemsForProjectByKind(db, projectId, 'criterion').map((item) => ({
+    ...item,
+    reviewStatus: reviewStatuses.get(item.id) ?? 'pending',
+  }));
+}
+
+function getReviewFromTurn<F extends 'requirementReview' | 'criterionReview'>(
+  turn: Pick<Turn, 'assistant_parts'>,
+  field: F,
+): NonNullable<StructuredQuestion[F]> | null {
   for (const part of safeDeserializeAssistantParts(turn.assistant_parts)) {
     if (!isAskQuestionUIPart(part) || !('input' in part)) {
       continue;
     }
 
     const parsedInput = structuredQuestionSchema.safeParse(part.input);
-    if (!parsedInput.success || !parsedInput.data.review) {
+    if (!parsedInput.success || !parsedInput.data[field]) {
       continue;
     }
 
-    return parsedInput.data.review;
+    return parsedInput.data[field];
   }
 
   return null;
 }
 
-export function recordRequirementReviewFromTurnResponse(
+export function recordReviewFromTurnResponse(
   db: DB,
   turn: Turn,
   selectedPositions: number[],
+  field: 'requirementReview' | 'criterionReview',
+  kind: 'requirement' | 'criterion',
 ): void {
-  const review = getRequirementReview(turn);
+  const review = getReviewFromTurn(turn, field);
   if (!review) {
     return;
   }
 
   const selectedReviewOptionPosition =
-    review.kind === 'requirement-approval' ? review.approveOptionPosition : review.rejectOptionPosition;
+    'approveOptionPosition' in review ? review.approveOptionPosition : review.rejectOptionPosition;
   if (!selectedPositions.includes(selectedReviewOptionPosition)) {
     return;
   }
 
-  const requirement = db
-    .select()
-    .from(schema.knowledgeItem)
-    .where(eq(schema.knowledgeItem.id, review.requirementId))
-    .get() as KnowledgeItem | undefined;
-  if (!requirement || requirement.project_id !== turn.project_id || requirement.kind !== 'requirement') {
+  const entityId =
+    kind === 'requirement'
+      ? (review as { requirementId: number }).requirementId
+      : (review as { criterionId: number }).criterionId;
+  const entity = db.select().from(schema.knowledgeItem).where(eq(schema.knowledgeItem.id, entityId)).get() as
+    | KnowledgeItem
+    | undefined;
+  if (!entity || entity.project_id !== turn.project_id || entity.kind !== kind) {
     return;
   }
 
   linkKnowledgeItemToTurn(
     db,
-    requirement.id,
+    entity.id,
     turn.id,
-    review.kind === 'requirement-approval' ? 'reviewed' : 'rejected',
+    'approveOptionPosition' in review ? 'reviewed' : 'rejected',
   );
 }
 
@@ -773,7 +798,9 @@ export function getEntitiesForProject(db: DB, projectId: number): EntitiesForPro
       entry.collectionKey,
       entry.kind === 'requirement'
         ? getRequirementEntitiesForProject(db, projectId)
-        : getKnowledgeItemsForProjectByKind(db, projectId, entry.kind),
+        : entry.kind === 'criterion'
+          ? getCriterionEntitiesForProject(db, projectId)
+          : getKnowledgeItemsForProjectByKind(db, projectId, entry.kind),
     ]),
   ) as Pick<EntitiesForProject, GenericKnowledgeCollectionKey>;
   const decisions = getKnowledgeItemsForProjectByKind(db, projectId, 'decision').map(toDecision);
diff --git a/src/server/interview.ts b/src/server/interview.ts
index f81380ca..93f3fceb 100644
--- a/src/server/interview.ts
+++ b/src/server/interview.ts
@@ -169,17 +169,27 @@ export async function streamInterviewer(
   phase: Phase,
 ) {
   const agent = createInterviewerAgent(db, turn.id, phase, turn.project_id);
+  const entities = getEntitiesForProject(db, turn.project_id);
   const fullPrompt = buildInterviewerContext(activePath, userMessage, {
     phase,
     entities:
       phase === 'requirements'
         ? {
-            requirements: getEntitiesForProject(db, turn.project_id).requirements.map((requirement) => ({
+            requirements: entities.requirements.map((requirement) => ({
               id: requirement.id,
               content: requirement.content,
             })),
           }
-        : undefined,
+        : phase === 'criteria'
+          ? {
+              approvedRequirements: entities.requirements
+                .filter((requirement) => requirement.reviewStatus === 'approved')
+                .map((requirement) => ({
+                  id: requirement.id,
+                  content: requirement.content,
+                })),
+            }
+          : undefined,
   });
   return agent.stream({
     prompt: fullPrompt,
diff --git a/src/shared/chat.ts b/src/shared/chat.ts
index 4345bced..8c3c9d88 100644
--- a/src/shared/chat.ts
+++ b/src/shared/chat.ts
@@ -21,6 +21,39 @@ export const requirementReviewSchema = z.union([
   requirementRejectionReviewSchema,
 ]);
 
+export const criterionApprovalReviewSchema = z.object({
+  kind: z.literal('criterion-approval'),
+  criterionId: z.number().int().positive(),
+  approveOptionPosition: z.number().int().min(0),
+});
+
+export const criterionRejectionReviewSchema = z.object({
+  kind: z.literal('criterion-rejection'),
+  criterionId: z.number().int().positive(),
+  rejectOptionPosition: z.number().int().min(0),
+});
+
+export const criterionReviewSchema = z.union([criterionApprovalReviewSchema, criterionRejectionReviewSchema]);
+
+function validateReviewOptionPosition(
+  review: { approveOptionPosition?: number; rejectOptionPosition?: number },
+  field: string,
+  optionCount: number,
+  ctx: z.RefinementCtx,
+): void {
+  const isApproval = 'approveOptionPosition' in review;
+  const position = isApproval ? review.approveOptionPosition! : review.rejectOptionPosition!;
+  const positionField = isApproval ? 'approveOptionPosition' : 'rejectOptionPosition';
+
+  if (position >= optionCount) {
+    ctx.addIssue({
+      code: 'custom',
+      message: `${field}.${positionField} must reference an existing option`,
+      path: [field, positionField],
+    });
+  }
+}
+
 export const structuredQuestionSchema = z
   .object({
     question: z.string().min(1),
@@ -34,30 +67,15 @@ export const structuredQuestionSchema = z
         }),
       )
       .min(2),
-    review: requirementReviewSchema.optional(),
+    requirementReview: requirementReviewSchema.optional(),
+    criterionReview: criterionReviewSchema.optional(),
   })
   .superRefine((value, ctx) => {
-    if (!value.review) {
-      return;
+    if (value.requirementReview) {
+      validateReviewOptionPosition(value.requirementReview, 'requirementReview', value.options.length, ctx);
     }
-
-    const reviewOptionPosition =
-      value.review.kind === 'requirement-approval'
-        ? value.review.approveOptionPosition
-        : value.review.rejectOptionPosition;
-
-    if (!value.options[reviewOptionPosition]) {
-      ctx.addIssue({
-        code: 'custom',
-        message:
-          value.review.kind === 'requirement-approval'
-            ? 'review.approveOptionPosition must reference an existing option'
-            : 'review.rejectOptionPosition must reference an existing option',
-        path: [
-          'review',
-          value.review.kind === 'requirement-approval' ? 'approveOptionPosition' : 'rejectOptionPosition',
-        ],
-      });
+    if (value.criterionReview) {
+      validateReviewOptionPosition(value.criterionReview, 'criterionReview', value.options.length, ctx);
     }
   });
 
@@ -108,6 +126,9 @@ export { dataConfirmationSchema };
 export type RequirementApprovalReview = z.infer<typeof requirementApprovalReviewSchema>;
 export type RequirementRejectionReview = z.infer<typeof requirementRejectionReviewSchema>;
 export type RequirementReview = z.infer<typeof requirementReviewSchema>;
+export type CriterionApprovalReview = z.infer<typeof criterionApprovalReviewSchema>;
+export type CriterionRejectionReview = z.infer<typeof criterionRejectionReviewSchema>;
+export type CriterionReview = z.infer<typeof criterionReviewSchema>;
 export type StructuredQuestion = z.infer<typeof structuredQuestionSchema>;
 export type AskQuestionToolOutput = z.infer<typeof askQuestionToolOutputSchema>;
 export type ObserverResultData = z.infer<typeof observerResultSchema>;