From 24ff6df825edc998aa115a7c3d696855f501aaea Mon Sep 17 00:00:00 2001
From: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
Date: Thu, 29 Oct 2026 11:02:07 -0400
Subject: [PATCH 01/18] Bind approvals to current content and review cycles

---
 ..._bind_review_cycles_to_versions.co_plan.rb |  27 ++++
 db/schema.rb                                  |  10 +-
 docs/DEMO_LIBRARY.md                          |   2 +
 docs/REVIEWS.md                               |  33 +++++
 .../coplan/api/v1/operations_controller.rb    |   5 +-
 .../coplan/api/v1/plans_controller.rb         |  13 +-
 .../api/v1/review_requests_controller.rb      |  11 +-
 .../coplan/review_requests_controller.rb      |  13 +-
 .../coplan/review_tray_controller.js          |  32 +++--
 engine/app/models/coplan/plan_version.rb      |  16 +++
 engine/app/models/coplan/review_request.rb    |  22 +++-
 .../services/coplan/plans/advance_version.rb  |  30 +++++
 .../services/coplan/plans/commit_session.rb   |   5 +-
 engine/app/services/coplan/plans/create.rb    |   2 +-
 .../services/coplan/plans/replace_content.rb  |   5 +-
 .../services/coplan/plans/toggle_checkbox.rb  |   2 +-
 .../app/services/coplan/reviews/evidence.rb   |  27 ++++
 .../services/coplan/reviews/record_request.rb |   2 +-
 engine/app/services/coplan/reviews/request.rb |   4 +-
 engine/app/services/coplan/reviews/respond.rb |  33 +++--
 .../app/services/coplan/reviews/serialize.rb  |  14 +-
 .../app/services/coplan/reviews/withdraw.rb   |   5 +-
 .../agent_instructions/guides/api.text.erb    |   6 +-
 .../guides/comments.text.erb                  |   4 +-
 .../agent_instructions/guides/live.text.erb   |   1 +
 .../views/coplan/plan_versions/show.html.erb  |   3 +
 .../views/coplan/reviews/_activity.html.erb   |   2 +-
 .../views/coplan/reviews/_controls.html.erb   |  16 ++-
 engine/app/views/coplan/reviews/_log.html.erb |   1 +
 .../app/views/coplan/reviews/_roster.html.erb |   6 +-
 .../app/views/coplan/reviews/_table.html.erb  |   4 +-
 engine/config/routes.rb                       |   2 +
 engine/db/demo/content/changed-review.md      |   5 +
 ...29000000_bind_review_cycles_to_versions.rb |  26 ++++
 engine/lib/coplan/development_seed.rb         |  12 +-
 spec/helpers/application_helper_spec.rb       |   4 +-
 spec/helpers/plans_helper_spec.rb             |   8 +-
 spec/lib/development_seed_spec.rb             |   7 +
 spec/models/plan_version_spec.rb              |  17 +++
 spec/requests/api/v1/operations_spec.rb       |   2 +-
 spec/requests/api/v1/review_evidence_spec.rb  |  55 ++++++++
 spec/requests/api/v1/review_requests_spec.rb  |   2 +-
 .../changed_sections_highlight_spec.rb        |   4 +-
 spec/requests/human_document_editor_spec.rb   |   2 +-
 spec/requests/plan_content_editing_spec.rb    |   2 +-
 spec/requests/plan_versions_spec.rb           |   2 +-
 spec/requests/plans_spec.rb                   |  10 +-
 spec/requests/review_requests_spec.rb         |  11 +-
 spec/requests/toggle_checkbox_spec.rb         |   4 +-
 spec/services/broadcaster_spec.rb             |   4 +-
 .../references/extract_from_content_spec.rb   |   4 +-
 .../coplan/review_concurrency_spec.rb         |  83 ++++++++++++
 spec/services/coplan/reviews_spec.rb          |  15 ++-
 .../services/coplan/versioned_reviews_spec.rb | 121 ++++++++++++++++++
 spec/services/link_previews_spec.rb           |   4 +-
 spec/services/plans/section_updates_spec.rb   |   2 +-
 spec/support/version_fixtures.rb              |  12 ++
 spec/system/changed_sections_ux_spec.rb       |   2 +-
 spec/system/checkbox_spec.rb                  |   4 +-
 spec/system/comment_ux_spec.rb                |  18 +--
 spec/system/folders_workspace_spec.rb         |   2 +-
 spec/system/plan_reviews_spec.rb              |  62 ++++++++-
 62 files changed, 740 insertions(+), 124 deletions(-)
 create mode 100644 db/migrate/20261029141536_bind_review_cycles_to_versions.co_plan.rb
 create mode 100644 docs/REVIEWS.md
 create mode 100644 engine/app/services/coplan/plans/advance_version.rb
 create mode 100644 engine/app/services/coplan/reviews/evidence.rb
 create mode 100644 engine/db/demo/content/changed-review.md
 create mode 100644 engine/db/migrate/20261029000000_bind_review_cycles_to_versions.rb
 create mode 100644 spec/requests/api/v1/review_evidence_spec.rb
 create mode 100644 spec/services/coplan/review_concurrency_spec.rb
 create mode 100644 spec/services/coplan/versioned_reviews_spec.rb
 create mode 100644 spec/support/version_fixtures.rb

diff --git a/db/migrate/20261029141536_bind_review_cycles_to_versions.co_plan.rb b/db/migrate/20261029141536_bind_review_cycles_to_versions.co_plan.rb
new file mode 100644
index 00000000..ceff6de7
--- /dev/null
+++ b/db/migrate/20261029141536_bind_review_cycles_to_versions.co_plan.rb
@@ -0,0 +1,27 @@
+# This migration comes from co_plan (originally 20261029000000)
+class BindReviewCyclesToVersions < ActiveRecord::Migration[8.1]
+  def up
+    add_column :coplan_plans, :review_sequence, :bigint, null: false, default: 0
+    add_column :coplan_review_requests, :generation, :bigint, null: false, default: 1
+    add_column :coplan_review_requests, :current_response_id, :string, limit: 36
+    add_column :coplan_review_requests, :reset_reason, :string
+    add_column :coplan_review_responses, :request_generation, :bigint
+    add_column :coplan_review_responses, :decision_sequence, :bigint
+    add_index :coplan_review_requests, :current_response_id
+    add_foreign_key :coplan_review_requests, :coplan_review_responses, column: :current_response_id, on_delete: :nullify
+    # Old timestamps cannot prove which request cycle a response completed.
+    # Keep those receipts as history; require a fresh decision for active tasks.
+    execute "UPDATE coplan_review_requests SET generation = 2"
+    execute "UPDATE coplan_review_requests SET status = 'pending', reset_reason = 'legacy_history' WHERE status <> 'withdrawn'"
+  end
+
+  def down
+    remove_foreign_key :coplan_review_requests, column: :current_response_id
+    remove_column :coplan_review_requests, :current_response_id
+    remove_column :coplan_review_requests, :generation
+    remove_column :coplan_review_requests, :reset_reason
+    remove_column :coplan_review_responses, :request_generation
+    remove_column :coplan_review_responses, :decision_sequence
+    remove_column :coplan_plans, :review_sequence
+  end
+end
diff --git a/db/schema.rb b/db/schema.rb
index a954c7a9..65543fc8 100644
--- a/db/schema.rb
+++ b/db/schema.rb
@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema[8.1].define(version: 2026_10_19_185311) do
+ActiveRecord::Schema[8.1].define(version: 2026_10_29_141536) do
   create_table "active_admin_comments", id: { type: :string, limit: 36 }, charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
     t.bigint "author_id"
     t.string "author_type"
@@ -411,6 +411,7 @@
     t.integer "current_revision", default: 0, null: false
     t.json "metadata"
     t.string "plan_type_id", limit: 36, null: false
+    t.bigint "review_sequence", default: 0, null: false
     t.text "search_text", size: :medium
     t.string "slug", null: false
     t.string "slug_suffix", limit: 8
@@ -454,14 +455,18 @@
 
   create_table "coplan_review_requests", id: { type: :string, limit: 36 }, charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
     t.datetime "created_at", null: false
+    t.string "current_response_id", limit: 36
+    t.bigint "generation", default: 1, null: false
     t.string "plan_id", limit: 36, null: false
     t.datetime "requested_at", null: false
     t.string "requested_by_user_id", limit: 36, null: false
     t.string "requested_plan_version_id", limit: 36, null: false
     t.string "requirement", null: false
+    t.string "reset_reason"
     t.string "reviewer_id", limit: 36, null: false
     t.string "status", null: false
     t.datetime "updated_at", null: false
+    t.index ["current_response_id"], name: "index_coplan_review_requests_on_current_response_id"
     t.index ["plan_id", "reviewer_id"], name: "index_coplan_review_requests_on_plan_id_and_reviewer_id", unique: true
     t.index ["requested_by_user_id"], name: "fk_rails_c5db6a7f68"
     t.index ["requested_plan_version_id"], name: "fk_rails_9648b04dbb"
@@ -475,8 +480,10 @@
     t.string "comment_thread_id", limit: 36
     t.datetime "created_at", null: false
     t.string "decision", null: false
+    t.bigint "decision_sequence"
     t.text "note"
     t.string "plan_version_id", limit: 36, null: false
+    t.bigint "request_generation"
     t.string "review_request_id", limit: 36, null: false
     t.string "user_id", limit: 36, null: false
     t.index ["api_token_id"], name: "fk_rails_edc220f557"
@@ -603,6 +610,7 @@
   add_foreign_key "coplan_references", "coplan_plans", column: "target_plan_id"
   add_foreign_key "coplan_review_requests", "coplan_plan_versions", column: "requested_plan_version_id"
   add_foreign_key "coplan_review_requests", "coplan_plans", column: "plan_id"
+  add_foreign_key "coplan_review_requests", "coplan_review_responses", column: "current_response_id", on_delete: :nullify
   add_foreign_key "coplan_review_requests", "coplan_users", column: "requested_by_user_id"
   add_foreign_key "coplan_review_requests", "coplan_users", column: "reviewer_id"
   add_foreign_key "coplan_review_responses", "coplan_api_tokens", column: "api_token_id", on_delete: :nullify
diff --git a/docs/DEMO_LIBRARY.md b/docs/DEMO_LIBRARY.md
index 914e979a..fe0014ca 100644
--- a/docs/DEMO_LIBRARY.md
+++ b/docs/DEMO_LIBRARY.md
@@ -37,6 +37,8 @@ install demo users or documents.
 
 ## Named scenarios
 
+The **Workspace invitations: review dismissed after edits** scenario keeps v1 approvals as history while v2 awaits fresh review. Sign in as Alex to approve v2, or Hampton to edit it again. See [Version-bound reviews](REVIEWS.md) for the source scope and lifecycle contract.
+
 The index starts with **Diagrams**, **Presentations**, **Tables and rich text**,
 and **References**. Every link labels the document's actual plan type. The
 **Every plan type** section links to a real example of each of the twelve
diff --git a/docs/REVIEWS.md b/docs/REVIEWS.md
new file mode 100644
index 00000000..048b10a8
--- /dev/null
+++ b/docs/REVIEWS.md
@@ -0,0 +1,33 @@
+# Version-bound reviews
+
+A native review means satisfaction with a specific Markdown source version. It grants no execution authority or permissions. An agent response remains an agent response attributed to its human principal; it is never a human sign-off.
+
+## Content and decision identity
+
+Responses retain `plan_version_id`, that version’s SHA-256, `request_generation`, and a server-assigned `decision_sequence`. UUIDs identify transport retries; they do not order decisions. A request’s `current_response_id` is the authoritative projection. A response is effective only when it belongs to that request, generation and current plan version and matches the task status. `effective_human_decision` is null for pending, withdrawn, dismissed or agent decisions. `latest_approval` is positive history for comparison, not qualification.
+
+The approval covers **Markdown source bytes only**. Title, tags, attachments, linked and embedded resources, child plans, and rendered output are excluded. URLs and embedded source syntax are approved as literal text, not as the bytes they might display. Historical pages expose exact source and hash and label the current title as metadata. Full rich-page approval requires a separate immutable asset envelope and renderer contract.
+
+## Edits and cycles
+
+All current-version writers use `Plans::AdvanceVersion`: Create, ReplaceContent (including SaveHumanDraft/web saves), CommitSession, ToggleCheckbox and the direct operations API. They already hold the plan row lock; CommitSession retains session-before-plan lock order. The version pointer, revision, review sequence, active task resets, generation increments and cleared current pointers commit together. Withdrawn tasks and all receipts remain intact. Resets broadcast after commit without sending a review-request notification for every edit.
+
+An identical normalized ReplaceContent save creates no version and preserves approval. An empty session creates no version. A nonempty session or operations commit creates a new version even if its operations net to identical bytes, and dismisses decisions. Returning A→B→A always produces a distinct version and requires fresh review. Existing edit leases, human-edit fences and merge guards remain in place.
+
+An explicit re-request advances the task generation and clears its effective decision. Creating an already existing request is a retry and leaves its state alone. Withdrawal clears the effective decision and preserves receipts. A fresh response supersedes the previous effective response, including a later agent response. The latest sequenced human response on the current version is exposed separately so consumers can inspect human feedback across request cycles; native CoPlan does not impose an external approval or objection policy.
+
+New responses send the viewed revision, fetched generation and a fresh UUID `idempotency_key`. Stale revisions or generations fail with 409. Repeating a recorded key returns its immutable receipt without touching status, current pointer, sequence, attribution or notifications, even after an edit, withdrawal or re-request. Unkeyed identical legacy retries return history too. First-cycle clients may omit generation; subsequent cycles require it, including first-seen delayed keyed submissions. A fresh intentional identical response needs a new key and the current generation.
+
+## Reads and compatibility
+
+`GET /api/v1/plans/:id/review_evidence` takes one plan-row transaction and returns exact current source/hash/version, scope, review sequence, current projection and complete response history. It creates no PlanRead or agent session. Ordinary authentication may still update token usage. The review sequence covers body and native review changes, not excluded metadata, sharing or external authorization. Existing snapshot reads retain their older behavior; consumers requiring coherent evidence use this endpoint.
+
+`GET /api/v1/plans/:id/versions/:version_id` returns that exact historical Markdown and hash. It never substitutes the current version. Both endpoints use existing Bearer authentication and visibility rules; neither establishes a read-only workload credential or employee identity mapping.
+
+Migration preserves old receipts with unknown generation/sequence. Existing active tasks become pending with `reset_reason=legacy_history`; withdrawn tasks stay withdrawn. Existing tasks enter generation 2 so first-seen old requests without a cycle cannot complete them. No timestamp or UUID ordering is used to invent legacy effective approvals. Hosts must install the engine migration and update clients to send generation. Downgrading drops the new projection but does not restore prior statuses.
+
+Persisted version IDs, plan IDs, revisions, Markdown and hashes reject ordinary Rails mutation, including `update_columns`. Writing provenance backfills remain supported. Hashes are checked at creation and before new responses or source evidence reads. These are application guarantees, not database/WORM protection against administrator SQL, bulk writes or deletion.
+
+## Local tryout
+
+Seed the shared demo library with `bin/rails coplan:demo:seed`. Sign in as `alex@example.com` and open **Workspace invitations: review dismissed after edits** in Hampton’s Demo scenarios. v1 approvals are history, v2 is pending, and the activity link opens the original source. Approve v2, then sign in as `hampton@example.com` and edit its body or toggle its checkbox. Alex’s task returns to pending. Re-seeding preserves edits and decisions.
diff --git a/engine/app/controllers/coplan/api/v1/operations_controller.rb b/engine/app/controllers/coplan/api/v1/operations_controller.rb
index 4086251b..7b83fb57 100644
--- a/engine/app/controllers/coplan/api/v1/operations_controller.rb
+++ b/engine/app/controllers/coplan/api/v1/operations_controller.rb
@@ -230,10 +230,7 @@ def commit_version(current_content, result)
             reason: params[:reason]
           )
 
-          @plan.update!(
-            current_plan_version: version,
-            current_revision: new_revision
-          )
+          Plans::AdvanceVersion.call(plan: @plan, version: version)
 
           @plan.comment_threads.mark_out_of_date_for_new_version!(version)
 
diff --git a/engine/app/controllers/coplan/api/v1/plans_controller.rb b/engine/app/controllers/coplan/api/v1/plans_controller.rb
index fb7cc2ab..29f0bb56 100644
--- a/engine/app/controllers/coplan/api/v1/plans_controller.rb
+++ b/engine/app/controllers/coplan/api/v1/plans_controller.rb
@@ -2,8 +2,8 @@ module CoPlan
   module Api
     module V1
       class PlansController < BaseController
-        before_action :set_plan, only: [ :show, :update, :versions, :comments, :snapshot, :locations, :writing_provenance ]
-        before_action :authorize_plan_access!, only: [ :show, :update, :versions, :comments, :snapshot, :locations, :writing_provenance ]
+        before_action :set_plan, only: [ :show, :update, :version, :versions, :comments, :snapshot, :review_evidence, :locations, :writing_provenance ]
+        before_action :authorize_plan_access!, only: [ :show, :update, :version, :versions, :comments, :snapshot, :review_evidence, :locations, :writing_provenance ]
 
         def index
           plans = Plan
@@ -270,6 +270,11 @@ def update
           render json: { error: e.record.errors.full_messages.join(", ") }, status: :unprocessable_content
         end
 
+        def version
+          version = @plan.plan_versions.find(params[:version_id])
+          render json: version_json(version).merge(content_markdown: version.verified_content!, approval_scope: Reviews::Evidence::SCOPE)
+        end
+
         def versions
           versions = @plan.plan_versions.order(revision: :desc)
           render json: versions.map { |v| version_json(v) }
@@ -307,6 +312,10 @@ def comments
           render json: threads.map { |t| thread_json(t) }
         end
 
+        def review_evidence
+          render json: Reviews::Evidence.call(plan: @plan)
+        end
+
         def snapshot
           record_plan_read!(@plan)
           threads = @plan.comment_threads.includes(:comments, :created_by_user).order(created_at: :desc)
diff --git a/engine/app/controllers/coplan/api/v1/review_requests_controller.rb b/engine/app/controllers/coplan/api/v1/review_requests_controller.rb
index c9b9d4da..015761d5 100644
--- a/engine/app/controllers/coplan/api/v1/review_requests_controller.rb
+++ b/engine/app/controllers/coplan/api/v1/review_requests_controller.rb
@@ -37,7 +37,10 @@ def update
             Reviews::Request.call(plan: @plan, reviewer: @review_request.reviewer, actor: current_user,
               requirement: params[:requirement].presence || @review_request.requirement, api_token: @api_token)
           else
-            @plan.with_lock { @review_request.update!(requirement: params.require(:requirement)) }
+            @plan.with_lock do
+              @review_request.update!(requirement: params.require(:requirement))
+              @plan.update!(review_sequence: @plan.review_sequence + 1)
+            end
             Reviews::Changed.call(request: @review_request, event_type: "review.requested", actor_token_id: api_token_id,
               payload: { "action" => "requirement_changed", "requirement" => @review_request.requirement })
           end
@@ -54,10 +57,12 @@ def respond
             return render json: { error: "Only the requested reviewer can respond" }, status: :forbidden
           end
           response = Reviews::Respond.call(request: @review_request, actor: current_user,
-            revision: params.require(:revision), decision: params.require(:decision), note: params[:note], api_token: @api_token, idempotency_key: params[:idempotency_key])
+            revision: params.require(:revision), decision: params.require(:decision), note: params[:note], api_token: @api_token, idempotency_key: params[:idempotency_key], generation: params[:generation])
           render json: { id: response.id, decision: response.decision, revision: response.plan_version.revision,
                          actor_type: response.actor_type, agent_name: response.agent_name,
-                         comment_thread_id: response.comment_thread_id }, status: :created
+                         comment_thread_id: response.comment_thread_id, plan_version_id: response.plan_version_id,
+                     content_sha256: response.plan_version.content_sha256, generation: response.request_generation,
+                     decision_sequence: response.decision_sequence, effective: @review_request.reload.effective_response&.id == response.id }, status: :created
         end
 
         private
diff --git a/engine/app/controllers/coplan/review_requests_controller.rb b/engine/app/controllers/coplan/review_requests_controller.rb
index f62be26d..dfd31bf7 100644
--- a/engine/app/controllers/coplan/review_requests_controller.rb
+++ b/engine/app/controllers/coplan/review_requests_controller.rb
@@ -31,7 +31,10 @@ def update
         Reviews::Request.call(plan: @plan, reviewer: @review_request.reviewer, actor: current_user,
           requirement: attributes[:requirement].presence || @review_request.requirement)
       else
-        @plan.with_lock { @review_request.update!(requirement: attributes.fetch(:requirement)) }
+        @plan.with_lock do
+          @review_request.update!(requirement: attributes.fetch(:requirement))
+          @plan.update!(review_sequence: @plan.review_sequence + 1)
+        end
         Reviews::Changed.call(request: @review_request, event_type: "review.requested",
           payload: { "action" => "requirement_changed", "requirement" => @review_request.requirement })
       end
@@ -46,11 +49,13 @@ def destroy
 
     def respond
       raise NotAuthorizedError unless @review_request.reviewer_id == current_user.id
-      attributes = params.expect(review_response: [ :revision, :decision, :note, :idempotency_key ])
+      attributes = params.expect(review_response: [ :revision, :decision, :note, :idempotency_key, :generation ])
       response = Reviews::Respond.call(request: @review_request, actor: current_user,
-        revision: attributes[:revision], decision: attributes[:decision], note: attributes[:note], idempotency_key: attributes[:idempotency_key])
+        revision: attributes[:revision], decision: attributes[:decision], note: attributes[:note], idempotency_key: attributes[:idempotency_key], generation: attributes[:generation])
       render json: { id: response.id, decision: response.decision, revision: response.plan_version.revision,
-                     comment_thread_id: response.comment_thread_id }, status: :created
+                     comment_thread_id: response.comment_thread_id, plan_version_id: response.plan_version_id,
+                     content_sha256: response.plan_version.content_sha256, generation: response.request_generation,
+                     decision_sequence: response.decision_sequence, effective: @review_request.reload.effective_response&.id == response.id }, status: :created
     end
 
     def compare
diff --git a/engine/app/javascript/controllers/coplan/review_tray_controller.js b/engine/app/javascript/controllers/coplan/review_tray_controller.js
index e818fb8b..14a23378 100644
--- a/engine/app/javascript/controllers/coplan/review_tray_controller.js
+++ b/engine/app/javascript/controllers/coplan/review_tray_controller.js
@@ -125,13 +125,17 @@ export default class extends Controller {
 
   requestChanges(event) {
     this.responseUrl = event.currentTarget.dataset.url
-    if (this.discussionTarget.hidden) this.changesRevision = this.viewedRevision()
+    if (this.discussionTarget.hidden) {
+      this.changesRevision = this.viewedRevision()
+      this.changesGeneration = this.element.dataset.reviewGeneration
+    }
     this.expand()
   }
 
   confirmApproval(event) {
     this.responseUrl = event.currentTarget.dataset.url
     this.approvalRevision = this.viewedRevision()
+    this.approvalGeneration = this.element.dataset.reviewGeneration
     this.approvalErrorTarget.textContent = ""
     this.approveButtonTarget.textContent = `Approve v${this.approvalRevision}`
     this.approvalTitleTarget.textContent = `Approve v${this.approvalRevision}?`
@@ -142,12 +146,14 @@ export default class extends Controller {
     this.approvalTarget.close()
   }
 
-  responseIntent(url, revision, decision, note) {
+  responseIntent(url, revision, decision, note, generation) {
     this.responseIntents ||= {}
+    // A lost result may be retried after a re-request. Keep its original
+    // generation with the key until the server acknowledges that intent.
     const fields = JSON.stringify([url, String(revision), note.trim()])
     const previous = this.responseIntents[decision]
     if (previous?.fields === fields) return previous
-    return this.responseIntents[decision] = { fields, key: crypto.randomUUID() }
+    return this.responseIntents[decision] = { fields, generation, key: crypto.randomUUID() }
   }
 
   confirmIntent(decision, intent) {
@@ -157,13 +163,15 @@ export default class extends Controller {
   async approve(event) {
     event.preventDefault()
     await this.withBusy(event.target, this.approvalErrorTarget, async () => {
-      const intent = this.responseIntent(this.responseUrl, this.approvalRevision, "approved", this.approvalNoteTarget.value)
-      const result = await this.write(this.responseUrl, "POST", { review_response: { revision: this.approvalRevision, decision: "approved", note: this.approvalNoteTarget.value, idempotency_key: intent.key } })
+      const intent = this.responseIntent(this.responseUrl, this.approvalRevision, "approved", this.approvalNoteTarget.value, this.approvalGeneration)
+      const result = await this.write(this.responseUrl, "POST", { review_response: { revision: this.approvalRevision, generation: intent.generation, decision: "approved", note: this.approvalNoteTarget.value, idempotency_key: intent.key } })
       this.confirmIntent("approved", intent)
       const synced = !result.comment_thread_id || await this.refreshThreads(result.comment_thread_id)
       this.approvalTarget.close()
       this.approvalNoteTarget.value = ""
-      if (this.hasNoticeTarget) this.noticeTarget.textContent = `Your approval of v${this.approvalRevision} is recorded.` + (synced ? "" : " Refresh the page to see your comment.")
+      if (this.hasNoticeTarget) this.noticeTarget.textContent = result.effective === false
+        ? "Your earlier decision was already recorded. Review the current request again."
+        : `Your approval of v${this.approvalRevision} is recorded.` + (synced ? "" : " Refresh the page to see your comment.")
       const tray = this.element.querySelector(".review-tray")
       if (tray) delete tray.dataset.reconsidering
       await this.refresh()
@@ -177,8 +185,8 @@ export default class extends Controller {
     if (form.closest('[data-dictation-busy="true"]') || form.querySelector('[data-dictation-busy="true"]')) return
     const error = form.querySelector('[role="alert"]')
     await this.withBusy(form, error, async () => {
-      const intent = this.responseIntent(form.action, this.changesRevision, "changes_requested", input.value)
-      const result = await this.write(form.action, "POST", { review_response: { revision: this.changesRevision, decision: "changes_requested", note: input.value, idempotency_key: intent.key } })
+      const intent = this.responseIntent(form.action, this.changesRevision, "changes_requested", input.value, this.changesGeneration)
+      const result = await this.write(form.action, "POST", { review_response: { revision: this.changesRevision, generation: intent.generation, decision: "changes_requested", note: input.value, idempotency_key: intent.key } })
       this.confirmIntent("changes_requested", intent)
       // Feedback lives in the ordinary discussion collection.
       const synced = await this.refreshThreads(result.comment_thread_id)
@@ -218,6 +226,7 @@ export default class extends Controller {
       if (!response.ok) return
       const incoming = new DOMParser().parseFromString(await response.text(), "text/html")
       if (sequence !== this.refreshSequence || !this.element.isConnected) return
+      this.element.dataset.reviewGeneration = incoming.getElementById("plan-review-controls")?.dataset.reviewGeneration || ""
       const tray = incoming.querySelector(".review-tray")
       const existingTray = this.element.querySelector(".review-tray")
       const wasWithdrawn = this.reviewWithdrawn
@@ -431,6 +440,13 @@ export default class extends Controller {
     let result
     try { result = await response.json() } catch { throw new Error("Couldn't save your response. Your draft is still here. Please try again.") }
     if (!response.ok) {
+      // A definite rejection did not record this intent. Refresh the cycle
+      // so closing and deliberately reopening the dialog can start a new one.
+      // Network failures and lost results keep their original key/generation.
+      if (String(url).endsWith("/respond") && response.status >= 400 && response.status < 500) {
+        this.responseIntents = {}
+        await this.refresh()
+      }
       const error = new Error(result.error || "Couldn't save. Please try again.")
       if (result.code === "authentication_required") error.signInPath = result.sign_in_path
       throw error
diff --git a/engine/app/models/coplan/plan_version.rb b/engine/app/models/coplan/plan_version.rb
index 66d25607..3279d2b1 100644
--- a/engine/app/models/coplan/plan_version.rb
+++ b/engine/app/models/coplan/plan_version.rb
@@ -1,5 +1,7 @@
 module CoPlan
   class PlanVersion < ApplicationRecord
+    attr_readonly :id, :plan_id, :revision, :content_markdown, :content_sha256
+
     attr_accessor :edit_lease_token, :input_sources, :writing_identity
 
     before_create :enforce_edit_lease
@@ -35,6 +37,16 @@ def self.ransackable_associations(_auth_object = nil)
 
     before_validation :compute_sha256, if: -> { content_markdown.present? && content_sha256.blank? }
 
+    validate :content_hash_matches, on: :create
+
+    def verified_content!
+      unless Digest::SHA256.hexdigest(content_markdown.to_s) == content_sha256
+        errors.add(:content_sha256, "does not match the stored Markdown bytes")
+        raise ActiveRecord::RecordInvalid, self
+      end
+      content_markdown
+    end
+
     # Marker so a mixed history feed (PlanVersion + PlanEvent) can render each
     # item appropriately without introspecting class names.
     def history_kind
@@ -99,6 +111,10 @@ def broadcast_history_update
       )
     end
 
+    def content_hash_matches
+      errors.add(:content_sha256, "must match the Markdown bytes") unless Digest::SHA256.hexdigest(content_markdown.to_s) == content_sha256
+    end
+
     def compute_sha256
       self.content_sha256 = Digest::SHA256.hexdigest(content_markdown)
     end
diff --git a/engine/app/models/coplan/review_request.rb b/engine/app/models/coplan/review_request.rb
index 27b9d963..140d1c12 100644
--- a/engine/app/models/coplan/review_request.rb
+++ b/engine/app/models/coplan/review_request.rb
@@ -10,7 +10,8 @@ class ReviewRequest < ApplicationRecord
     # Historical context of when the request was sent, never a review target.
     # Pending requests follow the plan; only responses bind to a version.
     belongs_to :requested_plan_version, class_name: "CoPlan::PlanVersion"
-    has_many :review_responses, -> { order(created_at: :desc, id: :desc) }, dependent: :delete_all
+    has_many :review_responses, -> { order(Arel.sql("CASE WHEN decision_sequence IS NULL THEN 0 ELSE 1 END DESC"), decision_sequence: :desc, created_at: :desc, id: :desc) }, dependent: :delete_all
+    belongs_to :current_response, class_name: "CoPlan::ReviewResponse", optional: true
     has_many :notifications, dependent: :destroy
 
     validates :reviewer_id, uniqueness: { scope: :plan_id }
@@ -23,13 +24,30 @@ class ReviewRequest < ApplicationRecord
     scope :pending, -> { where(status: "pending") }
 
     def pending?
-      status == "pending"
+      effective_status == "pending"
     end
 
+    # Positive history is for comparison only. Never use it as current evidence.
     def latest_approval
       review_responses.find { |response| response.decision == "approved" }
     end
 
+    def effective_response
+      response = current_response
+      response if response && status == response.decision &&
+        response.review_request_id == id && response.request_generation == generation &&
+        response.plan_version_id == plan.current_plan_version_id
+    end
+
+    def effective_status
+      status == "withdrawn" ? "withdrawn" : (effective_response&.decision || "pending")
+    end
+
+    def effective_human_decision
+      response = effective_response
+      response.decision if response&.actor_type == "human"
+    end
+
     def self.ransackable_attributes(_auth_object = nil)
       %w[id plan_id reviewer_id requirement status requested_at created_at updated_at]
     end
diff --git a/engine/app/services/coplan/plans/advance_version.rb b/engine/app/services/coplan/plans/advance_version.rb
new file mode 100644
index 00000000..fcd6d126
--- /dev/null
+++ b/engine/app/services/coplan/plans/advance_version.rb
@@ -0,0 +1,30 @@
+module CoPlan
+  module Plans
+    # All current-version writers call this inside their plan-row transaction.
+    # CommitSession still locks its session before the plan.
+    class AdvanceVersion
+      def self.call(plan:, version:)
+        raise ArgumentError, "Version advancement requires the writer’s plan transaction" unless plan.class.connection.transaction_open?
+        raise ArgumentError, "Version must belong to the plan and advance its revision" unless version.plan_id == plan.id && version.revision > plan.current_revision
+
+        plan.update!(current_plan_version: version, current_revision: version.revision,
+          review_sequence: plan.review_sequence + 1)
+        requests = plan.review_requests.active.to_a
+        requests.each do |request|
+          request.update!(status: "pending", generation: request.generation + 1,
+            current_response: nil, reset_reason: "content_changed")
+        end
+        # No new review notifications for each edit, and no reset broadcast
+        # for a transaction that rolls back.
+        ActiveRecord.after_all_transactions_commit do
+          requests.each do |request|
+            Reviews::Changed.call(request: request, event_type: "review.requested",
+              payload: { "action" => "content_changed", "revision" => version.revision,
+                         "generation" => request.generation })
+          end
+        end
+        version
+      end
+    end
+  end
+end
diff --git a/engine/app/services/coplan/plans/commit_session.rb b/engine/app/services/coplan/plans/commit_session.rb
index 7aae8325..e694834f 100644
--- a/engine/app/services/coplan/plans/commit_session.rb
+++ b/engine/app/services/coplan/plans/commit_session.rb
@@ -149,10 +149,7 @@ def call
             base_revision: @session.base_revision
           )
 
-          plan.update!(
-            current_plan_version: version,
-            current_revision: new_revision
-          )
+          Plans::AdvanceVersion.call(plan: plan, version: version)
 
           plan.comment_threads.mark_out_of_date_for_new_version!(version)
 
diff --git a/engine/app/services/coplan/plans/create.rb b/engine/app/services/coplan/plans/create.rb
index d72961e8..5ad811ae 100644
--- a/engine/app/services/coplan/plans/create.rb
+++ b/engine/app/services/coplan/plans/create.rb
@@ -43,7 +43,7 @@ def call
             agent_name: @agent_name,
             api_token_id: @api_token_id
           )
-          plan.update!(current_plan_version: version, current_revision: 1)
+          AdvanceVersion.call(plan: plan, version: version)
           plan
         end
 
diff --git a/engine/app/services/coplan/plans/replace_content.rb b/engine/app/services/coplan/plans/replace_content.rb
index f509011b..56858384 100644
--- a/engine/app/services/coplan/plans/replace_content.rb
+++ b/engine/app/services/coplan/plans/replace_content.rb
@@ -136,10 +136,7 @@ def call
             reason: @reason
           )
 
-          @plan.update!(
-            current_plan_version: version,
-            current_revision: new_revision
-          )
+          Plans::AdvanceVersion.call(plan: @plan, version: version)
 
           @plan.comment_threads.mark_out_of_date_for_new_version!(version)
 
diff --git a/engine/app/services/coplan/plans/toggle_checkbox.rb b/engine/app/services/coplan/plans/toggle_checkbox.rb
index 1b5b32e8..0c3a5d82 100644
--- a/engine/app/services/coplan/plans/toggle_checkbox.rb
+++ b/engine/app/services/coplan/plans/toggle_checkbox.rb
@@ -82,7 +82,7 @@ def call
             base_revision: @base_revision
           )
 
-          @plan.update!(current_plan_version: version, current_revision: new_revision)
+          AdvanceVersion.call(plan: @plan, version: version)
           @plan.comment_threads.mark_out_of_date_for_new_version!(version)
 
           Broadcaster.replace_to(
diff --git a/engine/app/services/coplan/reviews/evidence.rb b/engine/app/services/coplan/reviews/evidence.rb
new file mode 100644
index 00000000..7aa499c6
--- /dev/null
+++ b/engine/app/services/coplan/reviews/evidence.rb
@@ -0,0 +1,27 @@
+module CoPlan
+  module Reviews
+    # Body/review writers serialize on this row too. This read deliberately
+    # creates no PlanRead, agent session, or notification acknowledgement.
+    class Evidence
+      SCOPE = {
+        kind: "markdown_source", includes: [ "content_markdown" ],
+        excludes: %w[title tags attachments linked_resources embedded_resources child_plans rendered_output],
+        meaning: "Approval covers the Markdown source bytes only. Linked or embedded content is not captured or approved. Grants no execution authority or permissions."
+      }.freeze
+
+      def self.call(plan:)
+        plan.with_lock do
+          version = plan.current_plan_version
+          {
+            schema_version: 1, plan_id: plan.id, review_sequence: plan.review_sequence,
+            approval_scope: SCOPE,
+            version: { id: version.id, revision: version.revision,
+                       content_sha256: version.content_sha256, content_markdown: version.verified_content! },
+            review_requests: plan.review_requests.includes(:reviewer, :current_response,
+              review_responses: :plan_version).order(:id).map { |request| Serialize.call(request) }
+          }
+        end
+      end
+    end
+  end
+end
diff --git a/engine/app/services/coplan/reviews/record_request.rb b/engine/app/services/coplan/reviews/record_request.rb
index fbcb90da..7eba7829 100644
--- a/engine/app/services/coplan/reviews/record_request.rb
+++ b/engine/app/services/coplan/reviews/record_request.rb
@@ -16,7 +16,7 @@ def call
           api_token: api_token, agent_name: api_token && ApiToken.normalized_agent_name(api_token.agent_name.presence || api_token.name),
           created_at: request.requested_at,
           metadata: { "reviewer_name" => request.reviewer.name, "revision" => request.requested_plan_version.revision,
-                      "requirement" => request.requirement })
+                      "requirement" => request.requirement, "generation" => request.generation, "review_sequence" => request.plan.review_sequence })
       end
     end
   end
diff --git a/engine/app/services/coplan/reviews/request.rb b/engine/app/services/coplan/reviews/request.rb
index 5e646a28..8badd4c6 100644
--- a/engine/app/services/coplan/reviews/request.rb
+++ b/engine/app/services/coplan/reviews/request.rb
@@ -30,8 +30,10 @@ def call
             RecordRequest.call(request: request)
           end
           request.assign_attributes(requested_by_user: @actor, requested_plan_version: @plan.current_plan_version,
-            requirement: @requirement, status: "pending", requested_at: Time.current)
+            requirement: @requirement, status: "pending", requested_at: Time.current,
+            generation: request.persisted? ? request.generation + 1 : 1, current_response: nil, reset_reason: request.persisted? ? "requested_again" : nil)
           request.save!
+          @plan.update!(review_sequence: @plan.review_sequence + 1)
           RecordRequest.call(request: request, api_token: @api_token)
           # One unread nudge per task. Reading it never completes the task.
           request.notifications.unread.where(user: @reviewer).update_all(read_at: Time.current)
diff --git a/engine/app/services/coplan/reviews/respond.rb b/engine/app/services/coplan/reviews/respond.rb
index a004c2ca..f8fade4a 100644
--- a/engine/app/services/coplan/reviews/respond.rb
+++ b/engine/app/services/coplan/reviews/respond.rb
@@ -10,12 +10,13 @@ def initialize(message, code: "review_version_changed")
         end
       end
 
-      def self.call(request:, actor:, revision:, decision:, note: nil, api_token: nil, idempotency_key: nil)
-        new(request:, actor:, revision:, decision:, note:, api_token:, idempotency_key:).call
+      def self.call(request:, actor:, revision:, decision:, note: nil, api_token: nil, idempotency_key: nil, generation: nil)
+        new(request:, actor:, revision:, decision:, note:, api_token:, idempotency_key:, generation:).call
       end
 
-      def initialize(request:, actor:, revision:, decision:, note:, api_token:, idempotency_key:)
+      def initialize(request:, actor:, revision:, decision:, note:, api_token:, idempotency_key:, generation:)
         @request, @actor, @revision, @decision, @note, @api_token = request, actor, revision, decision, note, api_token
+        @generation = generation
         @idempotency_key = idempotency_key.presence
       end
 
@@ -45,16 +46,26 @@ def call
             end
             response.id = @idempotency_key
           end
+          # A legacy identical retry is historical even after a re-request.
+          # It cannot change status, attribution, sequence or the current pointer.
+          existing = @request.review_responses.find_by(user: @actor,
+            plan_version_id: plan.plan_versions.where(revision: @revision).select(:id),
+            decision: @decision, note: response.note)
+          next existing if existing && !@idempotency_key
+
           raise Conflict.new("This review request was withdrawn.", code: "review_request_withdrawn") if @request.status == "withdrawn"
           raise Conflict, "The plan has changed. Review the latest version before recording your response." unless @revision.to_s == plan.current_revision.to_s
 
-          # Legacy clients cannot distinguish two identical intentions. Keep
-          # the old response and preserve any newly re-requested pending task.
-          # Token renewal changes the credential, not the human's intention;
-          # returning the saved record preserves its original attribution.
-          existing = @request.review_responses.find_by(user: @actor, plan_version: plan.current_plan_version,
-            decision: @decision, note: response.note)
-          next existing if existing && !@idempotency_key
+          # First-cycle legacy clients remain usable. After any reset they
+          # must fetch and send the generation; a first-seen delayed request
+          # must never complete a reopened task at the same body revision.
+          unless @generation.to_s == @request.generation.to_s || (@generation.nil? && @request.generation == 1)
+            raise Conflict.new("The review request changed. Reload it before recording a new decision.", code: "review_request_changed")
+          end
+          plan.current_plan_version.verified_content!
+          plan.update!(review_sequence: plan.review_sequence + 1)
+          response.request_generation = @request.generation
+          response.decision_sequence = plan.review_sequence
 
           if response.note.present?
             thread = plan.comment_threads.create!(plan_version: plan.current_plan_version, created_by_user: @actor)
@@ -64,7 +75,7 @@ def call
           end
           response.save!
           @new_response = true
-          @request.update!(status: @decision)
+          @request.update!(status: @decision, current_response: response, reset_reason: nil)
           @request.notifications.unread.where(user: @actor).update_all(read_at: Time.current)
           unless @actor.id == plan.created_by_user_id
             Notification.create!(plan: plan, user_id: plan.created_by_user_id, review_request: @request,
diff --git a/engine/app/services/coplan/reviews/serialize.rb b/engine/app/services/coplan/reviews/serialize.rb
index aa7d3784..c70f0896 100644
--- a/engine/app/services/coplan/reviews/serialize.rb
+++ b/engine/app/services/coplan/reviews/serialize.rb
@@ -13,11 +13,19 @@ def call
         request = @request
         {
           id: request.id, reviewer: { id: request.reviewer_id, name: request.reviewer.name },
-          requirement: request.requirement, status: request.status,
-          requested_at: request.requested_at,
+          requirement: request.requirement, status: request.status, effective_status: request.effective_status,
+          requested_at: request.requested_at, generation: request.generation, reset_reason: request.reset_reason,
+          current_response_id: request.current_response_id,
+          effective_response_id: request.effective_response&.id,
+          effective_human_decision: request.effective_human_decision,
+          latest_human_response_id: request.review_responses.find { |response|
+            response.actor_type == "human" && response.decision_sequence && response.plan_version_id == request.plan.current_plan_version_id
+          }&.id,
           responses: request.review_responses.map do |response|
             { id: response.id, decision: response.decision, revision: response.plan_version.revision,
-              user_id: response.user_id, actor_type: response.actor_type, agent_name: response.agent_name,
+              plan_version_id: response.plan_version_id, content_sha256: response.plan_version.content_sha256,
+              generation: response.request_generation, decision_sequence: response.decision_sequence,
+              user_id: response.user_id, api_token_id: response.api_token_id, actor_type: response.actor_type, agent_name: response.agent_name,
               note: response.note, comment_thread_id: response.comment_thread_id, created_at: response.created_at }
           end
         }
diff --git a/engine/app/services/coplan/reviews/withdraw.rb b/engine/app/services/coplan/reviews/withdraw.rb
index ea5f1783..63b24b4c 100644
--- a/engine/app/services/coplan/reviews/withdraw.rb
+++ b/engine/app/services/coplan/reviews/withdraw.rb
@@ -18,12 +18,13 @@ def call
           unless request.plan.plan_events.where(event_type: "review_requested", after_value: request.id).exists?
             RecordRequest.call(request: request)
           end
-          request.update!(status: "withdrawn")
+          request.update!(status: "withdrawn", current_response: nil)
+          request.plan.update!(review_sequence: request.plan.review_sequence + 1)
           request.plan.plan_events.create!(event_type: "review_withdrawn", field: "reviews", after_value: request.id,
             actor_id: actor.id, actor_type: api_token ? "local_agent" : "human", api_token: api_token,
             agent_name: api_token && ApiToken.normalized_agent_name(api_token.agent_name.presence || api_token.name),
             metadata: { "reviewer_name" => request.reviewer.name, "revision" => request.plan.current_revision,
-                        "requirement" => request.requirement })
+                        "requirement" => request.requirement, "generation" => request.generation, "review_sequence" => request.plan.review_sequence })
           request.notifications.unread.where(user_id: request.reviewer_id, reason: "review_requested").update_all(read_at: Time.current)
           true
         end
diff --git a/engine/app/views/coplan/agent_instructions/guides/api.text.erb b/engine/app/views/coplan/agent_instructions/guides/api.text.erb
index d8087c87..8373ffea 100644
--- a/engine/app/views/coplan/agent_instructions/guides/api.text.erb
+++ b/engine/app/views/coplan/agent_instructions/guides/api.text.erb
@@ -34,6 +34,8 @@ return 429. Invalid names return 422 with `invalid_request`.
 | `GET /api/v1/plans` | List the plans that you can see. Filters: `?visibility=draft\|published`, `?archived=true`, `?folder_id=`. | primer |
 | `POST /api/v1/plans` | Create a plan. | creating |
 | `GET /api/v1/plans/:id` | Get a plan with its content and references. | primer |
+| `GET /api/v1/plans/:id/versions/:version_id` | Read exact historical Markdown bytes and SHA-256. No read receipt. | comments |
+| `GET /api/v1/plans/:id/review_evidence` | Read exact current Markdown bytes/hash and coherent review cycles and decisions, without a read receipt. | comments |
 | `GET /api/v1/plans/:id/snapshot` | Get a plan with content, threads, references, collaborators, and review requests. | primer |
 | `GET /api/v1/plans/:id/writing_provenance` | Get writing-origin counts and reported agent identities. `?ranges=1` includes compact source ranges. Older plans can return `202` while history is reconstructed. | editing |
 | `PATCH /api/v1/plans/:id` | Change the title, type, tags, folder, visibility, archive state, or references. Plan author only. | editing |
@@ -82,7 +84,9 @@ return 429. Invalid names return 422 with `invalid_request`.
 
 Creating a review request for an existing reviewer returns the current task with status 201. It leaves the requirement, decision, history, and notifications unchanged. Use `PATCH` to change the requirement or `request_again: true` to request another look.
 
-Include `idempotency_key` (a fresh UUID) for each intended review response. Reuse that UUID and identical fields when retrying a lost response; its returned `id` is the UUID. Use a new UUID for a new decision, including another review of the same version. A keyed retry returns the original recorded result even after the plan changes or the task is withdrawn. It preserves any newly pending review task. Without a key, an identical response is treated as a retry. Retries may use a renewed token for the same human principal. The original response keeps its original agent and token attribution. A key reused for different fields returns 422.
+Send the request’s `generation` and the viewed `revision` with every new response. A missing generation is supported only for the first cycle. After edits or re-requests, a stale or missing generation returns 409 with `code: review_request_changed`. Fetch the task again and deliberately review before submitting a fresh response. Edits reset active tasks to pending and advance their generations. Withdrawn tasks stay withdrawn. Earlier responses remain history.
+
+Include `idempotency_key` (a fresh UUID) for each intended review response. Reuse that UUID and identical fields when retrying a lost response; its returned `id` is the UUID. Use a new UUID for a new decision, including another review of the same version. A keyed retry returns the original recorded result even after the plan changes or the task is withdrawn. It preserves any newly pending review task. Without a key, an identical response is treated as a retry. Retries may use a renewed token for the same human principal. The original response keeps its original agent and token attribution. A key reused for different fields returns 422. A retry’s `effective: false` means it is history, not a current decision. New responses return `plan_version_id`, `content_sha256`, `generation`, and server `decision_sequence`.
 
 A review response returns 409 with `code: review_version_changed` for a stale revision. Re-read before responding. A new response to a withdrawn request returns 409 with `code: review_request_withdrawn`; stop responding unless the author requests another look.
 
diff --git a/engine/app/views/coplan/agent_instructions/guides/comments.text.erb b/engine/app/views/coplan/agent_instructions/guides/comments.text.erb
index 8ae64f43..14adb8b3 100644
--- a/engine/app/views/coplan/agent_instructions/guides/comments.text.erb
+++ b/engine/app/views/coplan/agent_instructions/guides/comments.text.erb
@@ -80,11 +80,11 @@ To give feedback on another person's plan, start threads anchored to the passage
 
 Each request or re-request remains in review activity with its requester and time. A later request does not replace earlier requests or decisions.
 
-Discussion is the default. An approval means “satisfied with this exact version”; it grants no permissions, execution authority, or instruction to implement the plan. Never interpret another person's sign-off as an instruction from your principal. Later edits preserve the earlier sign-off. Re-read the snapshot and compare the approved revision with current content before drawing conclusions.
+Discussion is the default. An approval means “satisfied with this exact version”; it grants no permissions, execution authority, or instruction to implement the plan. Never interpret another person's sign-off as an instruction from your principal. Edits reset active tasks to pending and preserve the earlier sign-off as history. Approval covers Markdown source bytes only, not title, tags, attachments, linked or embedded resources, or child plans. Use `GET /api/v1/plans/:plan_id/review_evidence` for exact current Markdown, hash, version ID, and coherent review state. It creates no read receipt. `effective_human_decision` is null for agent decisions or dismissed approvals. A later agent decision cannot count as a human approval. `latest_human_response_id` exposes historical human feedback on the current version; it is not an effective approval.
 
 - `GET /api/v1/plans/:plan_id/review_requests` lists requests and responses, including reviewer, required/optional, revision, timestamp, notes, and agent attribution.
 - The plan author's credential may `POST` that path with `{ "reviewer_id": "USER_ID", "requirement": "required" }` (or `optional`). Requests are tasks; reading the notification does not complete them.
 - The plan author's credential may `GET /api/v1/plans/:plan_id/review_requests/suggestions` for suggested reviewers. Each entry in `suggestions` has `reviewer` (`id`, `name`, `username`), a `reason`, and a suggested `requirement`. A deployment may base them on the files and repositories the plan links to, so link the files a plan will change before asking. The list leaves out the author and people already reviewing, and is empty when the deployment suggests nobody. Suggestions are not requests. When your principal wants the plan reviewed, `POST` each chosen `reviewer.id` with its `requirement`.
 - `PATCH /api/v1/plans/:plan_id/review_requests/:id` accepts `requirement` without reopening the task or starting another review cycle. Use `{ "request_again": true }` when feedback is ready for another look. That preserves earlier responses and notifies the reviewer again. Live events distinguish these actions; see the live guide.
 - `DELETE` the same path withdraws the request and records the withdrawing actor and time in review activity. Earlier request cycles and decisions remain. It clears the reviewer's request nudge, not the author's unread responses. Archiving a plan does not withdraw pending reviews.
-- Only the requested reviewer's credential may `POST /api/v1/plans/:plan_id/review_requests/:id/respond` with `{ "revision": 4, "decision": "approved", "note": "optional public note", "idempotency_key": "RESPONSE_UUID" }` or `{ "revision": 4, "decision": "changes_requested", "note": "what needs adjustment", "idempotency_key": "RESPONSE_UUID" }`. Change requests create ordinary public comment threads. Agent responses are explicitly attributed to the token's agent acting for its human owner. A stale revision returns 409 with `code: review_version_changed`; re-read before responding. A new response to a withdrawn request returns 409 with `code: review_request_withdrawn`; stop responding unless the author requests another look. Replace `RESPONSE_UUID` with a fresh UUID for each intended response. Retry with the same UUID and identical fields if the HTTP response is lost. Use a new UUID for another review, even for the same version and decision. A keyed retry returns the original result even after a plan edit or withdrawal. It does not complete a newly re-requested task. Without a key, identical fields are treated as a retry. Retries may use a renewed token for the same human principal. The original response keeps its original agent and token attribution. Reusing a key with different fields returns 422. Never manufacture a human sign-off.
+- Only the requested reviewer's credential may `POST /api/v1/plans/:plan_id/review_requests/:id/respond` with `{ "revision": 4, "generation": 2, "decision": "approved", "note": "optional public note", "idempotency_key": "RESPONSE_UUID" }` or `{ "revision": 4, "generation": 2, "decision": "changes_requested", "note": "what needs adjustment", "idempotency_key": "RESPONSE_UUID" }`. Use the generation returned by the request. Edits and re-requests advance it; a stale or missing generation after the first cycle returns 409 with `code: review_request_changed`. Change requests create ordinary public comment threads. Agent responses are explicitly attributed to the token's agent acting for its human owner. A stale revision returns 409 with `code: review_version_changed`; re-read before responding. A new response to a withdrawn request returns 409 with `code: review_request_withdrawn`; stop responding unless the author requests another look. Replace `RESPONSE_UUID` with a fresh UUID for each intended response. Retry with the same UUID and identical fields if the HTTP response is lost. Use a new UUID for another review, even for the same version and decision. A keyed retry returns the original result even after a plan edit or withdrawal. It does not complete a newly re-requested task. Without a key, identical fields are treated as a retry. Retries may use a renewed token for the same human principal. The original response keeps its original agent and token attribution. Reusing a key with different fields returns 422. Never manufacture a human sign-off.
diff --git a/engine/app/views/coplan/agent_instructions/guides/live.text.erb b/engine/app/views/coplan/agent_instructions/guides/live.text.erb
index c682ed2c..101aafe5 100644
--- a/engine/app/views/coplan/agent_instructions/guides/live.text.erb
+++ b/engine/app/views/coplan/agent_instructions/guides/live.text.erb
@@ -103,6 +103,7 @@ For `review.requested`, inspect `payload.action`:
 | Action | Meaning |
 |---|---|
 | `requested` | A new request or another look. `requirement` is `required` or `optional`. |
+| `content_changed` | A new Markdown version reset active tasks and advanced their generations. Earlier responses remain history. Read the current version and request before responding. No new inbox nudge is sent for each edit. |
 | `requirement_changed` | Only `requirement` changed. This does not reopen the task or start another review cycle. Do not treat it as a request for another look. |
 | `withdrawn` | The request was withdrawn. Stop working on that request; its earlier decisions remain. The payload also has `withdrawn: true`. |
 
diff --git a/engine/app/views/coplan/plan_versions/show.html.erb b/engine/app/views/coplan/plan_versions/show.html.erb
index ba777356..34ad8206 100644
--- a/engine/app/views/coplan/plan_versions/show.html.erb
+++ b/engine/app/views/coplan/plan_versions/show.html.erb
@@ -17,6 +17,9 @@
   </div>
 </div>
 
+<p class="text-sm text-muted">This snapshot records Markdown source only. The title above is current metadata. Attachments, linked or embedded content, and child plans are not part of this approval.</p>
+<details class="card mb-md"><summary>Exact Markdown source · SHA-256 <%= @version.content_sha256 %></summary><pre><code><%= @version.verified_content! %></code></pre></details>
+
 <% if @diff %>
   <div class="card mb-md">
     <h3>Changes from v<%= @version.revision - 1 %></h3>
diff --git a/engine/app/views/coplan/reviews/_activity.html.erb b/engine/app/views/coplan/reviews/_activity.html.erb
index 3eb92982..61f03592 100644
--- a/engine/app/views/coplan/reviews/_activity.html.erb
+++ b/engine/app/views/coplan/reviews/_activity.html.erb
@@ -12,7 +12,7 @@
           <div class="review-log__body">
             <p class="review-log__event"><strong><%= kind != :request && item.actor_type == "local_agent" ? "#{item.agent_name} (via #{actor.name})" : actor.name %></strong>
               <% if kind != :response %><%= kind == :request_event && item.event_type == "review_withdrawn" ? "withdrew the review request for" : "requested a review from" %> <strong><%= kind == :request_event ? item.metadata["reviewer_name"] : item.reviewer.name %></strong><% else %><%= item.decision == "approved" ? "approved" : "requested changes on" %><% end %>
-              <% if kind == :response %><span class="review-version">v<%= item.plan_version.revision %></span><% end %>
+              <% if kind == :response %><%= link_to "v#{item.plan_version.revision} · Markdown snapshot", plan_version_browse_path(item.review_request.plan, item.plan_version), class: "review-version" %><%= " · Historical decision" unless item.review_request.effective_response&.id == item.id %><% end %>
             </p>
             <time datetime="<%= at.iso8601 %>" title="<%= l(at, format: :long) %>"><%= l(at, format: :short) %></time>
             <% if kind == :response && item.note.present? %><p class="review-log__note"><%= item.note %></p><% end %>
diff --git a/engine/app/views/coplan/reviews/_controls.html.erb b/engine/app/views/coplan/reviews/_controls.html.erb
index 5255d239..ea8983b7 100644
--- a/engine/app/views/coplan/reviews/_controls.html.erb
+++ b/engine/app/views/coplan/reviews/_controls.html.erb
@@ -1,10 +1,10 @@
 <% requests = plan.review_requests.includes(:reviewer, :requested_by_user, :requested_plan_version, review_responses: [ :plan_version, :user ]).order(:requested_at).to_a %>
 <% request_events = plan.plan_events.where(event_type: %w[review_requested review_withdrawn]).includes(:actor_user).to_a %>
-<% active_requests = requests.reject { |request| request.status == "withdrawn" } %>
+<% active_requests = requests.reject { |request| request.effective_status == "withdrawn" } %>
 <% own_request = active_requests.find { |request| request.reviewer_id == current_user.id } %>
 <% response_thread_ids = requests.flat_map { |request| request.review_responses.map(&:comment_thread_id) }.compact %>
 <% feedback_thread_ids = plan.comment_threads.with_kept_comments.where(id: response_thread_ids).pluck(:id) %>
-<div id="plan-review-controls" data-review-record-count="<%= requests.size %>" data-controller="coplan--review-tray"
+<div id="plan-review-controls" data-review-generation="<%= own_request&.generation %>" data-review-record-count="<%= requests.size %>" data-controller="coplan--review-tray"
      data-coplan--review-tray-url-value="<%= plan_review_requests_path(plan) %>"
      data-coplan--review-tray-search-url-value="<%= search_users_path %>"
      <% if CoPlan.configuration.suggest_reviewers %>data-coplan--review-tray-suggestions-url-value="<%= suggestions_plan_review_requests_path(plan) %>"<% end %>
@@ -28,14 +28,15 @@
       </div>
       <div class="review-tray__bar">
         <div class="review-tray__status" data-review-status>
-          <% response = own_request.review_responses.first %>
+          <% response = own_request.effective_response %>
           <% approval = own_request.latest_approval %>
           <div class="review-tray__decision">
             <% if own_request.pending? %>
-              <span class="review-task-dot" aria-hidden="true"></span><strong>Your review is requested</strong><small><%= own_request.requirement.humanize %></small>
+              <span class="review-task-dot" aria-hidden="true"></span><strong>Your review is requested</strong><small><%= own_request.requirement.humanize %><%= " · Content changed; review v#{plan.current_revision} again" if own_request.reset_reason == "content_changed" %><%= " · Earlier decisions are history; please review again" if own_request.reset_reason == "legacy_history" %></small>
             <% elsif response %>
-              <span class="review-result-icon<%= ' review-result-icon--approved' if own_request.status == 'approved' %>" aria-hidden="true"><%= own_request.status == "approved" ? "✓" : "↩" %></span>
-              <span><strong><%= own_request.status == "approved" ? "You approved" : "You requested changes to" %> v<%= response.plan_version.revision %></strong> <span class="review-tray__date">on <time datetime="<%= response.created_at.iso8601 %>" title="<%= response.created_at.strftime('%B %-d, %Y at %H:%M %Z') %>"><%= response.created_at.strftime("%b %-d, %Y") %></time></span></span>
+              <span class="review-result-icon<%= ' review-result-icon--approved' if own_request.effective_status == 'approved' %>" aria-hidden="true"><%= own_request.effective_status == "approved" ? "✓" : "↩" %></span>
+              <% decision_actor = response.actor_type == "local_agent" ? "#{response.agent_name} (via you)" : "You" %>
+              <span><strong><%= own_request.effective_status == "approved" ? "#{decision_actor} approved" : "#{decision_actor} requested changes to" %> v<%= response.plan_version.revision %></strong> <span class="review-tray__date">on <time datetime="<%= response.created_at.iso8601 %>" title="<%= response.created_at.strftime('%B %-d, %Y at %H:%M %Z') %>"><%= response.created_at.strftime("%b %-d, %Y") %></time></span></span>
             <% end %>
           </div>
           <% if !own_request.pending? && feedback_thread_ids.include?(response&.comment_thread_id) %><button type="button" class="review-log__link review-feedback-link" data-action="coplan--review-tray#openThread" data-thread-id="<%= response.comment_thread_id %>">View feedback</button><% end %>
@@ -60,7 +61,8 @@
       <span class="review-confirmation__icon" aria-hidden="true"><svg width="26" height="26" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="m6 12 4 4 8-8"/></svg></span>
       <h2 id="approval-title" data-coplan--review-tray-target="approvalTitle">Approve this version?</h2>
     </div>
-    <p class="review-confirmation__statement">I’ve reviewed this version and approve it.</p>
+    <p class="review-confirmation__statement">I’ve reviewed and approve the Markdown source of this version.</p>
+    <p class="text-sm text-muted">Edits dismiss active decisions. Attachments, linked or embedded content, title, tags, and child plans are outside this approval.</p>
     <form data-action="submit->coplan--review-tray#approve">
       <label for="approval-note">Public note <span class="text-muted">(optional)</span></label><textarea id="approval-note" rows="3" placeholder="Anything you’d like to add?" data-coplan--review-tray-target="approvalNote"></textarea>
       <p class="review-error" role="alert" data-coplan--review-tray-target="approvalError"></p>
diff --git a/engine/app/views/coplan/reviews/_log.html.erb b/engine/app/views/coplan/reviews/_log.html.erb
index d89b01b7..2d4beeb3 100644
--- a/engine/app/views/coplan/reviews/_log.html.erb
+++ b/engine/app/views/coplan/reviews/_log.html.erb
@@ -2,6 +2,7 @@
   <details class="review-log-details document-support__disclosure" data-controller="coplan--support-disclosure" data-action="toggle->coplan--support-disclosure#remember">
     <summary class="review-log-panel__header document-support__heading"><span class="document-support__chevron" aria-hidden="true">›</span><h2 class="plan-footnote__title" id="review-log-title">Reviews</h2><span class="review-log-panel__summary" data-review-log-summary><span><%= pluralize(active_requests.size, "reviewer") %><%= " · #{active_requests.count(&:pending?)} awaiting review" if active_requests.any?(&:pending?) %></span></span></summary>
     <div class="review-log-panel__columns document-support__content">
+      <p class="text-sm text-muted">Reviews cover the Markdown source only. Edits dismiss active decisions; earlier decisions remain in activity.</p>
       <%= render "coplan/reviews/roster", plan: plan, active_requests: active_requests, manage: false %>
       <div class="review-log-panel__tools"><button type="button" class="btn btn--secondary btn--sm" data-action="coplan--review-tray#openActivity">View activity <span aria-hidden="true">↗</span></button></div>
     </div>
diff --git a/engine/app/views/coplan/reviews/_roster.html.erb b/engine/app/views/coplan/reviews/_roster.html.erb
index 2092a34b..b03ea688 100644
--- a/engine/app/views/coplan/reviews/_roster.html.erb
+++ b/engine/app/views/coplan/reviews/_roster.html.erb
@@ -10,14 +10,14 @@
             <%= user_avatar(request.reviewer, size: "md") %>
             <div class="review-person__info">
               <strong><%= request.reviewer.name %></strong>
-              <span class="review-person__meta"><span class="review-person__requirement"><%= requirement.humanize %></span> · <% if request.pending? %>Review requested<% elsif request.status == "changes_requested" %>Changes requested on v<%= request.review_responses.first&.plan_version&.revision %><% else %>Approved v<%= approval&.plan_version&.revision %><% end %></span>
+              <span class="review-person__meta"><span class="review-person__requirement"><%= requirement.humanize %></span> · <% if request.pending? %>Review requested<% elsif request.effective_status == "changes_requested" %>Changes requested on v<%= request.effective_response&.plan_version&.revision %><% else %>Approved v<%= request.effective_response&.plan_version&.revision %><%= " (agent)" if request.effective_response&.actor_type == "local_agent" %><% end %></span>
             </div>
-            <span class="review-state<%= ' review-state--approved' if request.status == 'approved' %><%= ' review-state--attention' if request.pending? && request.reviewer_id == current_user.id %>"><span aria-hidden="true"><%= request.pending? ? "◷" : request.status == "approved" ? "✓" : "↩" %></span> <%= request.pending? ? "Pending" : request.status.humanize %></span>
+            <span class="review-state<%= ' review-state--approved' if request.effective_status == 'approved' %><%= ' review-state--attention' if request.pending? && request.reviewer_id == current_user.id %>"><span aria-hidden="true"><%= request.pending? ? "◷" : request.effective_status == "approved" ? "✓" : "↩" %></span> <%= request.pending? ? "Pending" : request.effective_status.humanize %></span>
             <% if manage && allowed_to?(plan, :update?) %>
               <span class="review-person__actions" data-controller="coplan--menu">
                 <button type="button" class="review-person__menu-button" aria-label="Actions for <%= request.reviewer.name %>" title="Actions for <%= request.reviewer.name %>" popovertarget="review-menu-<%= request.id %>" data-coplan--menu-target="trigger"><svg width="16" height="16" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true"><circle cx="5" cy="12" r="2"/><circle cx="12" cy="12" r="2"/><circle cx="19" cy="12" r="2"/></svg></button>
                 <div id="review-menu-<%= request.id %>" class="menu review-person__menu" popover="auto" data-coplan--menu-target="menu" data-action="beforetoggle->coplan--menu#reposition" aria-label="Review actions for <%= request.reviewer.name %>">
-                  <button type="button" class="menu__item" data-action="coplan--review-tray#requestAgain coplan--menu#close" data-url="<%= plan_review_request_path(plan, request) %>"><%= request.status == "changes_requested" ? "Ready for another look" : "Request another review" %></button>
+                  <button type="button" class="menu__item" data-action="coplan--review-tray#requestAgain coplan--menu#close" data-url="<%= plan_review_request_path(plan, request) %>"><%= request.effective_status == "changes_requested" ? "Ready for another look" : "Request another review" %></button>
                   <button type="button" class="menu__item" data-action="coplan--review-tray#changeRequirement coplan--menu#close" data-url="<%= plan_review_request_path(plan, request) %>" data-requirement="<%= requirement == 'required' ? 'optional' : 'required' %>">Make <%= requirement == 'required' ? 'optional' : 'required' %></button>
                   <% if approval && approval.plan_version.revision != plan.current_revision %><button type="button" class="menu__item" data-action="coplan--review-tray#compare coplan--menu#close" data-url="<%= compare_plan_review_request_path(plan, request, response_id: approval.id) %>">Changes since approval</button><% end %>
                   <div class="menu__separator" role="separator"></div>
diff --git a/engine/app/views/coplan/reviews/_table.html.erb b/engine/app/views/coplan/reviews/_table.html.erb
index 0e5ead41..26fb14d3 100644
--- a/engine/app/views/coplan/reviews/_table.html.erb
+++ b/engine/app/views/coplan/reviews/_table.html.erb
@@ -3,12 +3,12 @@
     <thead><tr><th scope="col">Reviewer</th><th scope="col">Review</th><th scope="col">Decision</th><th scope="col">Version</th><th scope="col">Actions</th></tr></thead>
     <tbody>
       <% active_requests.sort_by { |request| [CoPlan::ReviewRequest::REQUIREMENTS.index(request.requirement), request.reviewer.name.downcase, request.id] }.each do |request| %>
-        <% response = request.review_responses.first %>
+        <% response = request.effective_response %>
         <% approval = request.latest_approval %>
         <tr class="review-person" data-reviewer-id="<%= request.reviewer_id %>">
           <td><div class="review-table__person"><%= user_avatar(request.reviewer) %><strong><%= request.reviewer.name %></strong></div></td>
           <td><span class="review-table__requirement"><%= request.requirement.humanize %></span></td>
-          <td><span class="review-state<%= ' review-state--approved' if request.status == 'approved' %><%= ' review-state--attention' if request.pending? && request.reviewer_id == current_user.id %>"><span aria-hidden="true"><%= request.pending? ? "◷" : request.status == "approved" ? "✓" : "↩" %></span><span class="review-person__meta"><%= request.pending? ? "Review requested" : request.status.humanize %></span></span></td>
+          <td><span class="review-state<%= ' review-state--approved' if request.effective_status == 'approved' %><%= ' review-state--attention' if request.pending? && request.reviewer_id == current_user.id %>"><span aria-hidden="true"><%= request.pending? ? "◷" : request.effective_status == "approved" ? "✓" : "↩" %></span><span class="review-person__meta"><%= request.pending? ? (request.reset_reason == "content_changed" ? "Content changed; review again" : "Review requested") : request.effective_status.humanize %><%= " (agent)" if response&.actor_type == "local_agent" %></span></span></td>
           <td><% if !request.pending? && response %><span class="review-version">v<%= response.plan_version.revision %></span><% else %><span class="text-muted" aria-label="Not reviewed yet">—</span><% end %></td>
           <td class="review-table__actions">
             <% if !request.pending? && request.reviewer_id == current_user.id %><button type="button" class="review-log__link review-reopen" aria-label="Change decision" title="Change decision" data-action="coplan--review-tray#reconsider"><svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M20 7v5h-5M4 17v-5h5"/><path d="M6.1 7a7 7 0 0 1 11.6-1L20 9M4 15l2.3 3A7 7 0 0 0 17.9 17"/></svg></button><% end %>
diff --git a/engine/config/routes.rb b/engine/config/routes.rb
index c2aaf2e9..a176e8af 100644
--- a/engine/config/routes.rb
+++ b/engine/config/routes.rb
@@ -170,9 +170,11 @@
           post :respond, on: :member
         end
         get :versions, on: :member
+        get "versions/:version_id", on: :member, action: :version, as: :version
         get :locations, on: :member
         get :comments, on: :member
         get :snapshot, on: :member
+        get :review_evidence, on: :member
         get :writing_provenance, on: :member
         resource :content, only: [ :update ], controller: "content"
         resource :lease, only: [ :create, :update, :destroy ], controller: "leases"
diff --git a/engine/db/demo/content/changed-review.md b/engine/db/demo/content/changed-review.md
new file mode 100644
index 00000000..8ccde544
--- /dev/null
+++ b/engine/db/demo/content/changed-review.md
@@ -0,0 +1,5 @@
+# Review the same content
+
+Approve this Markdown source, then edit the plan. Active decisions return to pending; v1 decisions stay in review activity.
+
+- [ ] Verify the retry policy
diff --git a/engine/db/migrate/20261029000000_bind_review_cycles_to_versions.rb b/engine/db/migrate/20261029000000_bind_review_cycles_to_versions.rb
new file mode 100644
index 00000000..ecda64f0
--- /dev/null
+++ b/engine/db/migrate/20261029000000_bind_review_cycles_to_versions.rb
@@ -0,0 +1,26 @@
+class BindReviewCyclesToVersions < ActiveRecord::Migration[8.1]
+  def up
+    add_column :coplan_plans, :review_sequence, :bigint, null: false, default: 0
+    add_column :coplan_review_requests, :generation, :bigint, null: false, default: 1
+    add_column :coplan_review_requests, :current_response_id, :string, limit: 36
+    add_column :coplan_review_requests, :reset_reason, :string
+    add_column :coplan_review_responses, :request_generation, :bigint
+    add_column :coplan_review_responses, :decision_sequence, :bigint
+    add_index :coplan_review_requests, :current_response_id
+    add_foreign_key :coplan_review_requests, :coplan_review_responses, column: :current_response_id, on_delete: :nullify
+    # Old timestamps cannot prove which request cycle a response completed.
+    # Keep those receipts as history; require a fresh decision for active tasks.
+    execute "UPDATE coplan_review_requests SET generation = 2"
+    execute "UPDATE coplan_review_requests SET status = 'pending', reset_reason = 'legacy_history' WHERE status <> 'withdrawn'"
+  end
+
+  def down
+    remove_foreign_key :coplan_review_requests, column: :current_response_id
+    remove_column :coplan_review_requests, :current_response_id
+    remove_column :coplan_review_requests, :generation
+    remove_column :coplan_review_requests, :reset_reason
+    remove_column :coplan_review_responses, :request_generation
+    remove_column :coplan_review_responses, :decision_sequence
+    remove_column :coplan_plans, :review_sequence
+  end
+end
diff --git a/engine/lib/coplan/development_seed.rb b/engine/lib/coplan/development_seed.rb
index 299ba685..0bbaff46 100644
--- a/engine/lib/coplan/development_seed.rb
+++ b/engine/lib/coplan/development_seed.rb
@@ -123,6 +123,11 @@ module DevelopmentSeed
         tags: %w[collaboration demo], visibility: "published", folder: "Demo scenarios",
         scenario: "Alex and Noura have pending approvals"
       },
+      {
+        key: "changed-review", author: "hampton", type: "Design Doc", title: "Workspace invitations: review dismissed after edits",
+        tags: %w[collaboration demo], visibility: "published", folder: "Demo scenarios",
+        scenario: "Earlier v1 approvals remain history; v2 requires fresh review"
+      },
       {
         key: "approved-review", author: "hampton", type: "Design Doc", title: "Workspace invitations: approved rollout",
         tags: %w[collaboration demo], visibility: "published", folder: "Demo scenarios",
@@ -245,7 +250,8 @@ module DevelopmentSeed
 
     REVIEW_SCENARIOS = {
       "pending-review" => false,
-      "approved-review" => true
+      "approved-review" => true,
+      "changed-review" => true
     }.freeze
 
     SMALL_EDITS = [
@@ -859,6 +865,10 @@ def seed_reviews(users, plans)
           request = Reviews::Request.call(plan: plan, reviewer: users.fetch(reviewer), actor: plan.created_by_user)
           Reviews::Respond.call(request: request, actor: request.reviewer, revision: plan.current_revision, decision: "approved") if approved
         end
+        if key == "changed-review" && plan.current_revision == 1
+          Plans::ReplaceContent.call(plan: plan, new_content: "#{plan.current_content}\n\nUpdated after approval: review the retry policy again.\n",
+            base_revision: 1, actor_type: "human", actor_id: plan.created_by_user_id)
+        end
       end
     end
 
diff --git a/spec/helpers/application_helper_spec.rb b/spec/helpers/application_helper_spec.rb
index 7de979af..540a6caa 100644
--- a/spec/helpers/application_helper_spec.rb
+++ b/spec/helpers/application_helper_spec.rb
@@ -73,7 +73,7 @@
     end
 
     it "includes a content excerpt when content is present" do
-      plan.current_plan_version.update!(content_markdown: "# Overview\n\nThis is the summary of the plan.")
+      set_version_fixture(plan.current_plan_version, content_markdown: "# Overview\n\nThis is the summary of the plan.")
       result = helper.plan_og_description(plan)
       expect(result).to include("This is the summary of the plan.")
     end
@@ -89,7 +89,7 @@
 
     it "truncates long content" do
       long_text = "A" * 500
-      plan.current_plan_version.update!(content_markdown: long_text)
+      set_version_fixture(plan.current_plan_version, content_markdown: long_text)
       result = helper.plan_og_description(plan)
       expect(result.length).to be <= 250
     end
diff --git a/spec/helpers/plans_helper_spec.rb b/spec/helpers/plans_helper_spec.rb
index cef13f85..508272f8 100644
--- a/spec/helpers/plans_helper_spec.rb
+++ b/spec/helpers/plans_helper_spec.rb
@@ -5,7 +5,7 @@
     let(:plan) { create(:plan, :considering) }
 
     it "strips markdown formatting and returns a plain-text preview" do
-      plan.current_plan_version.update!(
+      set_version_fixture(plan.current_plan_version,
         content_markdown: "# Heading\n\nA **bold** intro with [a link](https://example.com)."
       )
       preview = helper.plan_content_preview(plan)
@@ -16,7 +16,7 @@
     end
 
     it "omits presentation delimiters from a mixed plan preview" do
-      plan.current_plan_version.update!(content_markdown: "::: {.presentation}\n\n# Opening slide\n\n:::\n\nClosing context.")
+      set_version_fixture(plan.current_plan_version, content_markdown: "::: {.presentation}\n\n# Opening slide\n\n:::\n\nClosing context.")
 
       preview = helper.plan_content_preview(plan)
 
@@ -25,14 +25,14 @@
     end
 
     it "truncates to the requested limit" do
-      plan.current_plan_version.update!(content_markdown: "word " * 100)
+      set_version_fixture(plan.current_plan_version, content_markdown: "word " * 100)
       preview = helper.plan_content_preview(plan, limit: 40)
       expect(preview.length).to be <= 41 # 40 chars + ellipsis
       expect(preview).to end_with("…")
     end
 
     it "returns nil when the plan has no content" do
-      plan.current_plan_version.update_columns(content_markdown: "", content_sha256: Digest::SHA256.hexdigest(""))
+      set_version_fixture(plan.current_plan_version, content_markdown: "", content_sha256: Digest::SHA256.hexdigest(""))
       plan.reload
       expect(helper.plan_content_preview(plan)).to be_nil
     end
diff --git a/spec/lib/development_seed_spec.rb b/spec/lib/development_seed_spec.rb
index b1e8dbae..4d90fb0f 100644
--- a/spec/lib/development_seed_spec.rb
+++ b/spec/lib/development_seed_spec.rb
@@ -290,6 +290,13 @@ def seeded_plan(key)
       expect(agent_edits.pluck(:api_token_id)).to all(be_present)
       expect(agent_edits.pluck(:operations_json)).to all(have_attributes(size: 1))
 
+      changed = seeded_plan("changed-review")
+      expect(changed.current_revision).to eq(2)
+      expect(changed.review_requests.pluck(:status)).to eq(%w[pending pending])
+      expect(changed.review_requests.pluck(:reset_reason)).to eq(%w[content_changed content_changed])
+      expect(changed.review_requests.map(&:effective_response)).to all(be_nil)
+      expect(changed.review_requests.map { |r| r.latest_approval.plan_version.revision }).to eq([ 1, 1 ])
+
       pending = seeded_plan("pending-review").plan_collaborators.approvers
       approved = seeded_plan("approved-review").plan_collaborators.approvers
       expect(pending.count).to eq(2)
diff --git a/spec/models/plan_version_spec.rb b/spec/models/plan_version_spec.rb
index e8d11ced..aca0e2cb 100644
--- a/spec/models/plan_version_spec.rb
+++ b/spec/models/plan_version_spec.rb
@@ -13,6 +13,23 @@
     expect(version.content_sha256).to eq(Digest::SHA256.hexdigest("test content"))
   end
 
+  it "protects persisted body, hash and version identity while allowing provenance backfills" do
+    version = create(:plan).current_plan_version
+    { content_markdown: "changed", content_sha256: "bad", revision: 9, plan_id: SecureRandom.uuid, id: SecureRandom.uuid }.each do |field, value|
+      expect { version.update_columns(field => value) }.to raise_error(ActiveRecord::ActiveRecordError)
+    end
+    expect { version.update!(content_markdown: "changed") }.to raise_error(ActiveRecord::ReadonlyAttributeError)
+    version.reload.update!(writing_provenance: { "backfill" => true })
+    expect(version.reload.writing_provenance).to eq("backfill" => true)
+  end
+
+  it "rejects a supplied hash that differs from the stored bytes and fails closed on corrupt legacy data" do
+    expect(build(:plan_version, content_markdown: "body", content_sha256: "wrong")).not_to be_valid
+    version = create(:plan).current_plan_version
+    CoPlan::PlanVersion.where(id: version.id).update_all(content_markdown: "tampered")
+    expect { version.reload.verified_content! }.to raise_error(ActiveRecord::RecordInvalid)
+  end
+
   it "validates revision uniqueness per plan" do
     plan = create(:plan)
     existing_version = plan.current_plan_version
diff --git a/spec/requests/api/v1/operations_spec.rb b/spec/requests/api/v1/operations_spec.rb
index f175dd37..320546ec 100644
--- a/spec/requests/api/v1/operations_spec.rb
+++ b/spec/requests/api/v1/operations_spec.rb
@@ -95,7 +95,7 @@
   end
 
   it "apply replace_section operation creates new version" do
-    plan.current_plan_version.update!(content_markdown: "# Title\n\n## Goals\n\nGoal 1.\n\n## Timeline\n\nQ1.")
+    set_version_fixture(plan.current_plan_version, content_markdown: "# Title\n\n## Goals\n\nGoal 1.\n\n## Timeline\n\nQ1.")
     expect {
       post api_v1_plan_operations_path(plan),
         params: {
diff --git a/spec/requests/api/v1/review_evidence_spec.rb b/spec/requests/api/v1/review_evidence_spec.rb
new file mode 100644
index 00000000..3a272567
--- /dev/null
+++ b/spec/requests/api/v1/review_evidence_spec.rb
@@ -0,0 +1,55 @@
+require "rails_helper"
+
+RSpec.describe "Review evidence API", type: :request do
+  let(:author) { create(:coplan_user) }
+  let(:plan) { CoPlan::Plans::Create.call(title: "Approval API", content: "Exact bytes", user: author) }
+  let(:token) { create(:api_token, user: author, raw_token: "parity-fixture") }
+  let(:headers) { token; { "Authorization" => "Bearer parity-fixture" } }
+  let(:task) { CoPlan::Reviews::Request.call(plan: plan, reviewer: create(:coplan_user), actor: author) }
+
+  it "reads a coherent exact body, hash, current human decision and cycle without creating read receipts" do
+    receipt = CoPlan::Reviews::Respond.call(request: task, actor: task.reviewer, revision: 1, generation: task.generation, decision: "approved")
+    counts = [ CoPlan::PlanRead.count, CoPlan::AgentSession.count, CoPlan::Notification.count ]
+    get review_evidence_api_v1_plan_path(plan), headers: headers
+    expect(response).to have_http_status(:ok)
+    data = response.parsed_body
+    expect(data.fetch("version")).to include("id" => receipt.plan_version_id, "content_markdown" => "Exact bytes", "content_sha256" => Digest::SHA256.hexdigest("Exact bytes"))
+    expect(data.fetch("review_requests").first).to include("generation" => task.generation, "effective_response_id" => receipt.id, "effective_human_decision" => "approved")
+    expect(data.fetch("approval_scope").fetch("excludes")).to include("attachments", "title", "child_plans", "embedded_resources")
+    expect([ CoPlan::PlanRead.count, CoPlan::AgentSession.count, CoPlan::Notification.count ]).to eq(counts)
+  end
+
+  it "dismisses approvals through the direct operations API and rejects stale submissions" do
+    task
+    CoPlan::Reviews::Respond.call(request: task, actor: task.reviewer, revision: 1, generation: task.generation, decision: "approved")
+    CoPlan::PlanRead.record!(plan: plan, reader_type: "api_token", reader_id: token.id, revision: 1)
+    post api_v1_plan_operations_path(plan), headers: headers, as: :json,
+      params: { base_revision: 1, operations: [ { op: "replace_exact", old_text: "Exact", new_text: "Changed" } ] }
+    expect(response).to have_http_status(:created)
+    expect(task.reload).to have_attributes(status: "pending", current_response_id: nil)
+    expect {
+      CoPlan::Reviews::Respond.call(request: task, actor: task.reviewer, revision: 1, generation: 1, decision: "approved", idempotency_key: SecureRandom.uuid)
+    }.to raise_error(CoPlan::Reviews::Respond::Conflict)
+    get review_evidence_api_v1_plan_path(plan), headers: headers
+    expect(response.parsed_body.fetch("version")).to include("revision" => 2, "content_markdown" => "Changed bytes")
+    expect(response.parsed_body.fetch("review_requests").first.fetch("effective_response_id")).to be_nil
+  end
+
+  it "returns the exact historical source after edits and never substitutes current content" do
+    original = plan.current_plan_version
+    CoPlan::Plans::ReplaceContent.call(plan: plan, new_content: "New body", base_revision: 1, actor_type: "human", actor_id: author.id)
+    get version_api_v1_plan_path(plan, version_id: original.id), headers: headers
+    expect(response).to have_http_status(:ok)
+    expect(response.parsed_body).to include("id" => original.id, "revision" => 1, "content_markdown" => "Exact bytes")
+    get version_api_v1_plan_path(plan, version_id: SecureRandom.uuid), headers: headers
+    expect(response).to have_http_status(:not_found)
+  end
+
+  it "requires authentication and existing plan visibility" do
+    get review_evidence_api_v1_plan_path(plan)
+    expect(response).to have_http_status(:unauthorized)
+    # Drafts are readable by URL under the existing native policy.
+    get review_evidence_api_v1_plan_path(SecureRandom.uuid), headers: headers
+    expect(response).to have_http_status(:not_found)
+  end
+end
diff --git a/spec/requests/api/v1/review_requests_spec.rb b/spec/requests/api/v1/review_requests_spec.rb
index 3e0a02aa..784b66d7 100644
--- a/spec/requests/api/v1/review_requests_spec.rb
+++ b/spec/requests/api/v1/review_requests_spec.rb
@@ -171,7 +171,7 @@ def headers(token)
     expect(JSON.parse(response.body).fetch("id")).to eq(key)
     expect(task.reload.status).to eq("pending")
     expect(task.review_responses.count).to eq(1)
-    post respond_api_v1_plan_review_request_path(plan, task), params: payload.merge(idempotency_key: SecureRandom.uuid), headers: headers("reviews-reviewer"), as: :json
+    post respond_api_v1_plan_review_request_path(plan, task), params: payload.merge(idempotency_key: SecureRandom.uuid, generation: task.reload.generation), headers: headers("reviews-reviewer"), as: :json
     expect(response).to have_http_status(:created)
     expect(task.reload.status).to eq("approved")
     expect(task.review_responses.count).to eq(2)
diff --git a/spec/requests/changed_sections_highlight_spec.rb b/spec/requests/changed_sections_highlight_spec.rb
index 3efda6c9..fb7a552a 100644
--- a/spec/requests/changed_sections_highlight_spec.rb
+++ b/spec/requests/changed_sections_highlight_spec.rb
@@ -44,7 +44,7 @@ def rewritten_attr(body)
 
   it "compares against the most recent version the viewer read, without repeating older changes" do
     original = "## Design\n\nOriginal design.\n\n## Rollout\n\nOriginal rollout.\n"
-    plan.current_plan_version.update_columns(content_markdown: original, created_at: 1.hour.ago)
+    set_version_fixture(plan.current_plan_version, content_markdown: original, created_at: 1.hour.ago)
     read_version = create(:plan_version, plan: plan, revision: 2, actor_id: author.id,
       content_markdown: original.sub("Original design", "Revised design"), created_at: 30.minutes.ago)
     latest = create(:plan_version, plan: plan, revision: 3, actor_id: author.id,
@@ -65,7 +65,7 @@ def rewritten_attr(body)
   it "embeds the last section editor and time safely, without a summary banner" do
     author.update!(name: 'Editor "<design>"')
     original = "## Design\n\nOriginal design.\n\n## Rollout\n\nOriginal rollout.\n"
-    plan.current_plan_version.update_columns(content_markdown: original, created_at: 2.hours.ago)
+    set_version_fixture(plan.current_plan_version, content_markdown: original, created_at: 2.hours.ago)
     CoPlan::PlanViewer.create!(plan: plan, user: viewer, last_seen_at: 1.hour.ago)
     edited = create(:plan_version, plan: plan, revision: 2, actor_id: author.id,
       actor_type: "local_agent", agent_name: "Codex", created_at: 30.minutes.ago,
diff --git a/spec/requests/human_document_editor_spec.rb b/spec/requests/human_document_editor_spec.rb
index a8454051..f0c0b0ed 100644
--- a/spec/requests/human_document_editor_spec.rb
+++ b/spec/requests/human_document_editor_spec.rb
@@ -99,7 +99,7 @@ def acquire
   end
 
   it "merges stale disjoint edits and rejects overlapping edits atomically" do
-    plan.current_plan_version.update!(content_markdown: "Alpha. Beta.")
+    set_version_fixture(plan.current_plan_version, content_markdown: "Alpha. Beta.")
     patch update_content_plan_path(plan), params: { content: "Alpha! Beta.", base_revision: 1 }, as: :json
     expect(response).to have_http_status(:ok)
     patch update_content_plan_path(plan), params: { content: "Alpha. Beta!", base_revision: 1 }, as: :json
diff --git a/spec/requests/plan_content_editing_spec.rb b/spec/requests/plan_content_editing_spec.rb
index 64370d2c..296a082f 100644
--- a/spec/requests/plan_content_editing_spec.rb
+++ b/spec/requests/plan_content_editing_spec.rb
@@ -7,7 +7,7 @@
 
   before do
     sign_in_as(author)
-    plan.current_plan_version.update!(content_markdown: "# Plan\n\nOriginal body.\n")
+    set_version_fixture(plan.current_plan_version, content_markdown: "# Plan\n\nOriginal body.\n")
   end
 
   describe "GET legacy edit URL" do
diff --git a/spec/requests/plan_versions_spec.rb b/spec/requests/plan_versions_spec.rb
index 31a39c23..feb33be3 100644
--- a/spec/requests/plan_versions_spec.rb
+++ b/spec/requests/plan_versions_spec.rb
@@ -15,7 +15,7 @@
     end
 
     it "keeps footnote definitions in a historical mixed-content version" do
-      plan.current_plan_version.update!(content_markdown: <<~MD, content_sha256: nil)
+      set_version_fixture(plan.current_plan_version, content_markdown: <<~MD, content_sha256: nil)
         Context[^a].
 
         ::: {.presentation}
diff --git a/spec/requests/plans_spec.rb b/spec/requests/plans_spec.rb
index 89ba2267..6793eb53 100644
--- a/spec/requests/plans_spec.rb
+++ b/spec/requests/plans_spec.rb
@@ -212,7 +212,7 @@
 
   it "show a presentation region in any plan with its own Present control" do
     deck_plan = create(:plan, created_by_user: alice)
-    deck_plan.current_plan_version.update!(content_markdown: "Before\n\n::: {.presentation}\n\n# Slide\n\n:::\n\nAfter", content_sha256: nil)
+    set_version_fixture(deck_plan.current_plan_version, content_markdown: "Before\n\n::: {.presentation}\n\n# Slide\n\n:::\n\nAfter", content_sha256: nil)
     get plan_page_path(deck_plan)
     expect(response).to have_http_status(:success)
     expect(response.body).to include('coplan--deck-presenter coplan--deck-reader')
@@ -221,7 +221,7 @@
   end
 
   it "renders presentation regions in historical versions" do
-    plan.current_plan_version.update!(content_markdown: "Before\n\n::: {.presentation}\n\n# Historical slide\n\n:::\n\nAfter", content_sha256: nil)
+    set_version_fixture(plan.current_plan_version, content_markdown: "Before\n\n::: {.presentation}\n\n# Historical slide\n\n:::\n\nAfter", content_sha256: nil)
 
     get plan_version_page_path(plan, plan.current_plan_version)
 
@@ -238,7 +238,7 @@
 
   it "show plan without content hides the outline and keeps discussion controls" do
     empty_plan = create(:plan, :considering, created_by_user: alice)
-    empty_plan.current_plan_version.update_columns(content_markdown: "", content_sha256: Digest::SHA256.hexdigest(""))
+    set_version_fixture(empty_plan.current_plan_version, content_markdown: "", content_sha256: Digest::SHA256.hexdigest(""))
     get plan_page_path(empty_plan)
     expect(response).to have_http_status(:success)
     expect(response.body).to include("empty-state")
@@ -529,7 +529,7 @@
 
   describe "content preview on rows" do
     it "renders a markdown-stripped preview when there is no AI summary" do
-      plan.current_plan_version.update!(content_markdown: "# Heading\n\nThis is the **plan body** with [links](https://example.com).")
+      set_version_fixture(plan.current_plan_version, content_markdown: "# Heading\n\nThis is the **plan body** with [links](https://example.com).")
       get library_page_path(alice)
       expect(response.body).to include("plan-row__summary")
       expect(response.body).to include("This is the plan body with links")
@@ -537,7 +537,7 @@
     end
 
     it "omits the summary line when the plan has no content" do
-      plan.current_plan_version.update_columns(content_markdown: "", content_sha256: Digest::SHA256.hexdigest(""))
+      set_version_fixture(plan.current_plan_version, content_markdown: "", content_sha256: Digest::SHA256.hexdigest(""))
       get library_page_path(alice)
       expect(response.body).not_to include("plan-row__summary")
     end
diff --git a/spec/requests/review_requests_spec.rb b/spec/requests/review_requests_spec.rb
index 4a4c9baa..4706ec62 100644
--- a/spec/requests/review_requests_spec.rb
+++ b/spec/requests/review_requests_spec.rb
@@ -6,6 +6,15 @@
   let(:plan) { create(:plan, :published, created_by_user: author) }
   let(:task) { create(:review_request, plan: plan, reviewer: reviewer) }
 
+  it "labels an agent decision separately from the reviewer's own human approval" do
+    token = create(:api_token, user: reviewer, agent_name: "Reviewbot")
+    CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 1, decision: "approved", api_token: token)
+    sign_in_as(reviewer)
+    get plan_review_requests_path(plan)
+    expect(response.body).to include("Reviewbot (via you) approved")
+    expect(task.reload.effective_human_decision).to be_nil
+  end
+
   it "marks an unread note-less review decision as attention until its owner reads it", :review_attention do
     CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: plan.current_revision, decision: "approved")
     notice = author.notifications.find_by!(review_request: task, reason: "review_response")
@@ -122,7 +131,7 @@
     expect(entries.size).to eq(3)
     expect(entries.map { |entry| entry.at_css(".review-log__event").text.squish }).to eq([
       "#{author.name} requested a review from #{reviewer.name}",
-      "#{reviewer.name} approved v1",
+      "#{reviewer.name} approved v1 · Markdown snapshot · Historical decision",
       "#{author.name} requested a review from #{reviewer.name}"
     ])
     expect(Time.iso8601(entries.last.at_css("time")["datetime"]).to_i).to eq(first_at.to_i)
diff --git a/spec/requests/toggle_checkbox_spec.rb b/spec/requests/toggle_checkbox_spec.rb
index df474f77..37087cb5 100644
--- a/spec/requests/toggle_checkbox_spec.rb
+++ b/spec/requests/toggle_checkbox_spec.rb
@@ -7,7 +7,7 @@
 
   before do
     sign_in_as(user)
-    plan.current_plan_version.update!(content_markdown: "# Tasks\n\n- [ ] Buy milk\n- [x] Write tests\n- [ ] Deploy")
+    set_version_fixture(plan.current_plan_version, content_markdown: "# Tasks\n\n- [ ] Buy milk\n- [x] Write tests\n- [ ] Deploy")
   end
 
   describe "PATCH toggle_checkbox" do
@@ -146,7 +146,7 @@
 
   describe "PATCH toggle_checkbox with duplicate task lines" do
     before do
-      plan.current_plan_version.update!(
+      set_version_fixture(plan.current_plan_version,
         content_markdown: "# Tasks\n\n- [ ] TODO\n- [ ] TODO\n- [ ] Deploy to staging\n- [ ] Deploy"
       )
     end
diff --git a/spec/services/broadcaster_spec.rb b/spec/services/broadcaster_spec.rb
index 8a68ad74..a2738962 100644
--- a/spec/services/broadcaster_spec.rb
+++ b/spec/services/broadcaster_spec.rb
@@ -53,7 +53,7 @@
 
     it "refreshes attribution for writes without a diff flash, without crediting untouched sections" do
       original = "## Design\n\nKeep the design.\n\n## Rollout\n\nOriginal rollout.\n"
-      plan.current_plan_version.update_columns(content_markdown: original)
+      set_version_fixture(plan.current_plan_version, content_markdown: original)
       version = create(:plan_version, plan: plan, revision: 2, actor_id: author.id,
         content_markdown: original.sub("Original rollout", "New rollout"))
       plan.update!(current_plan_version: version, current_revision: 2)
@@ -72,7 +72,7 @@
 
     it "preserves extensive rewrite metadata even without a diff flash" do
       original = %w[Design Data Rollout Testing].map { |title| "## #{title}\n\nOriginal #{title} body.\n" }.join("\n")
-      plan.current_plan_version.update_columns(content_markdown: original)
+      set_version_fixture(plan.current_plan_version, content_markdown: original)
       version = create(:plan_version, plan: plan, revision: 2, actor_id: author.id,
         content_markdown: original.gsub("Original", "Entirely new"))
       plan.update!(current_plan_version: version, current_revision: 2)
diff --git a/spec/services/coplan/references/extract_from_content_spec.rb b/spec/services/coplan/references/extract_from_content_spec.rb
index a09945cf..7721d85c 100644
--- a/spec/services/coplan/references/extract_from_content_spec.rb
+++ b/spec/services/coplan/references/extract_from_content_spec.rb
@@ -6,7 +6,7 @@
 
   def update_content(plan, content)
     version = plan.current_plan_version
-    version.update!(content_markdown: content)
+    set_version_fixture(version, content_markdown: content)
   end
 
   describe ".call" do
@@ -101,7 +101,7 @@ def update_content(plan, content)
     end
 
     it "handles empty content" do
-      plan.current_plan_version.update_column(:content_markdown, "")
+      set_version_fixture(plan.current_plan_version, content_markdown: "")
       described_class.call(plan: plan)
       expect(plan.references.count).to eq(0)
     end
diff --git a/spec/services/coplan/review_concurrency_spec.rb b/spec/services/coplan/review_concurrency_spec.rb
new file mode 100644
index 00000000..07c90fa7
--- /dev/null
+++ b/spec/services/coplan/review_concurrency_spec.rb
@@ -0,0 +1,83 @@
+require "rails_helper"
+
+RSpec.describe "Concurrent review and content commits" do
+  self.use_transactional_tests = false
+
+  after do
+    truncate_tables(*(ActiveRecord::Base.connection.tables - %w[schema_migrations ar_internal_metadata]))
+  end
+
+  def threaded(&block)
+    Thread.new { ActiveRecord::Base.connection_pool.with_connection(&block) }
+  end
+
+  it "makes an evidence read and stale response wait for the complete edit/reset transaction" do
+    owner = create(:coplan_user)
+    reviewer = create(:coplan_user)
+    plan = CoPlan::Plans::Create.call(title: "Concurrent review", content: "Before", user: owner)
+    task = CoPlan::Reviews::Request.call(plan: plan, reviewer: reviewer, actor: owner)
+    first = CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 1, generation: 1, decision: "approved")
+    edited, release, attempting = Queue.new, Queue.new, Queue.new
+    writer = threaded do
+      local = CoPlan::Plan.find(plan.id)
+      local.with_lock do
+        CoPlan::Plans::ReplaceContent.call(plan: local, new_content: "After", base_revision: 1, actor_type: "human", actor_id: owner.id)
+        edited << true
+        release.pop
+      end
+    end
+    Timeout.timeout(10) { edited.pop }
+    reader = threaded do
+      attempting << true
+      CoPlan::Reviews::Evidence.call(plan: CoPlan::Plan.find(plan.id))
+    end
+    responder = threaded do
+      attempting << true
+      begin
+        CoPlan::Reviews::Respond.call(request: CoPlan::ReviewRequest.find(task.id), actor: reviewer,
+          revision: 1, generation: 1, decision: "approved", idempotency_key: SecureRandom.uuid)
+      rescue CoPlan::Reviews::Respond::Conflict => error
+        error.code
+      end
+    end
+    Timeout.timeout(10) { 2.times { attempting.pop } }
+    expect(reader).to be_alive
+    expect(responder).to be_alive
+    release << true
+    [ writer, reader, responder ].each { |thread| expect(thread.join(20)).to be_present }
+    evidence = reader.value
+    expect(evidence[:version]).to include(revision: 2, content_markdown: "After")
+    expect(evidence[:review_requests].first).to include(status: "pending", effective_response_id: nil, generation: 2)
+    expect(evidence[:review_sequence]).to eq(first.decision_sequence + 1)
+    expect(responder.value).to eq("review_version_changed")
+    expect(task.reload.review_responses.pluck(:id)).to eq([ first.id ])
+  ensure
+    release << true if release
+    [ writer, reader, responder ].compact.each { |thread| thread.kill if thread.alive? }
+  end
+
+  it "serializes two same-time decisions with unique increasing server sequences" do
+    owner = create(:coplan_user)
+    reviewer = create(:coplan_user)
+    plan = CoPlan::Plans::Create.call(title: "Decision race", content: "Reviewed", user: owner)
+    task = CoPlan::Reviews::Request.call(plan: plan, reviewer: reviewer, actor: owner)
+    ready, start = Queue.new, Queue.new
+    threads = 2.times.map do |index|
+      threaded do
+        ready << true
+        start.pop
+        CoPlan::Reviews::Respond.call(request: CoPlan::ReviewRequest.find(task.id), actor: reviewer,
+          revision: 1, generation: 1, decision: index.zero? ? "approved" : "changes_requested",
+          note: index.zero? ? nil : "Please clarify", idempotency_key: SecureRandom.uuid)
+      end
+    end
+    Timeout.timeout(10) { 2.times { ready.pop } }
+    2.times { start << true }
+    threads.each { |thread| expect(thread.join(20)).to be_present }
+    responses = threads.map(&:value).sort_by(&:decision_sequence)
+    expect(responses.last.decision_sequence).to eq(responses.first.decision_sequence + 1)
+    expect(task.reload.effective_response).to eq(responses.last)
+  ensure
+    threads&.each { |thread| thread.kill if thread.alive? }
+  end
+end
diff --git a/spec/services/coplan/reviews_spec.rb b/spec/services/coplan/reviews_spec.rb
index ba55bceb..e700f1d6 100644
--- a/spec/services/coplan/reviews_spec.rb
+++ b/spec/services/coplan/reviews_spec.rb
@@ -9,7 +9,7 @@
 
   def respond(decision: "approved", note: nil, **attributes)
     CoPlan::Reviews::Respond.call(request: request, actor: reviewer, revision: plan.current_revision,
-      decision: decision, note: note, **attributes)
+      decision: decision, note: note, generation: request.reload.generation, **attributes)
   end
 
   it "requests optional review and sends a notification without granting permissions" do
@@ -23,12 +23,13 @@ def respond(decision: "approved", note: nil, **attributes)
     expect(plan.plan_collaborators).to be_empty
   end
 
-  it "preserves the original approval after edits and another review request" do
+  it "dismisses the active approval after edits and preserves its receipt" do
     response = respond(note: "Looks right")
     expect(response.comment_thread.comments.first.body_markdown).to eq("Looks right")
     version = create(:plan_version, plan: plan, revision: 2, content_markdown: "A revised plan")
-    plan.update!(current_plan_version: version, current_revision: 2)
-    expect(request.reload.status).to eq("approved")
+    plan.with_lock { CoPlan::Plans::AdvanceVersion.call(plan: plan, version: version) }
+    expect(request.reload.status).to eq("pending")
+    expect(request.effective_response).to be_nil
     expect(response.reload.plan_version.revision).to eq(1)
     CoPlan::Reviews::Request.call(plan: plan, reviewer: reviewer, actor: plan.created_by_user)
     expect(request.reload).to be_pending
@@ -42,7 +43,7 @@ def respond(decision: "approved", note: nil, **attributes)
     original_actor = original.requested_by_user
     respond
     version = create(:plan_version, plan: plan, revision: 2, content_markdown: "A revised plan")
-    plan.update!(current_plan_version: version, current_revision: 2)
+    plan.with_lock { CoPlan::Plans::AdvanceVersion.call(plan: plan, version: version) }
     next_actor = create(:coplan_user)
     travel_to(1.hour.from_now) do
       CoPlan::Reviews::Request.call(plan: plan, reviewer: reviewer, actor: next_actor, requirement: "optional")
@@ -61,7 +62,7 @@ def respond(decision: "approved", note: nil, **attributes)
   it "keeps pending requests on the latest plan and binds only the completed response" do
     task = request
     version = create(:plan_version, plan: plan, revision: 2, content_markdown: "Latest plan")
-    plan.update!(current_plan_version: version, current_revision: 2)
+    plan.with_lock { CoPlan::Plans::AdvanceVersion.call(plan: plan, version: version) }
     expect(CoPlan::Reviews::Serialize.call(task)).not_to have_key(:requested_revision)
     response = respond
     expect(response.plan_version).to eq(version)
@@ -131,7 +132,7 @@ def respond(decision: "approved", note: nil, **attributes)
     key = SecureRandom.uuid
     first = respond(note: "Reviewed", idempotency_key: key)
     version = create(:plan_version, plan: plan, revision: 2, content_markdown: "A newer plan")
-    plan.update!(current_plan_version: version, current_revision: 2)
+    plan.with_lock { CoPlan::Plans::AdvanceVersion.call(plan: plan, version: version) }
     CoPlan::Reviews::Request.call(plan: plan, reviewer: reviewer, actor: plan.created_by_user)
     replay = CoPlan::Reviews::Respond.call(request: request, actor: reviewer,
       revision: 1, decision: "approved", note: "Reviewed", idempotency_key: key)
diff --git a/spec/services/coplan/versioned_reviews_spec.rb b/spec/services/coplan/versioned_reviews_spec.rb
new file mode 100644
index 00000000..6ba2785b
--- /dev/null
+++ b/spec/services/coplan/versioned_reviews_spec.rb
@@ -0,0 +1,121 @@
+require "rails_helper"
+
+RSpec.describe "Version-bound review evidence" do
+  let(:plan) { CoPlan::Plans::Create.call(title: "Reviewed body", content: "# Plan\n\n- [ ] Ship", user: create(:coplan_user)) }
+  let(:reviewer) { create(:coplan_user) }
+  let(:task) { CoPlan::Reviews::Request.call(plan: plan, reviewer: reviewer, actor: plan.created_by_user) }
+
+  def decide(**attributes)
+    CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: plan.reload.current_revision,
+      generation: task.reload.generation, decision: "approved", idempotency_key: SecureRandom.uuid, **attributes)
+  end
+
+  def replace(content)
+    CoPlan::Plans::ReplaceContent.call(plan: plan, new_content: content, base_revision: plan.reload.current_revision,
+      actor_type: "human", actor_id: plan.created_by_user_id)
+  end
+
+  it "pools current-version human decisions while retaining dismissed receipts and withdrawn tasks" do
+    first = decide
+    other = CoPlan::Reviews::Request.call(plan: plan, reviewer: create(:coplan_user), actor: plan.created_by_user)
+    CoPlan::Reviews::Respond.call(request: other, actor: other.reviewer, revision: 1, generation: other.generation, decision: "approved")
+    withdrawn = CoPlan::Reviews::Request.call(plan: plan, reviewer: create(:coplan_user), actor: plan.created_by_user)
+    CoPlan::Reviews::Withdraw.call(request: withdrawn, actor: plan.created_by_user)
+    expect(CoPlan::Reviews::Evidence.call(plan: plan)[:review_requests].count { |r| r[:effective_human_decision] == "approved" }).to eq(2)
+    count = CoPlan::Notification.count
+    replace("# Plan\n\nRevised")
+    expect(CoPlan::Notification.count).to eq(count)
+    expect(task.reload).to have_attributes(status: "pending", current_response_id: nil, reset_reason: "content_changed")
+    expect(other.reload.status).to eq("pending")
+    expect(withdrawn.reload.status).to eq("withdrawn")
+    expect(first.reload.plan_version.verified_content!).to eq("# Plan\n\n- [ ] Ship")
+    expect(CoPlan::Reviews::Evidence.call(plan: plan)[:review_requests].map { |r| r[:effective_human_decision] }).to all(be_nil)
+  end
+
+  it "keeps actual replacement no-ops approved, but never revives A after A to B to A" do
+    first = decide
+    original = plan.current_content
+    sequence = plan.reload.review_sequence
+    expect(replace(original.gsub("\n", "\r\n"))[:no_op]).to be(true)
+    expect(plan.reload.review_sequence).to eq(sequence)
+    expect(task.reload.effective_response).to eq(first)
+    replace("B")
+    replace(original)
+    expect(plan.current_plan_version.content_sha256).to eq(first.plan_version.content_sha256)
+    expect(plan.current_plan_version_id).not_to eq(first.plan_version_id)
+    expect(task.reload.effective_response).to be_nil
+  end
+
+  it "dismisses on human drafts and checkbox edits" do
+    decide
+    CoPlan::Plans::ToggleCheckbox.call(plan: plan, old_text: "- [ ] Ship", new_text: "- [x] Ship", base_revision: 1, actor_id: plan.created_by_user_id)
+    expect(task.reload.effective_response).to be_nil
+    decide
+    CoPlan::Plans::SaveHumanDraft.call(plan: plan, content: "A human draft", base_revision: 2, actor: plan.created_by_user)
+    expect(task.reload).to have_attributes(status: "pending", current_response_id: nil)
+  end
+
+  it "dismisses on session commits, including operations that net to the same bytes" do
+    first = decide
+    session = CoPlan::EditSession.create!(plan: plan, actor_type: "human", actor_id: plan.created_by_user_id,
+      base_revision: 1, status: "open", expires_at: 1.hour.from_now,
+      draft_content: plan.current_content, operations_json: [ { "op" => "replace_exact", "old_text" => "Ship", "new_text" => "Ship" } ])
+    result = CoPlan::Plans::CommitSession.call(session: session)
+    expect(result[:version].content_sha256).to eq(first.plan_version.content_sha256)
+    expect(task.reload.effective_response).to be_nil
+    decide
+    empty = CoPlan::EditSession.create!(plan: plan, actor_type: "human", actor_id: plan.created_by_user_id,
+      base_revision: 2, status: "open", expires_at: 1.hour.from_now)
+    expect(CoPlan::Plans::CommitSession.call(session: empty)[:version]).to be_nil
+    expect(task.reload.effective_human_decision).to eq("approved")
+  end
+
+  it "rejects delayed first-seen keyed and legacy intentions for a reopened task" do
+    task
+    old_generation = task.generation
+    CoPlan::Reviews::Request.call(plan: plan, reviewer: reviewer, actor: plan.created_by_user)
+    [ { idempotency_key: SecureRandom.uuid, generation: old_generation }, {} ].each do |attributes|
+      expect {
+        CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 1, decision: "approved", **attributes)
+      }.to raise_error(CoPlan::Reviews::Respond::Conflict, /request changed/)
+    end
+    expect(task.reload.effective_response).to be_nil
+    expect(decide.request_generation).to eq(task.generation)
+  end
+
+  it "orders reconsideration by server sequence, not caller UUID or timestamp, and distinguishes agents" do
+    travel_to(Time.current.change(usec: 0)) do
+      objection = decide(decision: "changes_requested", note: "Clarify this", idempotency_key: "ffffffff-ffff-4fff-afff-ffffffffffff")
+      agent = decide(api_token: create(:api_token, user: reviewer, agent_name: "Reviewbot"), idempotency_key: "00000000-0000-4000-a000-000000000000")
+      expect(task.reload.effective_response).to eq(agent)
+      expect(task.effective_human_decision).to be_nil
+      expect(CoPlan::Reviews::Serialize.call(task)[:latest_human_response_id]).to eq(objection.id)
+      human = decide
+      expect(task.reload.effective_human_decision).to eq("approved")
+      expect(task.review_responses.map(&:id)).to eq([ human.id, agent.id, objection.id ])
+      expect([ objection, agent, human ].map(&:decision_sequence)).to eq([ objection.decision_sequence, objection.decision_sequence + 1, objection.decision_sequence + 2 ])
+    end
+  end
+
+  it "rolls back version, resets and sequence together when a content transaction fails" do
+    first = decide
+    before = plan.reload.review_sequence
+    plan.with_lock do
+      replace("Rolled back")
+      raise ActiveRecord::Rollback
+    end
+    expect(plan.reload.current_revision).to eq(1)
+    expect(plan.review_sequence).to eq(before)
+    expect(task.reload.effective_response).to eq(first)
+  end
+
+  it "makes the content boundary explicit and leaves title and attachment metadata outside approval" do
+    first = decide
+    plan.update!(title: "Different title")
+    plan.attachments.attach(io: StringIO.new("mutable resource"), filename: "scope.txt", content_type: "text/plain")
+    evidence = CoPlan::Reviews::Evidence.call(plan: plan)
+    expect(evidence[:approval_scope][:excludes]).to include("title", "attachments", "embedded_resources", "child_plans")
+    expect(evidence[:version][:content_markdown]).to eq(first.plan_version.content_markdown)
+    expect(task.reload.effective_response).to eq(first)
+  end
+end
diff --git a/spec/services/link_previews_spec.rb b/spec/services/link_previews_spec.rb
index a84afa4e..8a4f4fe0 100644
--- a/spec/services/link_previews_spec.rb
+++ b/spec/services/link_previews_spec.rb
@@ -151,12 +151,12 @@
     expect(described_class.for_plan(plan, base_url: base_url).description).to eq("Generated summary")
 
     plan.update!(summary: nil)
-    plan.current_plan_version.update!(content_markdown: "# Heading\n\n#{"word " * 80}", content_sha256: nil)
+    set_version_fixture(plan.current_plan_version, content_markdown: "# Heading\n\n#{"word " * 80}", content_sha256: nil)
     first = described_class.for_plan(plan.reload, base_url: base_url)
     expect(first.description.length).to be <= 240
     expect(first.description).not_to include("#")
 
-    plan.current_plan_version.update!(content_markdown: "Changed", content_sha256: nil)
+    set_version_fixture(plan.current_plan_version, content_markdown: "Changed", content_sha256: nil)
     expect(described_class.for_plan(plan.reload, base_url: base_url).cache_key).not_to eq(first.cache_key)
   end
 
diff --git a/spec/services/plans/section_updates_spec.rb b/spec/services/plans/section_updates_spec.rb
index 66065288..e79f92e0 100644
--- a/spec/services/plans/section_updates_spec.rb
+++ b/spec/services/plans/section_updates_spec.rb
@@ -12,7 +12,7 @@ def add_version(revision, content, user = author)
     version
   end
 
-  before { plan.current_plan_version.update_columns(content_markdown: original) }
+  before { set_version_fixture(plan.current_plan_version, content_markdown: original) }
 
   it "attributes each section to its last actual edit, even after later unrelated edits" do
     design_content = original.sub("Original design", "Revised design")
diff --git a/spec/support/version_fixtures.rb b/spec/support/version_fixtures.rb
new file mode 100644
index 00000000..c9c0c2bf
--- /dev/null
+++ b/spec/support/version_fixtures.rb
@@ -0,0 +1,12 @@
+# Test setup for legacy/empty bodies. Production model writes remain immutable.
+module VersionFixtures
+  def set_version_fixture(version, **attributes)
+    if attributes.key?(:content_markdown)
+      attributes[:content_sha256] = Digest::SHA256.hexdigest(attributes[:content_markdown].to_s)
+    end
+    CoPlan::PlanVersion.where(id: version.id).update_all(attributes)
+    version.reload
+  end
+end
+
+RSpec.configure { |config| config.include VersionFixtures }
diff --git a/spec/system/changed_sections_ux_spec.rb b/spec/system/changed_sections_ux_spec.rb
index 63f7743b..9afbb6ed 100644
--- a/spec/system/changed_sections_ux_spec.rb
+++ b/spec/system/changed_sections_ux_spec.rb
@@ -43,7 +43,7 @@
   end
   let(:plan) do
     p = create(:plan, :published, created_by_user: author)
-    p.current_plan_version.update_columns(content_markdown: content, created_at: 2.hours.ago)
+    set_version_fixture(p.current_plan_version, content_markdown: content, created_at: 2.hours.ago)
     CoPlan::PlanViewer.create!(plan: p, user: viewer, last_seen_at: 1.hour.ago)
     version = create(:plan_version, plan: p, revision: 2, actor_id: author.id,
       content_markdown: content.sub("easy to read", "comfortable to read").sub("same heading", "same heading, now updated"))
diff --git a/spec/system/checkbox_spec.rb b/spec/system/checkbox_spec.rb
index c36884bd..9cafcbed 100644
--- a/spec/system/checkbox_spec.rb
+++ b/spec/system/checkbox_spec.rb
@@ -163,7 +163,7 @@ def sign_in(user)
   end
 
   it "toggles the correct checkbox when task lines are duplicated" do
-    plan.current_plan_version.update!(
+    set_version_fixture(plan.current_plan_version,
       content_markdown: "# Tasks\n\n- [ ] TODO\n- [ ] TODO\n- [ ] Deploy\n- [ ] Deploy to staging"
     )
 
@@ -179,7 +179,7 @@ def sign_in(user)
   end
 
   it "toggles a task whose text is a prefix of another task" do
-    plan.current_plan_version.update!(
+    set_version_fixture(plan.current_plan_version,
       content_markdown: "# Tasks\n\n- [ ] Deploy to staging\n- [ ] Deploy"
     )
 
diff --git a/spec/system/comment_ux_spec.rb b/spec/system/comment_ux_spec.rb
index 5e36dfde..47fdb1ca 100644
--- a/spec/system/comment_ux_spec.rb
+++ b/spec/system/comment_ux_spec.rb
@@ -135,7 +135,7 @@ def create_anchored_thread(plan:, anchor_text:, body:, user:)
     end
 
     it "preserves generated duplicate fragments and authored heading links" do
-      plan.current_plan_version.update!(content_markdown: "## Intro\n\nFirst\n\n## Intro\n\nSecond")
+      set_version_fixture(plan.current_plan_version, content_markdown: "## Intro\n\nFirst\n\n## Intro\n\nSecond")
       visit plan_page_path(plan)
 
       expect(all(".markdown-rendered h2").map { |heading| heading[:id] }).to eq(%w[intro intro-1])
@@ -153,7 +153,7 @@ def create_anchored_thread(plan:, anchor_text:, body:, user:)
     end
 
     it "renders Mermaid fences as diagrams" do
-      plan.current_plan_version.update!(content_markdown: <<~MARKDOWN)
+      set_version_fixture(plan.current_plan_version, content_markdown: <<~MARKDOWN)
         # Request flow
 
         ```mermaid
@@ -176,7 +176,7 @@ def create_anchored_thread(plan:, anchor_text:, body:, user:)
     end
 
     it "expands a Mermaid diagram using the expand control" do
-      plan.current_plan_version.update!(content_markdown: <<~MARKDOWN)
+      set_version_fixture(plan.current_plan_version, content_markdown: <<~MARKDOWN)
         ```mermaid
         flowchart LR
           Client --> API
@@ -197,7 +197,7 @@ def create_anchored_thread(plan:, anchor_text:, body:, user:)
     end
 
     it "keeps invalid Mermaid source readable" do
-      plan.current_plan_version.update!(content_markdown: <<~MARKDOWN)
+      set_version_fixture(plan.current_plan_version, content_markdown: <<~MARKDOWN)
         ```mermaid
         not a valid diagram
         ```
@@ -330,7 +330,7 @@ def create_anchored_thread(plan:, anchor_text:, body:, user:)
     end
 
     it "opens a popover for a comment anchored to a Mermaid label" do
-      plan.current_plan_version.update!(content_markdown: <<~MARKDOWN)
+      set_version_fixture(plan.current_plan_version, content_markdown: <<~MARKDOWN)
         # Request flow
 
         ```mermaid
@@ -380,7 +380,7 @@ def create_anchored_thread(plan:, anchor_text:, body:, user:)
     end
 
     it "keeps a keyboard-opened Mermaid popover attached across re-renders" do
-      plan.current_plan_version.update!(content_markdown: <<~MARKDOWN)
+      set_version_fixture(plan.current_plan_version, content_markdown: <<~MARKDOWN)
         ```mermaid
         flowchart LR
           Queue["assignment"] --> Printer
@@ -466,7 +466,7 @@ def create_anchored_thread(plan:, anchor_text:, body:, user:)
     end
 
     it "opens a linked comment anchored to a Mermaid label" do
-      plan.current_plan_version.update!(content_markdown: <<~MARKDOWN)
+      set_version_fixture(plan.current_plan_version, content_markdown: <<~MARKDOWN)
         ```mermaid
         flowchart LR
           Queue["~3 min retries"] --> Printer
@@ -499,7 +499,7 @@ def create_anchored_thread(plan:, anchor_text:, body:, user:)
     end
 
     it "opens a pending linked comment after Mermaid rendering fails" do
-      plan.current_plan_version.update!(content_markdown: <<~MARKDOWN)
+      set_version_fixture(plan.current_plan_version, content_markdown: <<~MARKDOWN)
         ```mermaid
         not a valid diagram
         ```
@@ -936,7 +936,7 @@ def create_anchored_thread(plan:, anchor_text:, body:, user:)
     before { sign_in(author) }
 
     it "keeps an overlapping heading comment visible and clickable after reload" do
-      plan.current_plan_version.update!(content_markdown: <<~MARKDOWN)
+      set_version_fixture(plan.current_plan_version, content_markdown: <<~MARKDOWN)
         # Performance
 
         ## 1.3 Hard carts — and why native degrades fast
diff --git a/spec/system/folders_workspace_spec.rb b/spec/system/folders_workspace_spec.rb
index 9f595f4f..fe6b0583 100644
--- a/spec/system/folders_workspace_spec.rb
+++ b/spec/system/folders_workspace_spec.rb
@@ -127,7 +127,7 @@ def sign_in(user)
     end
 
     it "goes up to the plan's containing folder from the masthead and sticky nav" do
-      foldered_plan.current_plan_version.update!(
+      set_version_fixture(foldered_plan.current_plan_version,
         content_markdown: (1..30).map { |n| "## Section #{n}\n\nEnough content to scroll past the masthead." }.join("\n\n")
       )
       # The masthead links straight at the canonical browsable path, so
diff --git a/spec/system/plan_reviews_spec.rb b/spec/system/plan_reviews_spec.rb
index 47fa5804..3a397417 100644
--- a/spec/system/plan_reviews_spec.rb
+++ b/spec/system/plan_reviews_spec.rb
@@ -40,6 +40,54 @@ def lose_next_review_result
 
   before { sign_in_browser(reviewer, open_sections: !RSpec.current_example.metadata[:collapsed_support]) }
 
+  it "dismisses an approval after an edit, preserves its snapshot and accepts a fresh review", :version_parity do
+    within(".review-tray") { click_button "Approve", exact: true }
+    within(".review-confirmation") do
+      expect(page).to have_text("Attachments, linked or embedded content")
+      click_button "Approve v1", exact: true
+    end
+    expect(page).to have_css(".review-tray", text: "You approved v1")
+    original = task.reload.effective_response.plan_version
+    CoPlan::Plans::ReplaceContent.call(plan: plan, new_content: "# Revised\n\nEveryone must review this change.",
+      base_revision: 1, actor_type: "human", actor_id: author.id)
+    visit plan_page_path(plan)
+    expand_plan_section("footnote-approvals")
+    expect(page).to have_css(".review-tray", text: "Content changed; review v2 again")
+    expect(page).to have_css(".review-person__meta", text: "Content changed; review again")
+    expect(task.reload.effective_response).to be_nil
+    [ "light", "dark" ].each do |theme|
+      page.execute_script("document.documentElement.dataset.theme = arguments[0]", theme)
+      page.save_screenshot(Rails.root.join("tmp/review-preview/version-dismissal-#{theme}.png"))
+    end
+    within("#footnote-approvals") { click_button "View activity", exact: false }
+    within(".review-activity-dialog[open]") do
+      expect(page).to have_text("Historical decision")
+      click_link "v1 · Markdown snapshot"
+    end
+    expect(page).to have_text("Exact Markdown source")
+    find("summary", text: "Exact Markdown source").click
+    expect(page).to have_css("pre code", text: original.content_markdown)
+    visit plan_page_path(plan)
+    within(".review-tray") { click_button "Approve", exact: true }
+    within(".review-confirmation") { click_button "Approve v2", exact: true }
+    expect(page).to have_css(".review-tray", text: "You approved v2")
+    expect(task.reload.effective_response.plan_version.revision).to eq(2)
+  end
+
+  it "rejects a decision opened before a same-version re-request", :version_parity do
+    within(".review-tray") { click_button "Approve", exact: true }
+    CoPlan::Reviews::Request.call(plan: plan, reviewer: reviewer, actor: author)
+    within(".review-confirmation") { click_button "Approve v1", exact: true }
+    expect(page).to have_css(".review-confirmation [role='alert']", text: "review request changed")
+    expect(task.reload).to be_pending
+    expect(task.review_responses).to be_empty
+    click_button "Close approval", enable_aria_label: true
+    within(".review-tray") { click_button "Approve", exact: true }
+    within(".review-confirmation") { click_button "Approve v1", exact: true }
+    expect(page).to have_css(".review-tray", text: "You approved v1")
+    expect(task.reload.effective_response.request_generation).to eq(2)
+  end
+
   it "keeps a withdrawn request between its two request cycles", :review_withdrawals do
     sign_in_browser(author)
     click_button "More actions"
@@ -165,7 +213,7 @@ def lose_next_review_result
 
   it "records approvals and public change requests on an empty version" do
     # Older hosts can have a persisted empty version, as in plans_spec.
-    plan.current_plan_version.update_columns(content_markdown: "", content_sha256: Digest::SHA256.hexdigest(""))
+    set_version_fixture(plan.current_plan_version, content_markdown: "", content_sha256: Digest::SHA256.hexdigest(""))
     visit plan_page_path(plan)
     expect(page).to have_content("This plan has no content yet.")
     within(".review-tray") { click_button "Approve", exact: true }
@@ -277,7 +325,7 @@ def lose_next_review_result
 
   it "confirms approval with simple wording and a top-left close control" do
     within(".review-tray") { click_button "Approve" }
-    expect(page).to have_css(".review-confirmation[open]", text: "I’ve reviewed this version and approve it.")
+    expect(page).to have_css(".review-confirmation[open]", text: "I’ve reviewed and approve the Markdown source of this version.")
     expect(page).to have_css(".review-confirmation__close:focus")
     expect(page).to have_css("#approval-title", text: "Approve v1?")
     expect(page).to have_no_content("AI agents can see this sign-off")
@@ -334,7 +382,7 @@ def lose_next_review_result
     within(".review-tray") { click_button "Approve" }
     fill_in "Public note", with: "An unsent approval note"
     version = create(:plan_version, plan: plan, revision: 2, content_markdown: "Changed while reviewing")
-    plan.update!(current_plan_version: version, current_revision: 2)
+    plan.with_lock { CoPlan::Plans::AdvanceVersion.call(plan: plan, version: version) }
     click_button "Approve v1"
     expect(page).to have_content("The plan has changed. Review the latest version")
     expect(page).to have_field("Public note", with: "An unsent approval note")
@@ -362,13 +410,13 @@ def lose_next_review_result
   it "compares later edits while preserving the approval of the earlier version" do
     CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 1, decision: "approved")
     version = create(:plan_version, plan: plan, revision: 2, content_markdown: "A clarified retry contract.")
-    plan.update!(current_plan_version: version, current_revision: 2)
+    plan.with_lock { CoPlan::Plans::AdvanceVersion.call(plan: plan, version: version) }
     visit plan_page_path(plan)
     within("#footnote-approvals") { click_button "Compare", exact: false }
     expect(page).to have_css(".review-comparison[open]", text: "Version 1 → 2")
     expect(page).to have_content("A clarified retry contract.")
     expect(page).to have_content("The earlier approval remains recorded")
-    expect(task.reload.status).to eq("approved")
+    expect(task.reload.status).to eq("pending")
     expect(task.latest_approval.plan_version.revision).to eq(1)
   end
 
@@ -837,11 +885,11 @@ def lose_next_review_result
     click_button "Close review activity", enable_aria_label: true
     CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 1, decision: "approved")
     version = create(:plan_version, plan: plan, revision: 2, content_markdown: "# Revised contract\n\nMore detail")
-    plan.update!(current_plan_version: version, current_revision: 2)
+    plan.with_lock { CoPlan::Plans::AdvanceVersion.call(plan: plan, version: version) }
     visit plan_page_path(plan)
     expect(page).to have_no_css("#plan-header [data-review-indicator]", visible: :all)
     within(".review-table") do
-      expect(page).to have_css(".review-version", text: "v1")
+      expect(page).to have_css(".review-person__meta", text: "Content changed; review again")
       expect(page).to have_button("Compare")
     end
     expect(page).to have_css(".review-activity-dialog .review-history", text: /Plan Reviewer approved\s+v1/, visible: :all)

From 66f199a81c5c426cc41842a2c75b598d3d581d17 Mon Sep 17 00:00:00 2001
From: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
Date: Thu, 29 Oct 2026 13:31:26 -0400
Subject: [PATCH 02/18] Show that approval resets are required

---
 engine/app/assets/stylesheets/coplan/review.css    |  2 ++
 .../app/views/coplan/reviews/_management.html.erb  |  4 ++++
 spec/system/plan_reviews_spec.rb                   | 14 ++++++++++++++
 3 files changed, 20 insertions(+)

diff --git a/engine/app/assets/stylesheets/coplan/review.css b/engine/app/assets/stylesheets/coplan/review.css
index e6603786..ea134b0c 100644
--- a/engine/app/assets/stylesheets/coplan/review.css
+++ b/engine/app/assets/stylesheets/coplan/review.css
@@ -241,6 +241,8 @@ button.visibility-option__button:hover:not(:disabled) { background: var(--color-
 .review-assignment-form__footer { display: flex; justify-content: space-between; align-items: center; gap: 12px; margin-top: 12px; }
 .review-dialog .review-required { display: flex; gap: 8px; align-items: center; margin: 0; color: var(--color-text); cursor: pointer; }
 .review-dialog .review-required input { width: 15px; height: 15px; padding: 0; margin: 0; accent-color: var(--color-primary); }
+.review-reset-policy { margin-bottom: 20px; }
+.review-reset-policy p { margin: 6px 0 0 23px; }
 .review-search-results { position: absolute; z-index: 1; top: calc(100% + 6px); left: 0; right: 0; max-height: 210px; overflow: auto; padding: 6px; border: 1px solid var(--glass-edge); border-radius: 10px; background: var(--color-surface); color: var(--color-text-muted); box-shadow: var(--shadow-lg); font-size: 12px; }
 .review-search-results[hidden] { display: none; }
 .review-search-result {
diff --git a/engine/app/views/coplan/reviews/_management.html.erb b/engine/app/views/coplan/reviews/_management.html.erb
index 4f943236..a0677a53 100644
--- a/engine/app/views/coplan/reviews/_management.html.erb
+++ b/engine/app/views/coplan/reviews/_management.html.erb
@@ -12,6 +12,10 @@
       <button type="button" class="review-add-button" title="Add reviewer" aria-expanded="false" aria-haspopup="dialog" aria-controls="review-assignment" popovertarget="review-assignment" data-coplan--review-tray-target="addReviewerButton"><span aria-hidden="true">+</span> Add reviewer</button>
     <% end %>
   </div>
+  <div class="review-reset-policy">
+    <label class="review-required"><input type="checkbox" checked disabled aria-describedby="review-reset-explanation"> Reset approvals when content changes</label>
+    <p id="review-reset-explanation" class="text-sm text-muted">Required for all reviewers. Every new content version needs fresh approvals.</p>
+  </div>
   <% if allowed_to?(plan, :update?) %>
     <div id="review-assignment" class="review-assignment" popover="auto" role="dialog" aria-label="Add reviewer" data-coplan--review-tray-target="assignment" data-action="toggle->coplan--review-tray#assignmentToggled keydown.esc->coplan--review-tray#dismissAssignment">
       <%= form_with url: plan_review_requests_path(plan), class: "review-assignment-form", data: { action: "submit->coplan--review-tray#assign" } do %>
diff --git a/spec/system/plan_reviews_spec.rb b/spec/system/plan_reviews_spec.rb
index 3a397417..98e7730a 100644
--- a/spec/system/plan_reviews_spec.rb
+++ b/spec/system/plan_reviews_spec.rb
@@ -40,6 +40,20 @@ def lose_next_review_result
 
   before { sign_in_browser(reviewer, open_sections: !RSpec.current_example.metadata[:collapsed_support]) }
 
+  [ "light", "dark" ].each do |theme|
+    it "shows content-change resets as required in the reviewer dialog in #{theme} theme", :review_reset_policy do
+      sign_in_browser(author)
+      page.execute_script("document.documentElement.dataset.theme = arguments[0]", theme)
+      click_button "More actions"
+      within("#plan-menu") { click_button "Manage reviewers" }
+      within(".review-management[open]") do
+        expect(page).to have_checked_field("Reset approvals when content changes", disabled: true)
+        expect(page).to have_text("Required for all reviewers. Every new content version needs fresh approvals.")
+      end
+      page.save_screenshot(Rails.root.join("tmp/review-preview/reset-policy-required-#{theme}.png"))
+    end
+  end
+
   it "dismisses an approval after an edit, preserves its snapshot and accepts a fresh review", :version_parity do
     within(".review-tray") { click_button "Approve", exact: true }
     within(".review-confirmation") do

From e1e91484cda166265549141cd510681e4070d206 Mon Sep 17 00:00:00 2001
From: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
Date: Thu, 29 Oct 2026 14:00:11 -0400
Subject: [PATCH 03/18] Make automatic review resets configurable

Signed-off-by: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
---
 ...ew_reset_policy_to_coplan_plans.co_plan.rb |   6 +
 db/schema.rb                                  |   3 +-
 docs/REVIEWS.md                               |  12 +-
 .../app/assets/stylesheets/coplan/review.css  |   3 +
 .../coplan/review_requests_controller.rb      |  13 ++
 .../coplan/review_tray_controller.js          |  69 +++++++-
 engine/app/models/coplan/plan.rb              |   1 +
 engine/app/models/coplan/review_request.rb    |  19 ++-
 .../services/coplan/plans/advance_version.rb  |   5 +-
 .../app/services/coplan/reviews/evidence.rb   |   1 +
 .../app/services/coplan/reviews/serialize.rb  |   3 +-
 .../agent_instructions/guides/api.text.erb    |   2 +-
 .../guides/comments.text.erb                  |   2 +-
 .../agent_instructions/guides/live.text.erb   |   2 +-
 .../views/coplan/reviews/_controls.html.erb   |  12 +-
 engine/app/views/coplan/reviews/_log.html.erb |   2 +-
 .../views/coplan/reviews/_management.html.erb |   8 +-
 .../app/views/coplan/reviews/_roster.html.erb |   6 +-
 .../app/views/coplan/reviews/_table.html.erb  |   6 +-
 engine/config/routes.rb                       |   1 +
 engine/db/demo/content/retained-review.md     |   7 +
 ...add_review_reset_policy_to_coplan_plans.rb |   5 +
 engine/lib/coplan/development_seed.rb         |  13 +-
 spec/lib/development_seed_spec.rb             |  10 ++
 spec/requests/api/v1/operations_spec.rb       |  15 ++
 spec/requests/api/v1/review_evidence_spec.rb  |  14 ++
 spec/requests/review_requests_spec.rb         |  22 +++
 .../coplan/review_concurrency_spec.rb         |  83 +++++-----
 .../services/coplan/versioned_reviews_spec.rb |  90 +++++++++++
 spec/system/plan_reviews_spec.rb              | 151 +++++++++++++++++-
 30 files changed, 507 insertions(+), 79 deletions(-)
 create mode 100644 db/migrate/20261029174023_add_review_reset_policy_to_coplan_plans.co_plan.rb
 create mode 100644 engine/db/demo/content/retained-review.md
 create mode 100644 engine/db/migrate/20261029120000_add_review_reset_policy_to_coplan_plans.rb

diff --git a/db/migrate/20261029174023_add_review_reset_policy_to_coplan_plans.co_plan.rb b/db/migrate/20261029174023_add_review_reset_policy_to_coplan_plans.co_plan.rb
new file mode 100644
index 00000000..508333f8
--- /dev/null
+++ b/db/migrate/20261029174023_add_review_reset_policy_to_coplan_plans.co_plan.rb
@@ -0,0 +1,6 @@
+# This migration comes from co_plan (originally 20261029120000)
+class AddReviewResetPolicyToCoplanPlans < ActiveRecord::Migration[8.1]
+  def change
+    add_column :coplan_plans, :reset_reviews_on_change, :boolean, null: false, default: true
+  end
+end
diff --git a/db/schema.rb b/db/schema.rb
index 65543fc8..69d0b64c 100644
--- a/db/schema.rb
+++ b/db/schema.rb
@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema[8.1].define(version: 2026_10_29_141536) do
+ActiveRecord::Schema[8.1].define(version: 2026_10_29_174023) do
   create_table "active_admin_comments", id: { type: :string, limit: 36 }, charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
     t.bigint "author_id"
     t.string "author_type"
@@ -411,6 +411,7 @@
     t.integer "current_revision", default: 0, null: false
     t.json "metadata"
     t.string "plan_type_id", limit: 36, null: false
+    t.boolean "reset_reviews_on_change", default: true, null: false
     t.bigint "review_sequence", default: 0, null: false
     t.text "search_text", size: :medium
     t.string "slug", null: false
diff --git a/docs/REVIEWS.md b/docs/REVIEWS.md
index 048b10a8..bbc9ce7f 100644
--- a/docs/REVIEWS.md
+++ b/docs/REVIEWS.md
@@ -4,15 +4,17 @@ A native review means satisfaction with a specific Markdown source version. It g
 
 ## Content and decision identity
 
-Responses retain `plan_version_id`, that version’s SHA-256, `request_generation`, and a server-assigned `decision_sequence`. UUIDs identify transport retries; they do not order decisions. A request’s `current_response_id` is the authoritative projection. A response is effective only when it belongs to that request, generation and current plan version and matches the task status. `effective_human_decision` is null for pending, withdrawn, dismissed or agent decisions. `latest_approval` is positive history for comparison, not qualification.
+Responses retain `plan_version_id`, that version’s SHA-256, `request_generation`, and a server-assigned `decision_sequence`. UUIDs identify transport retries; they do not order decisions. A request’s `current_response_id` is the authoritative projection. `review_status` and `recorded_response_id` describe lifecycle completion, including a decision retained across edits when automatic resets are off. A response is effective only when it belongs to that request, generation and current plan version and matches the task status. `effective_human_decision` is null for pending, withdrawn, dismissed or agent decisions. `latest_approval` is positive history for comparison, not qualification.
 
 The approval covers **Markdown source bytes only**. Title, tags, attachments, linked and embedded resources, child plans, and rendered output are excluded. URLs and embedded source syntax are approved as literal text, not as the bytes they might display. Historical pages expose exact source and hash and label the current title as metadata. Full rich-page approval requires a separate immutable asset envelope and renderer contract.
 
 ## Edits and cycles
 
-All current-version writers use `Plans::AdvanceVersion`: Create, ReplaceContent (including SaveHumanDraft/web saves), CommitSession, ToggleCheckbox and the direct operations API. They already hold the plan row lock; CommitSession retains session-before-plan lock order. The version pointer, revision, review sequence, active task resets, generation increments and cleared current pointers commit together. Withdrawn tasks and all receipts remain intact. Resets broadcast after commit without sending a review-request notification for every edit.
+All current-version writers use `Plans::AdvanceVersion`: Create, ReplaceContent (including SaveHumanDraft/web saves), CommitSession, ToggleCheckbox and the direct operations API. They already hold the plan row lock; CommitSession retains session-before-plan lock order. The version pointer, revision and review sequence always advance together. With `reset_reviews_on_change` enabled (the default), active task resets, generation increments and cleared current pointers commit in that same transaction. Withdrawn tasks and all receipts remain intact. Resets broadcast after commit without sending a review-request notification for every edit.
 
-An identical normalized ReplaceContent save creates no version and preserves approval. An empty session creates no version. A nonempty session or operations commit creates a new version even if its operations net to identical bytes, and dismisses decisions. Returning A→B→A always produces a distinct version and requires fresh review. Existing edit leases, human-edit fences and merge guards remain in place.
+An identical normalized ReplaceContent save creates no version and preserves approval. An empty session creates no version. A nonempty session or operations commit creates a new version even if its operations net to identical bytes, and resets reviews when the policy is enabled. Returning A→B→A always produces a distinct version; no older decision becomes exact-current-version evidence. Existing edit leases, human-edit fences and merge guards remain in place.
+
+Editors can toggle **Reset approvals when content changes** in Manage reviewers. The setting applies to future edits for every reviewer. When off, completed approvals and change requests remain completed on their original versions; edits require no fresh review. Pending tasks stay pending, and withdrawn tasks stay withdrawn. Turning resets back on affects the next edit; turning them off never restores an already dismissed decision. Exact-current-version `effective_status`, `effective_response_id` and `effective_human_decision` remain strict regardless of this preference. Policy updates take the same plan row lock and advance `review_sequence` only when changed.
 
 An explicit re-request advances the task generation and clears its effective decision. Creating an already existing request is a retry and leaves its state alone. Withdrawal clears the effective decision and preserves receipts. A fresh response supersedes the previous effective response, including a later agent response. The latest sequenced human response on the current version is exposed separately so consumers can inspect human feedback across request cycles; native CoPlan does not impose an external approval or objection policy.
 
@@ -20,7 +22,7 @@ New responses send the viewed revision, fetched generation and a fresh UUID `ide
 
 ## Reads and compatibility
 
-`GET /api/v1/plans/:id/review_evidence` takes one plan-row transaction and returns exact current source/hash/version, scope, review sequence, current projection and complete response history. It creates no PlanRead or agent session. Ordinary authentication may still update token usage. The review sequence covers body and native review changes, not excluded metadata, sharing or external authorization. Existing snapshot reads retain their older behavior; consumers requiring coherent evidence use this endpoint.
+`GET /api/v1/plans/:id/review_evidence` takes one plan-row transaction and returns exact current source/hash/version, scope, review sequence, reset preference, lifecycle and exact-version projections, and complete response history. It creates no PlanRead or agent session. Ordinary authentication may still update token usage. The review sequence covers body and native review changes, not excluded metadata, sharing or external authorization. Existing snapshot reads retain their older behavior; consumers requiring coherent evidence use this endpoint.
 
 `GET /api/v1/plans/:id/versions/:version_id` returns that exact historical Markdown and hash. It never substitutes the current version. Both endpoints use existing Bearer authentication and visibility rules; neither establishes a read-only workload credential or employee identity mapping.
 
@@ -31,3 +33,5 @@ Persisted version IDs, plan IDs, revisions, Markdown and hashes reject ordinary
 ## Local tryout
 
 Seed the shared demo library with `bin/rails coplan:demo:seed`. Sign in as `alex@example.com` and open **Workspace invitations: review dismissed after edits** in Hampton’s Demo scenarios. v1 approvals are history, v2 is pending, and the activity link opens the original source. Approve v2, then sign in as `hampton@example.com` and edit its body or toggle its checkbox. Alex’s task returns to pending. Re-seeding preserves edits and decisions.
+
+For the off state, open **Workspace invitations: reviews retained after edits**. Automatic resets are off: v1 decisions remain completed after v2, with an explicit changed-content label. Toggle the option in Manage reviewers to try both policies.
diff --git a/engine/app/assets/stylesheets/coplan/review.css b/engine/app/assets/stylesheets/coplan/review.css
index ea134b0c..78181942 100644
--- a/engine/app/assets/stylesheets/coplan/review.css
+++ b/engine/app/assets/stylesheets/coplan/review.css
@@ -530,3 +530,6 @@ body:has(.review-tray[data-completed="true"]:not([data-reconsidering="true"]):no
 
 /* Live content and the inline editor share this reader, including empty plans. */
 .plan-reader:has(.markdown-rendered > *) > .empty-state { display: none; }
+
+.review-reset-policy__status { display: inline-block; width: 1em; color: var(--color-text-muted); opacity: 0; }
+.review-reset-policy__status[data-state="saved"] { opacity: 1; }
diff --git a/engine/app/controllers/coplan/review_requests_controller.rb b/engine/app/controllers/coplan/review_requests_controller.rb
index dfd31bf7..47c2eafe 100644
--- a/engine/app/controllers/coplan/review_requests_controller.rb
+++ b/engine/app/controllers/coplan/review_requests_controller.rb
@@ -15,6 +15,19 @@ def suggestions
       render json: Reviews::Suggest.call(plan: @plan)
     end
 
+    def settings
+      authorize!(@plan, :update?)
+      attributes = params.expect(review_settings: [ :reset_reviews_on_change ])
+      enabled = ActiveModel::Type::Boolean.new.cast(attributes.fetch(:reset_reviews_on_change))
+      @plan.with_lock do
+        if @plan.reset_reviews_on_change != enabled
+          @plan.update!(reset_reviews_on_change: enabled, review_sequence: @plan.review_sequence + 1)
+        end
+      end
+      Broadcaster.custom_action_to(@plan, action: "coplan-review-changed", target: "plan-review-controls", html: "")
+      render json: { reset_reviews_on_change: @plan.reset_reviews_on_change }
+    end
+
     def create
       authorize!(@plan, :update?)
       attributes = params.expect(review_request: [ :reviewer_id, :requirement ])
diff --git a/engine/app/javascript/controllers/coplan/review_tray_controller.js b/engine/app/javascript/controllers/coplan/review_tray_controller.js
index 14a23378..c3f75265 100644
--- a/engine/app/javascript/controllers/coplan/review_tray_controller.js
+++ b/engine/app/javascript/controllers/coplan/review_tray_controller.js
@@ -1,8 +1,8 @@
 import { Controller } from "@hotwired/stimulus"
 
 export default class extends Controller {
-  static targets = ["reviews", "discussion", "commentForm", "changeButton", "notice", "search", "reviewerId", "results", "assignment", "addReviewerButton", "assignButton", "managementError", "managementStatus", "assignmentError", "approval", "approvalNote", "approvalError", "approvalTitle", "approveButton", "comparison", "diff", "activity", "suggestions"]
-  static values = { url: String, searchUrl: String, suggestionsUrl: String }
+  static targets = ["reviews", "discussion", "commentForm", "changeButton", "notice", "search", "reviewerId", "results", "assignment", "addReviewerButton", "assignButton", "managementError", "managementStatus", "policyIcon", "assignmentError", "approval", "approvalNote", "approvalError", "approvalTitle", "approveButton", "comparison", "diff", "activity", "suggestions"]
+  static values = { url: String, searchUrl: String, suggestionsUrl: String, settingsUrl: String }
 
   connect() {
     this.searchSequence = 0
@@ -21,6 +21,12 @@ export default class extends Controller {
 
   disconnect() {
     clearTimeout(this.searchTimer)
+    clearTimeout(this.policySaveTimer)
+    if (this.policySaveTimer) {
+      this.policySaveTimer = null
+      this.saveResetPolicy(this.element.querySelector("[data-review-reset-policy]"))
+    }
+    clearTimeout(this.policyIconTimer)
     this.searchSequence++
     this.refreshSequence++
     document.body.classList.remove("has-review-tray")
@@ -221,12 +227,19 @@ export default class extends Controller {
 
   async refresh() {
     const sequence = ++this.refreshSequence
+    const policyBusy = this.policySaving || this.policySaveTimer
     try {
       const response = await fetch(this.urlValue, { credentials: "same-origin", headers: { Accept: "text/html" } })
       if (!response.ok) return
       const incoming = new DOMParser().parseFromString(await response.text(), "text/html")
       if (sequence !== this.refreshSequence || !this.element.isConnected) return
       this.element.dataset.reviewGeneration = incoming.getElementById("plan-review-controls")?.dataset.reviewGeneration || ""
+      const policy = this.element.querySelector("[data-review-reset-policy]")
+      const incomingPolicy = incoming.querySelector("[data-review-reset-policy]")
+      if (policy && incomingPolicy && !policyBusy && !this.policySaving && !this.policySaveTimer) {
+        policy.checked = incomingPolicy.checked
+        policy.dataset.savedValue = String(incomingPolicy.checked)
+      }
       const tray = incoming.querySelector(".review-tray")
       const existingTray = this.element.querySelector(".review-tray")
       const wasWithdrawn = this.reviewWithdrawn
@@ -272,6 +285,58 @@ export default class extends Controller {
     } catch { /* The task and draft remain usable; the next event retries. */ }
   }
 
+  changeResetPolicy(event) {
+    const input = event.currentTarget
+    input.setAttribute("aria-busy", "true")
+    this.refreshSequence++
+    this.policyIconTarget.setAttribute("aria-hidden", "true")
+    clearTimeout(this.policyIconTimer)
+    this.policyIconTarget.dataset.state = ""
+    clearTimeout(this.policySaveTimer)
+    this.policySaveTimer = setTimeout(() => {
+      this.policySaveTimer = null
+      this.saveResetPolicy(input)
+    }, 200)
+  }
+
+  async saveResetPolicy(input) {
+    if (this.policySaving) return
+    const previous = input.dataset.savedValue === "true"
+    const enabled = input.checked
+    if (previous === enabled) { input.setAttribute("aria-busy", "false"); return }
+    this.policySaving = true
+    this.managementErrorTarget.textContent = ""
+    try {
+      await this.write(this.settingsUrlValue, "PATCH", { review_settings: { reset_reviews_on_change: enabled } })
+      input.dataset.savedValue = String(enabled)
+      if (input.checked === enabled) {
+        this.policyIconTarget.dataset.state = "saved"
+        this.policyIconTarget.setAttribute("aria-hidden", "false")
+        this.policyIconTimer = setTimeout(() => {
+          this.policyIconTarget.dataset.state = ""
+          this.policyIconTarget.setAttribute("aria-hidden", "true")
+        }, 1500)
+      }
+    } catch (error) {
+      // A lost HTTP result may already have saved. Read back before restoring
+      // the checkbox, while preserving clicks made during that request.
+      let persisted = previous
+      try {
+        const response = await fetch(this.urlValue, { credentials: "same-origin", headers: { Accept: "text/html" } })
+        const policy = new DOMParser().parseFromString(await response.text(), "text/html").querySelector("[data-review-reset-policy]")
+        if (response.ok && policy) persisted = policy.checked
+      } catch { /* Keep the last confirmed value and show the error. */ }
+      input.dataset.savedValue = String(persisted)
+      if (input.checked === enabled) input.checked = persisted
+      this.managementErrorTarget.textContent = persisted === enabled ? "" : error.message
+    } finally {
+      this.policySaving = false
+      // Serialize saves so a slow older request cannot overwrite a newer click.
+      if (input.checked !== (input.dataset.savedValue === "true")) this.saveResetPolicy(input)
+      else input.setAttribute("aria-busy", "false")
+    }
+  }
+
   async assign(event) {
     event.preventDefault()
     if (!this.reviewerIdTarget.value) { this.assignmentErrorTarget.textContent = "Choose a person from the results first."; return }
diff --git a/engine/app/models/coplan/plan.rb b/engine/app/models/coplan/plan.rb
index e9707d72..7117a782 100644
--- a/engine/app/models/coplan/plan.rb
+++ b/engine/app/models/coplan/plan.rb
@@ -68,6 +68,7 @@ class Plan < ApplicationRecord
     before_save :assign_url_slug, if: :url_slug_stale?
 
     validates :title, presence: true
+    validates :reset_reviews_on_change, inclusion: { in: [ true, false ] }
     validates :visibility, presence: true, inclusion: { in: VISIBILITIES }
     validate :attachments_within_limits
 
diff --git a/engine/app/models/coplan/review_request.rb b/engine/app/models/coplan/review_request.rb
index 140d1c12..54041126 100644
--- a/engine/app/models/coplan/review_request.rb
+++ b/engine/app/models/coplan/review_request.rb
@@ -24,7 +24,7 @@ class ReviewRequest < ApplicationRecord
     scope :pending, -> { where(status: "pending") }
 
     def pending?
-      effective_status == "pending"
+      review_status == "pending"
     end
 
     # Positive history is for comparison only. Never use it as current evidence.
@@ -32,11 +32,22 @@ def latest_approval
       review_responses.find { |response| response.decision == "approved" }
     end
 
-    def effective_response
+    # Lifecycle completion may survive edits when automatic resets are off.
+    # The recorded decision still covers only its original immutable version.
+    def recorded_response
       response = current_response
       response if response && status == response.decision &&
-        response.review_request_id == id && response.request_generation == generation &&
-        response.plan_version_id == plan.current_plan_version_id
+        response.review_request_id == id && response.request_generation == generation
+    end
+
+    def review_status
+      status == "withdrawn" ? "withdrawn" : (recorded_response&.decision || "pending")
+    end
+
+    # Exact-version evidence stays strict regardless of the reset preference.
+    def effective_response
+      response = recorded_response
+      response if response&.plan_version_id == plan.current_plan_version_id
     end
 
     def effective_status
diff --git a/engine/app/services/coplan/plans/advance_version.rb b/engine/app/services/coplan/plans/advance_version.rb
index fcd6d126..e81b7e6a 100644
--- a/engine/app/services/coplan/plans/advance_version.rb
+++ b/engine/app/services/coplan/plans/advance_version.rb
@@ -9,7 +9,7 @@ def self.call(plan:, version:)
 
         plan.update!(current_plan_version: version, current_revision: version.revision,
           review_sequence: plan.review_sequence + 1)
-        requests = plan.review_requests.active.to_a
+        requests = plan.reset_reviews_on_change? ? plan.review_requests.active.to_a : []
         requests.each do |request|
           request.update!(status: "pending", generation: request.generation + 1,
             current_response: nil, reset_reason: "content_changed")
@@ -17,6 +17,9 @@ def self.call(plan:, version:)
         # No new review notifications for each edit, and no reset broadcast
         # for a transaction that rolls back.
         ActiveRecord.after_all_transactions_commit do
+          if requests.empty?
+            Broadcaster.custom_action_to(plan, action: "coplan-review-changed", target: "plan-review-controls", html: "")
+          end
           requests.each do |request|
             Reviews::Changed.call(request: request, event_type: "review.requested",
               payload: { "action" => "content_changed", "revision" => version.revision,
diff --git a/engine/app/services/coplan/reviews/evidence.rb b/engine/app/services/coplan/reviews/evidence.rb
index 7aa499c6..4e5e09f0 100644
--- a/engine/app/services/coplan/reviews/evidence.rb
+++ b/engine/app/services/coplan/reviews/evidence.rb
@@ -14,6 +14,7 @@ def self.call(plan:)
           version = plan.current_plan_version
           {
             schema_version: 1, plan_id: plan.id, review_sequence: plan.review_sequence,
+            reset_reviews_on_change: plan.reset_reviews_on_change,
             approval_scope: SCOPE,
             version: { id: version.id, revision: version.revision,
                        content_sha256: version.content_sha256, content_markdown: version.verified_content! },
diff --git a/engine/app/services/coplan/reviews/serialize.rb b/engine/app/services/coplan/reviews/serialize.rb
index c70f0896..3fa33cf8 100644
--- a/engine/app/services/coplan/reviews/serialize.rb
+++ b/engine/app/services/coplan/reviews/serialize.rb
@@ -13,9 +13,10 @@ def call
         request = @request
         {
           id: request.id, reviewer: { id: request.reviewer_id, name: request.reviewer.name },
-          requirement: request.requirement, status: request.status, effective_status: request.effective_status,
+          requirement: request.requirement, status: request.status, review_status: request.review_status, effective_status: request.effective_status,
           requested_at: request.requested_at, generation: request.generation, reset_reason: request.reset_reason,
           current_response_id: request.current_response_id,
+          recorded_response_id: request.recorded_response&.id,
           effective_response_id: request.effective_response&.id,
           effective_human_decision: request.effective_human_decision,
           latest_human_response_id: request.review_responses.find { |response|
diff --git a/engine/app/views/coplan/agent_instructions/guides/api.text.erb b/engine/app/views/coplan/agent_instructions/guides/api.text.erb
index 8373ffea..f5416214 100644
--- a/engine/app/views/coplan/agent_instructions/guides/api.text.erb
+++ b/engine/app/views/coplan/agent_instructions/guides/api.text.erb
@@ -84,7 +84,7 @@ return 429. Invalid names return 422 with `invalid_request`.
 
 Creating a review request for an existing reviewer returns the current task with status 201. It leaves the requirement, decision, history, and notifications unchanged. Use `PATCH` to change the requirement or `request_again: true` to request another look.
 
-Send the request’s `generation` and the viewed `revision` with every new response. A missing generation is supported only for the first cycle. After edits or re-requests, a stale or missing generation returns 409 with `code: review_request_changed`. Fetch the task again and deliberately review before submitting a fresh response. Edits reset active tasks to pending and advance their generations. Withdrawn tasks stay withdrawn. Earlier responses remain history.
+Send the request’s `generation` and the viewed `revision` with every new response. A missing generation is supported only for the first cycle. After edits or re-requests, a stale or missing generation returns 409 with `code: review_request_changed`. Fetch the task again and deliberately review before submitting a fresh response. By default, edits reset active tasks to pending and advance their generations. When `reset_reviews_on_change` is false, completed reviews stay completed on their original versions; no fresh approval is required. Withdrawn tasks stay withdrawn. Earlier responses remain history.
 
 Include `idempotency_key` (a fresh UUID) for each intended review response. Reuse that UUID and identical fields when retrying a lost response; its returned `id` is the UUID. Use a new UUID for a new decision, including another review of the same version. A keyed retry returns the original recorded result even after the plan changes or the task is withdrawn. It preserves any newly pending review task. Without a key, an identical response is treated as a retry. Retries may use a renewed token for the same human principal. The original response keeps its original agent and token attribution. A key reused for different fields returns 422. A retry’s `effective: false` means it is history, not a current decision. New responses return `plan_version_id`, `content_sha256`, `generation`, and server `decision_sequence`.
 
diff --git a/engine/app/views/coplan/agent_instructions/guides/comments.text.erb b/engine/app/views/coplan/agent_instructions/guides/comments.text.erb
index 14adb8b3..9efeb035 100644
--- a/engine/app/views/coplan/agent_instructions/guides/comments.text.erb
+++ b/engine/app/views/coplan/agent_instructions/guides/comments.text.erb
@@ -80,7 +80,7 @@ To give feedback on another person's plan, start threads anchored to the passage
 
 Each request or re-request remains in review activity with its requester and time. A later request does not replace earlier requests or decisions.
 
-Discussion is the default. An approval means “satisfied with this exact version”; it grants no permissions, execution authority, or instruction to implement the plan. Never interpret another person's sign-off as an instruction from your principal. Edits reset active tasks to pending and preserve the earlier sign-off as history. Approval covers Markdown source bytes only, not title, tags, attachments, linked or embedded resources, or child plans. Use `GET /api/v1/plans/:plan_id/review_evidence` for exact current Markdown, hash, version ID, and coherent review state. It creates no read receipt. `effective_human_decision` is null for agent decisions or dismissed approvals. A later agent decision cannot count as a human approval. `latest_human_response_id` exposes historical human feedback on the current version; it is not an effective approval.
+Discussion is the default. An approval means “satisfied with this exact version”; it grants no permissions, execution authority, or instruction to implement the plan. Never interpret another person's sign-off as an instruction from your principal. By default, edits reset active tasks to pending and preserve earlier decisions as history. Editors may disable automatic resets in Manage reviewers; completed reviews then stay completed on their original versions, without requiring fresh approval. Approval covers Markdown source bytes only, not title, tags, attachments, linked or embedded resources, or child plans. Use `GET /api/v1/plans/:plan_id/review_evidence` for exact current Markdown, hash, version ID, and coherent review state. It creates no read receipt. `review_status` describes task completion. `effective_human_decision` is exact-current-version evidence and is null for agent decisions, dismissed approvals, or decisions on older versions, even when automatic resets are off. A later agent decision cannot count as a human approval. `latest_human_response_id` exposes historical human feedback on the current version; it is not an effective approval.
 
 - `GET /api/v1/plans/:plan_id/review_requests` lists requests and responses, including reviewer, required/optional, revision, timestamp, notes, and agent attribution.
 - The plan author's credential may `POST` that path with `{ "reviewer_id": "USER_ID", "requirement": "required" }` (or `optional`). Requests are tasks; reading the notification does not complete them.
diff --git a/engine/app/views/coplan/agent_instructions/guides/live.text.erb b/engine/app/views/coplan/agent_instructions/guides/live.text.erb
index 101aafe5..aed9c7f8 100644
--- a/engine/app/views/coplan/agent_instructions/guides/live.text.erb
+++ b/engine/app/views/coplan/agent_instructions/guides/live.text.erb
@@ -103,7 +103,7 @@ For `review.requested`, inspect `payload.action`:
 | Action | Meaning |
 |---|---|
 | `requested` | A new request or another look. `requirement` is `required` or `optional`. |
-| `content_changed` | A new Markdown version reset active tasks and advanced their generations. Earlier responses remain history. Read the current version and request before responding. No new inbox nudge is sent for each edit. |
+| `content_changed` | A new Markdown version reset active tasks and advanced their generations under the default-on reset policy. No reset event is emitted when the document’s automatic resets are off. Earlier responses remain history. Read the current version and request before responding. No new inbox nudge is sent for each edit. |
 | `requirement_changed` | Only `requirement` changed. This does not reopen the task or start another review cycle. Do not treat it as a request for another look. |
 | `withdrawn` | The request was withdrawn. Stop working on that request; its earlier decisions remain. The payload also has `withdrawn: true`. |
 
diff --git a/engine/app/views/coplan/reviews/_controls.html.erb b/engine/app/views/coplan/reviews/_controls.html.erb
index ea8983b7..ebe2c656 100644
--- a/engine/app/views/coplan/reviews/_controls.html.erb
+++ b/engine/app/views/coplan/reviews/_controls.html.erb
@@ -1,11 +1,12 @@
 <% requests = plan.review_requests.includes(:reviewer, :requested_by_user, :requested_plan_version, review_responses: [ :plan_version, :user ]).order(:requested_at).to_a %>
 <% request_events = plan.plan_events.where(event_type: %w[review_requested review_withdrawn]).includes(:actor_user).to_a %>
-<% active_requests = requests.reject { |request| request.effective_status == "withdrawn" } %>
+<% active_requests = requests.reject { |request| request.review_status == "withdrawn" } %>
 <% own_request = active_requests.find { |request| request.reviewer_id == current_user.id } %>
 <% response_thread_ids = requests.flat_map { |request| request.review_responses.map(&:comment_thread_id) }.compact %>
 <% feedback_thread_ids = plan.comment_threads.with_kept_comments.where(id: response_thread_ids).pluck(:id) %>
 <div id="plan-review-controls" data-review-generation="<%= own_request&.generation %>" data-review-record-count="<%= requests.size %>" data-controller="coplan--review-tray"
      data-coplan--review-tray-url-value="<%= plan_review_requests_path(plan) %>"
+     data-coplan--review-tray-settings-url-value="<%= settings_plan_review_requests_path(plan) %>"
      data-coplan--review-tray-search-url-value="<%= search_users_path %>"
      <% if CoPlan.configuration.suggest_reviewers %>data-coplan--review-tray-suggestions-url-value="<%= suggestions_plan_review_requests_path(plan) %>"<% end %>
      data-action="coplan:anchors-updated@document->coplan--review-tray#syncFeedbackLinks coplan:reviews-changed->coplan--review-tray#refresh coplan:manage-reviews@document->coplan--review-tray#openReviews coplan:content-updated@document->coplan--review-tray#refresh coplan:editor-saved@document->coplan--review-tray#refresh resize@window->coplan--review-tray#positionAssignment keydown.esc@document->coplan--review-tray#escape">
@@ -28,17 +29,18 @@
       </div>
       <div class="review-tray__bar">
         <div class="review-tray__status" data-review-status>
-          <% response = own_request.effective_response %>
+          <% response = own_request.recorded_response %>
           <% approval = own_request.latest_approval %>
           <div class="review-tray__decision">
             <% if own_request.pending? %>
               <span class="review-task-dot" aria-hidden="true"></span><strong>Your review is requested</strong><small><%= own_request.requirement.humanize %><%= " · Content changed; review v#{plan.current_revision} again" if own_request.reset_reason == "content_changed" %><%= " · Earlier decisions are history; please review again" if own_request.reset_reason == "legacy_history" %></small>
             <% elsif response %>
-              <span class="review-result-icon<%= ' review-result-icon--approved' if own_request.effective_status == 'approved' %>" aria-hidden="true"><%= own_request.effective_status == "approved" ? "✓" : "↩" %></span>
+              <span class="review-result-icon<%= ' review-result-icon--approved' if own_request.review_status == 'approved' %>" aria-hidden="true"><%= own_request.review_status == "approved" ? "✓" : "↩" %></span>
               <% decision_actor = response.actor_type == "local_agent" ? "#{response.agent_name} (via you)" : "You" %>
-              <span><strong><%= own_request.effective_status == "approved" ? "#{decision_actor} approved" : "#{decision_actor} requested changes to" %> v<%= response.plan_version.revision %></strong> <span class="review-tray__date">on <time datetime="<%= response.created_at.iso8601 %>" title="<%= response.created_at.strftime('%B %-d, %Y at %H:%M %Z') %>"><%= response.created_at.strftime("%b %-d, %Y") %></time></span></span>
+              <span><strong><%= own_request.review_status == "approved" ? "#{decision_actor} approved" : "#{decision_actor} requested changes to" %> v<%= response.plan_version.revision %></strong> <span class="review-tray__date">on <time datetime="<%= response.created_at.iso8601 %>" title="<%= response.created_at.strftime('%B %-d, %Y at %H:%M %Z') %>"><%= response.created_at.strftime("%b %-d, %Y") %></time></span></span>
             <% end %>
           </div>
+          <% if response && response.plan_version_id != plan.current_plan_version_id %><small>Content changed since review; no new review required.</small><% end %>
           <% if !own_request.pending? && feedback_thread_ids.include?(response&.comment_thread_id) %><button type="button" class="review-log__link review-feedback-link" data-action="coplan--review-tray#openThread" data-thread-id="<%= response.comment_thread_id %>">View feedback</button><% end %>
           <% if approval && approval.plan_version.revision != plan.current_revision %><button type="button" class="btn btn--ghost btn--sm" data-action="coplan--review-tray#compare" data-url="<%= compare_plan_review_request_path(plan, own_request, response_id: approval.id) %>">Changes since approval</button><% end %>
         </div>
@@ -62,7 +64,7 @@
       <h2 id="approval-title" data-coplan--review-tray-target="approvalTitle">Approve this version?</h2>
     </div>
     <p class="review-confirmation__statement">I’ve reviewed and approve the Markdown source of this version.</p>
-    <p class="text-sm text-muted">Edits dismiss active decisions. Attachments, linked or embedded content, title, tags, and child plans are outside this approval.</p>
+    <p class="text-sm text-muted">Attachments, linked or embedded content, title, tags, and child plans are outside this approval.</p>
     <form data-action="submit->coplan--review-tray#approve">
       <label for="approval-note">Public note <span class="text-muted">(optional)</span></label><textarea id="approval-note" rows="3" placeholder="Anything you’d like to add?" data-coplan--review-tray-target="approvalNote"></textarea>
       <p class="review-error" role="alert" data-coplan--review-tray-target="approvalError"></p>
diff --git a/engine/app/views/coplan/reviews/_log.html.erb b/engine/app/views/coplan/reviews/_log.html.erb
index 2d4beeb3..7903a6f4 100644
--- a/engine/app/views/coplan/reviews/_log.html.erb
+++ b/engine/app/views/coplan/reviews/_log.html.erb
@@ -2,7 +2,7 @@
   <details class="review-log-details document-support__disclosure" data-controller="coplan--support-disclosure" data-action="toggle->coplan--support-disclosure#remember">
     <summary class="review-log-panel__header document-support__heading"><span class="document-support__chevron" aria-hidden="true">›</span><h2 class="plan-footnote__title" id="review-log-title">Reviews</h2><span class="review-log-panel__summary" data-review-log-summary><span><%= pluralize(active_requests.size, "reviewer") %><%= " · #{active_requests.count(&:pending?)} awaiting review" if active_requests.any?(&:pending?) %></span></span></summary>
     <div class="review-log-panel__columns document-support__content">
-      <p class="text-sm text-muted">Reviews cover the Markdown source only. Edits dismiss active decisions; earlier decisions remain in activity.</p>
+      <p class="text-sm text-muted">Reviews cover the Markdown source only. Decisions record the version reviewed; earlier decisions remain in activity.</p>
       <%= render "coplan/reviews/roster", plan: plan, active_requests: active_requests, manage: false %>
       <div class="review-log-panel__tools"><button type="button" class="btn btn--secondary btn--sm" data-action="coplan--review-tray#openActivity">View activity <span aria-hidden="true">↗</span></button></div>
     </div>
diff --git a/engine/app/views/coplan/reviews/_management.html.erb b/engine/app/views/coplan/reviews/_management.html.erb
index a0677a53..791c77f7 100644
--- a/engine/app/views/coplan/reviews/_management.html.erb
+++ b/engine/app/views/coplan/reviews/_management.html.erb
@@ -12,11 +12,11 @@
       <button type="button" class="review-add-button" title="Add reviewer" aria-expanded="false" aria-haspopup="dialog" aria-controls="review-assignment" popovertarget="review-assignment" data-coplan--review-tray-target="addReviewerButton"><span aria-hidden="true">+</span> Add reviewer</button>
     <% end %>
   </div>
-  <div class="review-reset-policy">
-    <label class="review-required"><input type="checkbox" checked disabled aria-describedby="review-reset-explanation"> Reset approvals when content changes</label>
-    <p id="review-reset-explanation" class="text-sm text-muted">Required for all reviewers. Every new content version needs fresh approvals.</p>
-  </div>
   <% if allowed_to?(plan, :update?) %>
+    <div class="review-reset-policy">
+      <label class="review-required"><input type="checkbox" <%= "checked" if plan.reset_reviews_on_change %> data-action="change->coplan--review-tray#changeResetPolicy" data-review-reset-policy data-saved-value="<%= plan.reset_reviews_on_change %>"> Reset approvals when content changes <span class="review-reset-policy__status" data-coplan--review-tray-target="policyIcon" role="img" aria-hidden="true" aria-label="Saved" title="Saved">✓</span></label>
+      <p class="text-sm text-muted">Applies to future edits for all reviewers. When off, completed reviews stay completed.</p>
+    </div>
     <div id="review-assignment" class="review-assignment" popover="auto" role="dialog" aria-label="Add reviewer" data-coplan--review-tray-target="assignment" data-action="toggle->coplan--review-tray#assignmentToggled keydown.esc->coplan--review-tray#dismissAssignment">
       <%= form_with url: plan_review_requests_path(plan), class: "review-assignment-form", data: { action: "submit->coplan--review-tray#assign" } do %>
         <label for="reviewer-search">Find a reviewer</label>
diff --git a/engine/app/views/coplan/reviews/_roster.html.erb b/engine/app/views/coplan/reviews/_roster.html.erb
index b03ea688..23ea9b77 100644
--- a/engine/app/views/coplan/reviews/_roster.html.erb
+++ b/engine/app/views/coplan/reviews/_roster.html.erb
@@ -10,14 +10,14 @@
             <%= user_avatar(request.reviewer, size: "md") %>
             <div class="review-person__info">
               <strong><%= request.reviewer.name %></strong>
-              <span class="review-person__meta"><span class="review-person__requirement"><%= requirement.humanize %></span> · <% if request.pending? %>Review requested<% elsif request.effective_status == "changes_requested" %>Changes requested on v<%= request.effective_response&.plan_version&.revision %><% else %>Approved v<%= request.effective_response&.plan_version&.revision %><%= " (agent)" if request.effective_response&.actor_type == "local_agent" %><% end %></span>
+              <span class="review-person__meta"><span class="review-person__requirement"><%= requirement.humanize %></span> · <% if request.pending? %>Review requested<% elsif request.review_status == "changes_requested" %>Changes requested on v<%= request.recorded_response&.plan_version&.revision %><% else %>Approved v<%= request.recorded_response&.plan_version&.revision %><%= " (agent)" if request.recorded_response&.actor_type == "local_agent" %><% end %></span>
             </div>
-            <span class="review-state<%= ' review-state--approved' if request.effective_status == 'approved' %><%= ' review-state--attention' if request.pending? && request.reviewer_id == current_user.id %>"><span aria-hidden="true"><%= request.pending? ? "◷" : request.effective_status == "approved" ? "✓" : "↩" %></span> <%= request.pending? ? "Pending" : request.effective_status.humanize %></span>
+            <span class="review-state<%= ' review-state--approved' if request.review_status == 'approved' %><%= ' review-state--attention' if request.pending? && request.reviewer_id == current_user.id %>"><span aria-hidden="true"><%= request.pending? ? "◷" : request.review_status == "approved" ? "✓" : "↩" %></span> <%= request.pending? ? "Pending" : request.review_status.humanize %></span>
             <% if manage && allowed_to?(plan, :update?) %>
               <span class="review-person__actions" data-controller="coplan--menu">
                 <button type="button" class="review-person__menu-button" aria-label="Actions for <%= request.reviewer.name %>" title="Actions for <%= request.reviewer.name %>" popovertarget="review-menu-<%= request.id %>" data-coplan--menu-target="trigger"><svg width="16" height="16" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true"><circle cx="5" cy="12" r="2"/><circle cx="12" cy="12" r="2"/><circle cx="19" cy="12" r="2"/></svg></button>
                 <div id="review-menu-<%= request.id %>" class="menu review-person__menu" popover="auto" data-coplan--menu-target="menu" data-action="beforetoggle->coplan--menu#reposition" aria-label="Review actions for <%= request.reviewer.name %>">
-                  <button type="button" class="menu__item" data-action="coplan--review-tray#requestAgain coplan--menu#close" data-url="<%= plan_review_request_path(plan, request) %>"><%= request.effective_status == "changes_requested" ? "Ready for another look" : "Request another review" %></button>
+                  <button type="button" class="menu__item" data-action="coplan--review-tray#requestAgain coplan--menu#close" data-url="<%= plan_review_request_path(plan, request) %>"><%= request.review_status == "changes_requested" ? "Ready for another look" : "Request another review" %></button>
                   <button type="button" class="menu__item" data-action="coplan--review-tray#changeRequirement coplan--menu#close" data-url="<%= plan_review_request_path(plan, request) %>" data-requirement="<%= requirement == 'required' ? 'optional' : 'required' %>">Make <%= requirement == 'required' ? 'optional' : 'required' %></button>
                   <% if approval && approval.plan_version.revision != plan.current_revision %><button type="button" class="menu__item" data-action="coplan--review-tray#compare coplan--menu#close" data-url="<%= compare_plan_review_request_path(plan, request, response_id: approval.id) %>">Changes since approval</button><% end %>
                   <div class="menu__separator" role="separator"></div>
diff --git a/engine/app/views/coplan/reviews/_table.html.erb b/engine/app/views/coplan/reviews/_table.html.erb
index 26fb14d3..eba61d10 100644
--- a/engine/app/views/coplan/reviews/_table.html.erb
+++ b/engine/app/views/coplan/reviews/_table.html.erb
@@ -3,13 +3,13 @@
     <thead><tr><th scope="col">Reviewer</th><th scope="col">Review</th><th scope="col">Decision</th><th scope="col">Version</th><th scope="col">Actions</th></tr></thead>
     <tbody>
       <% active_requests.sort_by { |request| [CoPlan::ReviewRequest::REQUIREMENTS.index(request.requirement), request.reviewer.name.downcase, request.id] }.each do |request| %>
-        <% response = request.effective_response %>
+        <% response = request.recorded_response %>
         <% approval = request.latest_approval %>
         <tr class="review-person" data-reviewer-id="<%= request.reviewer_id %>">
           <td><div class="review-table__person"><%= user_avatar(request.reviewer) %><strong><%= request.reviewer.name %></strong></div></td>
           <td><span class="review-table__requirement"><%= request.requirement.humanize %></span></td>
-          <td><span class="review-state<%= ' review-state--approved' if request.effective_status == 'approved' %><%= ' review-state--attention' if request.pending? && request.reviewer_id == current_user.id %>"><span aria-hidden="true"><%= request.pending? ? "◷" : request.effective_status == "approved" ? "✓" : "↩" %></span><span class="review-person__meta"><%= request.pending? ? (request.reset_reason == "content_changed" ? "Content changed; review again" : "Review requested") : request.effective_status.humanize %><%= " (agent)" if response&.actor_type == "local_agent" %></span></span></td>
-          <td><% if !request.pending? && response %><span class="review-version">v<%= response.plan_version.revision %></span><% else %><span class="text-muted" aria-label="Not reviewed yet">—</span><% end %></td>
+          <td><span class="review-state<%= ' review-state--approved' if request.review_status == 'approved' %><%= ' review-state--attention' if request.pending? && request.reviewer_id == current_user.id %>"><span aria-hidden="true"><%= request.pending? ? "◷" : request.review_status == "approved" ? "✓" : "↩" %></span><span class="review-person__meta"><%= request.pending? ? (request.reset_reason == "content_changed" ? "Content changed; review again" : "Review requested") : request.review_status.humanize %><%= " (agent)" if response&.actor_type == "local_agent" %></span></span></td>
+          <td><% if !request.pending? && response %><span class="review-version">v<%= response.plan_version.revision %></span><% if response.plan_version_id != plan.current_plan_version_id %> <span class="text-muted">Content changed since review</span><% end %><% else %><span class="text-muted" aria-label="Not reviewed yet">—</span><% end %></td>
           <td class="review-table__actions">
             <% if !request.pending? && request.reviewer_id == current_user.id %><button type="button" class="review-log__link review-reopen" aria-label="Change decision" title="Change decision" data-action="coplan--review-tray#reconsider"><svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M20 7v5h-5M4 17v-5h5"/><path d="M6.1 7a7 7 0 0 1 11.6-1L20 9M4 15l2.3 3A7 7 0 0 0 17.9 17"/></svg></button><% end %>
             <% if approval && approval.plan_version.revision != plan.current_revision %><button type="button" class="review-log__link" data-action="coplan--review-tray#compare" data-url="<%= compare_plan_review_request_path(plan, request, response_id: approval.id) %>">Compare</button><% end %>
diff --git a/engine/config/routes.rb b/engine/config/routes.rb
index a176e8af..2b06c2b3 100644
--- a/engine/config/routes.rb
+++ b/engine/config/routes.rb
@@ -75,6 +75,7 @@
       # see DictationsController.
       resources :dictations, only: [ :create ]
       resources :review_requests, only: [ :index, :create, :update, :destroy ] do
+        patch :settings, on: :collection
         get :suggestions, on: :collection
         post :respond, on: :member
         get :compare, on: :member
diff --git a/engine/db/demo/content/retained-review.md b/engine/db/demo/content/retained-review.md
new file mode 100644
index 00000000..0befe697
--- /dev/null
+++ b/engine/db/demo/content/retained-review.md
@@ -0,0 +1,7 @@
+# Keep completed reviews after edits
+
+Automatic approval resets are off for this document. The v1 reviews remain completed after the v2 edit, without requiring new approvals. Each review still identifies the immutable Markdown version reviewed.
+
+Enable **Reset approvals when content changes** in Manage reviewers, then edit again to return active reviews to Pending.
+
+- [ ] Verify the retry policy
diff --git a/engine/db/migrate/20261029120000_add_review_reset_policy_to_coplan_plans.rb b/engine/db/migrate/20261029120000_add_review_reset_policy_to_coplan_plans.rb
new file mode 100644
index 00000000..0320f41c
--- /dev/null
+++ b/engine/db/migrate/20261029120000_add_review_reset_policy_to_coplan_plans.rb
@@ -0,0 +1,5 @@
+class AddReviewResetPolicyToCoplanPlans < ActiveRecord::Migration[8.1]
+  def change
+    add_column :coplan_plans, :reset_reviews_on_change, :boolean, null: false, default: true
+  end
+end
diff --git a/engine/lib/coplan/development_seed.rb b/engine/lib/coplan/development_seed.rb
index 0bbaff46..1d943294 100644
--- a/engine/lib/coplan/development_seed.rb
+++ b/engine/lib/coplan/development_seed.rb
@@ -128,6 +128,11 @@ module DevelopmentSeed
         tags: %w[collaboration demo], visibility: "published", folder: "Demo scenarios",
         scenario: "Earlier v1 approvals remain history; v2 requires fresh review"
       },
+      {
+        key: "retained-review", author: "hampton", type: "Design Doc", title: "Workspace invitations: reviews retained after edits",
+        tags: %w[collaboration demo], visibility: "published", folder: "Demo scenarios",
+        scenario: "Automatic resets off; v1 reviews stay completed after v2 edits"
+      },
       {
         key: "approved-review", author: "hampton", type: "Design Doc", title: "Workspace invitations: approved rollout",
         tags: %w[collaboration demo], visibility: "published", folder: "Demo scenarios",
@@ -251,7 +256,8 @@ module DevelopmentSeed
     REVIEW_SCENARIOS = {
       "pending-review" => false,
       "approved-review" => true,
-      "changed-review" => true
+      "changed-review" => true,
+      "retained-review" => true
     }.freeze
 
     SMALL_EDITS = [
@@ -853,6 +859,7 @@ def seed_writing_history(users, plans, catalog)
     def seed_reviews(users, plans)
       REVIEW_SCENARIOS.each do |key, approved|
         plan = plans.fetch(key)
+        plan.update!(reset_reviews_on_change: false) if key == "retained-review" && plan.current_revision == 1
         %w[alex noura].each do |reviewer|
           collaborator = plan.plan_collaborators.find_or_initialize_by(user: users.fetch(reviewer))
           unless collaborator.persisted?
@@ -865,8 +872,8 @@ def seed_reviews(users, plans)
           request = Reviews::Request.call(plan: plan, reviewer: users.fetch(reviewer), actor: plan.created_by_user)
           Reviews::Respond.call(request: request, actor: request.reviewer, revision: plan.current_revision, decision: "approved") if approved
         end
-        if key == "changed-review" && plan.current_revision == 1
-          Plans::ReplaceContent.call(plan: plan, new_content: "#{plan.current_content}\n\nUpdated after approval: review the retry policy again.\n",
+        if %w[changed-review retained-review].include?(key) && plan.current_revision == 1
+          Plans::ReplaceContent.call(plan: plan, new_content: "#{plan.current_content}\n\nUpdated after approval: the retry policy has changed.\n",
             base_revision: 1, actor_type: "human", actor_id: plan.created_by_user_id)
         end
       end
diff --git a/spec/lib/development_seed_spec.rb b/spec/lib/development_seed_spec.rb
index 4d90fb0f..b75dc657 100644
--- a/spec/lib/development_seed_spec.rb
+++ b/spec/lib/development_seed_spec.rb
@@ -297,6 +297,13 @@ def seeded_plan(key)
       expect(changed.review_requests.map(&:effective_response)).to all(be_nil)
       expect(changed.review_requests.map { |r| r.latest_approval.plan_version.revision }).to eq([ 1, 1 ])
 
+      retained = seeded_plan("retained-review")
+      expect(retained.current_revision).to eq(2)
+      expect(retained.reset_reviews_on_change).to be(false)
+      expect(retained.review_requests.map(&:review_status)).to eq(%w[approved approved])
+      expect(retained.review_requests.map(&:effective_response)).to all(be_nil)
+      retained_ids = retained.review_requests.pluck(:current_response_id)
+
       pending = seeded_plan("pending-review").plan_collaborators.approvers
       approved = seeded_plan("approved-review").plan_collaborators.approvers
       expect(pending.count).to eq(2)
@@ -323,6 +330,9 @@ def seeded_plan(key)
       expect(pending.reload.where(approved_at: nil).count).to eq(1)
       expect(thread.reload.status).to eq("resolved")
       expect(edited.reload.current_revision).to eq(8)
+      expect(retained.reload.current_revision).to eq(2)
+      expect(retained.review_requests.pluck(:current_response_id)).to match_array(retained_ids)
+      expect(retained.reset_reviews_on_change).to be(false)
     end
 
     it "refreshes a generated index while preserving a locally edited index" do
diff --git a/spec/requests/api/v1/operations_spec.rb b/spec/requests/api/v1/operations_spec.rb
index 320546ec..1dd7c105 100644
--- a/spec/requests/api/v1/operations_spec.rb
+++ b/spec/requests/api/v1/operations_spec.rb
@@ -20,6 +20,21 @@
     )
   end
 
+  [ true, false ].each do |reset|
+    it "honors reset_reviews_on_change=#{reset} for direct operations" do
+      plan.update!(reset_reviews_on_change: reset)
+      task = CoPlan::Reviews::Request.call(plan: plan, reviewer: alice, actor: alice)
+      receipt = CoPlan::Reviews::Respond.call(request: task, actor: alice, revision: 1, generation: task.generation, decision: "approved")
+      post api_v1_plan_operations_path(plan), params: { lease_token: lease_token, base_revision: 1,
+        operations: [ { op: "replace_exact", old_text: "Some content here.", new_text: "Updated content.", count: 1 } ] },
+        headers: headers, as: :json
+      expect(response).to have_http_status(:created)
+      expect(task.reload.review_status).to eq(reset ? "pending" : "approved")
+      expect(task.recorded_response).to eq(reset ? nil : receipt)
+      expect(task.effective_human_decision).to be_nil
+    end
+  end
+
   it "apply operations creates new version" do
     expect {
       post api_v1_plan_operations_path(plan),
diff --git a/spec/requests/api/v1/review_evidence_spec.rb b/spec/requests/api/v1/review_evidence_spec.rb
index 3a272567..05479c51 100644
--- a/spec/requests/api/v1/review_evidence_spec.rb
+++ b/spec/requests/api/v1/review_evidence_spec.rb
@@ -35,6 +35,20 @@
     expect(response.parsed_body.fetch("review_requests").first.fetch("effective_response_id")).to be_nil
   end
 
+  it "distinguishes retained task completion from current-version approval when resets are off" do
+    plan.update!(reset_reviews_on_change: false)
+    receipt = CoPlan::Reviews::Respond.call(request: task, actor: task.reviewer, revision: 1, generation: 1, decision: "approved")
+    CoPlan::Plans::ReplaceContent.call(plan: plan, new_content: "New source", base_revision: 1, actor_type: "human", actor_id: author.id)
+    get review_evidence_api_v1_plan_path(plan), headers: headers
+    expect(response).to have_http_status(:ok)
+    data = response.parsed_body
+    expect(data.fetch("reset_reviews_on_change")).to be(false)
+    expect(data.fetch("version").fetch("revision")).to eq(2)
+    expect(data.fetch("review_requests").first).to include("review_status" => "approved", "recorded_response_id" => receipt.id,
+      "effective_status" => "pending", "effective_human_decision" => nil, "effective_response_id" => nil)
+    expect(data.fetch("review_requests").first.fetch("responses").first).to include("revision" => 1, "plan_version_id" => receipt.plan_version_id)
+  end
+
   it "returns the exact historical source after edits and never substitutes current content" do
     original = plan.current_plan_version
     CoPlan::Plans::ReplaceContent.call(plan: plan, new_content: "New body", base_revision: 1, actor_type: "human", actor_id: author.id)
diff --git a/spec/requests/review_requests_spec.rb b/spec/requests/review_requests_spec.rb
index 4706ec62..8ad4e332 100644
--- a/spec/requests/review_requests_spec.rb
+++ b/spec/requests/review_requests_spec.rb
@@ -6,6 +6,28 @@
   let(:plan) { create(:plan, :published, created_by_user: author) }
   let(:task) { create(:review_request, plan: plan, reviewer: reviewer) }
 
+  it "defaults to resetting reviews and persists an editor's document-wide preference", :review_reset_policy do
+    expect(plan.reset_reviews_on_change).to be(true)
+    sequence = plan.review_sequence
+    sign_in_as(author)
+    [ false, false, true ].each_with_index do |enabled, index|
+      patch settings_plan_review_requests_path(plan), params: { review_settings: { reset_reviews_on_change: enabled } }, as: :json
+      expect(response).to have_http_status(:ok)
+      expect(response.parsed_body).to eq("reset_reviews_on_change" => enabled)
+      expect(plan.reload.reset_reviews_on_change).to eq(enabled)
+      expect(plan.review_sequence).to eq(sequence + (index == 2 ? 2 : 1))
+      expect(CoPlan::Reviews::Evidence.call(plan: plan)[:reset_reviews_on_change]).to eq(enabled)
+    end
+  end
+
+  it "does not let a reviewer change the document's reset policy", :review_reset_policy do
+    task
+    sign_in_as(reviewer)
+    patch settings_plan_review_requests_path(plan), params: { review_settings: { reset_reviews_on_change: false } }, as: :json
+    expect(response).to have_http_status(:not_found)
+    expect(plan.reload.reset_reviews_on_change).to be(true)
+  end
+
   it "labels an agent decision separately from the reviewer's own human approval" do
     token = create(:api_token, user: reviewer, agent_name: "Reviewbot")
     CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 1, decision: "approved", api_token: token)
diff --git a/spec/services/coplan/review_concurrency_spec.rb b/spec/services/coplan/review_concurrency_spec.rb
index 07c90fa7..00d3393b 100644
--- a/spec/services/coplan/review_concurrency_spec.rb
+++ b/spec/services/coplan/review_concurrency_spec.rb
@@ -11,49 +11,52 @@ def threaded(&block)
     Thread.new { ActiveRecord::Base.connection_pool.with_connection(&block) }
   end
 
-  it "makes an evidence read and stale response wait for the complete edit/reset transaction" do
-    owner = create(:coplan_user)
-    reviewer = create(:coplan_user)
-    plan = CoPlan::Plans::Create.call(title: "Concurrent review", content: "Before", user: owner)
-    task = CoPlan::Reviews::Request.call(plan: plan, reviewer: reviewer, actor: owner)
-    first = CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 1, generation: 1, decision: "approved")
-    edited, release, attempting = Queue.new, Queue.new, Queue.new
-    writer = threaded do
-      local = CoPlan::Plan.find(plan.id)
-      local.with_lock do
-        CoPlan::Plans::ReplaceContent.call(plan: local, new_content: "After", base_revision: 1, actor_type: "human", actor_id: owner.id)
-        edited << true
-        release.pop
+  [ true, false ].each do |reset|
+    it "makes evidence and stale responses wait for a complete edit with resets=#{reset}" do
+      owner = create(:coplan_user)
+      reviewer = create(:coplan_user)
+      plan = CoPlan::Plans::Create.call(title: "Concurrent review", content: "Before", user: owner)
+      plan.update!(reset_reviews_on_change: reset)
+      task = CoPlan::Reviews::Request.call(plan: plan, reviewer: reviewer, actor: owner)
+      first = CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 1, generation: 1, decision: "approved")
+      edited, release, attempting = Queue.new, Queue.new, Queue.new
+      writer = threaded do
+        local = CoPlan::Plan.find(plan.id)
+        local.with_lock do
+          CoPlan::Plans::ReplaceContent.call(plan: local, new_content: "After", base_revision: 1, actor_type: "human", actor_id: owner.id)
+          edited << true
+          release.pop
+        end
       end
-    end
-    Timeout.timeout(10) { edited.pop }
-    reader = threaded do
-      attempting << true
-      CoPlan::Reviews::Evidence.call(plan: CoPlan::Plan.find(plan.id))
-    end
-    responder = threaded do
-      attempting << true
-      begin
-        CoPlan::Reviews::Respond.call(request: CoPlan::ReviewRequest.find(task.id), actor: reviewer,
-          revision: 1, generation: 1, decision: "approved", idempotency_key: SecureRandom.uuid)
-      rescue CoPlan::Reviews::Respond::Conflict => error
-        error.code
+      Timeout.timeout(10) { edited.pop }
+      reader = threaded do
+        attempting << true
+        CoPlan::Reviews::Evidence.call(plan: CoPlan::Plan.find(plan.id))
       end
+      responder = threaded do
+        attempting << true
+        begin
+          CoPlan::Reviews::Respond.call(request: CoPlan::ReviewRequest.find(task.id), actor: reviewer,
+            revision: 1, generation: 1, decision: "approved", idempotency_key: SecureRandom.uuid)
+        rescue CoPlan::Reviews::Respond::Conflict => error
+          error.code
+        end
+      end
+      Timeout.timeout(10) { 2.times { attempting.pop } }
+      expect(reader).to be_alive
+      expect(responder).to be_alive
+      release << true
+      [ writer, reader, responder ].each { |thread| expect(thread.join(20)).to be_present }
+      evidence = reader.value
+      expect(evidence[:version]).to include(revision: 2, content_markdown: "After")
+      expect(evidence[:review_requests].first).to include(status: reset ? "pending" : "approved", effective_response_id: nil, generation: reset ? 2 : 1)
+      expect(evidence[:review_sequence]).to eq(first.decision_sequence + 1)
+      expect(responder.value).to eq("review_version_changed")
+      expect(task.reload.review_responses.pluck(:id)).to eq([ first.id ])
+    ensure
+      release << true if release
+      [ writer, reader, responder ].compact.each { |thread| thread.kill if thread.alive? }
     end
-    Timeout.timeout(10) { 2.times { attempting.pop } }
-    expect(reader).to be_alive
-    expect(responder).to be_alive
-    release << true
-    [ writer, reader, responder ].each { |thread| expect(thread.join(20)).to be_present }
-    evidence = reader.value
-    expect(evidence[:version]).to include(revision: 2, content_markdown: "After")
-    expect(evidence[:review_requests].first).to include(status: "pending", effective_response_id: nil, generation: 2)
-    expect(evidence[:review_sequence]).to eq(first.decision_sequence + 1)
-    expect(responder.value).to eq("review_version_changed")
-    expect(task.reload.review_responses.pluck(:id)).to eq([ first.id ])
-  ensure
-    release << true if release
-    [ writer, reader, responder ].compact.each { |thread| thread.kill if thread.alive? }
   end
 
   it "serializes two same-time decisions with unique increasing server sequences" do
diff --git a/spec/services/coplan/versioned_reviews_spec.rb b/spec/services/coplan/versioned_reviews_spec.rb
index 6ba2785b..a199fcb8 100644
--- a/spec/services/coplan/versioned_reviews_spec.rb
+++ b/spec/services/coplan/versioned_reviews_spec.rb
@@ -118,4 +118,94 @@ def replace(content)
     expect(evidence[:version][:content_markdown]).to eq(first.plan_version.content_markdown)
     expect(task.reload.effective_response).to eq(first)
   end
+
+  context "when automatic resets are off" do
+    before { plan.update!(reset_reviews_on_change: false) }
+
+    [ :replace, :draft, :checkbox, :session ].each do |writer|
+      it "preserves completed review lifecycle, not current-version evidence, after #{writer}" do
+        first = decide
+        sequence = plan.reload.review_sequence
+        case writer
+        when :replace then replace("New source")
+        when :draft
+          CoPlan::Plans::SaveHumanDraft.call(plan: plan, content: "A human draft", base_revision: 1, actor: plan.created_by_user)
+        when :checkbox
+          CoPlan::Plans::ToggleCheckbox.call(plan: plan, old_text: "- [ ] Ship", new_text: "- [x] Ship", base_revision: 1, actor_id: plan.created_by_user_id)
+        when :session
+          session = CoPlan::EditSession.create!(plan: plan, actor_type: "human", actor_id: plan.created_by_user_id,
+            base_revision: 1, status: "open", expires_at: 1.hour.from_now,
+            draft_content: "Revised by session", operations_json: [ { "op" => "replace_exact", "old_text" => "Ship", "new_text" => "Ship" } ])
+          CoPlan::Plans::CommitSession.call(session: session)
+        end
+        expect(plan.reload.review_sequence).to eq(sequence + 1)
+        expect(task.reload).to have_attributes(status: "approved", generation: 1, recorded_response: first, review_status: "approved")
+        expect(task).not_to be_pending
+        expect(task.effective_response).to be_nil
+        evidence = CoPlan::Reviews::Evidence.call(plan: plan)
+        expect(evidence[:reset_reviews_on_change]).to be(false)
+        expect(evidence[:review_requests].first).to include(review_status: "approved", effective_status: "pending",
+          recorded_response_id: first.id, effective_human_decision: nil, effective_response_id: nil)
+      end
+    end
+
+    it "preserves objections and agent attribution without inventing human evidence" do
+      response = decide(decision: "changes_requested", note: "Clarify this", api_token: create(:api_token, user: reviewer))
+      replace("New source")
+      expect(task.reload.review_status).to eq("changes_requested")
+      expect(task.recorded_response).to eq(response)
+      expect(task.recorded_response.actor_type).to eq("local_agent")
+      expect(task.effective_human_decision).to be_nil
+    end
+
+    it "keeps no-ops completed and never treats returned bytes or old retries as current approval" do
+      first = decide
+      original = plan.current_content
+      expect(replace(original)[:no_op]).to be(true)
+      expect(task.reload.effective_response).to eq(first)
+      replace("B")
+      replace(original)
+      [ { idempotency_key: first.id }, {} ].each do |attributes|
+        retry_response = CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 1, decision: "approved", **attributes)
+        expect(retry_response).to eq(first)
+      end
+      expect(task.reload.recorded_response).to eq(first)
+      expect(task.effective_response).to be_nil
+      expect(decide.plan_version.revision).to eq(3)
+      expect(task.reload.effective_human_decision).to eq("approved")
+    end
+
+    it "applies enabling to the next edit and never resurrects a dismissed decision when disabled" do
+      first = decide
+      replace("B")
+      plan.update!(reset_reviews_on_change: true)
+      expect(task.reload.recorded_response).to eq(first)
+      replace("C")
+      expect(task.reload).to be_pending
+      generation = task.generation
+      plan.update!(reset_reviews_on_change: false)
+      expect(task.reload.recorded_response).to be_nil
+      replace("D")
+      expect(task.reload).to be_pending
+      expect(task.generation).to eq(generation)
+      expect {
+        CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 3, generation: generation, decision: "approved", idempotency_key: SecureRandom.uuid)
+      }.to raise_error(CoPlan::Reviews::Respond::Conflict)
+      expect(decide.plan_version.revision).to eq(4)
+    end
+
+    it "preserves withdrawal and explicit re-request semantics across edits and retries" do
+      first = decide
+      CoPlan::Reviews::Withdraw.call(request: task, actor: plan.created_by_user)
+      replace("B")
+      expect(task.reload.review_status).to eq("withdrawn")
+      CoPlan::Reviews::Request.call(plan: plan, reviewer: reviewer, actor: plan.created_by_user)
+      [ { idempotency_key: first.id }, {} ].each do |attributes|
+        CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 1, decision: "approved", **attributes)
+      end
+      expect(task.reload).to be_pending
+      expect(task.recorded_response).to be_nil
+      expect(decide.plan_version.revision).to eq(2)
+    end
+  end
 end
diff --git a/spec/system/plan_reviews_spec.rb b/spec/system/plan_reviews_spec.rb
index 98e7730a..55e4225c 100644
--- a/spec/system/plan_reviews_spec.rb
+++ b/spec/system/plan_reviews_spec.rb
@@ -41,17 +41,160 @@ def lose_next_review_result
   before { sign_in_browser(reviewer, open_sections: !RSpec.current_example.metadata[:collapsed_support]) }
 
   [ "light", "dark" ].each do |theme|
-    it "shows content-change resets as required in the reviewer dialog in #{theme} theme", :review_reset_policy do
+    it "persists the default-on reset policy from the reviewer dialog in #{theme} theme", :review_reset_policy do
       sign_in_browser(author)
       page.execute_script("document.documentElement.dataset.theme = arguments[0]", theme)
       click_button "More actions"
       within("#plan-menu") { click_button "Manage reviewers" }
       within(".review-management[open]") do
-        expect(page).to have_checked_field("Reset approvals when content changes", disabled: true)
-        expect(page).to have_text("Required for all reviewers. Every new content version needs fresh approvals.")
+        expect(page).to have_checked_field("Reset approvals when content changes")
+        uncheck "Reset approvals when content changes"
+        expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
       end
-      page.save_screenshot(Rails.root.join("tmp/review-preview/reset-policy-required-#{theme}.png"))
+      expect(page).to have_css(".review-reset-policy__status[data-state='saved']")
+      expect(plan.reload.reset_reviews_on_change).to be(false)
+      visit plan_page_path(plan)
+      page.execute_script("document.documentElement.dataset.theme = arguments[0]", theme)
+      click_button "More actions"
+      within("#plan-menu") { click_button "Manage reviewers" }
+      within(".review-management[open]") do
+        expect(page).to have_unchecked_field("Reset approvals when content changes")
+        check "Reset approvals when content changes"
+        expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+      end
+      expect(plan.reload.reset_reviews_on_change).to be(true)
+      page.save_screenshot(Rails.root.join("tmp/review-preview/reset-policy-#{theme}.png"))
+    end
+  end
+
+  it "keeps reviews completed after edits when off, then resets after the next edit when enabled", :review_reset_policy do
+    sign_in_browser(author)
+    click_button "More actions"
+    within("#plan-menu") { click_button "Manage reviewers" }
+    within(".review-management[open]") do
+      uncheck "Reset approvals when content changes"
+      expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+    end
+    sign_in_browser(reviewer)
+    within(".review-tray") { click_button "Approve", exact: true }
+    within(".review-confirmation") { click_button "Approve v1", exact: true }
+    expect(page).to have_css(".review-tray", text: "You approved v1")
+    CoPlan::Plans::ReplaceContent.call(plan: plan, new_content: "# Second version", base_revision: 1, actor_type: "human", actor_id: author.id)
+    visit plan_page_path(plan)
+    expand_plan_section("footnote-approvals")
+    expect(page).to have_css(".review-tray", text: "You approved v1")
+    expect(page).to have_css(".review-tray", text: "no new review required")
+    expect(page).to have_css(".review-person", text: "Content changed since review")
+    expect(page).to have_no_css(".review-tray", text: "Your review is requested")
+    expect(task.reload.effective_human_decision).to be_nil
+    [ "light", "dark" ].each do |theme|
+      page.execute_script("document.documentElement.dataset.theme = arguments[0]", theme)
+      page.save_screenshot(Rails.root.join("tmp/review-preview/retained-review-#{theme}.png"))
+    end
+    sign_in_browser(author)
+    click_button "More actions"
+    within("#plan-menu") { click_button "Manage reviewers" }
+    within(".review-management[open]") do
+      check "Reset approvals when content changes"
+      expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+    end
+    expect(task.reload.review_status).to eq("approved")
+    CoPlan::Plans::ReplaceContent.call(plan: plan, new_content: "# Third version", base_revision: 2, actor_type: "human", actor_id: author.id)
+    visit plan_page_path(plan)
+    expand_plan_section("footnote-approvals")
+    expect(page).to have_css(".review-person__meta", text: "Content changed; review again")
+    expect(task.reload).to be_pending
+  end
+
+  it "autosaves the latest checkbox choice without save text or blocking more clicks", :review_reset_policy do
+    sign_in_browser(author)
+    click_button "More actions"
+    within("#plan-menu") { click_button "Manage reviewers" }
+    page.execute_script(<<~JS)
+      const originalFetch = window.fetch.bind(window)
+      window.policyWrites = []
+      window.fetch = async (url, options) => {
+        if (options?.method === 'PATCH' && String(url).endsWith('/settings')) {
+          window.policyWrites.push(JSON.parse(options.body).review_settings.reset_reviews_on_change)
+          document.querySelector("[data-review-reset-policy]").dataset.firstPolicyWrite = "true"
+          const result = await originalFetch(url, options)
+          await new Promise(resolve => setTimeout(resolve, 400))
+          return result
+        }
+        return originalFetch(url, options)
+      }
+    JS
+    within(".review-management[open]") do
+      page.execute_script('const input = document.querySelector("[data-review-reset-policy]"); input.click(); input.click()')
+      expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+      expect(page.evaluate_script("window.policyWrites")).to eq([])
+      uncheck "Reset approvals when content changes"
+      expect(page).to have_css("[data-review-reset-policy][aria-busy='true']")
+      expect(page).to have_no_text("Saving…")
+      expect(page).to have_no_text("Saved")
+      # Wait until the first request is in flight, then change our mind.
+      expect(page).to have_selector("[data-review-reset-policy][data-saved-value='true']")
+      expect(page).to have_css("[data-review-reset-policy][data-first-policy-write='true']")
+      check "Reset approvals when content changes"
+      expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+      expect(page).to have_checked_field("Reset approvals when content changes", disabled: false)
+    end
+    expect(plan.reload.reset_reviews_on_change).to be(true)
+    expect(page.evaluate_script("window.policyWrites")).to eq([ false, true ])
+  end
+
+  it "reconciles a lost save response with the persisted checkbox value", :review_reset_policy do
+    sign_in_browser(author)
+    click_button "More actions"
+    within("#plan-menu") { click_button "Manage reviewers" }
+    page.execute_script(<<~JS)
+      const originalFetch = window.fetch.bind(window)
+      let loseResult = true
+      window.fetch = async (url, options) => {
+        const result = await originalFetch(url, options)
+        if (loseResult && options?.method === 'PATCH' && String(url).endsWith('/settings')) {
+          loseResult = false
+          throw new TypeError('Lost saved result')
+        }
+        return result
+      }
+    JS
+    within(".review-management[open]") do
+      uncheck "Reset approvals when content changes"
+      expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+      expect(page).to have_unchecked_field("Reset approvals when content changes")
+    end
+    expect(plan.reload.reset_reviews_on_change).to be(false)
+    visit plan_page_path(plan)
+    click_button "More actions"
+    within("#plan-menu") { click_button "Manage reviewers" }
+    expect(page).to have_unchecked_field("Reset approvals when content changes")
+  end
+
+  it "restores the saved reset preference after a rejected settings update", :review_reset_policy do
+    sign_in_browser(author)
+    click_button "More actions"
+    within("#plan-menu") { click_button "Manage reviewers" }
+    page.execute_script(<<~JS)
+      const originalFetch = window.fetch.bind(window)
+      let reject = true
+      window.fetch = (url, options) => {
+        if (reject && options?.method === 'PATCH' && String(url).endsWith('/settings')) {
+          reject = false
+          return Promise.resolve(new Response(JSON.stringify({error: 'Unable to save settings'}), {status: 422, headers: {'Content-Type': 'application/json'}}))
+        }
+        return originalFetch(url, options)
+      }
+    JS
+    within(".review-management[open]") do
+      uncheck "Reset approvals when content changes"
+      expect(page).to have_text("Unable to save settings")
+      expect(page).to have_checked_field("Reset approvals when content changes", disabled: false)
+      expect(plan.reload.reset_reviews_on_change).to be(true)
+      uncheck "Reset approvals when content changes"
+      expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
     end
+    expect(plan.reload.reset_reviews_on_change).to be(false)
   end
 
   it "dismisses an approval after an edit, preserves its snapshot and accepts a fresh review", :version_parity do

From f1c9208e4b22eec23447fa220b2ecf6da79409f9 Mon Sep 17 00:00:00 2001
From: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
Date: Thu, 29 Oct 2026 14:11:56 -0400
Subject: [PATCH 04/18] Wait for review settings actions after navigation

Signed-off-by: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
---
 spec/system/plan_reviews_spec.rb | 44 ++++++++++++++++++++------------
 1 file changed, 28 insertions(+), 16 deletions(-)

diff --git a/spec/system/plan_reviews_spec.rb b/spec/system/plan_reviews_spec.rb
index 55e4225c..3ee39e40 100644
--- a/spec/system/plan_reviews_spec.rb
+++ b/spec/system/plan_reviews_spec.rb
@@ -40,12 +40,31 @@ def lose_next_review_result
 
   before { sign_in_browser(reviewer, open_sections: !RSpec.current_example.metadata[:collapsed_support]) }
 
+  def open_review_settings
+    expect(page).to have_no_css("html[aria-busy='true']")
+    # Turbo can paint cached HTML before Stimulus reconnects its actions.
+    expect(page.evaluate_async_script(<<~JS)).to be(true)
+      const done = arguments[arguments.length - 1]
+      const timeout = setTimeout(() => done(false), 5000)
+      const ready = () => {
+        const controls = document.getElementById('plan-review-controls')
+        const details = document.querySelector('[data-controller~="coplan--plan-details"]')
+        if (controls && details && window.Stimulus?.getControllerForElementAndIdentifier(controls, 'coplan--review-tray') && window.Stimulus.getControllerForElementAndIdentifier(details, 'coplan--plan-details')) {
+          clearTimeout(timeout); done(true)
+        } else requestAnimationFrame(ready)
+      }
+      ready()
+    JS
+    click_button "More actions"
+    within("#plan-menu") { click_button "Manage reviewers" }
+    expect(page).to have_css(".review-management[open]")
+  end
+
   [ "light", "dark" ].each do |theme|
     it "persists the default-on reset policy from the reviewer dialog in #{theme} theme", :review_reset_policy do
       sign_in_browser(author)
       page.execute_script("document.documentElement.dataset.theme = arguments[0]", theme)
-      click_button "More actions"
-      within("#plan-menu") { click_button "Manage reviewers" }
+      open_review_settings
       within(".review-management[open]") do
         expect(page).to have_checked_field("Reset approvals when content changes")
         uncheck "Reset approvals when content changes"
@@ -55,8 +74,7 @@ def lose_next_review_result
       expect(plan.reload.reset_reviews_on_change).to be(false)
       visit plan_page_path(plan)
       page.execute_script("document.documentElement.dataset.theme = arguments[0]", theme)
-      click_button "More actions"
-      within("#plan-menu") { click_button "Manage reviewers" }
+      open_review_settings
       within(".review-management[open]") do
         expect(page).to have_unchecked_field("Reset approvals when content changes")
         check "Reset approvals when content changes"
@@ -69,8 +87,7 @@ def lose_next_review_result
 
   it "keeps reviews completed after edits when off, then resets after the next edit when enabled", :review_reset_policy do
     sign_in_browser(author)
-    click_button "More actions"
-    within("#plan-menu") { click_button "Manage reviewers" }
+    open_review_settings
     within(".review-management[open]") do
       uncheck "Reset approvals when content changes"
       expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
@@ -92,8 +109,7 @@ def lose_next_review_result
       page.save_screenshot(Rails.root.join("tmp/review-preview/retained-review-#{theme}.png"))
     end
     sign_in_browser(author)
-    click_button "More actions"
-    within("#plan-menu") { click_button "Manage reviewers" }
+    open_review_settings
     within(".review-management[open]") do
       check "Reset approvals when content changes"
       expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
@@ -108,8 +124,7 @@ def lose_next_review_result
 
   it "autosaves the latest checkbox choice without save text or blocking more clicks", :review_reset_policy do
     sign_in_browser(author)
-    click_button "More actions"
-    within("#plan-menu") { click_button "Manage reviewers" }
+    open_review_settings
     page.execute_script(<<~JS)
       const originalFetch = window.fetch.bind(window)
       window.policyWrites = []
@@ -145,8 +160,7 @@ def lose_next_review_result
 
   it "reconciles a lost save response with the persisted checkbox value", :review_reset_policy do
     sign_in_browser(author)
-    click_button "More actions"
-    within("#plan-menu") { click_button "Manage reviewers" }
+    open_review_settings
     page.execute_script(<<~JS)
       const originalFetch = window.fetch.bind(window)
       let loseResult = true
@@ -166,15 +180,13 @@ def lose_next_review_result
     end
     expect(plan.reload.reset_reviews_on_change).to be(false)
     visit plan_page_path(plan)
-    click_button "More actions"
-    within("#plan-menu") { click_button "Manage reviewers" }
+    open_review_settings
     expect(page).to have_unchecked_field("Reset approvals when content changes")
   end
 
   it "restores the saved reset preference after a rejected settings update", :review_reset_policy do
     sign_in_browser(author)
-    click_button "More actions"
-    within("#plan-menu") { click_button "Manage reviewers" }
+    open_review_settings
     page.execute_script(<<~JS)
       const originalFetch = window.fetch.bind(window)
       let reject = true

From 97c08bf23b1e39f152e286dd9190ba706b749d32 Mon Sep 17 00:00:00 2001
From: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
Date: Thu, 29 Oct 2026 14:19:36 -0400
Subject: [PATCH 05/18] Exercise review settings through the Reviews section

Signed-off-by: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
---
 spec/system/plan_reviews_spec.rb | 17 ++---------------
 1 file changed, 2 insertions(+), 15 deletions(-)

diff --git a/spec/system/plan_reviews_spec.rb b/spec/system/plan_reviews_spec.rb
index 3ee39e40..a743500f 100644
--- a/spec/system/plan_reviews_spec.rb
+++ b/spec/system/plan_reviews_spec.rb
@@ -42,21 +42,8 @@ def lose_next_review_result
 
   def open_review_settings
     expect(page).to have_no_css("html[aria-busy='true']")
-    # Turbo can paint cached HTML before Stimulus reconnects its actions.
-    expect(page.evaluate_async_script(<<~JS)).to be(true)
-      const done = arguments[arguments.length - 1]
-      const timeout = setTimeout(() => done(false), 5000)
-      const ready = () => {
-        const controls = document.getElementById('plan-review-controls')
-        const details = document.querySelector('[data-controller~="coplan--plan-details"]')
-        if (controls && details && window.Stimulus?.getControllerForElementAndIdentifier(controls, 'coplan--review-tray') && window.Stimulus.getControllerForElementAndIdentifier(details, 'coplan--plan-details')) {
-          clearTimeout(timeout); done(true)
-        } else requestAnimationFrame(ready)
-      }
-      ready()
-    JS
-    click_button "More actions"
-    within("#plan-menu") { click_button "Manage reviewers" }
+    expand_plan_section("footnote-approvals")
+    within("#footnote-approvals") { click_button "Manage reviewers" }
     expect(page).to have_css(".review-management[open]")
   end
 

From 1e5f3be32ff6aaa24a9c7961a925cf5dbe292e07 Mon Sep 17 00:00:00 2001
From: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
Date: Thu, 29 Oct 2026 14:40:32 -0400
Subject: [PATCH 06/18] Move optional reset settings to a separate PR

Signed-off-by: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
---
 ...ew_reset_policy_to_coplan_plans.co_plan.rb |   6 -
 db/schema.rb                                  |   3 +-
 docs/REVIEWS.md                               |  12 +-
 .../app/assets/stylesheets/coplan/review.css  |   5 -
 .../coplan/review_requests_controller.rb      |  13 --
 .../coplan/review_tray_controller.js          |  69 +-------
 engine/app/models/coplan/plan.rb              |   1 -
 engine/app/models/coplan/review_request.rb    |  19 +--
 .../services/coplan/plans/advance_version.rb  |   5 +-
 .../app/services/coplan/reviews/evidence.rb   |   1 -
 .../app/services/coplan/reviews/serialize.rb  |   3 +-
 .../agent_instructions/guides/api.text.erb    |   2 +-
 .../guides/comments.text.erb                  |   2 +-
 .../agent_instructions/guides/live.text.erb   |   2 +-
 .../views/coplan/reviews/_controls.html.erb   |  12 +-
 engine/app/views/coplan/reviews/_log.html.erb |   2 +-
 .../views/coplan/reviews/_management.html.erb |   4 -
 .../app/views/coplan/reviews/_roster.html.erb |   6 +-
 .../app/views/coplan/reviews/_table.html.erb  |   6 +-
 engine/config/routes.rb                       |   1 -
 engine/db/demo/content/retained-review.md     |   7 -
 ...add_review_reset_policy_to_coplan_plans.rb |   5 -
 engine/lib/coplan/development_seed.rb         |  13 +-
 spec/lib/development_seed_spec.rb             |  10 --
 spec/requests/api/v1/operations_spec.rb       |  15 --
 spec/requests/api/v1/review_evidence_spec.rb  |  14 --
 spec/requests/review_requests_spec.rb         |  22 ---
 .../coplan/review_concurrency_spec.rb         |  83 +++++-----
 .../services/coplan/versioned_reviews_spec.rb |  90 ----------
 spec/system/plan_reviews_spec.rb              | 156 ------------------
 30 files changed, 71 insertions(+), 518 deletions(-)
 delete mode 100644 db/migrate/20261029174023_add_review_reset_policy_to_coplan_plans.co_plan.rb
 delete mode 100644 engine/db/demo/content/retained-review.md
 delete mode 100644 engine/db/migrate/20261029120000_add_review_reset_policy_to_coplan_plans.rb

diff --git a/db/migrate/20261029174023_add_review_reset_policy_to_coplan_plans.co_plan.rb b/db/migrate/20261029174023_add_review_reset_policy_to_coplan_plans.co_plan.rb
deleted file mode 100644
index 508333f8..00000000
--- a/db/migrate/20261029174023_add_review_reset_policy_to_coplan_plans.co_plan.rb
+++ /dev/null
@@ -1,6 +0,0 @@
-# This migration comes from co_plan (originally 20261029120000)
-class AddReviewResetPolicyToCoplanPlans < ActiveRecord::Migration[8.1]
-  def change
-    add_column :coplan_plans, :reset_reviews_on_change, :boolean, null: false, default: true
-  end
-end
diff --git a/db/schema.rb b/db/schema.rb
index 69d0b64c..65543fc8 100644
--- a/db/schema.rb
+++ b/db/schema.rb
@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema[8.1].define(version: 2026_10_29_174023) do
+ActiveRecord::Schema[8.1].define(version: 2026_10_29_141536) do
   create_table "active_admin_comments", id: { type: :string, limit: 36 }, charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
     t.bigint "author_id"
     t.string "author_type"
@@ -411,7 +411,6 @@
     t.integer "current_revision", default: 0, null: false
     t.json "metadata"
     t.string "plan_type_id", limit: 36, null: false
-    t.boolean "reset_reviews_on_change", default: true, null: false
     t.bigint "review_sequence", default: 0, null: false
     t.text "search_text", size: :medium
     t.string "slug", null: false
diff --git a/docs/REVIEWS.md b/docs/REVIEWS.md
index bbc9ce7f..048b10a8 100644
--- a/docs/REVIEWS.md
+++ b/docs/REVIEWS.md
@@ -4,17 +4,15 @@ A native review means satisfaction with a specific Markdown source version. It g
 
 ## Content and decision identity
 
-Responses retain `plan_version_id`, that version’s SHA-256, `request_generation`, and a server-assigned `decision_sequence`. UUIDs identify transport retries; they do not order decisions. A request’s `current_response_id` is the authoritative projection. `review_status` and `recorded_response_id` describe lifecycle completion, including a decision retained across edits when automatic resets are off. A response is effective only when it belongs to that request, generation and current plan version and matches the task status. `effective_human_decision` is null for pending, withdrawn, dismissed or agent decisions. `latest_approval` is positive history for comparison, not qualification.
+Responses retain `plan_version_id`, that version’s SHA-256, `request_generation`, and a server-assigned `decision_sequence`. UUIDs identify transport retries; they do not order decisions. A request’s `current_response_id` is the authoritative projection. A response is effective only when it belongs to that request, generation and current plan version and matches the task status. `effective_human_decision` is null for pending, withdrawn, dismissed or agent decisions. `latest_approval` is positive history for comparison, not qualification.
 
 The approval covers **Markdown source bytes only**. Title, tags, attachments, linked and embedded resources, child plans, and rendered output are excluded. URLs and embedded source syntax are approved as literal text, not as the bytes they might display. Historical pages expose exact source and hash and label the current title as metadata. Full rich-page approval requires a separate immutable asset envelope and renderer contract.
 
 ## Edits and cycles
 
-All current-version writers use `Plans::AdvanceVersion`: Create, ReplaceContent (including SaveHumanDraft/web saves), CommitSession, ToggleCheckbox and the direct operations API. They already hold the plan row lock; CommitSession retains session-before-plan lock order. The version pointer, revision and review sequence always advance together. With `reset_reviews_on_change` enabled (the default), active task resets, generation increments and cleared current pointers commit in that same transaction. Withdrawn tasks and all receipts remain intact. Resets broadcast after commit without sending a review-request notification for every edit.
+All current-version writers use `Plans::AdvanceVersion`: Create, ReplaceContent (including SaveHumanDraft/web saves), CommitSession, ToggleCheckbox and the direct operations API. They already hold the plan row lock; CommitSession retains session-before-plan lock order. The version pointer, revision, review sequence, active task resets, generation increments and cleared current pointers commit together. Withdrawn tasks and all receipts remain intact. Resets broadcast after commit without sending a review-request notification for every edit.
 
-An identical normalized ReplaceContent save creates no version and preserves approval. An empty session creates no version. A nonempty session or operations commit creates a new version even if its operations net to identical bytes, and resets reviews when the policy is enabled. Returning A→B→A always produces a distinct version; no older decision becomes exact-current-version evidence. Existing edit leases, human-edit fences and merge guards remain in place.
-
-Editors can toggle **Reset approvals when content changes** in Manage reviewers. The setting applies to future edits for every reviewer. When off, completed approvals and change requests remain completed on their original versions; edits require no fresh review. Pending tasks stay pending, and withdrawn tasks stay withdrawn. Turning resets back on affects the next edit; turning them off never restores an already dismissed decision. Exact-current-version `effective_status`, `effective_response_id` and `effective_human_decision` remain strict regardless of this preference. Policy updates take the same plan row lock and advance `review_sequence` only when changed.
+An identical normalized ReplaceContent save creates no version and preserves approval. An empty session creates no version. A nonempty session or operations commit creates a new version even if its operations net to identical bytes, and dismisses decisions. Returning A→B→A always produces a distinct version and requires fresh review. Existing edit leases, human-edit fences and merge guards remain in place.
 
 An explicit re-request advances the task generation and clears its effective decision. Creating an already existing request is a retry and leaves its state alone. Withdrawal clears the effective decision and preserves receipts. A fresh response supersedes the previous effective response, including a later agent response. The latest sequenced human response on the current version is exposed separately so consumers can inspect human feedback across request cycles; native CoPlan does not impose an external approval or objection policy.
 
@@ -22,7 +20,7 @@ New responses send the viewed revision, fetched generation and a fresh UUID `ide
 
 ## Reads and compatibility
 
-`GET /api/v1/plans/:id/review_evidence` takes one plan-row transaction and returns exact current source/hash/version, scope, review sequence, reset preference, lifecycle and exact-version projections, and complete response history. It creates no PlanRead or agent session. Ordinary authentication may still update token usage. The review sequence covers body and native review changes, not excluded metadata, sharing or external authorization. Existing snapshot reads retain their older behavior; consumers requiring coherent evidence use this endpoint.
+`GET /api/v1/plans/:id/review_evidence` takes one plan-row transaction and returns exact current source/hash/version, scope, review sequence, current projection and complete response history. It creates no PlanRead or agent session. Ordinary authentication may still update token usage. The review sequence covers body and native review changes, not excluded metadata, sharing or external authorization. Existing snapshot reads retain their older behavior; consumers requiring coherent evidence use this endpoint.
 
 `GET /api/v1/plans/:id/versions/:version_id` returns that exact historical Markdown and hash. It never substitutes the current version. Both endpoints use existing Bearer authentication and visibility rules; neither establishes a read-only workload credential or employee identity mapping.
 
@@ -33,5 +31,3 @@ Persisted version IDs, plan IDs, revisions, Markdown and hashes reject ordinary
 ## Local tryout
 
 Seed the shared demo library with `bin/rails coplan:demo:seed`. Sign in as `alex@example.com` and open **Workspace invitations: review dismissed after edits** in Hampton’s Demo scenarios. v1 approvals are history, v2 is pending, and the activity link opens the original source. Approve v2, then sign in as `hampton@example.com` and edit its body or toggle its checkbox. Alex’s task returns to pending. Re-seeding preserves edits and decisions.
-
-For the off state, open **Workspace invitations: reviews retained after edits**. Automatic resets are off: v1 decisions remain completed after v2, with an explicit changed-content label. Toggle the option in Manage reviewers to try both policies.
diff --git a/engine/app/assets/stylesheets/coplan/review.css b/engine/app/assets/stylesheets/coplan/review.css
index 78181942..e6603786 100644
--- a/engine/app/assets/stylesheets/coplan/review.css
+++ b/engine/app/assets/stylesheets/coplan/review.css
@@ -241,8 +241,6 @@ button.visibility-option__button:hover:not(:disabled) { background: var(--color-
 .review-assignment-form__footer { display: flex; justify-content: space-between; align-items: center; gap: 12px; margin-top: 12px; }
 .review-dialog .review-required { display: flex; gap: 8px; align-items: center; margin: 0; color: var(--color-text); cursor: pointer; }
 .review-dialog .review-required input { width: 15px; height: 15px; padding: 0; margin: 0; accent-color: var(--color-primary); }
-.review-reset-policy { margin-bottom: 20px; }
-.review-reset-policy p { margin: 6px 0 0 23px; }
 .review-search-results { position: absolute; z-index: 1; top: calc(100% + 6px); left: 0; right: 0; max-height: 210px; overflow: auto; padding: 6px; border: 1px solid var(--glass-edge); border-radius: 10px; background: var(--color-surface); color: var(--color-text-muted); box-shadow: var(--shadow-lg); font-size: 12px; }
 .review-search-results[hidden] { display: none; }
 .review-search-result {
@@ -530,6 +528,3 @@ body:has(.review-tray[data-completed="true"]:not([data-reconsidering="true"]):no
 
 /* Live content and the inline editor share this reader, including empty plans. */
 .plan-reader:has(.markdown-rendered > *) > .empty-state { display: none; }
-
-.review-reset-policy__status { display: inline-block; width: 1em; color: var(--color-text-muted); opacity: 0; }
-.review-reset-policy__status[data-state="saved"] { opacity: 1; }
diff --git a/engine/app/controllers/coplan/review_requests_controller.rb b/engine/app/controllers/coplan/review_requests_controller.rb
index 47c2eafe..dfd31bf7 100644
--- a/engine/app/controllers/coplan/review_requests_controller.rb
+++ b/engine/app/controllers/coplan/review_requests_controller.rb
@@ -15,19 +15,6 @@ def suggestions
       render json: Reviews::Suggest.call(plan: @plan)
     end
 
-    def settings
-      authorize!(@plan, :update?)
-      attributes = params.expect(review_settings: [ :reset_reviews_on_change ])
-      enabled = ActiveModel::Type::Boolean.new.cast(attributes.fetch(:reset_reviews_on_change))
-      @plan.with_lock do
-        if @plan.reset_reviews_on_change != enabled
-          @plan.update!(reset_reviews_on_change: enabled, review_sequence: @plan.review_sequence + 1)
-        end
-      end
-      Broadcaster.custom_action_to(@plan, action: "coplan-review-changed", target: "plan-review-controls", html: "")
-      render json: { reset_reviews_on_change: @plan.reset_reviews_on_change }
-    end
-
     def create
       authorize!(@plan, :update?)
       attributes = params.expect(review_request: [ :reviewer_id, :requirement ])
diff --git a/engine/app/javascript/controllers/coplan/review_tray_controller.js b/engine/app/javascript/controllers/coplan/review_tray_controller.js
index c3f75265..14a23378 100644
--- a/engine/app/javascript/controllers/coplan/review_tray_controller.js
+++ b/engine/app/javascript/controllers/coplan/review_tray_controller.js
@@ -1,8 +1,8 @@
 import { Controller } from "@hotwired/stimulus"
 
 export default class extends Controller {
-  static targets = ["reviews", "discussion", "commentForm", "changeButton", "notice", "search", "reviewerId", "results", "assignment", "addReviewerButton", "assignButton", "managementError", "managementStatus", "policyIcon", "assignmentError", "approval", "approvalNote", "approvalError", "approvalTitle", "approveButton", "comparison", "diff", "activity", "suggestions"]
-  static values = { url: String, searchUrl: String, suggestionsUrl: String, settingsUrl: String }
+  static targets = ["reviews", "discussion", "commentForm", "changeButton", "notice", "search", "reviewerId", "results", "assignment", "addReviewerButton", "assignButton", "managementError", "managementStatus", "assignmentError", "approval", "approvalNote", "approvalError", "approvalTitle", "approveButton", "comparison", "diff", "activity", "suggestions"]
+  static values = { url: String, searchUrl: String, suggestionsUrl: String }
 
   connect() {
     this.searchSequence = 0
@@ -21,12 +21,6 @@ export default class extends Controller {
 
   disconnect() {
     clearTimeout(this.searchTimer)
-    clearTimeout(this.policySaveTimer)
-    if (this.policySaveTimer) {
-      this.policySaveTimer = null
-      this.saveResetPolicy(this.element.querySelector("[data-review-reset-policy]"))
-    }
-    clearTimeout(this.policyIconTimer)
     this.searchSequence++
     this.refreshSequence++
     document.body.classList.remove("has-review-tray")
@@ -227,19 +221,12 @@ export default class extends Controller {
 
   async refresh() {
     const sequence = ++this.refreshSequence
-    const policyBusy = this.policySaving || this.policySaveTimer
     try {
       const response = await fetch(this.urlValue, { credentials: "same-origin", headers: { Accept: "text/html" } })
       if (!response.ok) return
       const incoming = new DOMParser().parseFromString(await response.text(), "text/html")
       if (sequence !== this.refreshSequence || !this.element.isConnected) return
       this.element.dataset.reviewGeneration = incoming.getElementById("plan-review-controls")?.dataset.reviewGeneration || ""
-      const policy = this.element.querySelector("[data-review-reset-policy]")
-      const incomingPolicy = incoming.querySelector("[data-review-reset-policy]")
-      if (policy && incomingPolicy && !policyBusy && !this.policySaving && !this.policySaveTimer) {
-        policy.checked = incomingPolicy.checked
-        policy.dataset.savedValue = String(incomingPolicy.checked)
-      }
       const tray = incoming.querySelector(".review-tray")
       const existingTray = this.element.querySelector(".review-tray")
       const wasWithdrawn = this.reviewWithdrawn
@@ -285,58 +272,6 @@ export default class extends Controller {
     } catch { /* The task and draft remain usable; the next event retries. */ }
   }
 
-  changeResetPolicy(event) {
-    const input = event.currentTarget
-    input.setAttribute("aria-busy", "true")
-    this.refreshSequence++
-    this.policyIconTarget.setAttribute("aria-hidden", "true")
-    clearTimeout(this.policyIconTimer)
-    this.policyIconTarget.dataset.state = ""
-    clearTimeout(this.policySaveTimer)
-    this.policySaveTimer = setTimeout(() => {
-      this.policySaveTimer = null
-      this.saveResetPolicy(input)
-    }, 200)
-  }
-
-  async saveResetPolicy(input) {
-    if (this.policySaving) return
-    const previous = input.dataset.savedValue === "true"
-    const enabled = input.checked
-    if (previous === enabled) { input.setAttribute("aria-busy", "false"); return }
-    this.policySaving = true
-    this.managementErrorTarget.textContent = ""
-    try {
-      await this.write(this.settingsUrlValue, "PATCH", { review_settings: { reset_reviews_on_change: enabled } })
-      input.dataset.savedValue = String(enabled)
-      if (input.checked === enabled) {
-        this.policyIconTarget.dataset.state = "saved"
-        this.policyIconTarget.setAttribute("aria-hidden", "false")
-        this.policyIconTimer = setTimeout(() => {
-          this.policyIconTarget.dataset.state = ""
-          this.policyIconTarget.setAttribute("aria-hidden", "true")
-        }, 1500)
-      }
-    } catch (error) {
-      // A lost HTTP result may already have saved. Read back before restoring
-      // the checkbox, while preserving clicks made during that request.
-      let persisted = previous
-      try {
-        const response = await fetch(this.urlValue, { credentials: "same-origin", headers: { Accept: "text/html" } })
-        const policy = new DOMParser().parseFromString(await response.text(), "text/html").querySelector("[data-review-reset-policy]")
-        if (response.ok && policy) persisted = policy.checked
-      } catch { /* Keep the last confirmed value and show the error. */ }
-      input.dataset.savedValue = String(persisted)
-      if (input.checked === enabled) input.checked = persisted
-      this.managementErrorTarget.textContent = persisted === enabled ? "" : error.message
-    } finally {
-      this.policySaving = false
-      // Serialize saves so a slow older request cannot overwrite a newer click.
-      if (input.checked !== (input.dataset.savedValue === "true")) this.saveResetPolicy(input)
-      else input.setAttribute("aria-busy", "false")
-    }
-  }
-
   async assign(event) {
     event.preventDefault()
     if (!this.reviewerIdTarget.value) { this.assignmentErrorTarget.textContent = "Choose a person from the results first."; return }
diff --git a/engine/app/models/coplan/plan.rb b/engine/app/models/coplan/plan.rb
index 7117a782..e9707d72 100644
--- a/engine/app/models/coplan/plan.rb
+++ b/engine/app/models/coplan/plan.rb
@@ -68,7 +68,6 @@ class Plan < ApplicationRecord
     before_save :assign_url_slug, if: :url_slug_stale?
 
     validates :title, presence: true
-    validates :reset_reviews_on_change, inclusion: { in: [ true, false ] }
     validates :visibility, presence: true, inclusion: { in: VISIBILITIES }
     validate :attachments_within_limits
 
diff --git a/engine/app/models/coplan/review_request.rb b/engine/app/models/coplan/review_request.rb
index 54041126..140d1c12 100644
--- a/engine/app/models/coplan/review_request.rb
+++ b/engine/app/models/coplan/review_request.rb
@@ -24,7 +24,7 @@ class ReviewRequest < ApplicationRecord
     scope :pending, -> { where(status: "pending") }
 
     def pending?
-      review_status == "pending"
+      effective_status == "pending"
     end
 
     # Positive history is for comparison only. Never use it as current evidence.
@@ -32,22 +32,11 @@ def latest_approval
       review_responses.find { |response| response.decision == "approved" }
     end
 
-    # Lifecycle completion may survive edits when automatic resets are off.
-    # The recorded decision still covers only its original immutable version.
-    def recorded_response
+    def effective_response
       response = current_response
       response if response && status == response.decision &&
-        response.review_request_id == id && response.request_generation == generation
-    end
-
-    def review_status
-      status == "withdrawn" ? "withdrawn" : (recorded_response&.decision || "pending")
-    end
-
-    # Exact-version evidence stays strict regardless of the reset preference.
-    def effective_response
-      response = recorded_response
-      response if response&.plan_version_id == plan.current_plan_version_id
+        response.review_request_id == id && response.request_generation == generation &&
+        response.plan_version_id == plan.current_plan_version_id
     end
 
     def effective_status
diff --git a/engine/app/services/coplan/plans/advance_version.rb b/engine/app/services/coplan/plans/advance_version.rb
index e81b7e6a..fcd6d126 100644
--- a/engine/app/services/coplan/plans/advance_version.rb
+++ b/engine/app/services/coplan/plans/advance_version.rb
@@ -9,7 +9,7 @@ def self.call(plan:, version:)
 
         plan.update!(current_plan_version: version, current_revision: version.revision,
           review_sequence: plan.review_sequence + 1)
-        requests = plan.reset_reviews_on_change? ? plan.review_requests.active.to_a : []
+        requests = plan.review_requests.active.to_a
         requests.each do |request|
           request.update!(status: "pending", generation: request.generation + 1,
             current_response: nil, reset_reason: "content_changed")
@@ -17,9 +17,6 @@ def self.call(plan:, version:)
         # No new review notifications for each edit, and no reset broadcast
         # for a transaction that rolls back.
         ActiveRecord.after_all_transactions_commit do
-          if requests.empty?
-            Broadcaster.custom_action_to(plan, action: "coplan-review-changed", target: "plan-review-controls", html: "")
-          end
           requests.each do |request|
             Reviews::Changed.call(request: request, event_type: "review.requested",
               payload: { "action" => "content_changed", "revision" => version.revision,
diff --git a/engine/app/services/coplan/reviews/evidence.rb b/engine/app/services/coplan/reviews/evidence.rb
index 4e5e09f0..7aa499c6 100644
--- a/engine/app/services/coplan/reviews/evidence.rb
+++ b/engine/app/services/coplan/reviews/evidence.rb
@@ -14,7 +14,6 @@ def self.call(plan:)
           version = plan.current_plan_version
           {
             schema_version: 1, plan_id: plan.id, review_sequence: plan.review_sequence,
-            reset_reviews_on_change: plan.reset_reviews_on_change,
             approval_scope: SCOPE,
             version: { id: version.id, revision: version.revision,
                        content_sha256: version.content_sha256, content_markdown: version.verified_content! },
diff --git a/engine/app/services/coplan/reviews/serialize.rb b/engine/app/services/coplan/reviews/serialize.rb
index 3fa33cf8..c70f0896 100644
--- a/engine/app/services/coplan/reviews/serialize.rb
+++ b/engine/app/services/coplan/reviews/serialize.rb
@@ -13,10 +13,9 @@ def call
         request = @request
         {
           id: request.id, reviewer: { id: request.reviewer_id, name: request.reviewer.name },
-          requirement: request.requirement, status: request.status, review_status: request.review_status, effective_status: request.effective_status,
+          requirement: request.requirement, status: request.status, effective_status: request.effective_status,
           requested_at: request.requested_at, generation: request.generation, reset_reason: request.reset_reason,
           current_response_id: request.current_response_id,
-          recorded_response_id: request.recorded_response&.id,
           effective_response_id: request.effective_response&.id,
           effective_human_decision: request.effective_human_decision,
           latest_human_response_id: request.review_responses.find { |response|
diff --git a/engine/app/views/coplan/agent_instructions/guides/api.text.erb b/engine/app/views/coplan/agent_instructions/guides/api.text.erb
index f5416214..8373ffea 100644
--- a/engine/app/views/coplan/agent_instructions/guides/api.text.erb
+++ b/engine/app/views/coplan/agent_instructions/guides/api.text.erb
@@ -84,7 +84,7 @@ return 429. Invalid names return 422 with `invalid_request`.
 
 Creating a review request for an existing reviewer returns the current task with status 201. It leaves the requirement, decision, history, and notifications unchanged. Use `PATCH` to change the requirement or `request_again: true` to request another look.
 
-Send the request’s `generation` and the viewed `revision` with every new response. A missing generation is supported only for the first cycle. After edits or re-requests, a stale or missing generation returns 409 with `code: review_request_changed`. Fetch the task again and deliberately review before submitting a fresh response. By default, edits reset active tasks to pending and advance their generations. When `reset_reviews_on_change` is false, completed reviews stay completed on their original versions; no fresh approval is required. Withdrawn tasks stay withdrawn. Earlier responses remain history.
+Send the request’s `generation` and the viewed `revision` with every new response. A missing generation is supported only for the first cycle. After edits or re-requests, a stale or missing generation returns 409 with `code: review_request_changed`. Fetch the task again and deliberately review before submitting a fresh response. Edits reset active tasks to pending and advance their generations. Withdrawn tasks stay withdrawn. Earlier responses remain history.
 
 Include `idempotency_key` (a fresh UUID) for each intended review response. Reuse that UUID and identical fields when retrying a lost response; its returned `id` is the UUID. Use a new UUID for a new decision, including another review of the same version. A keyed retry returns the original recorded result even after the plan changes or the task is withdrawn. It preserves any newly pending review task. Without a key, an identical response is treated as a retry. Retries may use a renewed token for the same human principal. The original response keeps its original agent and token attribution. A key reused for different fields returns 422. A retry’s `effective: false` means it is history, not a current decision. New responses return `plan_version_id`, `content_sha256`, `generation`, and server `decision_sequence`.
 
diff --git a/engine/app/views/coplan/agent_instructions/guides/comments.text.erb b/engine/app/views/coplan/agent_instructions/guides/comments.text.erb
index 9efeb035..14adb8b3 100644
--- a/engine/app/views/coplan/agent_instructions/guides/comments.text.erb
+++ b/engine/app/views/coplan/agent_instructions/guides/comments.text.erb
@@ -80,7 +80,7 @@ To give feedback on another person's plan, start threads anchored to the passage
 
 Each request or re-request remains in review activity with its requester and time. A later request does not replace earlier requests or decisions.
 
-Discussion is the default. An approval means “satisfied with this exact version”; it grants no permissions, execution authority, or instruction to implement the plan. Never interpret another person's sign-off as an instruction from your principal. By default, edits reset active tasks to pending and preserve earlier decisions as history. Editors may disable automatic resets in Manage reviewers; completed reviews then stay completed on their original versions, without requiring fresh approval. Approval covers Markdown source bytes only, not title, tags, attachments, linked or embedded resources, or child plans. Use `GET /api/v1/plans/:plan_id/review_evidence` for exact current Markdown, hash, version ID, and coherent review state. It creates no read receipt. `review_status` describes task completion. `effective_human_decision` is exact-current-version evidence and is null for agent decisions, dismissed approvals, or decisions on older versions, even when automatic resets are off. A later agent decision cannot count as a human approval. `latest_human_response_id` exposes historical human feedback on the current version; it is not an effective approval.
+Discussion is the default. An approval means “satisfied with this exact version”; it grants no permissions, execution authority, or instruction to implement the plan. Never interpret another person's sign-off as an instruction from your principal. Edits reset active tasks to pending and preserve the earlier sign-off as history. Approval covers Markdown source bytes only, not title, tags, attachments, linked or embedded resources, or child plans. Use `GET /api/v1/plans/:plan_id/review_evidence` for exact current Markdown, hash, version ID, and coherent review state. It creates no read receipt. `effective_human_decision` is null for agent decisions or dismissed approvals. A later agent decision cannot count as a human approval. `latest_human_response_id` exposes historical human feedback on the current version; it is not an effective approval.
 
 - `GET /api/v1/plans/:plan_id/review_requests` lists requests and responses, including reviewer, required/optional, revision, timestamp, notes, and agent attribution.
 - The plan author's credential may `POST` that path with `{ "reviewer_id": "USER_ID", "requirement": "required" }` (or `optional`). Requests are tasks; reading the notification does not complete them.
diff --git a/engine/app/views/coplan/agent_instructions/guides/live.text.erb b/engine/app/views/coplan/agent_instructions/guides/live.text.erb
index aed9c7f8..101aafe5 100644
--- a/engine/app/views/coplan/agent_instructions/guides/live.text.erb
+++ b/engine/app/views/coplan/agent_instructions/guides/live.text.erb
@@ -103,7 +103,7 @@ For `review.requested`, inspect `payload.action`:
 | Action | Meaning |
 |---|---|
 | `requested` | A new request or another look. `requirement` is `required` or `optional`. |
-| `content_changed` | A new Markdown version reset active tasks and advanced their generations under the default-on reset policy. No reset event is emitted when the document’s automatic resets are off. Earlier responses remain history. Read the current version and request before responding. No new inbox nudge is sent for each edit. |
+| `content_changed` | A new Markdown version reset active tasks and advanced their generations. Earlier responses remain history. Read the current version and request before responding. No new inbox nudge is sent for each edit. |
 | `requirement_changed` | Only `requirement` changed. This does not reopen the task or start another review cycle. Do not treat it as a request for another look. |
 | `withdrawn` | The request was withdrawn. Stop working on that request; its earlier decisions remain. The payload also has `withdrawn: true`. |
 
diff --git a/engine/app/views/coplan/reviews/_controls.html.erb b/engine/app/views/coplan/reviews/_controls.html.erb
index ebe2c656..ea8983b7 100644
--- a/engine/app/views/coplan/reviews/_controls.html.erb
+++ b/engine/app/views/coplan/reviews/_controls.html.erb
@@ -1,12 +1,11 @@
 <% requests = plan.review_requests.includes(:reviewer, :requested_by_user, :requested_plan_version, review_responses: [ :plan_version, :user ]).order(:requested_at).to_a %>
 <% request_events = plan.plan_events.where(event_type: %w[review_requested review_withdrawn]).includes(:actor_user).to_a %>
-<% active_requests = requests.reject { |request| request.review_status == "withdrawn" } %>
+<% active_requests = requests.reject { |request| request.effective_status == "withdrawn" } %>
 <% own_request = active_requests.find { |request| request.reviewer_id == current_user.id } %>
 <% response_thread_ids = requests.flat_map { |request| request.review_responses.map(&:comment_thread_id) }.compact %>
 <% feedback_thread_ids = plan.comment_threads.with_kept_comments.where(id: response_thread_ids).pluck(:id) %>
 <div id="plan-review-controls" data-review-generation="<%= own_request&.generation %>" data-review-record-count="<%= requests.size %>" data-controller="coplan--review-tray"
      data-coplan--review-tray-url-value="<%= plan_review_requests_path(plan) %>"
-     data-coplan--review-tray-settings-url-value="<%= settings_plan_review_requests_path(plan) %>"
      data-coplan--review-tray-search-url-value="<%= search_users_path %>"
      <% if CoPlan.configuration.suggest_reviewers %>data-coplan--review-tray-suggestions-url-value="<%= suggestions_plan_review_requests_path(plan) %>"<% end %>
      data-action="coplan:anchors-updated@document->coplan--review-tray#syncFeedbackLinks coplan:reviews-changed->coplan--review-tray#refresh coplan:manage-reviews@document->coplan--review-tray#openReviews coplan:content-updated@document->coplan--review-tray#refresh coplan:editor-saved@document->coplan--review-tray#refresh resize@window->coplan--review-tray#positionAssignment keydown.esc@document->coplan--review-tray#escape">
@@ -29,18 +28,17 @@
       </div>
       <div class="review-tray__bar">
         <div class="review-tray__status" data-review-status>
-          <% response = own_request.recorded_response %>
+          <% response = own_request.effective_response %>
           <% approval = own_request.latest_approval %>
           <div class="review-tray__decision">
             <% if own_request.pending? %>
               <span class="review-task-dot" aria-hidden="true"></span><strong>Your review is requested</strong><small><%= own_request.requirement.humanize %><%= " · Content changed; review v#{plan.current_revision} again" if own_request.reset_reason == "content_changed" %><%= " · Earlier decisions are history; please review again" if own_request.reset_reason == "legacy_history" %></small>
             <% elsif response %>
-              <span class="review-result-icon<%= ' review-result-icon--approved' if own_request.review_status == 'approved' %>" aria-hidden="true"><%= own_request.review_status == "approved" ? "✓" : "↩" %></span>
+              <span class="review-result-icon<%= ' review-result-icon--approved' if own_request.effective_status == 'approved' %>" aria-hidden="true"><%= own_request.effective_status == "approved" ? "✓" : "↩" %></span>
               <% decision_actor = response.actor_type == "local_agent" ? "#{response.agent_name} (via you)" : "You" %>
-              <span><strong><%= own_request.review_status == "approved" ? "#{decision_actor} approved" : "#{decision_actor} requested changes to" %> v<%= response.plan_version.revision %></strong> <span class="review-tray__date">on <time datetime="<%= response.created_at.iso8601 %>" title="<%= response.created_at.strftime('%B %-d, %Y at %H:%M %Z') %>"><%= response.created_at.strftime("%b %-d, %Y") %></time></span></span>
+              <span><strong><%= own_request.effective_status == "approved" ? "#{decision_actor} approved" : "#{decision_actor} requested changes to" %> v<%= response.plan_version.revision %></strong> <span class="review-tray__date">on <time datetime="<%= response.created_at.iso8601 %>" title="<%= response.created_at.strftime('%B %-d, %Y at %H:%M %Z') %>"><%= response.created_at.strftime("%b %-d, %Y") %></time></span></span>
             <% end %>
           </div>
-          <% if response && response.plan_version_id != plan.current_plan_version_id %><small>Content changed since review; no new review required.</small><% end %>
           <% if !own_request.pending? && feedback_thread_ids.include?(response&.comment_thread_id) %><button type="button" class="review-log__link review-feedback-link" data-action="coplan--review-tray#openThread" data-thread-id="<%= response.comment_thread_id %>">View feedback</button><% end %>
           <% if approval && approval.plan_version.revision != plan.current_revision %><button type="button" class="btn btn--ghost btn--sm" data-action="coplan--review-tray#compare" data-url="<%= compare_plan_review_request_path(plan, own_request, response_id: approval.id) %>">Changes since approval</button><% end %>
         </div>
@@ -64,7 +62,7 @@
       <h2 id="approval-title" data-coplan--review-tray-target="approvalTitle">Approve this version?</h2>
     </div>
     <p class="review-confirmation__statement">I’ve reviewed and approve the Markdown source of this version.</p>
-    <p class="text-sm text-muted">Attachments, linked or embedded content, title, tags, and child plans are outside this approval.</p>
+    <p class="text-sm text-muted">Edits dismiss active decisions. Attachments, linked or embedded content, title, tags, and child plans are outside this approval.</p>
     <form data-action="submit->coplan--review-tray#approve">
       <label for="approval-note">Public note <span class="text-muted">(optional)</span></label><textarea id="approval-note" rows="3" placeholder="Anything you’d like to add?" data-coplan--review-tray-target="approvalNote"></textarea>
       <p class="review-error" role="alert" data-coplan--review-tray-target="approvalError"></p>
diff --git a/engine/app/views/coplan/reviews/_log.html.erb b/engine/app/views/coplan/reviews/_log.html.erb
index 7903a6f4..2d4beeb3 100644
--- a/engine/app/views/coplan/reviews/_log.html.erb
+++ b/engine/app/views/coplan/reviews/_log.html.erb
@@ -2,7 +2,7 @@
   <details class="review-log-details document-support__disclosure" data-controller="coplan--support-disclosure" data-action="toggle->coplan--support-disclosure#remember">
     <summary class="review-log-panel__header document-support__heading"><span class="document-support__chevron" aria-hidden="true">›</span><h2 class="plan-footnote__title" id="review-log-title">Reviews</h2><span class="review-log-panel__summary" data-review-log-summary><span><%= pluralize(active_requests.size, "reviewer") %><%= " · #{active_requests.count(&:pending?)} awaiting review" if active_requests.any?(&:pending?) %></span></span></summary>
     <div class="review-log-panel__columns document-support__content">
-      <p class="text-sm text-muted">Reviews cover the Markdown source only. Decisions record the version reviewed; earlier decisions remain in activity.</p>
+      <p class="text-sm text-muted">Reviews cover the Markdown source only. Edits dismiss active decisions; earlier decisions remain in activity.</p>
       <%= render "coplan/reviews/roster", plan: plan, active_requests: active_requests, manage: false %>
       <div class="review-log-panel__tools"><button type="button" class="btn btn--secondary btn--sm" data-action="coplan--review-tray#openActivity">View activity <span aria-hidden="true">↗</span></button></div>
     </div>
diff --git a/engine/app/views/coplan/reviews/_management.html.erb b/engine/app/views/coplan/reviews/_management.html.erb
index 791c77f7..4f943236 100644
--- a/engine/app/views/coplan/reviews/_management.html.erb
+++ b/engine/app/views/coplan/reviews/_management.html.erb
@@ -13,10 +13,6 @@
     <% end %>
   </div>
   <% if allowed_to?(plan, :update?) %>
-    <div class="review-reset-policy">
-      <label class="review-required"><input type="checkbox" <%= "checked" if plan.reset_reviews_on_change %> data-action="change->coplan--review-tray#changeResetPolicy" data-review-reset-policy data-saved-value="<%= plan.reset_reviews_on_change %>"> Reset approvals when content changes <span class="review-reset-policy__status" data-coplan--review-tray-target="policyIcon" role="img" aria-hidden="true" aria-label="Saved" title="Saved">✓</span></label>
-      <p class="text-sm text-muted">Applies to future edits for all reviewers. When off, completed reviews stay completed.</p>
-    </div>
     <div id="review-assignment" class="review-assignment" popover="auto" role="dialog" aria-label="Add reviewer" data-coplan--review-tray-target="assignment" data-action="toggle->coplan--review-tray#assignmentToggled keydown.esc->coplan--review-tray#dismissAssignment">
       <%= form_with url: plan_review_requests_path(plan), class: "review-assignment-form", data: { action: "submit->coplan--review-tray#assign" } do %>
         <label for="reviewer-search">Find a reviewer</label>
diff --git a/engine/app/views/coplan/reviews/_roster.html.erb b/engine/app/views/coplan/reviews/_roster.html.erb
index 23ea9b77..b03ea688 100644
--- a/engine/app/views/coplan/reviews/_roster.html.erb
+++ b/engine/app/views/coplan/reviews/_roster.html.erb
@@ -10,14 +10,14 @@
             <%= user_avatar(request.reviewer, size: "md") %>
             <div class="review-person__info">
               <strong><%= request.reviewer.name %></strong>
-              <span class="review-person__meta"><span class="review-person__requirement"><%= requirement.humanize %></span> · <% if request.pending? %>Review requested<% elsif request.review_status == "changes_requested" %>Changes requested on v<%= request.recorded_response&.plan_version&.revision %><% else %>Approved v<%= request.recorded_response&.plan_version&.revision %><%= " (agent)" if request.recorded_response&.actor_type == "local_agent" %><% end %></span>
+              <span class="review-person__meta"><span class="review-person__requirement"><%= requirement.humanize %></span> · <% if request.pending? %>Review requested<% elsif request.effective_status == "changes_requested" %>Changes requested on v<%= request.effective_response&.plan_version&.revision %><% else %>Approved v<%= request.effective_response&.plan_version&.revision %><%= " (agent)" if request.effective_response&.actor_type == "local_agent" %><% end %></span>
             </div>
-            <span class="review-state<%= ' review-state--approved' if request.review_status == 'approved' %><%= ' review-state--attention' if request.pending? && request.reviewer_id == current_user.id %>"><span aria-hidden="true"><%= request.pending? ? "◷" : request.review_status == "approved" ? "✓" : "↩" %></span> <%= request.pending? ? "Pending" : request.review_status.humanize %></span>
+            <span class="review-state<%= ' review-state--approved' if request.effective_status == 'approved' %><%= ' review-state--attention' if request.pending? && request.reviewer_id == current_user.id %>"><span aria-hidden="true"><%= request.pending? ? "◷" : request.effective_status == "approved" ? "✓" : "↩" %></span> <%= request.pending? ? "Pending" : request.effective_status.humanize %></span>
             <% if manage && allowed_to?(plan, :update?) %>
               <span class="review-person__actions" data-controller="coplan--menu">
                 <button type="button" class="review-person__menu-button" aria-label="Actions for <%= request.reviewer.name %>" title="Actions for <%= request.reviewer.name %>" popovertarget="review-menu-<%= request.id %>" data-coplan--menu-target="trigger"><svg width="16" height="16" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true"><circle cx="5" cy="12" r="2"/><circle cx="12" cy="12" r="2"/><circle cx="19" cy="12" r="2"/></svg></button>
                 <div id="review-menu-<%= request.id %>" class="menu review-person__menu" popover="auto" data-coplan--menu-target="menu" data-action="beforetoggle->coplan--menu#reposition" aria-label="Review actions for <%= request.reviewer.name %>">
-                  <button type="button" class="menu__item" data-action="coplan--review-tray#requestAgain coplan--menu#close" data-url="<%= plan_review_request_path(plan, request) %>"><%= request.review_status == "changes_requested" ? "Ready for another look" : "Request another review" %></button>
+                  <button type="button" class="menu__item" data-action="coplan--review-tray#requestAgain coplan--menu#close" data-url="<%= plan_review_request_path(plan, request) %>"><%= request.effective_status == "changes_requested" ? "Ready for another look" : "Request another review" %></button>
                   <button type="button" class="menu__item" data-action="coplan--review-tray#changeRequirement coplan--menu#close" data-url="<%= plan_review_request_path(plan, request) %>" data-requirement="<%= requirement == 'required' ? 'optional' : 'required' %>">Make <%= requirement == 'required' ? 'optional' : 'required' %></button>
                   <% if approval && approval.plan_version.revision != plan.current_revision %><button type="button" class="menu__item" data-action="coplan--review-tray#compare coplan--menu#close" data-url="<%= compare_plan_review_request_path(plan, request, response_id: approval.id) %>">Changes since approval</button><% end %>
                   <div class="menu__separator" role="separator"></div>
diff --git a/engine/app/views/coplan/reviews/_table.html.erb b/engine/app/views/coplan/reviews/_table.html.erb
index eba61d10..26fb14d3 100644
--- a/engine/app/views/coplan/reviews/_table.html.erb
+++ b/engine/app/views/coplan/reviews/_table.html.erb
@@ -3,13 +3,13 @@
     <thead><tr><th scope="col">Reviewer</th><th scope="col">Review</th><th scope="col">Decision</th><th scope="col">Version</th><th scope="col">Actions</th></tr></thead>
     <tbody>
       <% active_requests.sort_by { |request| [CoPlan::ReviewRequest::REQUIREMENTS.index(request.requirement), request.reviewer.name.downcase, request.id] }.each do |request| %>
-        <% response = request.recorded_response %>
+        <% response = request.effective_response %>
         <% approval = request.latest_approval %>
         <tr class="review-person" data-reviewer-id="<%= request.reviewer_id %>">
           <td><div class="review-table__person"><%= user_avatar(request.reviewer) %><strong><%= request.reviewer.name %></strong></div></td>
           <td><span class="review-table__requirement"><%= request.requirement.humanize %></span></td>
-          <td><span class="review-state<%= ' review-state--approved' if request.review_status == 'approved' %><%= ' review-state--attention' if request.pending? && request.reviewer_id == current_user.id %>"><span aria-hidden="true"><%= request.pending? ? "◷" : request.review_status == "approved" ? "✓" : "↩" %></span><span class="review-person__meta"><%= request.pending? ? (request.reset_reason == "content_changed" ? "Content changed; review again" : "Review requested") : request.review_status.humanize %><%= " (agent)" if response&.actor_type == "local_agent" %></span></span></td>
-          <td><% if !request.pending? && response %><span class="review-version">v<%= response.plan_version.revision %></span><% if response.plan_version_id != plan.current_plan_version_id %> <span class="text-muted">Content changed since review</span><% end %><% else %><span class="text-muted" aria-label="Not reviewed yet">—</span><% end %></td>
+          <td><span class="review-state<%= ' review-state--approved' if request.effective_status == 'approved' %><%= ' review-state--attention' if request.pending? && request.reviewer_id == current_user.id %>"><span aria-hidden="true"><%= request.pending? ? "◷" : request.effective_status == "approved" ? "✓" : "↩" %></span><span class="review-person__meta"><%= request.pending? ? (request.reset_reason == "content_changed" ? "Content changed; review again" : "Review requested") : request.effective_status.humanize %><%= " (agent)" if response&.actor_type == "local_agent" %></span></span></td>
+          <td><% if !request.pending? && response %><span class="review-version">v<%= response.plan_version.revision %></span><% else %><span class="text-muted" aria-label="Not reviewed yet">—</span><% end %></td>
           <td class="review-table__actions">
             <% if !request.pending? && request.reviewer_id == current_user.id %><button type="button" class="review-log__link review-reopen" aria-label="Change decision" title="Change decision" data-action="coplan--review-tray#reconsider"><svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M20 7v5h-5M4 17v-5h5"/><path d="M6.1 7a7 7 0 0 1 11.6-1L20 9M4 15l2.3 3A7 7 0 0 0 17.9 17"/></svg></button><% end %>
             <% if approval && approval.plan_version.revision != plan.current_revision %><button type="button" class="review-log__link" data-action="coplan--review-tray#compare" data-url="<%= compare_plan_review_request_path(plan, request, response_id: approval.id) %>">Compare</button><% end %>
diff --git a/engine/config/routes.rb b/engine/config/routes.rb
index 2b06c2b3..a176e8af 100644
--- a/engine/config/routes.rb
+++ b/engine/config/routes.rb
@@ -75,7 +75,6 @@
       # see DictationsController.
       resources :dictations, only: [ :create ]
       resources :review_requests, only: [ :index, :create, :update, :destroy ] do
-        patch :settings, on: :collection
         get :suggestions, on: :collection
         post :respond, on: :member
         get :compare, on: :member
diff --git a/engine/db/demo/content/retained-review.md b/engine/db/demo/content/retained-review.md
deleted file mode 100644
index 0befe697..00000000
--- a/engine/db/demo/content/retained-review.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# Keep completed reviews after edits
-
-Automatic approval resets are off for this document. The v1 reviews remain completed after the v2 edit, without requiring new approvals. Each review still identifies the immutable Markdown version reviewed.
-
-Enable **Reset approvals when content changes** in Manage reviewers, then edit again to return active reviews to Pending.
-
-- [ ] Verify the retry policy
diff --git a/engine/db/migrate/20261029120000_add_review_reset_policy_to_coplan_plans.rb b/engine/db/migrate/20261029120000_add_review_reset_policy_to_coplan_plans.rb
deleted file mode 100644
index 0320f41c..00000000
--- a/engine/db/migrate/20261029120000_add_review_reset_policy_to_coplan_plans.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-class AddReviewResetPolicyToCoplanPlans < ActiveRecord::Migration[8.1]
-  def change
-    add_column :coplan_plans, :reset_reviews_on_change, :boolean, null: false, default: true
-  end
-end
diff --git a/engine/lib/coplan/development_seed.rb b/engine/lib/coplan/development_seed.rb
index 1d943294..0bbaff46 100644
--- a/engine/lib/coplan/development_seed.rb
+++ b/engine/lib/coplan/development_seed.rb
@@ -128,11 +128,6 @@ module DevelopmentSeed
         tags: %w[collaboration demo], visibility: "published", folder: "Demo scenarios",
         scenario: "Earlier v1 approvals remain history; v2 requires fresh review"
       },
-      {
-        key: "retained-review", author: "hampton", type: "Design Doc", title: "Workspace invitations: reviews retained after edits",
-        tags: %w[collaboration demo], visibility: "published", folder: "Demo scenarios",
-        scenario: "Automatic resets off; v1 reviews stay completed after v2 edits"
-      },
       {
         key: "approved-review", author: "hampton", type: "Design Doc", title: "Workspace invitations: approved rollout",
         tags: %w[collaboration demo], visibility: "published", folder: "Demo scenarios",
@@ -256,8 +251,7 @@ module DevelopmentSeed
     REVIEW_SCENARIOS = {
       "pending-review" => false,
       "approved-review" => true,
-      "changed-review" => true,
-      "retained-review" => true
+      "changed-review" => true
     }.freeze
 
     SMALL_EDITS = [
@@ -859,7 +853,6 @@ def seed_writing_history(users, plans, catalog)
     def seed_reviews(users, plans)
       REVIEW_SCENARIOS.each do |key, approved|
         plan = plans.fetch(key)
-        plan.update!(reset_reviews_on_change: false) if key == "retained-review" && plan.current_revision == 1
         %w[alex noura].each do |reviewer|
           collaborator = plan.plan_collaborators.find_or_initialize_by(user: users.fetch(reviewer))
           unless collaborator.persisted?
@@ -872,8 +865,8 @@ def seed_reviews(users, plans)
           request = Reviews::Request.call(plan: plan, reviewer: users.fetch(reviewer), actor: plan.created_by_user)
           Reviews::Respond.call(request: request, actor: request.reviewer, revision: plan.current_revision, decision: "approved") if approved
         end
-        if %w[changed-review retained-review].include?(key) && plan.current_revision == 1
-          Plans::ReplaceContent.call(plan: plan, new_content: "#{plan.current_content}\n\nUpdated after approval: the retry policy has changed.\n",
+        if key == "changed-review" && plan.current_revision == 1
+          Plans::ReplaceContent.call(plan: plan, new_content: "#{plan.current_content}\n\nUpdated after approval: review the retry policy again.\n",
             base_revision: 1, actor_type: "human", actor_id: plan.created_by_user_id)
         end
       end
diff --git a/spec/lib/development_seed_spec.rb b/spec/lib/development_seed_spec.rb
index b75dc657..4d90fb0f 100644
--- a/spec/lib/development_seed_spec.rb
+++ b/spec/lib/development_seed_spec.rb
@@ -297,13 +297,6 @@ def seeded_plan(key)
       expect(changed.review_requests.map(&:effective_response)).to all(be_nil)
       expect(changed.review_requests.map { |r| r.latest_approval.plan_version.revision }).to eq([ 1, 1 ])
 
-      retained = seeded_plan("retained-review")
-      expect(retained.current_revision).to eq(2)
-      expect(retained.reset_reviews_on_change).to be(false)
-      expect(retained.review_requests.map(&:review_status)).to eq(%w[approved approved])
-      expect(retained.review_requests.map(&:effective_response)).to all(be_nil)
-      retained_ids = retained.review_requests.pluck(:current_response_id)
-
       pending = seeded_plan("pending-review").plan_collaborators.approvers
       approved = seeded_plan("approved-review").plan_collaborators.approvers
       expect(pending.count).to eq(2)
@@ -330,9 +323,6 @@ def seeded_plan(key)
       expect(pending.reload.where(approved_at: nil).count).to eq(1)
       expect(thread.reload.status).to eq("resolved")
       expect(edited.reload.current_revision).to eq(8)
-      expect(retained.reload.current_revision).to eq(2)
-      expect(retained.review_requests.pluck(:current_response_id)).to match_array(retained_ids)
-      expect(retained.reset_reviews_on_change).to be(false)
     end
 
     it "refreshes a generated index while preserving a locally edited index" do
diff --git a/spec/requests/api/v1/operations_spec.rb b/spec/requests/api/v1/operations_spec.rb
index 1dd7c105..320546ec 100644
--- a/spec/requests/api/v1/operations_spec.rb
+++ b/spec/requests/api/v1/operations_spec.rb
@@ -20,21 +20,6 @@
     )
   end
 
-  [ true, false ].each do |reset|
-    it "honors reset_reviews_on_change=#{reset} for direct operations" do
-      plan.update!(reset_reviews_on_change: reset)
-      task = CoPlan::Reviews::Request.call(plan: plan, reviewer: alice, actor: alice)
-      receipt = CoPlan::Reviews::Respond.call(request: task, actor: alice, revision: 1, generation: task.generation, decision: "approved")
-      post api_v1_plan_operations_path(plan), params: { lease_token: lease_token, base_revision: 1,
-        operations: [ { op: "replace_exact", old_text: "Some content here.", new_text: "Updated content.", count: 1 } ] },
-        headers: headers, as: :json
-      expect(response).to have_http_status(:created)
-      expect(task.reload.review_status).to eq(reset ? "pending" : "approved")
-      expect(task.recorded_response).to eq(reset ? nil : receipt)
-      expect(task.effective_human_decision).to be_nil
-    end
-  end
-
   it "apply operations creates new version" do
     expect {
       post api_v1_plan_operations_path(plan),
diff --git a/spec/requests/api/v1/review_evidence_spec.rb b/spec/requests/api/v1/review_evidence_spec.rb
index 05479c51..3a272567 100644
--- a/spec/requests/api/v1/review_evidence_spec.rb
+++ b/spec/requests/api/v1/review_evidence_spec.rb
@@ -35,20 +35,6 @@
     expect(response.parsed_body.fetch("review_requests").first.fetch("effective_response_id")).to be_nil
   end
 
-  it "distinguishes retained task completion from current-version approval when resets are off" do
-    plan.update!(reset_reviews_on_change: false)
-    receipt = CoPlan::Reviews::Respond.call(request: task, actor: task.reviewer, revision: 1, generation: 1, decision: "approved")
-    CoPlan::Plans::ReplaceContent.call(plan: plan, new_content: "New source", base_revision: 1, actor_type: "human", actor_id: author.id)
-    get review_evidence_api_v1_plan_path(plan), headers: headers
-    expect(response).to have_http_status(:ok)
-    data = response.parsed_body
-    expect(data.fetch("reset_reviews_on_change")).to be(false)
-    expect(data.fetch("version").fetch("revision")).to eq(2)
-    expect(data.fetch("review_requests").first).to include("review_status" => "approved", "recorded_response_id" => receipt.id,
-      "effective_status" => "pending", "effective_human_decision" => nil, "effective_response_id" => nil)
-    expect(data.fetch("review_requests").first.fetch("responses").first).to include("revision" => 1, "plan_version_id" => receipt.plan_version_id)
-  end
-
   it "returns the exact historical source after edits and never substitutes current content" do
     original = plan.current_plan_version
     CoPlan::Plans::ReplaceContent.call(plan: plan, new_content: "New body", base_revision: 1, actor_type: "human", actor_id: author.id)
diff --git a/spec/requests/review_requests_spec.rb b/spec/requests/review_requests_spec.rb
index 8ad4e332..4706ec62 100644
--- a/spec/requests/review_requests_spec.rb
+++ b/spec/requests/review_requests_spec.rb
@@ -6,28 +6,6 @@
   let(:plan) { create(:plan, :published, created_by_user: author) }
   let(:task) { create(:review_request, plan: plan, reviewer: reviewer) }
 
-  it "defaults to resetting reviews and persists an editor's document-wide preference", :review_reset_policy do
-    expect(plan.reset_reviews_on_change).to be(true)
-    sequence = plan.review_sequence
-    sign_in_as(author)
-    [ false, false, true ].each_with_index do |enabled, index|
-      patch settings_plan_review_requests_path(plan), params: { review_settings: { reset_reviews_on_change: enabled } }, as: :json
-      expect(response).to have_http_status(:ok)
-      expect(response.parsed_body).to eq("reset_reviews_on_change" => enabled)
-      expect(plan.reload.reset_reviews_on_change).to eq(enabled)
-      expect(plan.review_sequence).to eq(sequence + (index == 2 ? 2 : 1))
-      expect(CoPlan::Reviews::Evidence.call(plan: plan)[:reset_reviews_on_change]).to eq(enabled)
-    end
-  end
-
-  it "does not let a reviewer change the document's reset policy", :review_reset_policy do
-    task
-    sign_in_as(reviewer)
-    patch settings_plan_review_requests_path(plan), params: { review_settings: { reset_reviews_on_change: false } }, as: :json
-    expect(response).to have_http_status(:not_found)
-    expect(plan.reload.reset_reviews_on_change).to be(true)
-  end
-
   it "labels an agent decision separately from the reviewer's own human approval" do
     token = create(:api_token, user: reviewer, agent_name: "Reviewbot")
     CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 1, decision: "approved", api_token: token)
diff --git a/spec/services/coplan/review_concurrency_spec.rb b/spec/services/coplan/review_concurrency_spec.rb
index 00d3393b..07c90fa7 100644
--- a/spec/services/coplan/review_concurrency_spec.rb
+++ b/spec/services/coplan/review_concurrency_spec.rb
@@ -11,52 +11,49 @@ def threaded(&block)
     Thread.new { ActiveRecord::Base.connection_pool.with_connection(&block) }
   end
 
-  [ true, false ].each do |reset|
-    it "makes evidence and stale responses wait for a complete edit with resets=#{reset}" do
-      owner = create(:coplan_user)
-      reviewer = create(:coplan_user)
-      plan = CoPlan::Plans::Create.call(title: "Concurrent review", content: "Before", user: owner)
-      plan.update!(reset_reviews_on_change: reset)
-      task = CoPlan::Reviews::Request.call(plan: plan, reviewer: reviewer, actor: owner)
-      first = CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 1, generation: 1, decision: "approved")
-      edited, release, attempting = Queue.new, Queue.new, Queue.new
-      writer = threaded do
-        local = CoPlan::Plan.find(plan.id)
-        local.with_lock do
-          CoPlan::Plans::ReplaceContent.call(plan: local, new_content: "After", base_revision: 1, actor_type: "human", actor_id: owner.id)
-          edited << true
-          release.pop
-        end
-      end
-      Timeout.timeout(10) { edited.pop }
-      reader = threaded do
-        attempting << true
-        CoPlan::Reviews::Evidence.call(plan: CoPlan::Plan.find(plan.id))
+  it "makes an evidence read and stale response wait for the complete edit/reset transaction" do
+    owner = create(:coplan_user)
+    reviewer = create(:coplan_user)
+    plan = CoPlan::Plans::Create.call(title: "Concurrent review", content: "Before", user: owner)
+    task = CoPlan::Reviews::Request.call(plan: plan, reviewer: reviewer, actor: owner)
+    first = CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 1, generation: 1, decision: "approved")
+    edited, release, attempting = Queue.new, Queue.new, Queue.new
+    writer = threaded do
+      local = CoPlan::Plan.find(plan.id)
+      local.with_lock do
+        CoPlan::Plans::ReplaceContent.call(plan: local, new_content: "After", base_revision: 1, actor_type: "human", actor_id: owner.id)
+        edited << true
+        release.pop
       end
-      responder = threaded do
-        attempting << true
-        begin
-          CoPlan::Reviews::Respond.call(request: CoPlan::ReviewRequest.find(task.id), actor: reviewer,
-            revision: 1, generation: 1, decision: "approved", idempotency_key: SecureRandom.uuid)
-        rescue CoPlan::Reviews::Respond::Conflict => error
-          error.code
-        end
+    end
+    Timeout.timeout(10) { edited.pop }
+    reader = threaded do
+      attempting << true
+      CoPlan::Reviews::Evidence.call(plan: CoPlan::Plan.find(plan.id))
+    end
+    responder = threaded do
+      attempting << true
+      begin
+        CoPlan::Reviews::Respond.call(request: CoPlan::ReviewRequest.find(task.id), actor: reviewer,
+          revision: 1, generation: 1, decision: "approved", idempotency_key: SecureRandom.uuid)
+      rescue CoPlan::Reviews::Respond::Conflict => error
+        error.code
       end
-      Timeout.timeout(10) { 2.times { attempting.pop } }
-      expect(reader).to be_alive
-      expect(responder).to be_alive
-      release << true
-      [ writer, reader, responder ].each { |thread| expect(thread.join(20)).to be_present }
-      evidence = reader.value
-      expect(evidence[:version]).to include(revision: 2, content_markdown: "After")
-      expect(evidence[:review_requests].first).to include(status: reset ? "pending" : "approved", effective_response_id: nil, generation: reset ? 2 : 1)
-      expect(evidence[:review_sequence]).to eq(first.decision_sequence + 1)
-      expect(responder.value).to eq("review_version_changed")
-      expect(task.reload.review_responses.pluck(:id)).to eq([ first.id ])
-    ensure
-      release << true if release
-      [ writer, reader, responder ].compact.each { |thread| thread.kill if thread.alive? }
     end
+    Timeout.timeout(10) { 2.times { attempting.pop } }
+    expect(reader).to be_alive
+    expect(responder).to be_alive
+    release << true
+    [ writer, reader, responder ].each { |thread| expect(thread.join(20)).to be_present }
+    evidence = reader.value
+    expect(evidence[:version]).to include(revision: 2, content_markdown: "After")
+    expect(evidence[:review_requests].first).to include(status: "pending", effective_response_id: nil, generation: 2)
+    expect(evidence[:review_sequence]).to eq(first.decision_sequence + 1)
+    expect(responder.value).to eq("review_version_changed")
+    expect(task.reload.review_responses.pluck(:id)).to eq([ first.id ])
+  ensure
+    release << true if release
+    [ writer, reader, responder ].compact.each { |thread| thread.kill if thread.alive? }
   end
 
   it "serializes two same-time decisions with unique increasing server sequences" do
diff --git a/spec/services/coplan/versioned_reviews_spec.rb b/spec/services/coplan/versioned_reviews_spec.rb
index a199fcb8..6ba2785b 100644
--- a/spec/services/coplan/versioned_reviews_spec.rb
+++ b/spec/services/coplan/versioned_reviews_spec.rb
@@ -118,94 +118,4 @@ def replace(content)
     expect(evidence[:version][:content_markdown]).to eq(first.plan_version.content_markdown)
     expect(task.reload.effective_response).to eq(first)
   end
-
-  context "when automatic resets are off" do
-    before { plan.update!(reset_reviews_on_change: false) }
-
-    [ :replace, :draft, :checkbox, :session ].each do |writer|
-      it "preserves completed review lifecycle, not current-version evidence, after #{writer}" do
-        first = decide
-        sequence = plan.reload.review_sequence
-        case writer
-        when :replace then replace("New source")
-        when :draft
-          CoPlan::Plans::SaveHumanDraft.call(plan: plan, content: "A human draft", base_revision: 1, actor: plan.created_by_user)
-        when :checkbox
-          CoPlan::Plans::ToggleCheckbox.call(plan: plan, old_text: "- [ ] Ship", new_text: "- [x] Ship", base_revision: 1, actor_id: plan.created_by_user_id)
-        when :session
-          session = CoPlan::EditSession.create!(plan: plan, actor_type: "human", actor_id: plan.created_by_user_id,
-            base_revision: 1, status: "open", expires_at: 1.hour.from_now,
-            draft_content: "Revised by session", operations_json: [ { "op" => "replace_exact", "old_text" => "Ship", "new_text" => "Ship" } ])
-          CoPlan::Plans::CommitSession.call(session: session)
-        end
-        expect(plan.reload.review_sequence).to eq(sequence + 1)
-        expect(task.reload).to have_attributes(status: "approved", generation: 1, recorded_response: first, review_status: "approved")
-        expect(task).not_to be_pending
-        expect(task.effective_response).to be_nil
-        evidence = CoPlan::Reviews::Evidence.call(plan: plan)
-        expect(evidence[:reset_reviews_on_change]).to be(false)
-        expect(evidence[:review_requests].first).to include(review_status: "approved", effective_status: "pending",
-          recorded_response_id: first.id, effective_human_decision: nil, effective_response_id: nil)
-      end
-    end
-
-    it "preserves objections and agent attribution without inventing human evidence" do
-      response = decide(decision: "changes_requested", note: "Clarify this", api_token: create(:api_token, user: reviewer))
-      replace("New source")
-      expect(task.reload.review_status).to eq("changes_requested")
-      expect(task.recorded_response).to eq(response)
-      expect(task.recorded_response.actor_type).to eq("local_agent")
-      expect(task.effective_human_decision).to be_nil
-    end
-
-    it "keeps no-ops completed and never treats returned bytes or old retries as current approval" do
-      first = decide
-      original = plan.current_content
-      expect(replace(original)[:no_op]).to be(true)
-      expect(task.reload.effective_response).to eq(first)
-      replace("B")
-      replace(original)
-      [ { idempotency_key: first.id }, {} ].each do |attributes|
-        retry_response = CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 1, decision: "approved", **attributes)
-        expect(retry_response).to eq(first)
-      end
-      expect(task.reload.recorded_response).to eq(first)
-      expect(task.effective_response).to be_nil
-      expect(decide.plan_version.revision).to eq(3)
-      expect(task.reload.effective_human_decision).to eq("approved")
-    end
-
-    it "applies enabling to the next edit and never resurrects a dismissed decision when disabled" do
-      first = decide
-      replace("B")
-      plan.update!(reset_reviews_on_change: true)
-      expect(task.reload.recorded_response).to eq(first)
-      replace("C")
-      expect(task.reload).to be_pending
-      generation = task.generation
-      plan.update!(reset_reviews_on_change: false)
-      expect(task.reload.recorded_response).to be_nil
-      replace("D")
-      expect(task.reload).to be_pending
-      expect(task.generation).to eq(generation)
-      expect {
-        CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 3, generation: generation, decision: "approved", idempotency_key: SecureRandom.uuid)
-      }.to raise_error(CoPlan::Reviews::Respond::Conflict)
-      expect(decide.plan_version.revision).to eq(4)
-    end
-
-    it "preserves withdrawal and explicit re-request semantics across edits and retries" do
-      first = decide
-      CoPlan::Reviews::Withdraw.call(request: task, actor: plan.created_by_user)
-      replace("B")
-      expect(task.reload.review_status).to eq("withdrawn")
-      CoPlan::Reviews::Request.call(plan: plan, reviewer: reviewer, actor: plan.created_by_user)
-      [ { idempotency_key: first.id }, {} ].each do |attributes|
-        CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 1, decision: "approved", **attributes)
-      end
-      expect(task.reload).to be_pending
-      expect(task.recorded_response).to be_nil
-      expect(decide.plan_version.revision).to eq(2)
-    end
-  end
 end
diff --git a/spec/system/plan_reviews_spec.rb b/spec/system/plan_reviews_spec.rb
index a743500f..3a397417 100644
--- a/spec/system/plan_reviews_spec.rb
+++ b/spec/system/plan_reviews_spec.rb
@@ -40,162 +40,6 @@ def lose_next_review_result
 
   before { sign_in_browser(reviewer, open_sections: !RSpec.current_example.metadata[:collapsed_support]) }
 
-  def open_review_settings
-    expect(page).to have_no_css("html[aria-busy='true']")
-    expand_plan_section("footnote-approvals")
-    within("#footnote-approvals") { click_button "Manage reviewers" }
-    expect(page).to have_css(".review-management[open]")
-  end
-
-  [ "light", "dark" ].each do |theme|
-    it "persists the default-on reset policy from the reviewer dialog in #{theme} theme", :review_reset_policy do
-      sign_in_browser(author)
-      page.execute_script("document.documentElement.dataset.theme = arguments[0]", theme)
-      open_review_settings
-      within(".review-management[open]") do
-        expect(page).to have_checked_field("Reset approvals when content changes")
-        uncheck "Reset approvals when content changes"
-        expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
-      end
-      expect(page).to have_css(".review-reset-policy__status[data-state='saved']")
-      expect(plan.reload.reset_reviews_on_change).to be(false)
-      visit plan_page_path(plan)
-      page.execute_script("document.documentElement.dataset.theme = arguments[0]", theme)
-      open_review_settings
-      within(".review-management[open]") do
-        expect(page).to have_unchecked_field("Reset approvals when content changes")
-        check "Reset approvals when content changes"
-        expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
-      end
-      expect(plan.reload.reset_reviews_on_change).to be(true)
-      page.save_screenshot(Rails.root.join("tmp/review-preview/reset-policy-#{theme}.png"))
-    end
-  end
-
-  it "keeps reviews completed after edits when off, then resets after the next edit when enabled", :review_reset_policy do
-    sign_in_browser(author)
-    open_review_settings
-    within(".review-management[open]") do
-      uncheck "Reset approvals when content changes"
-      expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
-    end
-    sign_in_browser(reviewer)
-    within(".review-tray") { click_button "Approve", exact: true }
-    within(".review-confirmation") { click_button "Approve v1", exact: true }
-    expect(page).to have_css(".review-tray", text: "You approved v1")
-    CoPlan::Plans::ReplaceContent.call(plan: plan, new_content: "# Second version", base_revision: 1, actor_type: "human", actor_id: author.id)
-    visit plan_page_path(plan)
-    expand_plan_section("footnote-approvals")
-    expect(page).to have_css(".review-tray", text: "You approved v1")
-    expect(page).to have_css(".review-tray", text: "no new review required")
-    expect(page).to have_css(".review-person", text: "Content changed since review")
-    expect(page).to have_no_css(".review-tray", text: "Your review is requested")
-    expect(task.reload.effective_human_decision).to be_nil
-    [ "light", "dark" ].each do |theme|
-      page.execute_script("document.documentElement.dataset.theme = arguments[0]", theme)
-      page.save_screenshot(Rails.root.join("tmp/review-preview/retained-review-#{theme}.png"))
-    end
-    sign_in_browser(author)
-    open_review_settings
-    within(".review-management[open]") do
-      check "Reset approvals when content changes"
-      expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
-    end
-    expect(task.reload.review_status).to eq("approved")
-    CoPlan::Plans::ReplaceContent.call(plan: plan, new_content: "# Third version", base_revision: 2, actor_type: "human", actor_id: author.id)
-    visit plan_page_path(plan)
-    expand_plan_section("footnote-approvals")
-    expect(page).to have_css(".review-person__meta", text: "Content changed; review again")
-    expect(task.reload).to be_pending
-  end
-
-  it "autosaves the latest checkbox choice without save text or blocking more clicks", :review_reset_policy do
-    sign_in_browser(author)
-    open_review_settings
-    page.execute_script(<<~JS)
-      const originalFetch = window.fetch.bind(window)
-      window.policyWrites = []
-      window.fetch = async (url, options) => {
-        if (options?.method === 'PATCH' && String(url).endsWith('/settings')) {
-          window.policyWrites.push(JSON.parse(options.body).review_settings.reset_reviews_on_change)
-          document.querySelector("[data-review-reset-policy]").dataset.firstPolicyWrite = "true"
-          const result = await originalFetch(url, options)
-          await new Promise(resolve => setTimeout(resolve, 400))
-          return result
-        }
-        return originalFetch(url, options)
-      }
-    JS
-    within(".review-management[open]") do
-      page.execute_script('const input = document.querySelector("[data-review-reset-policy]"); input.click(); input.click()')
-      expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
-      expect(page.evaluate_script("window.policyWrites")).to eq([])
-      uncheck "Reset approvals when content changes"
-      expect(page).to have_css("[data-review-reset-policy][aria-busy='true']")
-      expect(page).to have_no_text("Saving…")
-      expect(page).to have_no_text("Saved")
-      # Wait until the first request is in flight, then change our mind.
-      expect(page).to have_selector("[data-review-reset-policy][data-saved-value='true']")
-      expect(page).to have_css("[data-review-reset-policy][data-first-policy-write='true']")
-      check "Reset approvals when content changes"
-      expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
-      expect(page).to have_checked_field("Reset approvals when content changes", disabled: false)
-    end
-    expect(plan.reload.reset_reviews_on_change).to be(true)
-    expect(page.evaluate_script("window.policyWrites")).to eq([ false, true ])
-  end
-
-  it "reconciles a lost save response with the persisted checkbox value", :review_reset_policy do
-    sign_in_browser(author)
-    open_review_settings
-    page.execute_script(<<~JS)
-      const originalFetch = window.fetch.bind(window)
-      let loseResult = true
-      window.fetch = async (url, options) => {
-        const result = await originalFetch(url, options)
-        if (loseResult && options?.method === 'PATCH' && String(url).endsWith('/settings')) {
-          loseResult = false
-          throw new TypeError('Lost saved result')
-        }
-        return result
-      }
-    JS
-    within(".review-management[open]") do
-      uncheck "Reset approvals when content changes"
-      expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
-      expect(page).to have_unchecked_field("Reset approvals when content changes")
-    end
-    expect(plan.reload.reset_reviews_on_change).to be(false)
-    visit plan_page_path(plan)
-    open_review_settings
-    expect(page).to have_unchecked_field("Reset approvals when content changes")
-  end
-
-  it "restores the saved reset preference after a rejected settings update", :review_reset_policy do
-    sign_in_browser(author)
-    open_review_settings
-    page.execute_script(<<~JS)
-      const originalFetch = window.fetch.bind(window)
-      let reject = true
-      window.fetch = (url, options) => {
-        if (reject && options?.method === 'PATCH' && String(url).endsWith('/settings')) {
-          reject = false
-          return Promise.resolve(new Response(JSON.stringify({error: 'Unable to save settings'}), {status: 422, headers: {'Content-Type': 'application/json'}}))
-        }
-        return originalFetch(url, options)
-      }
-    JS
-    within(".review-management[open]") do
-      uncheck "Reset approvals when content changes"
-      expect(page).to have_text("Unable to save settings")
-      expect(page).to have_checked_field("Reset approvals when content changes", disabled: false)
-      expect(plan.reload.reset_reviews_on_change).to be(true)
-      uncheck "Reset approvals when content changes"
-      expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
-    end
-    expect(plan.reload.reset_reviews_on_change).to be(false)
-  end
-
   it "dismisses an approval after an edit, preserves its snapshot and accepts a fresh review", :version_parity do
     within(".review-tray") { click_button "Approve", exact: true }
     within(".review-confirmation") do

From 512934f123515d7e4e00f763238513bd1b420333 Mon Sep 17 00:00:00 2001
From: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
Date: Thu, 29 Oct 2026 14:41:19 -0400
Subject: [PATCH 07/18] Add an optional automatic review reset setting

Signed-off-by: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
---
 ...ew_reset_policy_to_coplan_plans.co_plan.rb |   6 +
 db/schema.rb                                  |   3 +-
 docs/REVIEWS.md                               |  12 +-
 .../app/assets/stylesheets/coplan/review.css  |   5 +
 .../coplan/review_requests_controller.rb      |  13 ++
 .../coplan/review_tray_controller.js          |  69 +++++++-
 engine/app/models/coplan/plan.rb              |   1 +
 engine/app/models/coplan/review_request.rb    |  19 ++-
 .../services/coplan/plans/advance_version.rb  |   5 +-
 .../app/services/coplan/reviews/evidence.rb   |   1 +
 .../app/services/coplan/reviews/serialize.rb  |   3 +-
 .../agent_instructions/guides/api.text.erb    |   2 +-
 .../guides/comments.text.erb                  |   2 +-
 .../agent_instructions/guides/live.text.erb   |   2 +-
 .../views/coplan/reviews/_controls.html.erb   |  12 +-
 engine/app/views/coplan/reviews/_log.html.erb |   2 +-
 .../views/coplan/reviews/_management.html.erb |   4 +
 .../app/views/coplan/reviews/_roster.html.erb |   6 +-
 .../app/views/coplan/reviews/_table.html.erb  |   6 +-
 engine/config/routes.rb                       |   1 +
 engine/db/demo/content/retained-review.md     |   7 +
 ...add_review_reset_policy_to_coplan_plans.rb |   5 +
 engine/lib/coplan/development_seed.rb         |  13 +-
 spec/lib/development_seed_spec.rb             |  10 ++
 spec/requests/api/v1/operations_spec.rb       |  15 ++
 spec/requests/api/v1/review_evidence_spec.rb  |  14 ++
 spec/requests/review_requests_spec.rb         |  22 +++
 .../coplan/review_concurrency_spec.rb         |  83 +++++-----
 .../services/coplan/versioned_reviews_spec.rb |  90 ++++++++++
 spec/system/plan_reviews_spec.rb              | 156 ++++++++++++++++++
 30 files changed, 518 insertions(+), 71 deletions(-)
 create mode 100644 db/migrate/20261029174023_add_review_reset_policy_to_coplan_plans.co_plan.rb
 create mode 100644 engine/db/demo/content/retained-review.md
 create mode 100644 engine/db/migrate/20261029120000_add_review_reset_policy_to_coplan_plans.rb

diff --git a/db/migrate/20261029174023_add_review_reset_policy_to_coplan_plans.co_plan.rb b/db/migrate/20261029174023_add_review_reset_policy_to_coplan_plans.co_plan.rb
new file mode 100644
index 00000000..508333f8
--- /dev/null
+++ b/db/migrate/20261029174023_add_review_reset_policy_to_coplan_plans.co_plan.rb
@@ -0,0 +1,6 @@
+# This migration comes from co_plan (originally 20261029120000)
+class AddReviewResetPolicyToCoplanPlans < ActiveRecord::Migration[8.1]
+  def change
+    add_column :coplan_plans, :reset_reviews_on_change, :boolean, null: false, default: true
+  end
+end
diff --git a/db/schema.rb b/db/schema.rb
index 65543fc8..69d0b64c 100644
--- a/db/schema.rb
+++ b/db/schema.rb
@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema[8.1].define(version: 2026_10_29_141536) do
+ActiveRecord::Schema[8.1].define(version: 2026_10_29_174023) do
   create_table "active_admin_comments", id: { type: :string, limit: 36 }, charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
     t.bigint "author_id"
     t.string "author_type"
@@ -411,6 +411,7 @@
     t.integer "current_revision", default: 0, null: false
     t.json "metadata"
     t.string "plan_type_id", limit: 36, null: false
+    t.boolean "reset_reviews_on_change", default: true, null: false
     t.bigint "review_sequence", default: 0, null: false
     t.text "search_text", size: :medium
     t.string "slug", null: false
diff --git a/docs/REVIEWS.md b/docs/REVIEWS.md
index 048b10a8..bbc9ce7f 100644
--- a/docs/REVIEWS.md
+++ b/docs/REVIEWS.md
@@ -4,15 +4,17 @@ A native review means satisfaction with a specific Markdown source version. It g
 
 ## Content and decision identity
 
-Responses retain `plan_version_id`, that version’s SHA-256, `request_generation`, and a server-assigned `decision_sequence`. UUIDs identify transport retries; they do not order decisions. A request’s `current_response_id` is the authoritative projection. A response is effective only when it belongs to that request, generation and current plan version and matches the task status. `effective_human_decision` is null for pending, withdrawn, dismissed or agent decisions. `latest_approval` is positive history for comparison, not qualification.
+Responses retain `plan_version_id`, that version’s SHA-256, `request_generation`, and a server-assigned `decision_sequence`. UUIDs identify transport retries; they do not order decisions. A request’s `current_response_id` is the authoritative projection. `review_status` and `recorded_response_id` describe lifecycle completion, including a decision retained across edits when automatic resets are off. A response is effective only when it belongs to that request, generation and current plan version and matches the task status. `effective_human_decision` is null for pending, withdrawn, dismissed or agent decisions. `latest_approval` is positive history for comparison, not qualification.
 
 The approval covers **Markdown source bytes only**. Title, tags, attachments, linked and embedded resources, child plans, and rendered output are excluded. URLs and embedded source syntax are approved as literal text, not as the bytes they might display. Historical pages expose exact source and hash and label the current title as metadata. Full rich-page approval requires a separate immutable asset envelope and renderer contract.
 
 ## Edits and cycles
 
-All current-version writers use `Plans::AdvanceVersion`: Create, ReplaceContent (including SaveHumanDraft/web saves), CommitSession, ToggleCheckbox and the direct operations API. They already hold the plan row lock; CommitSession retains session-before-plan lock order. The version pointer, revision, review sequence, active task resets, generation increments and cleared current pointers commit together. Withdrawn tasks and all receipts remain intact. Resets broadcast after commit without sending a review-request notification for every edit.
+All current-version writers use `Plans::AdvanceVersion`: Create, ReplaceContent (including SaveHumanDraft/web saves), CommitSession, ToggleCheckbox and the direct operations API. They already hold the plan row lock; CommitSession retains session-before-plan lock order. The version pointer, revision and review sequence always advance together. With `reset_reviews_on_change` enabled (the default), active task resets, generation increments and cleared current pointers commit in that same transaction. Withdrawn tasks and all receipts remain intact. Resets broadcast after commit without sending a review-request notification for every edit.
 
-An identical normalized ReplaceContent save creates no version and preserves approval. An empty session creates no version. A nonempty session or operations commit creates a new version even if its operations net to identical bytes, and dismisses decisions. Returning A→B→A always produces a distinct version and requires fresh review. Existing edit leases, human-edit fences and merge guards remain in place.
+An identical normalized ReplaceContent save creates no version and preserves approval. An empty session creates no version. A nonempty session or operations commit creates a new version even if its operations net to identical bytes, and resets reviews when the policy is enabled. Returning A→B→A always produces a distinct version; no older decision becomes exact-current-version evidence. Existing edit leases, human-edit fences and merge guards remain in place.
+
+Editors can toggle **Reset approvals when content changes** in Manage reviewers. The setting applies to future edits for every reviewer. When off, completed approvals and change requests remain completed on their original versions; edits require no fresh review. Pending tasks stay pending, and withdrawn tasks stay withdrawn. Turning resets back on affects the next edit; turning them off never restores an already dismissed decision. Exact-current-version `effective_status`, `effective_response_id` and `effective_human_decision` remain strict regardless of this preference. Policy updates take the same plan row lock and advance `review_sequence` only when changed.
 
 An explicit re-request advances the task generation and clears its effective decision. Creating an already existing request is a retry and leaves its state alone. Withdrawal clears the effective decision and preserves receipts. A fresh response supersedes the previous effective response, including a later agent response. The latest sequenced human response on the current version is exposed separately so consumers can inspect human feedback across request cycles; native CoPlan does not impose an external approval or objection policy.
 
@@ -20,7 +22,7 @@ New responses send the viewed revision, fetched generation and a fresh UUID `ide
 
 ## Reads and compatibility
 
-`GET /api/v1/plans/:id/review_evidence` takes one plan-row transaction and returns exact current source/hash/version, scope, review sequence, current projection and complete response history. It creates no PlanRead or agent session. Ordinary authentication may still update token usage. The review sequence covers body and native review changes, not excluded metadata, sharing or external authorization. Existing snapshot reads retain their older behavior; consumers requiring coherent evidence use this endpoint.
+`GET /api/v1/plans/:id/review_evidence` takes one plan-row transaction and returns exact current source/hash/version, scope, review sequence, reset preference, lifecycle and exact-version projections, and complete response history. It creates no PlanRead or agent session. Ordinary authentication may still update token usage. The review sequence covers body and native review changes, not excluded metadata, sharing or external authorization. Existing snapshot reads retain their older behavior; consumers requiring coherent evidence use this endpoint.
 
 `GET /api/v1/plans/:id/versions/:version_id` returns that exact historical Markdown and hash. It never substitutes the current version. Both endpoints use existing Bearer authentication and visibility rules; neither establishes a read-only workload credential or employee identity mapping.
 
@@ -31,3 +33,5 @@ Persisted version IDs, plan IDs, revisions, Markdown and hashes reject ordinary
 ## Local tryout
 
 Seed the shared demo library with `bin/rails coplan:demo:seed`. Sign in as `alex@example.com` and open **Workspace invitations: review dismissed after edits** in Hampton’s Demo scenarios. v1 approvals are history, v2 is pending, and the activity link opens the original source. Approve v2, then sign in as `hampton@example.com` and edit its body or toggle its checkbox. Alex’s task returns to pending. Re-seeding preserves edits and decisions.
+
+For the off state, open **Workspace invitations: reviews retained after edits**. Automatic resets are off: v1 decisions remain completed after v2, with an explicit changed-content label. Toggle the option in Manage reviewers to try both policies.
diff --git a/engine/app/assets/stylesheets/coplan/review.css b/engine/app/assets/stylesheets/coplan/review.css
index e6603786..78181942 100644
--- a/engine/app/assets/stylesheets/coplan/review.css
+++ b/engine/app/assets/stylesheets/coplan/review.css
@@ -241,6 +241,8 @@ button.visibility-option__button:hover:not(:disabled) { background: var(--color-
 .review-assignment-form__footer { display: flex; justify-content: space-between; align-items: center; gap: 12px; margin-top: 12px; }
 .review-dialog .review-required { display: flex; gap: 8px; align-items: center; margin: 0; color: var(--color-text); cursor: pointer; }
 .review-dialog .review-required input { width: 15px; height: 15px; padding: 0; margin: 0; accent-color: var(--color-primary); }
+.review-reset-policy { margin-bottom: 20px; }
+.review-reset-policy p { margin: 6px 0 0 23px; }
 .review-search-results { position: absolute; z-index: 1; top: calc(100% + 6px); left: 0; right: 0; max-height: 210px; overflow: auto; padding: 6px; border: 1px solid var(--glass-edge); border-radius: 10px; background: var(--color-surface); color: var(--color-text-muted); box-shadow: var(--shadow-lg); font-size: 12px; }
 .review-search-results[hidden] { display: none; }
 .review-search-result {
@@ -528,3 +530,6 @@ body:has(.review-tray[data-completed="true"]:not([data-reconsidering="true"]):no
 
 /* Live content and the inline editor share this reader, including empty plans. */
 .plan-reader:has(.markdown-rendered > *) > .empty-state { display: none; }
+
+.review-reset-policy__status { display: inline-block; width: 1em; color: var(--color-text-muted); opacity: 0; }
+.review-reset-policy__status[data-state="saved"] { opacity: 1; }
diff --git a/engine/app/controllers/coplan/review_requests_controller.rb b/engine/app/controllers/coplan/review_requests_controller.rb
index dfd31bf7..47c2eafe 100644
--- a/engine/app/controllers/coplan/review_requests_controller.rb
+++ b/engine/app/controllers/coplan/review_requests_controller.rb
@@ -15,6 +15,19 @@ def suggestions
       render json: Reviews::Suggest.call(plan: @plan)
     end
 
+    def settings
+      authorize!(@plan, :update?)
+      attributes = params.expect(review_settings: [ :reset_reviews_on_change ])
+      enabled = ActiveModel::Type::Boolean.new.cast(attributes.fetch(:reset_reviews_on_change))
+      @plan.with_lock do
+        if @plan.reset_reviews_on_change != enabled
+          @plan.update!(reset_reviews_on_change: enabled, review_sequence: @plan.review_sequence + 1)
+        end
+      end
+      Broadcaster.custom_action_to(@plan, action: "coplan-review-changed", target: "plan-review-controls", html: "")
+      render json: { reset_reviews_on_change: @plan.reset_reviews_on_change }
+    end
+
     def create
       authorize!(@plan, :update?)
       attributes = params.expect(review_request: [ :reviewer_id, :requirement ])
diff --git a/engine/app/javascript/controllers/coplan/review_tray_controller.js b/engine/app/javascript/controllers/coplan/review_tray_controller.js
index 14a23378..c3f75265 100644
--- a/engine/app/javascript/controllers/coplan/review_tray_controller.js
+++ b/engine/app/javascript/controllers/coplan/review_tray_controller.js
@@ -1,8 +1,8 @@
 import { Controller } from "@hotwired/stimulus"
 
 export default class extends Controller {
-  static targets = ["reviews", "discussion", "commentForm", "changeButton", "notice", "search", "reviewerId", "results", "assignment", "addReviewerButton", "assignButton", "managementError", "managementStatus", "assignmentError", "approval", "approvalNote", "approvalError", "approvalTitle", "approveButton", "comparison", "diff", "activity", "suggestions"]
-  static values = { url: String, searchUrl: String, suggestionsUrl: String }
+  static targets = ["reviews", "discussion", "commentForm", "changeButton", "notice", "search", "reviewerId", "results", "assignment", "addReviewerButton", "assignButton", "managementError", "managementStatus", "policyIcon", "assignmentError", "approval", "approvalNote", "approvalError", "approvalTitle", "approveButton", "comparison", "diff", "activity", "suggestions"]
+  static values = { url: String, searchUrl: String, suggestionsUrl: String, settingsUrl: String }
 
   connect() {
     this.searchSequence = 0
@@ -21,6 +21,12 @@ export default class extends Controller {
 
   disconnect() {
     clearTimeout(this.searchTimer)
+    clearTimeout(this.policySaveTimer)
+    if (this.policySaveTimer) {
+      this.policySaveTimer = null
+      this.saveResetPolicy(this.element.querySelector("[data-review-reset-policy]"))
+    }
+    clearTimeout(this.policyIconTimer)
     this.searchSequence++
     this.refreshSequence++
     document.body.classList.remove("has-review-tray")
@@ -221,12 +227,19 @@ export default class extends Controller {
 
   async refresh() {
     const sequence = ++this.refreshSequence
+    const policyBusy = this.policySaving || this.policySaveTimer
     try {
       const response = await fetch(this.urlValue, { credentials: "same-origin", headers: { Accept: "text/html" } })
       if (!response.ok) return
       const incoming = new DOMParser().parseFromString(await response.text(), "text/html")
       if (sequence !== this.refreshSequence || !this.element.isConnected) return
       this.element.dataset.reviewGeneration = incoming.getElementById("plan-review-controls")?.dataset.reviewGeneration || ""
+      const policy = this.element.querySelector("[data-review-reset-policy]")
+      const incomingPolicy = incoming.querySelector("[data-review-reset-policy]")
+      if (policy && incomingPolicy && !policyBusy && !this.policySaving && !this.policySaveTimer) {
+        policy.checked = incomingPolicy.checked
+        policy.dataset.savedValue = String(incomingPolicy.checked)
+      }
       const tray = incoming.querySelector(".review-tray")
       const existingTray = this.element.querySelector(".review-tray")
       const wasWithdrawn = this.reviewWithdrawn
@@ -272,6 +285,58 @@ export default class extends Controller {
     } catch { /* The task and draft remain usable; the next event retries. */ }
   }
 
+  changeResetPolicy(event) {
+    const input = event.currentTarget
+    input.setAttribute("aria-busy", "true")
+    this.refreshSequence++
+    this.policyIconTarget.setAttribute("aria-hidden", "true")
+    clearTimeout(this.policyIconTimer)
+    this.policyIconTarget.dataset.state = ""
+    clearTimeout(this.policySaveTimer)
+    this.policySaveTimer = setTimeout(() => {
+      this.policySaveTimer = null
+      this.saveResetPolicy(input)
+    }, 200)
+  }
+
+  async saveResetPolicy(input) {
+    if (this.policySaving) return
+    const previous = input.dataset.savedValue === "true"
+    const enabled = input.checked
+    if (previous === enabled) { input.setAttribute("aria-busy", "false"); return }
+    this.policySaving = true
+    this.managementErrorTarget.textContent = ""
+    try {
+      await this.write(this.settingsUrlValue, "PATCH", { review_settings: { reset_reviews_on_change: enabled } })
+      input.dataset.savedValue = String(enabled)
+      if (input.checked === enabled) {
+        this.policyIconTarget.dataset.state = "saved"
+        this.policyIconTarget.setAttribute("aria-hidden", "false")
+        this.policyIconTimer = setTimeout(() => {
+          this.policyIconTarget.dataset.state = ""
+          this.policyIconTarget.setAttribute("aria-hidden", "true")
+        }, 1500)
+      }
+    } catch (error) {
+      // A lost HTTP result may already have saved. Read back before restoring
+      // the checkbox, while preserving clicks made during that request.
+      let persisted = previous
+      try {
+        const response = await fetch(this.urlValue, { credentials: "same-origin", headers: { Accept: "text/html" } })
+        const policy = new DOMParser().parseFromString(await response.text(), "text/html").querySelector("[data-review-reset-policy]")
+        if (response.ok && policy) persisted = policy.checked
+      } catch { /* Keep the last confirmed value and show the error. */ }
+      input.dataset.savedValue = String(persisted)
+      if (input.checked === enabled) input.checked = persisted
+      this.managementErrorTarget.textContent = persisted === enabled ? "" : error.message
+    } finally {
+      this.policySaving = false
+      // Serialize saves so a slow older request cannot overwrite a newer click.
+      if (input.checked !== (input.dataset.savedValue === "true")) this.saveResetPolicy(input)
+      else input.setAttribute("aria-busy", "false")
+    }
+  }
+
   async assign(event) {
     event.preventDefault()
     if (!this.reviewerIdTarget.value) { this.assignmentErrorTarget.textContent = "Choose a person from the results first."; return }
diff --git a/engine/app/models/coplan/plan.rb b/engine/app/models/coplan/plan.rb
index e9707d72..7117a782 100644
--- a/engine/app/models/coplan/plan.rb
+++ b/engine/app/models/coplan/plan.rb
@@ -68,6 +68,7 @@ class Plan < ApplicationRecord
     before_save :assign_url_slug, if: :url_slug_stale?
 
     validates :title, presence: true
+    validates :reset_reviews_on_change, inclusion: { in: [ true, false ] }
     validates :visibility, presence: true, inclusion: { in: VISIBILITIES }
     validate :attachments_within_limits
 
diff --git a/engine/app/models/coplan/review_request.rb b/engine/app/models/coplan/review_request.rb
index 140d1c12..54041126 100644
--- a/engine/app/models/coplan/review_request.rb
+++ b/engine/app/models/coplan/review_request.rb
@@ -24,7 +24,7 @@ class ReviewRequest < ApplicationRecord
     scope :pending, -> { where(status: "pending") }
 
     def pending?
-      effective_status == "pending"
+      review_status == "pending"
     end
 
     # Positive history is for comparison only. Never use it as current evidence.
@@ -32,11 +32,22 @@ def latest_approval
       review_responses.find { |response| response.decision == "approved" }
     end
 
-    def effective_response
+    # Lifecycle completion may survive edits when automatic resets are off.
+    # The recorded decision still covers only its original immutable version.
+    def recorded_response
       response = current_response
       response if response && status == response.decision &&
-        response.review_request_id == id && response.request_generation == generation &&
-        response.plan_version_id == plan.current_plan_version_id
+        response.review_request_id == id && response.request_generation == generation
+    end
+
+    def review_status
+      status == "withdrawn" ? "withdrawn" : (recorded_response&.decision || "pending")
+    end
+
+    # Exact-version evidence stays strict regardless of the reset preference.
+    def effective_response
+      response = recorded_response
+      response if response&.plan_version_id == plan.current_plan_version_id
     end
 
     def effective_status
diff --git a/engine/app/services/coplan/plans/advance_version.rb b/engine/app/services/coplan/plans/advance_version.rb
index fcd6d126..e81b7e6a 100644
--- a/engine/app/services/coplan/plans/advance_version.rb
+++ b/engine/app/services/coplan/plans/advance_version.rb
@@ -9,7 +9,7 @@ def self.call(plan:, version:)
 
         plan.update!(current_plan_version: version, current_revision: version.revision,
           review_sequence: plan.review_sequence + 1)
-        requests = plan.review_requests.active.to_a
+        requests = plan.reset_reviews_on_change? ? plan.review_requests.active.to_a : []
         requests.each do |request|
           request.update!(status: "pending", generation: request.generation + 1,
             current_response: nil, reset_reason: "content_changed")
@@ -17,6 +17,9 @@ def self.call(plan:, version:)
         # No new review notifications for each edit, and no reset broadcast
         # for a transaction that rolls back.
         ActiveRecord.after_all_transactions_commit do
+          if requests.empty?
+            Broadcaster.custom_action_to(plan, action: "coplan-review-changed", target: "plan-review-controls", html: "")
+          end
           requests.each do |request|
             Reviews::Changed.call(request: request, event_type: "review.requested",
               payload: { "action" => "content_changed", "revision" => version.revision,
diff --git a/engine/app/services/coplan/reviews/evidence.rb b/engine/app/services/coplan/reviews/evidence.rb
index 7aa499c6..4e5e09f0 100644
--- a/engine/app/services/coplan/reviews/evidence.rb
+++ b/engine/app/services/coplan/reviews/evidence.rb
@@ -14,6 +14,7 @@ def self.call(plan:)
           version = plan.current_plan_version
           {
             schema_version: 1, plan_id: plan.id, review_sequence: plan.review_sequence,
+            reset_reviews_on_change: plan.reset_reviews_on_change,
             approval_scope: SCOPE,
             version: { id: version.id, revision: version.revision,
                        content_sha256: version.content_sha256, content_markdown: version.verified_content! },
diff --git a/engine/app/services/coplan/reviews/serialize.rb b/engine/app/services/coplan/reviews/serialize.rb
index c70f0896..3fa33cf8 100644
--- a/engine/app/services/coplan/reviews/serialize.rb
+++ b/engine/app/services/coplan/reviews/serialize.rb
@@ -13,9 +13,10 @@ def call
         request = @request
         {
           id: request.id, reviewer: { id: request.reviewer_id, name: request.reviewer.name },
-          requirement: request.requirement, status: request.status, effective_status: request.effective_status,
+          requirement: request.requirement, status: request.status, review_status: request.review_status, effective_status: request.effective_status,
           requested_at: request.requested_at, generation: request.generation, reset_reason: request.reset_reason,
           current_response_id: request.current_response_id,
+          recorded_response_id: request.recorded_response&.id,
           effective_response_id: request.effective_response&.id,
           effective_human_decision: request.effective_human_decision,
           latest_human_response_id: request.review_responses.find { |response|
diff --git a/engine/app/views/coplan/agent_instructions/guides/api.text.erb b/engine/app/views/coplan/agent_instructions/guides/api.text.erb
index 8373ffea..f5416214 100644
--- a/engine/app/views/coplan/agent_instructions/guides/api.text.erb
+++ b/engine/app/views/coplan/agent_instructions/guides/api.text.erb
@@ -84,7 +84,7 @@ return 429. Invalid names return 422 with `invalid_request`.
 
 Creating a review request for an existing reviewer returns the current task with status 201. It leaves the requirement, decision, history, and notifications unchanged. Use `PATCH` to change the requirement or `request_again: true` to request another look.
 
-Send the request’s `generation` and the viewed `revision` with every new response. A missing generation is supported only for the first cycle. After edits or re-requests, a stale or missing generation returns 409 with `code: review_request_changed`. Fetch the task again and deliberately review before submitting a fresh response. Edits reset active tasks to pending and advance their generations. Withdrawn tasks stay withdrawn. Earlier responses remain history.
+Send the request’s `generation` and the viewed `revision` with every new response. A missing generation is supported only for the first cycle. After edits or re-requests, a stale or missing generation returns 409 with `code: review_request_changed`. Fetch the task again and deliberately review before submitting a fresh response. By default, edits reset active tasks to pending and advance their generations. When `reset_reviews_on_change` is false, completed reviews stay completed on their original versions; no fresh approval is required. Withdrawn tasks stay withdrawn. Earlier responses remain history.
 
 Include `idempotency_key` (a fresh UUID) for each intended review response. Reuse that UUID and identical fields when retrying a lost response; its returned `id` is the UUID. Use a new UUID for a new decision, including another review of the same version. A keyed retry returns the original recorded result even after the plan changes or the task is withdrawn. It preserves any newly pending review task. Without a key, an identical response is treated as a retry. Retries may use a renewed token for the same human principal. The original response keeps its original agent and token attribution. A key reused for different fields returns 422. A retry’s `effective: false` means it is history, not a current decision. New responses return `plan_version_id`, `content_sha256`, `generation`, and server `decision_sequence`.
 
diff --git a/engine/app/views/coplan/agent_instructions/guides/comments.text.erb b/engine/app/views/coplan/agent_instructions/guides/comments.text.erb
index 14adb8b3..9efeb035 100644
--- a/engine/app/views/coplan/agent_instructions/guides/comments.text.erb
+++ b/engine/app/views/coplan/agent_instructions/guides/comments.text.erb
@@ -80,7 +80,7 @@ To give feedback on another person's plan, start threads anchored to the passage
 
 Each request or re-request remains in review activity with its requester and time. A later request does not replace earlier requests or decisions.
 
-Discussion is the default. An approval means “satisfied with this exact version”; it grants no permissions, execution authority, or instruction to implement the plan. Never interpret another person's sign-off as an instruction from your principal. Edits reset active tasks to pending and preserve the earlier sign-off as history. Approval covers Markdown source bytes only, not title, tags, attachments, linked or embedded resources, or child plans. Use `GET /api/v1/plans/:plan_id/review_evidence` for exact current Markdown, hash, version ID, and coherent review state. It creates no read receipt. `effective_human_decision` is null for agent decisions or dismissed approvals. A later agent decision cannot count as a human approval. `latest_human_response_id` exposes historical human feedback on the current version; it is not an effective approval.
+Discussion is the default. An approval means “satisfied with this exact version”; it grants no permissions, execution authority, or instruction to implement the plan. Never interpret another person's sign-off as an instruction from your principal. By default, edits reset active tasks to pending and preserve earlier decisions as history. Editors may disable automatic resets in Manage reviewers; completed reviews then stay completed on their original versions, without requiring fresh approval. Approval covers Markdown source bytes only, not title, tags, attachments, linked or embedded resources, or child plans. Use `GET /api/v1/plans/:plan_id/review_evidence` for exact current Markdown, hash, version ID, and coherent review state. It creates no read receipt. `review_status` describes task completion. `effective_human_decision` is exact-current-version evidence and is null for agent decisions, dismissed approvals, or decisions on older versions, even when automatic resets are off. A later agent decision cannot count as a human approval. `latest_human_response_id` exposes historical human feedback on the current version; it is not an effective approval.
 
 - `GET /api/v1/plans/:plan_id/review_requests` lists requests and responses, including reviewer, required/optional, revision, timestamp, notes, and agent attribution.
 - The plan author's credential may `POST` that path with `{ "reviewer_id": "USER_ID", "requirement": "required" }` (or `optional`). Requests are tasks; reading the notification does not complete them.
diff --git a/engine/app/views/coplan/agent_instructions/guides/live.text.erb b/engine/app/views/coplan/agent_instructions/guides/live.text.erb
index 101aafe5..aed9c7f8 100644
--- a/engine/app/views/coplan/agent_instructions/guides/live.text.erb
+++ b/engine/app/views/coplan/agent_instructions/guides/live.text.erb
@@ -103,7 +103,7 @@ For `review.requested`, inspect `payload.action`:
 | Action | Meaning |
 |---|---|
 | `requested` | A new request or another look. `requirement` is `required` or `optional`. |
-| `content_changed` | A new Markdown version reset active tasks and advanced their generations. Earlier responses remain history. Read the current version and request before responding. No new inbox nudge is sent for each edit. |
+| `content_changed` | A new Markdown version reset active tasks and advanced their generations under the default-on reset policy. No reset event is emitted when the document’s automatic resets are off. Earlier responses remain history. Read the current version and request before responding. No new inbox nudge is sent for each edit. |
 | `requirement_changed` | Only `requirement` changed. This does not reopen the task or start another review cycle. Do not treat it as a request for another look. |
 | `withdrawn` | The request was withdrawn. Stop working on that request; its earlier decisions remain. The payload also has `withdrawn: true`. |
 
diff --git a/engine/app/views/coplan/reviews/_controls.html.erb b/engine/app/views/coplan/reviews/_controls.html.erb
index ea8983b7..ebe2c656 100644
--- a/engine/app/views/coplan/reviews/_controls.html.erb
+++ b/engine/app/views/coplan/reviews/_controls.html.erb
@@ -1,11 +1,12 @@
 <% requests = plan.review_requests.includes(:reviewer, :requested_by_user, :requested_plan_version, review_responses: [ :plan_version, :user ]).order(:requested_at).to_a %>
 <% request_events = plan.plan_events.where(event_type: %w[review_requested review_withdrawn]).includes(:actor_user).to_a %>
-<% active_requests = requests.reject { |request| request.effective_status == "withdrawn" } %>
+<% active_requests = requests.reject { |request| request.review_status == "withdrawn" } %>
 <% own_request = active_requests.find { |request| request.reviewer_id == current_user.id } %>
 <% response_thread_ids = requests.flat_map { |request| request.review_responses.map(&:comment_thread_id) }.compact %>
 <% feedback_thread_ids = plan.comment_threads.with_kept_comments.where(id: response_thread_ids).pluck(:id) %>
 <div id="plan-review-controls" data-review-generation="<%= own_request&.generation %>" data-review-record-count="<%= requests.size %>" data-controller="coplan--review-tray"
      data-coplan--review-tray-url-value="<%= plan_review_requests_path(plan) %>"
+     data-coplan--review-tray-settings-url-value="<%= settings_plan_review_requests_path(plan) %>"
      data-coplan--review-tray-search-url-value="<%= search_users_path %>"
      <% if CoPlan.configuration.suggest_reviewers %>data-coplan--review-tray-suggestions-url-value="<%= suggestions_plan_review_requests_path(plan) %>"<% end %>
      data-action="coplan:anchors-updated@document->coplan--review-tray#syncFeedbackLinks coplan:reviews-changed->coplan--review-tray#refresh coplan:manage-reviews@document->coplan--review-tray#openReviews coplan:content-updated@document->coplan--review-tray#refresh coplan:editor-saved@document->coplan--review-tray#refresh resize@window->coplan--review-tray#positionAssignment keydown.esc@document->coplan--review-tray#escape">
@@ -28,17 +29,18 @@
       </div>
       <div class="review-tray__bar">
         <div class="review-tray__status" data-review-status>
-          <% response = own_request.effective_response %>
+          <% response = own_request.recorded_response %>
           <% approval = own_request.latest_approval %>
           <div class="review-tray__decision">
             <% if own_request.pending? %>
               <span class="review-task-dot" aria-hidden="true"></span><strong>Your review is requested</strong><small><%= own_request.requirement.humanize %><%= " · Content changed; review v#{plan.current_revision} again" if own_request.reset_reason == "content_changed" %><%= " · Earlier decisions are history; please review again" if own_request.reset_reason == "legacy_history" %></small>
             <% elsif response %>
-              <span class="review-result-icon<%= ' review-result-icon--approved' if own_request.effective_status == 'approved' %>" aria-hidden="true"><%= own_request.effective_status == "approved" ? "✓" : "↩" %></span>
+              <span class="review-result-icon<%= ' review-result-icon--approved' if own_request.review_status == 'approved' %>" aria-hidden="true"><%= own_request.review_status == "approved" ? "✓" : "↩" %></span>
               <% decision_actor = response.actor_type == "local_agent" ? "#{response.agent_name} (via you)" : "You" %>
-              <span><strong><%= own_request.effective_status == "approved" ? "#{decision_actor} approved" : "#{decision_actor} requested changes to" %> v<%= response.plan_version.revision %></strong> <span class="review-tray__date">on <time datetime="<%= response.created_at.iso8601 %>" title="<%= response.created_at.strftime('%B %-d, %Y at %H:%M %Z') %>"><%= response.created_at.strftime("%b %-d, %Y") %></time></span></span>
+              <span><strong><%= own_request.review_status == "approved" ? "#{decision_actor} approved" : "#{decision_actor} requested changes to" %> v<%= response.plan_version.revision %></strong> <span class="review-tray__date">on <time datetime="<%= response.created_at.iso8601 %>" title="<%= response.created_at.strftime('%B %-d, %Y at %H:%M %Z') %>"><%= response.created_at.strftime("%b %-d, %Y") %></time></span></span>
             <% end %>
           </div>
+          <% if response && response.plan_version_id != plan.current_plan_version_id %><small>Content changed since review; no new review required.</small><% end %>
           <% if !own_request.pending? && feedback_thread_ids.include?(response&.comment_thread_id) %><button type="button" class="review-log__link review-feedback-link" data-action="coplan--review-tray#openThread" data-thread-id="<%= response.comment_thread_id %>">View feedback</button><% end %>
           <% if approval && approval.plan_version.revision != plan.current_revision %><button type="button" class="btn btn--ghost btn--sm" data-action="coplan--review-tray#compare" data-url="<%= compare_plan_review_request_path(plan, own_request, response_id: approval.id) %>">Changes since approval</button><% end %>
         </div>
@@ -62,7 +64,7 @@
       <h2 id="approval-title" data-coplan--review-tray-target="approvalTitle">Approve this version?</h2>
     </div>
     <p class="review-confirmation__statement">I’ve reviewed and approve the Markdown source of this version.</p>
-    <p class="text-sm text-muted">Edits dismiss active decisions. Attachments, linked or embedded content, title, tags, and child plans are outside this approval.</p>
+    <p class="text-sm text-muted">Attachments, linked or embedded content, title, tags, and child plans are outside this approval.</p>
     <form data-action="submit->coplan--review-tray#approve">
       <label for="approval-note">Public note <span class="text-muted">(optional)</span></label><textarea id="approval-note" rows="3" placeholder="Anything you’d like to add?" data-coplan--review-tray-target="approvalNote"></textarea>
       <p class="review-error" role="alert" data-coplan--review-tray-target="approvalError"></p>
diff --git a/engine/app/views/coplan/reviews/_log.html.erb b/engine/app/views/coplan/reviews/_log.html.erb
index 2d4beeb3..7903a6f4 100644
--- a/engine/app/views/coplan/reviews/_log.html.erb
+++ b/engine/app/views/coplan/reviews/_log.html.erb
@@ -2,7 +2,7 @@
   <details class="review-log-details document-support__disclosure" data-controller="coplan--support-disclosure" data-action="toggle->coplan--support-disclosure#remember">
     <summary class="review-log-panel__header document-support__heading"><span class="document-support__chevron" aria-hidden="true">›</span><h2 class="plan-footnote__title" id="review-log-title">Reviews</h2><span class="review-log-panel__summary" data-review-log-summary><span><%= pluralize(active_requests.size, "reviewer") %><%= " · #{active_requests.count(&:pending?)} awaiting review" if active_requests.any?(&:pending?) %></span></span></summary>
     <div class="review-log-panel__columns document-support__content">
-      <p class="text-sm text-muted">Reviews cover the Markdown source only. Edits dismiss active decisions; earlier decisions remain in activity.</p>
+      <p class="text-sm text-muted">Reviews cover the Markdown source only. Decisions record the version reviewed; earlier decisions remain in activity.</p>
       <%= render "coplan/reviews/roster", plan: plan, active_requests: active_requests, manage: false %>
       <div class="review-log-panel__tools"><button type="button" class="btn btn--secondary btn--sm" data-action="coplan--review-tray#openActivity">View activity <span aria-hidden="true">↗</span></button></div>
     </div>
diff --git a/engine/app/views/coplan/reviews/_management.html.erb b/engine/app/views/coplan/reviews/_management.html.erb
index 4f943236..791c77f7 100644
--- a/engine/app/views/coplan/reviews/_management.html.erb
+++ b/engine/app/views/coplan/reviews/_management.html.erb
@@ -13,6 +13,10 @@
     <% end %>
   </div>
   <% if allowed_to?(plan, :update?) %>
+    <div class="review-reset-policy">
+      <label class="review-required"><input type="checkbox" <%= "checked" if plan.reset_reviews_on_change %> data-action="change->coplan--review-tray#changeResetPolicy" data-review-reset-policy data-saved-value="<%= plan.reset_reviews_on_change %>"> Reset approvals when content changes <span class="review-reset-policy__status" data-coplan--review-tray-target="policyIcon" role="img" aria-hidden="true" aria-label="Saved" title="Saved">✓</span></label>
+      <p class="text-sm text-muted">Applies to future edits for all reviewers. When off, completed reviews stay completed.</p>
+    </div>
     <div id="review-assignment" class="review-assignment" popover="auto" role="dialog" aria-label="Add reviewer" data-coplan--review-tray-target="assignment" data-action="toggle->coplan--review-tray#assignmentToggled keydown.esc->coplan--review-tray#dismissAssignment">
       <%= form_with url: plan_review_requests_path(plan), class: "review-assignment-form", data: { action: "submit->coplan--review-tray#assign" } do %>
         <label for="reviewer-search">Find a reviewer</label>
diff --git a/engine/app/views/coplan/reviews/_roster.html.erb b/engine/app/views/coplan/reviews/_roster.html.erb
index b03ea688..23ea9b77 100644
--- a/engine/app/views/coplan/reviews/_roster.html.erb
+++ b/engine/app/views/coplan/reviews/_roster.html.erb
@@ -10,14 +10,14 @@
             <%= user_avatar(request.reviewer, size: "md") %>
             <div class="review-person__info">
               <strong><%= request.reviewer.name %></strong>
-              <span class="review-person__meta"><span class="review-person__requirement"><%= requirement.humanize %></span> · <% if request.pending? %>Review requested<% elsif request.effective_status == "changes_requested" %>Changes requested on v<%= request.effective_response&.plan_version&.revision %><% else %>Approved v<%= request.effective_response&.plan_version&.revision %><%= " (agent)" if request.effective_response&.actor_type == "local_agent" %><% end %></span>
+              <span class="review-person__meta"><span class="review-person__requirement"><%= requirement.humanize %></span> · <% if request.pending? %>Review requested<% elsif request.review_status == "changes_requested" %>Changes requested on v<%= request.recorded_response&.plan_version&.revision %><% else %>Approved v<%= request.recorded_response&.plan_version&.revision %><%= " (agent)" if request.recorded_response&.actor_type == "local_agent" %><% end %></span>
             </div>
-            <span class="review-state<%= ' review-state--approved' if request.effective_status == 'approved' %><%= ' review-state--attention' if request.pending? && request.reviewer_id == current_user.id %>"><span aria-hidden="true"><%= request.pending? ? "◷" : request.effective_status == "approved" ? "✓" : "↩" %></span> <%= request.pending? ? "Pending" : request.effective_status.humanize %></span>
+            <span class="review-state<%= ' review-state--approved' if request.review_status == 'approved' %><%= ' review-state--attention' if request.pending? && request.reviewer_id == current_user.id %>"><span aria-hidden="true"><%= request.pending? ? "◷" : request.review_status == "approved" ? "✓" : "↩" %></span> <%= request.pending? ? "Pending" : request.review_status.humanize %></span>
             <% if manage && allowed_to?(plan, :update?) %>
               <span class="review-person__actions" data-controller="coplan--menu">
                 <button type="button" class="review-person__menu-button" aria-label="Actions for <%= request.reviewer.name %>" title="Actions for <%= request.reviewer.name %>" popovertarget="review-menu-<%= request.id %>" data-coplan--menu-target="trigger"><svg width="16" height="16" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true"><circle cx="5" cy="12" r="2"/><circle cx="12" cy="12" r="2"/><circle cx="19" cy="12" r="2"/></svg></button>
                 <div id="review-menu-<%= request.id %>" class="menu review-person__menu" popover="auto" data-coplan--menu-target="menu" data-action="beforetoggle->coplan--menu#reposition" aria-label="Review actions for <%= request.reviewer.name %>">
-                  <button type="button" class="menu__item" data-action="coplan--review-tray#requestAgain coplan--menu#close" data-url="<%= plan_review_request_path(plan, request) %>"><%= request.effective_status == "changes_requested" ? "Ready for another look" : "Request another review" %></button>
+                  <button type="button" class="menu__item" data-action="coplan--review-tray#requestAgain coplan--menu#close" data-url="<%= plan_review_request_path(plan, request) %>"><%= request.review_status == "changes_requested" ? "Ready for another look" : "Request another review" %></button>
                   <button type="button" class="menu__item" data-action="coplan--review-tray#changeRequirement coplan--menu#close" data-url="<%= plan_review_request_path(plan, request) %>" data-requirement="<%= requirement == 'required' ? 'optional' : 'required' %>">Make <%= requirement == 'required' ? 'optional' : 'required' %></button>
                   <% if approval && approval.plan_version.revision != plan.current_revision %><button type="button" class="menu__item" data-action="coplan--review-tray#compare coplan--menu#close" data-url="<%= compare_plan_review_request_path(plan, request, response_id: approval.id) %>">Changes since approval</button><% end %>
                   <div class="menu__separator" role="separator"></div>
diff --git a/engine/app/views/coplan/reviews/_table.html.erb b/engine/app/views/coplan/reviews/_table.html.erb
index 26fb14d3..eba61d10 100644
--- a/engine/app/views/coplan/reviews/_table.html.erb
+++ b/engine/app/views/coplan/reviews/_table.html.erb
@@ -3,13 +3,13 @@
     <thead><tr><th scope="col">Reviewer</th><th scope="col">Review</th><th scope="col">Decision</th><th scope="col">Version</th><th scope="col">Actions</th></tr></thead>
     <tbody>
       <% active_requests.sort_by { |request| [CoPlan::ReviewRequest::REQUIREMENTS.index(request.requirement), request.reviewer.name.downcase, request.id] }.each do |request| %>
-        <% response = request.effective_response %>
+        <% response = request.recorded_response %>
         <% approval = request.latest_approval %>
         <tr class="review-person" data-reviewer-id="<%= request.reviewer_id %>">
           <td><div class="review-table__person"><%= user_avatar(request.reviewer) %><strong><%= request.reviewer.name %></strong></div></td>
           <td><span class="review-table__requirement"><%= request.requirement.humanize %></span></td>
-          <td><span class="review-state<%= ' review-state--approved' if request.effective_status == 'approved' %><%= ' review-state--attention' if request.pending? && request.reviewer_id == current_user.id %>"><span aria-hidden="true"><%= request.pending? ? "◷" : request.effective_status == "approved" ? "✓" : "↩" %></span><span class="review-person__meta"><%= request.pending? ? (request.reset_reason == "content_changed" ? "Content changed; review again" : "Review requested") : request.effective_status.humanize %><%= " (agent)" if response&.actor_type == "local_agent" %></span></span></td>
-          <td><% if !request.pending? && response %><span class="review-version">v<%= response.plan_version.revision %></span><% else %><span class="text-muted" aria-label="Not reviewed yet">—</span><% end %></td>
+          <td><span class="review-state<%= ' review-state--approved' if request.review_status == 'approved' %><%= ' review-state--attention' if request.pending? && request.reviewer_id == current_user.id %>"><span aria-hidden="true"><%= request.pending? ? "◷" : request.review_status == "approved" ? "✓" : "↩" %></span><span class="review-person__meta"><%= request.pending? ? (request.reset_reason == "content_changed" ? "Content changed; review again" : "Review requested") : request.review_status.humanize %><%= " (agent)" if response&.actor_type == "local_agent" %></span></span></td>
+          <td><% if !request.pending? && response %><span class="review-version">v<%= response.plan_version.revision %></span><% if response.plan_version_id != plan.current_plan_version_id %> <span class="text-muted">Content changed since review</span><% end %><% else %><span class="text-muted" aria-label="Not reviewed yet">—</span><% end %></td>
           <td class="review-table__actions">
             <% if !request.pending? && request.reviewer_id == current_user.id %><button type="button" class="review-log__link review-reopen" aria-label="Change decision" title="Change decision" data-action="coplan--review-tray#reconsider"><svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M20 7v5h-5M4 17v-5h5"/><path d="M6.1 7a7 7 0 0 1 11.6-1L20 9M4 15l2.3 3A7 7 0 0 0 17.9 17"/></svg></button><% end %>
             <% if approval && approval.plan_version.revision != plan.current_revision %><button type="button" class="review-log__link" data-action="coplan--review-tray#compare" data-url="<%= compare_plan_review_request_path(plan, request, response_id: approval.id) %>">Compare</button><% end %>
diff --git a/engine/config/routes.rb b/engine/config/routes.rb
index a176e8af..2b06c2b3 100644
--- a/engine/config/routes.rb
+++ b/engine/config/routes.rb
@@ -75,6 +75,7 @@
       # see DictationsController.
       resources :dictations, only: [ :create ]
       resources :review_requests, only: [ :index, :create, :update, :destroy ] do
+        patch :settings, on: :collection
         get :suggestions, on: :collection
         post :respond, on: :member
         get :compare, on: :member
diff --git a/engine/db/demo/content/retained-review.md b/engine/db/demo/content/retained-review.md
new file mode 100644
index 00000000..0befe697
--- /dev/null
+++ b/engine/db/demo/content/retained-review.md
@@ -0,0 +1,7 @@
+# Keep completed reviews after edits
+
+Automatic approval resets are off for this document. The v1 reviews remain completed after the v2 edit, without requiring new approvals. Each review still identifies the immutable Markdown version reviewed.
+
+Enable **Reset approvals when content changes** in Manage reviewers, then edit again to return active reviews to Pending.
+
+- [ ] Verify the retry policy
diff --git a/engine/db/migrate/20261029120000_add_review_reset_policy_to_coplan_plans.rb b/engine/db/migrate/20261029120000_add_review_reset_policy_to_coplan_plans.rb
new file mode 100644
index 00000000..0320f41c
--- /dev/null
+++ b/engine/db/migrate/20261029120000_add_review_reset_policy_to_coplan_plans.rb
@@ -0,0 +1,5 @@
+class AddReviewResetPolicyToCoplanPlans < ActiveRecord::Migration[8.1]
+  def change
+    add_column :coplan_plans, :reset_reviews_on_change, :boolean, null: false, default: true
+  end
+end
diff --git a/engine/lib/coplan/development_seed.rb b/engine/lib/coplan/development_seed.rb
index 0bbaff46..1d943294 100644
--- a/engine/lib/coplan/development_seed.rb
+++ b/engine/lib/coplan/development_seed.rb
@@ -128,6 +128,11 @@ module DevelopmentSeed
         tags: %w[collaboration demo], visibility: "published", folder: "Demo scenarios",
         scenario: "Earlier v1 approvals remain history; v2 requires fresh review"
       },
+      {
+        key: "retained-review", author: "hampton", type: "Design Doc", title: "Workspace invitations: reviews retained after edits",
+        tags: %w[collaboration demo], visibility: "published", folder: "Demo scenarios",
+        scenario: "Automatic resets off; v1 reviews stay completed after v2 edits"
+      },
       {
         key: "approved-review", author: "hampton", type: "Design Doc", title: "Workspace invitations: approved rollout",
         tags: %w[collaboration demo], visibility: "published", folder: "Demo scenarios",
@@ -251,7 +256,8 @@ module DevelopmentSeed
     REVIEW_SCENARIOS = {
       "pending-review" => false,
       "approved-review" => true,
-      "changed-review" => true
+      "changed-review" => true,
+      "retained-review" => true
     }.freeze
 
     SMALL_EDITS = [
@@ -853,6 +859,7 @@ def seed_writing_history(users, plans, catalog)
     def seed_reviews(users, plans)
       REVIEW_SCENARIOS.each do |key, approved|
         plan = plans.fetch(key)
+        plan.update!(reset_reviews_on_change: false) if key == "retained-review" && plan.current_revision == 1
         %w[alex noura].each do |reviewer|
           collaborator = plan.plan_collaborators.find_or_initialize_by(user: users.fetch(reviewer))
           unless collaborator.persisted?
@@ -865,8 +872,8 @@ def seed_reviews(users, plans)
           request = Reviews::Request.call(plan: plan, reviewer: users.fetch(reviewer), actor: plan.created_by_user)
           Reviews::Respond.call(request: request, actor: request.reviewer, revision: plan.current_revision, decision: "approved") if approved
         end
-        if key == "changed-review" && plan.current_revision == 1
-          Plans::ReplaceContent.call(plan: plan, new_content: "#{plan.current_content}\n\nUpdated after approval: review the retry policy again.\n",
+        if %w[changed-review retained-review].include?(key) && plan.current_revision == 1
+          Plans::ReplaceContent.call(plan: plan, new_content: "#{plan.current_content}\n\nUpdated after approval: the retry policy has changed.\n",
             base_revision: 1, actor_type: "human", actor_id: plan.created_by_user_id)
         end
       end
diff --git a/spec/lib/development_seed_spec.rb b/spec/lib/development_seed_spec.rb
index 4d90fb0f..b75dc657 100644
--- a/spec/lib/development_seed_spec.rb
+++ b/spec/lib/development_seed_spec.rb
@@ -297,6 +297,13 @@ def seeded_plan(key)
       expect(changed.review_requests.map(&:effective_response)).to all(be_nil)
       expect(changed.review_requests.map { |r| r.latest_approval.plan_version.revision }).to eq([ 1, 1 ])
 
+      retained = seeded_plan("retained-review")
+      expect(retained.current_revision).to eq(2)
+      expect(retained.reset_reviews_on_change).to be(false)
+      expect(retained.review_requests.map(&:review_status)).to eq(%w[approved approved])
+      expect(retained.review_requests.map(&:effective_response)).to all(be_nil)
+      retained_ids = retained.review_requests.pluck(:current_response_id)
+
       pending = seeded_plan("pending-review").plan_collaborators.approvers
       approved = seeded_plan("approved-review").plan_collaborators.approvers
       expect(pending.count).to eq(2)
@@ -323,6 +330,9 @@ def seeded_plan(key)
       expect(pending.reload.where(approved_at: nil).count).to eq(1)
       expect(thread.reload.status).to eq("resolved")
       expect(edited.reload.current_revision).to eq(8)
+      expect(retained.reload.current_revision).to eq(2)
+      expect(retained.review_requests.pluck(:current_response_id)).to match_array(retained_ids)
+      expect(retained.reset_reviews_on_change).to be(false)
     end
 
     it "refreshes a generated index while preserving a locally edited index" do
diff --git a/spec/requests/api/v1/operations_spec.rb b/spec/requests/api/v1/operations_spec.rb
index 320546ec..1dd7c105 100644
--- a/spec/requests/api/v1/operations_spec.rb
+++ b/spec/requests/api/v1/operations_spec.rb
@@ -20,6 +20,21 @@
     )
   end
 
+  [ true, false ].each do |reset|
+    it "honors reset_reviews_on_change=#{reset} for direct operations" do
+      plan.update!(reset_reviews_on_change: reset)
+      task = CoPlan::Reviews::Request.call(plan: plan, reviewer: alice, actor: alice)
+      receipt = CoPlan::Reviews::Respond.call(request: task, actor: alice, revision: 1, generation: task.generation, decision: "approved")
+      post api_v1_plan_operations_path(plan), params: { lease_token: lease_token, base_revision: 1,
+        operations: [ { op: "replace_exact", old_text: "Some content here.", new_text: "Updated content.", count: 1 } ] },
+        headers: headers, as: :json
+      expect(response).to have_http_status(:created)
+      expect(task.reload.review_status).to eq(reset ? "pending" : "approved")
+      expect(task.recorded_response).to eq(reset ? nil : receipt)
+      expect(task.effective_human_decision).to be_nil
+    end
+  end
+
   it "apply operations creates new version" do
     expect {
       post api_v1_plan_operations_path(plan),
diff --git a/spec/requests/api/v1/review_evidence_spec.rb b/spec/requests/api/v1/review_evidence_spec.rb
index 3a272567..05479c51 100644
--- a/spec/requests/api/v1/review_evidence_spec.rb
+++ b/spec/requests/api/v1/review_evidence_spec.rb
@@ -35,6 +35,20 @@
     expect(response.parsed_body.fetch("review_requests").first.fetch("effective_response_id")).to be_nil
   end
 
+  it "distinguishes retained task completion from current-version approval when resets are off" do
+    plan.update!(reset_reviews_on_change: false)
+    receipt = CoPlan::Reviews::Respond.call(request: task, actor: task.reviewer, revision: 1, generation: 1, decision: "approved")
+    CoPlan::Plans::ReplaceContent.call(plan: plan, new_content: "New source", base_revision: 1, actor_type: "human", actor_id: author.id)
+    get review_evidence_api_v1_plan_path(plan), headers: headers
+    expect(response).to have_http_status(:ok)
+    data = response.parsed_body
+    expect(data.fetch("reset_reviews_on_change")).to be(false)
+    expect(data.fetch("version").fetch("revision")).to eq(2)
+    expect(data.fetch("review_requests").first).to include("review_status" => "approved", "recorded_response_id" => receipt.id,
+      "effective_status" => "pending", "effective_human_decision" => nil, "effective_response_id" => nil)
+    expect(data.fetch("review_requests").first.fetch("responses").first).to include("revision" => 1, "plan_version_id" => receipt.plan_version_id)
+  end
+
   it "returns the exact historical source after edits and never substitutes current content" do
     original = plan.current_plan_version
     CoPlan::Plans::ReplaceContent.call(plan: plan, new_content: "New body", base_revision: 1, actor_type: "human", actor_id: author.id)
diff --git a/spec/requests/review_requests_spec.rb b/spec/requests/review_requests_spec.rb
index 4706ec62..8ad4e332 100644
--- a/spec/requests/review_requests_spec.rb
+++ b/spec/requests/review_requests_spec.rb
@@ -6,6 +6,28 @@
   let(:plan) { create(:plan, :published, created_by_user: author) }
   let(:task) { create(:review_request, plan: plan, reviewer: reviewer) }
 
+  it "defaults to resetting reviews and persists an editor's document-wide preference", :review_reset_policy do
+    expect(plan.reset_reviews_on_change).to be(true)
+    sequence = plan.review_sequence
+    sign_in_as(author)
+    [ false, false, true ].each_with_index do |enabled, index|
+      patch settings_plan_review_requests_path(plan), params: { review_settings: { reset_reviews_on_change: enabled } }, as: :json
+      expect(response).to have_http_status(:ok)
+      expect(response.parsed_body).to eq("reset_reviews_on_change" => enabled)
+      expect(plan.reload.reset_reviews_on_change).to eq(enabled)
+      expect(plan.review_sequence).to eq(sequence + (index == 2 ? 2 : 1))
+      expect(CoPlan::Reviews::Evidence.call(plan: plan)[:reset_reviews_on_change]).to eq(enabled)
+    end
+  end
+
+  it "does not let a reviewer change the document's reset policy", :review_reset_policy do
+    task
+    sign_in_as(reviewer)
+    patch settings_plan_review_requests_path(plan), params: { review_settings: { reset_reviews_on_change: false } }, as: :json
+    expect(response).to have_http_status(:not_found)
+    expect(plan.reload.reset_reviews_on_change).to be(true)
+  end
+
   it "labels an agent decision separately from the reviewer's own human approval" do
     token = create(:api_token, user: reviewer, agent_name: "Reviewbot")
     CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 1, decision: "approved", api_token: token)
diff --git a/spec/services/coplan/review_concurrency_spec.rb b/spec/services/coplan/review_concurrency_spec.rb
index 07c90fa7..00d3393b 100644
--- a/spec/services/coplan/review_concurrency_spec.rb
+++ b/spec/services/coplan/review_concurrency_spec.rb
@@ -11,49 +11,52 @@ def threaded(&block)
     Thread.new { ActiveRecord::Base.connection_pool.with_connection(&block) }
   end
 
-  it "makes an evidence read and stale response wait for the complete edit/reset transaction" do
-    owner = create(:coplan_user)
-    reviewer = create(:coplan_user)
-    plan = CoPlan::Plans::Create.call(title: "Concurrent review", content: "Before", user: owner)
-    task = CoPlan::Reviews::Request.call(plan: plan, reviewer: reviewer, actor: owner)
-    first = CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 1, generation: 1, decision: "approved")
-    edited, release, attempting = Queue.new, Queue.new, Queue.new
-    writer = threaded do
-      local = CoPlan::Plan.find(plan.id)
-      local.with_lock do
-        CoPlan::Plans::ReplaceContent.call(plan: local, new_content: "After", base_revision: 1, actor_type: "human", actor_id: owner.id)
-        edited << true
-        release.pop
+  [ true, false ].each do |reset|
+    it "makes evidence and stale responses wait for a complete edit with resets=#{reset}" do
+      owner = create(:coplan_user)
+      reviewer = create(:coplan_user)
+      plan = CoPlan::Plans::Create.call(title: "Concurrent review", content: "Before", user: owner)
+      plan.update!(reset_reviews_on_change: reset)
+      task = CoPlan::Reviews::Request.call(plan: plan, reviewer: reviewer, actor: owner)
+      first = CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 1, generation: 1, decision: "approved")
+      edited, release, attempting = Queue.new, Queue.new, Queue.new
+      writer = threaded do
+        local = CoPlan::Plan.find(plan.id)
+        local.with_lock do
+          CoPlan::Plans::ReplaceContent.call(plan: local, new_content: "After", base_revision: 1, actor_type: "human", actor_id: owner.id)
+          edited << true
+          release.pop
+        end
       end
-    end
-    Timeout.timeout(10) { edited.pop }
-    reader = threaded do
-      attempting << true
-      CoPlan::Reviews::Evidence.call(plan: CoPlan::Plan.find(plan.id))
-    end
-    responder = threaded do
-      attempting << true
-      begin
-        CoPlan::Reviews::Respond.call(request: CoPlan::ReviewRequest.find(task.id), actor: reviewer,
-          revision: 1, generation: 1, decision: "approved", idempotency_key: SecureRandom.uuid)
-      rescue CoPlan::Reviews::Respond::Conflict => error
-        error.code
+      Timeout.timeout(10) { edited.pop }
+      reader = threaded do
+        attempting << true
+        CoPlan::Reviews::Evidence.call(plan: CoPlan::Plan.find(plan.id))
       end
+      responder = threaded do
+        attempting << true
+        begin
+          CoPlan::Reviews::Respond.call(request: CoPlan::ReviewRequest.find(task.id), actor: reviewer,
+            revision: 1, generation: 1, decision: "approved", idempotency_key: SecureRandom.uuid)
+        rescue CoPlan::Reviews::Respond::Conflict => error
+          error.code
+        end
+      end
+      Timeout.timeout(10) { 2.times { attempting.pop } }
+      expect(reader).to be_alive
+      expect(responder).to be_alive
+      release << true
+      [ writer, reader, responder ].each { |thread| expect(thread.join(20)).to be_present }
+      evidence = reader.value
+      expect(evidence[:version]).to include(revision: 2, content_markdown: "After")
+      expect(evidence[:review_requests].first).to include(status: reset ? "pending" : "approved", effective_response_id: nil, generation: reset ? 2 : 1)
+      expect(evidence[:review_sequence]).to eq(first.decision_sequence + 1)
+      expect(responder.value).to eq("review_version_changed")
+      expect(task.reload.review_responses.pluck(:id)).to eq([ first.id ])
+    ensure
+      release << true if release
+      [ writer, reader, responder ].compact.each { |thread| thread.kill if thread.alive? }
     end
-    Timeout.timeout(10) { 2.times { attempting.pop } }
-    expect(reader).to be_alive
-    expect(responder).to be_alive
-    release << true
-    [ writer, reader, responder ].each { |thread| expect(thread.join(20)).to be_present }
-    evidence = reader.value
-    expect(evidence[:version]).to include(revision: 2, content_markdown: "After")
-    expect(evidence[:review_requests].first).to include(status: "pending", effective_response_id: nil, generation: 2)
-    expect(evidence[:review_sequence]).to eq(first.decision_sequence + 1)
-    expect(responder.value).to eq("review_version_changed")
-    expect(task.reload.review_responses.pluck(:id)).to eq([ first.id ])
-  ensure
-    release << true if release
-    [ writer, reader, responder ].compact.each { |thread| thread.kill if thread.alive? }
   end
 
   it "serializes two same-time decisions with unique increasing server sequences" do
diff --git a/spec/services/coplan/versioned_reviews_spec.rb b/spec/services/coplan/versioned_reviews_spec.rb
index 6ba2785b..a199fcb8 100644
--- a/spec/services/coplan/versioned_reviews_spec.rb
+++ b/spec/services/coplan/versioned_reviews_spec.rb
@@ -118,4 +118,94 @@ def replace(content)
     expect(evidence[:version][:content_markdown]).to eq(first.plan_version.content_markdown)
     expect(task.reload.effective_response).to eq(first)
   end
+
+  context "when automatic resets are off" do
+    before { plan.update!(reset_reviews_on_change: false) }
+
+    [ :replace, :draft, :checkbox, :session ].each do |writer|
+      it "preserves completed review lifecycle, not current-version evidence, after #{writer}" do
+        first = decide
+        sequence = plan.reload.review_sequence
+        case writer
+        when :replace then replace("New source")
+        when :draft
+          CoPlan::Plans::SaveHumanDraft.call(plan: plan, content: "A human draft", base_revision: 1, actor: plan.created_by_user)
+        when :checkbox
+          CoPlan::Plans::ToggleCheckbox.call(plan: plan, old_text: "- [ ] Ship", new_text: "- [x] Ship", base_revision: 1, actor_id: plan.created_by_user_id)
+        when :session
+          session = CoPlan::EditSession.create!(plan: plan, actor_type: "human", actor_id: plan.created_by_user_id,
+            base_revision: 1, status: "open", expires_at: 1.hour.from_now,
+            draft_content: "Revised by session", operations_json: [ { "op" => "replace_exact", "old_text" => "Ship", "new_text" => "Ship" } ])
+          CoPlan::Plans::CommitSession.call(session: session)
+        end
+        expect(plan.reload.review_sequence).to eq(sequence + 1)
+        expect(task.reload).to have_attributes(status: "approved", generation: 1, recorded_response: first, review_status: "approved")
+        expect(task).not_to be_pending
+        expect(task.effective_response).to be_nil
+        evidence = CoPlan::Reviews::Evidence.call(plan: plan)
+        expect(evidence[:reset_reviews_on_change]).to be(false)
+        expect(evidence[:review_requests].first).to include(review_status: "approved", effective_status: "pending",
+          recorded_response_id: first.id, effective_human_decision: nil, effective_response_id: nil)
+      end
+    end
+
+    it "preserves objections and agent attribution without inventing human evidence" do
+      response = decide(decision: "changes_requested", note: "Clarify this", api_token: create(:api_token, user: reviewer))
+      replace("New source")
+      expect(task.reload.review_status).to eq("changes_requested")
+      expect(task.recorded_response).to eq(response)
+      expect(task.recorded_response.actor_type).to eq("local_agent")
+      expect(task.effective_human_decision).to be_nil
+    end
+
+    it "keeps no-ops completed and never treats returned bytes or old retries as current approval" do
+      first = decide
+      original = plan.current_content
+      expect(replace(original)[:no_op]).to be(true)
+      expect(task.reload.effective_response).to eq(first)
+      replace("B")
+      replace(original)
+      [ { idempotency_key: first.id }, {} ].each do |attributes|
+        retry_response = CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 1, decision: "approved", **attributes)
+        expect(retry_response).to eq(first)
+      end
+      expect(task.reload.recorded_response).to eq(first)
+      expect(task.effective_response).to be_nil
+      expect(decide.plan_version.revision).to eq(3)
+      expect(task.reload.effective_human_decision).to eq("approved")
+    end
+
+    it "applies enabling to the next edit and never resurrects a dismissed decision when disabled" do
+      first = decide
+      replace("B")
+      plan.update!(reset_reviews_on_change: true)
+      expect(task.reload.recorded_response).to eq(first)
+      replace("C")
+      expect(task.reload).to be_pending
+      generation = task.generation
+      plan.update!(reset_reviews_on_change: false)
+      expect(task.reload.recorded_response).to be_nil
+      replace("D")
+      expect(task.reload).to be_pending
+      expect(task.generation).to eq(generation)
+      expect {
+        CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 3, generation: generation, decision: "approved", idempotency_key: SecureRandom.uuid)
+      }.to raise_error(CoPlan::Reviews::Respond::Conflict)
+      expect(decide.plan_version.revision).to eq(4)
+    end
+
+    it "preserves withdrawal and explicit re-request semantics across edits and retries" do
+      first = decide
+      CoPlan::Reviews::Withdraw.call(request: task, actor: plan.created_by_user)
+      replace("B")
+      expect(task.reload.review_status).to eq("withdrawn")
+      CoPlan::Reviews::Request.call(plan: plan, reviewer: reviewer, actor: plan.created_by_user)
+      [ { idempotency_key: first.id }, {} ].each do |attributes|
+        CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 1, decision: "approved", **attributes)
+      end
+      expect(task.reload).to be_pending
+      expect(task.recorded_response).to be_nil
+      expect(decide.plan_version.revision).to eq(2)
+    end
+  end
 end
diff --git a/spec/system/plan_reviews_spec.rb b/spec/system/plan_reviews_spec.rb
index 3a397417..a743500f 100644
--- a/spec/system/plan_reviews_spec.rb
+++ b/spec/system/plan_reviews_spec.rb
@@ -40,6 +40,162 @@ def lose_next_review_result
 
   before { sign_in_browser(reviewer, open_sections: !RSpec.current_example.metadata[:collapsed_support]) }
 
+  def open_review_settings
+    expect(page).to have_no_css("html[aria-busy='true']")
+    expand_plan_section("footnote-approvals")
+    within("#footnote-approvals") { click_button "Manage reviewers" }
+    expect(page).to have_css(".review-management[open]")
+  end
+
+  [ "light", "dark" ].each do |theme|
+    it "persists the default-on reset policy from the reviewer dialog in #{theme} theme", :review_reset_policy do
+      sign_in_browser(author)
+      page.execute_script("document.documentElement.dataset.theme = arguments[0]", theme)
+      open_review_settings
+      within(".review-management[open]") do
+        expect(page).to have_checked_field("Reset approvals when content changes")
+        uncheck "Reset approvals when content changes"
+        expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+      end
+      expect(page).to have_css(".review-reset-policy__status[data-state='saved']")
+      expect(plan.reload.reset_reviews_on_change).to be(false)
+      visit plan_page_path(plan)
+      page.execute_script("document.documentElement.dataset.theme = arguments[0]", theme)
+      open_review_settings
+      within(".review-management[open]") do
+        expect(page).to have_unchecked_field("Reset approvals when content changes")
+        check "Reset approvals when content changes"
+        expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+      end
+      expect(plan.reload.reset_reviews_on_change).to be(true)
+      page.save_screenshot(Rails.root.join("tmp/review-preview/reset-policy-#{theme}.png"))
+    end
+  end
+
+  it "keeps reviews completed after edits when off, then resets after the next edit when enabled", :review_reset_policy do
+    sign_in_browser(author)
+    open_review_settings
+    within(".review-management[open]") do
+      uncheck "Reset approvals when content changes"
+      expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+    end
+    sign_in_browser(reviewer)
+    within(".review-tray") { click_button "Approve", exact: true }
+    within(".review-confirmation") { click_button "Approve v1", exact: true }
+    expect(page).to have_css(".review-tray", text: "You approved v1")
+    CoPlan::Plans::ReplaceContent.call(plan: plan, new_content: "# Second version", base_revision: 1, actor_type: "human", actor_id: author.id)
+    visit plan_page_path(plan)
+    expand_plan_section("footnote-approvals")
+    expect(page).to have_css(".review-tray", text: "You approved v1")
+    expect(page).to have_css(".review-tray", text: "no new review required")
+    expect(page).to have_css(".review-person", text: "Content changed since review")
+    expect(page).to have_no_css(".review-tray", text: "Your review is requested")
+    expect(task.reload.effective_human_decision).to be_nil
+    [ "light", "dark" ].each do |theme|
+      page.execute_script("document.documentElement.dataset.theme = arguments[0]", theme)
+      page.save_screenshot(Rails.root.join("tmp/review-preview/retained-review-#{theme}.png"))
+    end
+    sign_in_browser(author)
+    open_review_settings
+    within(".review-management[open]") do
+      check "Reset approvals when content changes"
+      expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+    end
+    expect(task.reload.review_status).to eq("approved")
+    CoPlan::Plans::ReplaceContent.call(plan: plan, new_content: "# Third version", base_revision: 2, actor_type: "human", actor_id: author.id)
+    visit plan_page_path(plan)
+    expand_plan_section("footnote-approvals")
+    expect(page).to have_css(".review-person__meta", text: "Content changed; review again")
+    expect(task.reload).to be_pending
+  end
+
+  it "autosaves the latest checkbox choice without save text or blocking more clicks", :review_reset_policy do
+    sign_in_browser(author)
+    open_review_settings
+    page.execute_script(<<~JS)
+      const originalFetch = window.fetch.bind(window)
+      window.policyWrites = []
+      window.fetch = async (url, options) => {
+        if (options?.method === 'PATCH' && String(url).endsWith('/settings')) {
+          window.policyWrites.push(JSON.parse(options.body).review_settings.reset_reviews_on_change)
+          document.querySelector("[data-review-reset-policy]").dataset.firstPolicyWrite = "true"
+          const result = await originalFetch(url, options)
+          await new Promise(resolve => setTimeout(resolve, 400))
+          return result
+        }
+        return originalFetch(url, options)
+      }
+    JS
+    within(".review-management[open]") do
+      page.execute_script('const input = document.querySelector("[data-review-reset-policy]"); input.click(); input.click()')
+      expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+      expect(page.evaluate_script("window.policyWrites")).to eq([])
+      uncheck "Reset approvals when content changes"
+      expect(page).to have_css("[data-review-reset-policy][aria-busy='true']")
+      expect(page).to have_no_text("Saving…")
+      expect(page).to have_no_text("Saved")
+      # Wait until the first request is in flight, then change our mind.
+      expect(page).to have_selector("[data-review-reset-policy][data-saved-value='true']")
+      expect(page).to have_css("[data-review-reset-policy][data-first-policy-write='true']")
+      check "Reset approvals when content changes"
+      expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+      expect(page).to have_checked_field("Reset approvals when content changes", disabled: false)
+    end
+    expect(plan.reload.reset_reviews_on_change).to be(true)
+    expect(page.evaluate_script("window.policyWrites")).to eq([ false, true ])
+  end
+
+  it "reconciles a lost save response with the persisted checkbox value", :review_reset_policy do
+    sign_in_browser(author)
+    open_review_settings
+    page.execute_script(<<~JS)
+      const originalFetch = window.fetch.bind(window)
+      let loseResult = true
+      window.fetch = async (url, options) => {
+        const result = await originalFetch(url, options)
+        if (loseResult && options?.method === 'PATCH' && String(url).endsWith('/settings')) {
+          loseResult = false
+          throw new TypeError('Lost saved result')
+        }
+        return result
+      }
+    JS
+    within(".review-management[open]") do
+      uncheck "Reset approvals when content changes"
+      expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+      expect(page).to have_unchecked_field("Reset approvals when content changes")
+    end
+    expect(plan.reload.reset_reviews_on_change).to be(false)
+    visit plan_page_path(plan)
+    open_review_settings
+    expect(page).to have_unchecked_field("Reset approvals when content changes")
+  end
+
+  it "restores the saved reset preference after a rejected settings update", :review_reset_policy do
+    sign_in_browser(author)
+    open_review_settings
+    page.execute_script(<<~JS)
+      const originalFetch = window.fetch.bind(window)
+      let reject = true
+      window.fetch = (url, options) => {
+        if (reject && options?.method === 'PATCH' && String(url).endsWith('/settings')) {
+          reject = false
+          return Promise.resolve(new Response(JSON.stringify({error: 'Unable to save settings'}), {status: 422, headers: {'Content-Type': 'application/json'}}))
+        }
+        return originalFetch(url, options)
+      }
+    JS
+    within(".review-management[open]") do
+      uncheck "Reset approvals when content changes"
+      expect(page).to have_text("Unable to save settings")
+      expect(page).to have_checked_field("Reset approvals when content changes", disabled: false)
+      expect(plan.reload.reset_reviews_on_change).to be(true)
+      uncheck "Reset approvals when content changes"
+      expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+    end
+    expect(plan.reload.reset_reviews_on_change).to be(false)
+  end
+
   it "dismisses an approval after an edit, preserves its snapshot and accepts a fresh review", :version_parity do
     within(".review-tray") { click_button "Approve", exact: true }
     within(".review-confirmation") do

From 77e3f3ea44ad9798a0b51f6e066c71af3c8b1f44 Mon Sep 17 00:00:00 2001
From: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
Date: Thu, 29 Oct 2026 15:33:18 -0400
Subject: [PATCH 08/18] Fix approval retry and reset update races

Signed-off-by: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
---
 .../coplan/review_tray_controller.js          |  86 ++++++++----
 .../services/coplan/plans/advance_version.rb  |   5 +-
 engine/app/services/coplan/reviews/changed.rb |   9 +-
 .../services/coplan/versioned_reviews_spec.rb |  17 +++
 spec/system/plan_reviews_spec.rb              | 129 ++++++++++++++++++
 5 files changed, 213 insertions(+), 33 deletions(-)

diff --git a/engine/app/javascript/controllers/coplan/review_tray_controller.js b/engine/app/javascript/controllers/coplan/review_tray_controller.js
index c3f75265..612c3ae7 100644
--- a/engine/app/javascript/controllers/coplan/review_tray_controller.js
+++ b/engine/app/javascript/controllers/coplan/review_tray_controller.js
@@ -228,6 +228,7 @@ export default class extends Controller {
   async refresh() {
     const sequence = ++this.refreshSequence
     const policyBusy = this.policySaving || this.policySaveTimer
+    const policyGeneration = this.policyInputGeneration
     try {
       const response = await fetch(this.urlValue, { credentials: "same-origin", headers: { Accept: "text/html" } })
       if (!response.ok) return
@@ -236,9 +237,13 @@ export default class extends Controller {
       this.element.dataset.reviewGeneration = incoming.getElementById("plan-review-controls")?.dataset.reviewGeneration || ""
       const policy = this.element.querySelector("[data-review-reset-policy]")
       const incomingPolicy = incoming.querySelector("[data-review-reset-policy]")
-      if (policy && incomingPolicy && !policyBusy && !this.policySaving && !this.policySaveTimer) {
-        policy.checked = incomingPolicy.checked
-        policy.dataset.savedValue = String(incomingPolicy.checked)
+      if (policy && incomingPolicy) {
+        if (!policyBusy && !this.policySaving && !this.policySaveTimer && policyGeneration === this.policyInputGeneration) {
+          if (policy.checked !== incomingPolicy.checked) this.clearPolicyIcon()
+          policy.checked = incomingPolicy.checked
+          policy.dataset.savedValue = String(incomingPolicy.checked)
+          this.policyRefreshPending = false
+        } else this.policyRefreshPending = true
       }
       const tray = incoming.querySelector(".review-tray")
       const existingTray = this.element.querySelector(".review-tray")
@@ -282,16 +287,15 @@ export default class extends Controller {
       if (navCount) navCount.textContent = Number(incoming.getElementById("plan-review-controls")?.dataset.reviewRecordCount) || ""
       if (this.hasChangeButtonTarget) this.changeButtonTarget.setAttribute("aria-expanded", String(!this.discussionTarget.hidden))
       this.syncFeedbackLinks()
+      if (this.policyRefreshPending && !this.policySaving && !this.policySaveTimer) this.refresh()
     } catch { /* The task and draft remain usable; the next event retries. */ }
   }
 
   changeResetPolicy(event) {
     const input = event.currentTarget
     input.setAttribute("aria-busy", "true")
-    this.refreshSequence++
-    this.policyIconTarget.setAttribute("aria-hidden", "true")
-    clearTimeout(this.policyIconTimer)
-    this.policyIconTarget.dataset.state = ""
+    this.policyInputGeneration = (this.policyInputGeneration || 0) + 1
+    this.clearPolicyIcon()
     clearTimeout(this.policySaveTimer)
     this.policySaveTimer = setTimeout(() => {
       this.policySaveTimer = null
@@ -303,40 +307,70 @@ export default class extends Controller {
     if (this.policySaving) return
     const previous = input.dataset.savedValue === "true"
     const enabled = input.checked
-    if (previous === enabled) { input.setAttribute("aria-busy", "false"); return }
+    const generation = this.policyInputGeneration
+    if (previous === enabled) {
+      input.setAttribute("aria-busy", "false")
+      if (this.policyRefreshPending) await this.refresh()
+      return
+    }
     this.policySaving = true
     this.managementErrorTarget.textContent = ""
+    let confirmed = false
     try {
-      await this.write(this.settingsUrlValue, "PATCH", { review_settings: { reset_reviews_on_change: enabled } })
+      await this.withPolicyDeadline(signal => this.write(this.settingsUrlValue, "PATCH", { review_settings: { reset_reviews_on_change: enabled } }, signal))
       input.dataset.savedValue = String(enabled)
-      if (input.checked === enabled) {
-        this.policyIconTarget.dataset.state = "saved"
-        this.policyIconTarget.setAttribute("aria-hidden", "false")
-        this.policyIconTimer = setTimeout(() => {
-          this.policyIconTarget.dataset.state = ""
-          this.policyIconTarget.setAttribute("aria-hidden", "true")
-        }, 1500)
-      }
+      confirmed = true
     } catch (error) {
       // A lost HTTP result may already have saved. Read back before restoring
       // the checkbox, while preserving clicks made during that request.
       let persisted = previous
       try {
-        const response = await fetch(this.urlValue, { credentials: "same-origin", headers: { Accept: "text/html" } })
-        const policy = new DOMParser().parseFromString(await response.text(), "text/html").querySelector("[data-review-reset-policy]")
-        if (response.ok && policy) persisted = policy.checked
+        persisted = await this.withPolicyDeadline(async signal => {
+          const response = await fetch(this.urlValue, { credentials: "same-origin", headers: { Accept: "text/html" }, signal })
+          const policy = new DOMParser().parseFromString(await response.text(), "text/html").querySelector("[data-review-reset-policy]")
+          if (!response.ok || !policy) throw error
+          return policy.checked
+        })
+        confirmed = persisted === enabled
       } catch { /* Keep the last confirmed value and show the error. */ }
       input.dataset.savedValue = String(persisted)
-      if (input.checked === enabled) input.checked = persisted
-      this.managementErrorTarget.textContent = persisted === enabled ? "" : error.message
+      if (generation === this.policyInputGeneration) input.checked = persisted
+      this.managementErrorTarget.textContent = confirmed ? "" : error.message
     } finally {
       this.policySaving = false
       // Serialize saves so a slow older request cannot overwrite a newer click.
       if (input.checked !== (input.dataset.savedValue === "true")) this.saveResetPolicy(input)
-      else input.setAttribute("aria-busy", "false")
+      else {
+        input.setAttribute("aria-busy", "false")
+        if (this.policyRefreshPending) await this.refresh()
+        if (confirmed && !this.policySaving && !this.policySaveTimer && !this.policyRefreshPending && input.checked === enabled) {
+          this.policyIconTarget.dataset.state = "saved"
+          this.policyIconTarget.setAttribute("aria-hidden", "false")
+          this.policyIconTimer = setTimeout(() => this.clearPolicyIcon(), 1500)
+        }
+      }
     }
   }
 
+  clearPolicyIcon() {
+    clearTimeout(this.policyIconTimer)
+    this.policyIconTarget.dataset.state = ""
+    this.policyIconTarget.setAttribute("aria-hidden", "true")
+  }
+
+  async withPolicyDeadline(action) {
+    const controller = new AbortController()
+    let timer
+    try {
+      return await Promise.race([action(controller.signal), new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          controller.abort()
+          reject(new Error("Couldn't confirm the setting. Please try again."))
+        }, 10000)
+      })])
+    } finally { clearTimeout(timer) }
+  }
+
   async assign(event) {
     event.preventDefault()
     if (!this.reviewerIdTarget.value) { this.assignmentErrorTarget.textContent = "Choose a person from the results first."; return }
@@ -494,10 +528,10 @@ export default class extends Controller {
 
   csrfToken() { return document.querySelector('meta[name="csrf-token"]')?.content || "" }
 
-  async write(url, method, body) {
+  async write(url, method, body, signal) {
     let response
     try {
-      response = await fetch(url, { method, headers: { "X-CSRF-Token": this.csrfToken(), "Content-Type": "application/json", Accept: "application/json" }, credentials: "same-origin", body: body ? JSON.stringify(body) : undefined })
+      response = await fetch(url, { method, headers: { "X-CSRF-Token": this.csrfToken(), "Content-Type": "application/json", Accept: "application/json" }, credentials: "same-origin", body: body ? JSON.stringify(body) : undefined, signal })
     } catch {
       throw new Error("Couldn't reach CoPlan. Your draft is still here. Check that the server is running and try again.")
     }
@@ -508,7 +542,7 @@ export default class extends Controller {
       // A definite rejection did not record this intent. Refresh the cycle
       // so closing and deliberately reopening the dialog can start a new one.
       // Network failures and lost results keep their original key/generation.
-      if (String(url).endsWith("/respond") && response.status >= 400 && response.status < 500) {
+      if (String(url).endsWith("/respond") && [409, 422].includes(response.status)) {
         this.responseIntents = {}
         await this.refresh()
       }
diff --git a/engine/app/services/coplan/plans/advance_version.rb b/engine/app/services/coplan/plans/advance_version.rb
index e81b7e6a..f4584494 100644
--- a/engine/app/services/coplan/plans/advance_version.rb
+++ b/engine/app/services/coplan/plans/advance_version.rb
@@ -17,14 +17,13 @@ def self.call(plan:, version:)
         # No new review notifications for each edit, and no reset broadcast
         # for a transaction that rolls back.
         ActiveRecord.after_all_transactions_commit do
-          if requests.empty?
-            Broadcaster.custom_action_to(plan, action: "coplan-review-changed", target: "plan-review-controls", html: "")
-          end
           requests.each do |request|
             Reviews::Changed.call(request: request, event_type: "review.requested",
+              actor_token_id: version.api_token_id, broadcast_controls: false,
               payload: { "action" => "content_changed", "revision" => version.revision,
                          "generation" => request.generation })
           end
+          Broadcaster.custom_action_to(plan, action: "coplan-review-changed", target: "plan-review-controls", html: "")
         end
         version
       end
diff --git a/engine/app/services/coplan/reviews/changed.rb b/engine/app/services/coplan/reviews/changed.rb
index 14d76fe7..87f893c2 100644
--- a/engine/app/services/coplan/reviews/changed.rb
+++ b/engine/app/services/coplan/reviews/changed.rb
@@ -1,12 +1,13 @@
 module CoPlan
   module Reviews
     class Changed
-      def self.call(request:, event_type:, actor_token_id: nil, payload: {})
-        new(request:, event_type:, actor_token_id:, payload:).call
+      def self.call(request:, event_type:, actor_token_id: nil, payload: {}, broadcast_controls: true)
+        new(request:, event_type:, actor_token_id:, payload:, broadcast_controls:).call
       end
 
-      def initialize(request:, event_type:, actor_token_id:, payload:)
+      def initialize(request:, event_type:, actor_token_id:, payload:, broadcast_controls:)
         @request, @event_type, @actor_token_id, @payload = request, event_type, actor_token_id, payload
+        @broadcast_controls = broadcast_controls
       end
 
       def call
@@ -16,7 +17,7 @@ def call
         Notifications::BroadcastBadges.call(user_ids: [ request.reviewer_id, request.plan.created_by_user_id ])
         # No viewer-relative HTML or CSRF tokens on a shared stream. Each
         # open tab fetches its own controls, preserving its current draft.
-        Broadcaster.custom_action_to(request.plan, action: "coplan-review-changed", target: "plan-review-controls", html: "")
+        Broadcaster.custom_action_to(request.plan, action: "coplan-review-changed", target: "plan-review-controls", html: "") if @broadcast_controls
       end
     end
   end
diff --git a/spec/services/coplan/versioned_reviews_spec.rb b/spec/services/coplan/versioned_reviews_spec.rb
index a199fcb8..3c7579d4 100644
--- a/spec/services/coplan/versioned_reviews_spec.rb
+++ b/spec/services/coplan/versioned_reviews_spec.rb
@@ -46,6 +46,23 @@ def replace(content)
     expect(task.reload.effective_response).to be_nil
   end
 
+  it "publishes one controls invalidation per edit and excludes the editing agent from reset events" do
+    task
+    CoPlan::Reviews::Request.call(plan: plan, reviewer: create(:coplan_user), actor: plan.created_by_user)
+    writer = create(:api_token, user: plan.created_by_user)
+    observer = create(:api_token, user: reviewer)
+    [ writer, observer ].each do |token|
+      CoPlan::AgentSession.create!(plan: plan, api_token: token, state: "watching", agent_name: "Watcher")
+    end
+    allow(CoPlan::Broadcaster).to receive(:custom_action_to)
+    CoPlan::Plans::ReplaceContent.call(plan: plan, new_content: "Edited by agent", base_revision: 1,
+      actor_type: "local_agent", actor_id: writer.user_id, api_token_id: writer.id)
+    expect(CoPlan::AgentEvent.where(api_token: writer, event_type: "review.requested")).to be_empty
+    expect(CoPlan::AgentEvent.where(api_token: observer, event_type: "review.requested").count).to eq(2)
+    expect(CoPlan::Broadcaster).to have_received(:custom_action_to).with(plan,
+      action: "coplan-review-changed", target: "plan-review-controls", html: "").once
+  end
+
   it "dismisses on human drafts and checkbox edits" do
     decide
     CoPlan::Plans::ToggleCheckbox.call(plan: plan, old_text: "- [ ] Ship", new_text: "- [x] Ship", base_revision: 1, actor_id: plan.created_by_user_id)
diff --git a/spec/system/plan_reviews_spec.rb b/spec/system/plan_reviews_spec.rb
index a743500f..c2f47d99 100644
--- a/spec/system/plan_reviews_spec.rb
+++ b/spec/system/plan_reviews_spec.rb
@@ -196,6 +196,123 @@ def open_review_settings
     expect(plan.reload.reset_reviews_on_change).to be(false)
   end
 
+  it "replays another tab's policy invalidation after a delayed save response", :review_reset_policy do
+    sign_in_browser(author)
+    open_review_settings
+    page.execute_script(<<~JS)
+      const originalFetch = window.fetch.bind(window)
+      window.fetch = async (url, options) => {
+        const result = await originalFetch(url, options)
+        if (options?.method === 'PATCH' && String(url).endsWith('/settings')) {
+          document.querySelector('[data-review-reset-policy]').dataset.committed = 'true'
+          await new Promise(resolve => { window.releasePolicy = resolve })
+        }
+        return result
+      }
+    JS
+    uncheck "Reset approvals when content changes"
+    expect(page).to have_css("[data-review-reset-policy][data-committed='true']")
+    # Another author tab commits the opposite setting before our response arrives.
+    plan.reload.update!(reset_reviews_on_change: true)
+    page.evaluate_async_script(<<~JS)
+      const done = arguments[arguments.length - 1]
+      const root = document.getElementById('plan-review-controls')
+      window.Stimulus.getControllerForElementAndIdentifier(root, 'coplan--review-tray').refresh().then(done)
+    JS
+    page.execute_script("window.releasePolicy()")
+    expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+    expect(page).to have_checked_field("Reset approvals when content changes")
+    expect(plan.reload.reset_reviews_on_change).to be(true)
+    expect(page).to have_no_css(".review-reset-policy__status[data-state='saved']")
+  end
+
+  it "keeps a newer off choice when the first off request fails", :review_reset_policy do
+    sign_in_browser(author)
+    open_review_settings
+    page.execute_script(<<~JS)
+      const originalFetch = window.fetch.bind(window)
+      window.policyWrites = []
+      window.fetch = async (url, options) => {
+        if (options?.method === 'PATCH' && String(url).endsWith('/settings')) {
+          window.policyWrites.push(JSON.parse(options.body).review_settings.reset_reviews_on_change)
+          if (window.policyWrites.length === 1) {
+            document.querySelector('[data-review-reset-policy]').dataset.inFlight = 'true'
+            return await new Promise(resolve => { window.rejectPolicy = () => resolve(new Response(JSON.stringify({error: 'Rejected'}), {status: 422})) })
+          }
+        }
+        return originalFetch(url, options)
+      }
+    JS
+    uncheck "Reset approvals when content changes"
+    expect(page).to have_css("[data-review-reset-policy][data-in-flight='true']")
+    page.execute_script(<<~JS)
+      const input = document.querySelector('[data-review-reset-policy]')
+      input.click(); input.click(); window.rejectPolicy()
+    JS
+    expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+    expect(page).to have_unchecked_field("Reset approvals when content changes")
+    expect(plan.reload.reset_reviews_on_change).to be(false)
+    expect(page.evaluate_script("window.policyWrites")).to eq([ false, false ])
+  end
+
+  it "keeps a review refresh when policy toggles cancel out", :review_reset_policy do
+    sign_in_browser(author)
+    open_review_settings
+    allow(CoPlan::Broadcaster).to receive(:custom_action_to)
+    CoPlan::Reviews::Respond.call(request: task, actor: reviewer, revision: 1, generation: task.generation, decision: "approved")
+    page.execute_script(<<~JS)
+      const root = document.getElementById('plan-review-controls')
+      const controller = window.Stimulus.getControllerForElementAndIdentifier(root, 'coplan--review-tray')
+      const originalFetch = window.fetch.bind(window)
+      let hold = true
+      window.fetch = async (url, options) => {
+        const result = await originalFetch(url, options)
+        if (hold && url === controller.urlValue && !options?.method) {
+          hold = false
+          root.dataset.refreshHeld = 'true'
+          await new Promise(resolve => { window.releaseControls = resolve })
+        }
+        return result
+      }
+      controller.refresh()
+    JS
+    expect(page).to have_css("[data-refresh-held='true']")
+    page.execute_script("const input = document.querySelector('[data-review-reset-policy]'); input.click(); input.click(); window.releaseControls()")
+    expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+    expect(page).to have_css(".review-person", text: "Approved")
+    expect(plan.reload.reset_reviews_on_change).to be(true)
+  end
+
+  [ "write body", "readback" ].each do |stall|
+    it "releases autosave after a stalled #{stall} and allows retry", :review_reset_policy do
+      sign_in_browser(author)
+      open_review_settings
+      page.execute_script(<<~JS, stall)
+        const stall = arguments[0]
+        const originalFetch = window.fetch.bind(window)
+        const originalTimeout = window.setTimeout.bind(window)
+        window.setTimeout = (action, delay, ...args) => originalTimeout(action, delay === 10000 ? 100 : delay, ...args)
+        window.fetch = async (url, options) => {
+          if (options?.method === 'PATCH' && String(url).endsWith('/settings')) {
+            if (stall === 'write body') return {ok: true, status: 200, json: () => new Promise(() => {})}
+            throw new TypeError('Lost response')
+          }
+          if (stall === 'readback' && String(url).endsWith('/review_requests')) return new Promise(() => {})
+          return originalFetch(url, options)
+        }
+        window.restorePolicyNetwork = () => { window.fetch = originalFetch; window.setTimeout = originalTimeout }
+      JS
+      uncheck "Reset approvals when content changes"
+      expect(page).to have_text(/Couldn't confirm|Couldn't reach/)
+      expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+      expect(page).to have_checked_field("Reset approvals when content changes", disabled: false)
+      page.execute_script("window.restorePolicyNetwork()")
+      uncheck "Reset approvals when content changes"
+      expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+      expect(plan.reload.reset_reviews_on_change).to be(false)
+    end
+  end
+
   it "dismisses an approval after an edit, preserves its snapshot and accepts a fresh review", :version_parity do
     within(".review-tray") { click_button "Approve", exact: true }
     within(".review-confirmation") do
@@ -239,6 +356,18 @@ def open_review_settings
     expect(task.review_responses).to be_empty
     click_button "Close approval", enable_aria_label: true
     within(".review-tray") { click_button "Approve", exact: true }
+    page.execute_script(<<~JS)
+      const originalFetch = window.fetch.bind(window)
+      window.fetch = (url, options) => {
+        if (options?.method === 'POST' && String(url).endsWith('/respond')) {
+          window.fetch = originalFetch
+          return Promise.resolve(new Response(JSON.stringify({error: 'Sign in again', code: 'authentication_required', sign_in_path: '/sign_in'}), {status: 401}))
+        }
+        return originalFetch(url, options)
+      }
+    JS
+    within(".review-confirmation") { click_button "Approve v1", exact: true }
+    expect(page).to have_link("Sign in in a new tab")
     within(".review-confirmation") { click_button "Approve v1", exact: true }
     expect(page).to have_css(".review-tray", text: "You approved v1")
     expect(task.reload.effective_response.request_generation).to eq(2)

From e936258e576dbc3273ff8cac129e77877a058374 Mon Sep 17 00:00:00 2001
From: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
Date: Thu, 29 Oct 2026 15:37:50 -0400
Subject: [PATCH 09/18] Fence delayed reset saves with the review sequence

Signed-off-by: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
---
 docs/REVIEWS.md                               |  2 +-
 .../coplan/review_requests_controller.rb      | 11 +++--
 .../coplan/review_tray_controller.js          | 20 ++++++--
 .../views/coplan/reviews/_management.html.erb |  2 +-
 spec/requests/review_requests_spec.rb         | 17 +++++--
 spec/system/plan_reviews_spec.rb              | 46 ++++++++++++++++++-
 6 files changed, 83 insertions(+), 15 deletions(-)

diff --git a/docs/REVIEWS.md b/docs/REVIEWS.md
index bbc9ce7f..c900e375 100644
--- a/docs/REVIEWS.md
+++ b/docs/REVIEWS.md
@@ -14,7 +14,7 @@ All current-version writers use `Plans::AdvanceVersion`: Create, ReplaceContent
 
 An identical normalized ReplaceContent save creates no version and preserves approval. An empty session creates no version. A nonempty session or operations commit creates a new version even if its operations net to identical bytes, and resets reviews when the policy is enabled. Returning A→B→A always produces a distinct version; no older decision becomes exact-current-version evidence. Existing edit leases, human-edit fences and merge guards remain in place.
 
-Editors can toggle **Reset approvals when content changes** in Manage reviewers. The setting applies to future edits for every reviewer. When off, completed approvals and change requests remain completed on their original versions; edits require no fresh review. Pending tasks stay pending, and withdrawn tasks stay withdrawn. Turning resets back on affects the next edit; turning them off never restores an already dismissed decision. Exact-current-version `effective_status`, `effective_response_id` and `effective_human_decision` remain strict regardless of this preference. Policy updates take the same plan row lock and advance `review_sequence` only when changed.
+Editors can toggle **Reset approvals when content changes** in Manage reviewers. The setting applies to future edits for every reviewer. When off, completed approvals and change requests remain completed on their original versions; edits require no fresh review. Pending tasks stay pending, and withdrawn tasks stay withdrawn. Turning resets back on affects the next edit; turning them off never restores an already dismissed decision. Exact-current-version `effective_status`, `effective_response_id` and `effective_human_decision` remain strict regardless of this preference. Policy updates take the same plan row lock and require the displayed `review_sequence`. Every accepted write advances it, including same-value writes that fence older requests with lost results. A stale sequence returns 409; the dialog reads back the setting before retrying the latest choice.
 
 An explicit re-request advances the task generation and clears its effective decision. Creating an already existing request is a retry and leaves its state alone. Withdrawal clears the effective decision and preserves receipts. A fresh response supersedes the previous effective response, including a later agent response. The latest sequenced human response on the current version is exposed separately so consumers can inspect human feedback across request cycles; native CoPlan does not impose an external approval or objection policy.
 
diff --git a/engine/app/controllers/coplan/review_requests_controller.rb b/engine/app/controllers/coplan/review_requests_controller.rb
index 47c2eafe..2732cf9a 100644
--- a/engine/app/controllers/coplan/review_requests_controller.rb
+++ b/engine/app/controllers/coplan/review_requests_controller.rb
@@ -17,15 +17,18 @@ def suggestions
 
     def settings
       authorize!(@plan, :update?)
-      attributes = params.expect(review_settings: [ :reset_reviews_on_change ])
+      attributes = params.expect(review_settings: [ :reset_reviews_on_change, :review_sequence ])
       enabled = ActiveModel::Type::Boolean.new.cast(attributes.fetch(:reset_reviews_on_change))
       @plan.with_lock do
-        if @plan.reset_reviews_on_change != enabled
-          @plan.update!(reset_reviews_on_change: enabled, review_sequence: @plan.review_sequence + 1)
+        unless attributes.fetch(:review_sequence).to_s == @plan.review_sequence.to_s
+          render json: { error: "Review settings changed. Please try again." }, status: :conflict
+          return
         end
+        # Even a same-value write fences an older, indeterminate request.
+        @plan.update!(reset_reviews_on_change: enabled, review_sequence: @plan.review_sequence + 1)
       end
       Broadcaster.custom_action_to(@plan, action: "coplan-review-changed", target: "plan-review-controls", html: "")
-      render json: { reset_reviews_on_change: @plan.reset_reviews_on_change }
+      render json: { reset_reviews_on_change: @plan.reset_reviews_on_change, review_sequence: @plan.review_sequence }
     end
 
     def create
diff --git a/engine/app/javascript/controllers/coplan/review_tray_controller.js b/engine/app/javascript/controllers/coplan/review_tray_controller.js
index 612c3ae7..cc266742 100644
--- a/engine/app/javascript/controllers/coplan/review_tray_controller.js
+++ b/engine/app/javascript/controllers/coplan/review_tray_controller.js
@@ -196,7 +196,9 @@ export default class extends Controller {
       this.confirmIntent("changes_requested", intent)
       // Feedback lives in the ordinary discussion collection.
       const synced = await this.refreshThreads(result.comment_thread_id)
-      this.noticeTarget.textContent = "Changes requested. Your feedback is in the plan’s comments." + (synced ? "" : " Refresh the page to see your comment.")
+      this.noticeTarget.textContent = result.effective === false
+        ? "Your earlier change request was already recorded. Review the current request again."
+        : "Changes requested. Your feedback is in the plan’s comments." + (synced ? "" : " Refresh the page to see your comment.")
       input.value = ""
       this.collapse()
       await this.refresh()
@@ -242,6 +244,7 @@ export default class extends Controller {
           if (policy.checked !== incomingPolicy.checked) this.clearPolicyIcon()
           policy.checked = incomingPolicy.checked
           policy.dataset.savedValue = String(incomingPolicy.checked)
+          policy.dataset.reviewSequence = incomingPolicy.dataset.reviewSequence
           this.policyRefreshPending = false
         } else this.policyRefreshPending = true
       }
@@ -295,6 +298,7 @@ export default class extends Controller {
     const input = event.currentTarget
     input.setAttribute("aria-busy", "true")
     this.policyInputGeneration = (this.policyInputGeneration || 0) + 1
+    this.policyConflictRetries = 0
     this.clearPolicyIcon()
     clearTimeout(this.policySaveTimer)
     this.policySaveTimer = setTimeout(() => {
@@ -308,17 +312,20 @@ export default class extends Controller {
     const previous = input.dataset.savedValue === "true"
     const enabled = input.checked
     const generation = this.policyInputGeneration
-    if (previous === enabled) {
+    if (previous === enabled && !this.policyMustSave) {
       input.setAttribute("aria-busy", "false")
       if (this.policyRefreshPending) await this.refresh()
       return
     }
     this.policySaving = true
+    this.policyMustSave = false
     this.managementErrorTarget.textContent = ""
     let confirmed = false
     try {
-      await this.withPolicyDeadline(signal => this.write(this.settingsUrlValue, "PATCH", { review_settings: { reset_reviews_on_change: enabled } }, signal))
+      const result = await this.withPolicyDeadline(signal => this.write(this.settingsUrlValue, "PATCH", { review_settings: { reset_reviews_on_change: enabled, review_sequence: input.dataset.reviewSequence } }, signal))
       input.dataset.savedValue = String(enabled)
+      input.dataset.reviewSequence = String(result.review_sequence)
+      this.policyConflictRetries = 0
       confirmed = true
     } catch (error) {
       // A lost HTTP result may already have saved. Read back before restoring
@@ -329,17 +336,19 @@ export default class extends Controller {
           const response = await fetch(this.urlValue, { credentials: "same-origin", headers: { Accept: "text/html" }, signal })
           const policy = new DOMParser().parseFromString(await response.text(), "text/html").querySelector("[data-review-reset-policy]")
           if (!response.ok || !policy) throw error
+          input.dataset.reviewSequence = policy.dataset.reviewSequence
           return policy.checked
         })
         confirmed = persisted === enabled
       } catch { /* Keep the last confirmed value and show the error. */ }
       input.dataset.savedValue = String(persisted)
-      if (generation === this.policyInputGeneration) input.checked = persisted
+      if (generation !== this.policyInputGeneration || (error.status === 409 && ++this.policyConflictRetries <= 2)) this.policyMustSave = true
+      else input.checked = persisted
       this.managementErrorTarget.textContent = confirmed ? "" : error.message
     } finally {
       this.policySaving = false
       // Serialize saves so a slow older request cannot overwrite a newer click.
-      if (input.checked !== (input.dataset.savedValue === "true")) this.saveResetPolicy(input)
+      if (this.policyMustSave || input.checked !== (input.dataset.savedValue === "true")) this.saveResetPolicy(input)
       else {
         input.setAttribute("aria-busy", "false")
         if (this.policyRefreshPending) await this.refresh()
@@ -547,6 +556,7 @@ export default class extends Controller {
         await this.refresh()
       }
       const error = new Error(result.error || "Couldn't save. Please try again.")
+      error.status = response.status
       if (result.code === "authentication_required") error.signInPath = result.sign_in_path
       throw error
     }
diff --git a/engine/app/views/coplan/reviews/_management.html.erb b/engine/app/views/coplan/reviews/_management.html.erb
index 791c77f7..95407b39 100644
--- a/engine/app/views/coplan/reviews/_management.html.erb
+++ b/engine/app/views/coplan/reviews/_management.html.erb
@@ -14,7 +14,7 @@
   </div>
   <% if allowed_to?(plan, :update?) %>
     <div class="review-reset-policy">
-      <label class="review-required"><input type="checkbox" <%= "checked" if plan.reset_reviews_on_change %> data-action="change->coplan--review-tray#changeResetPolicy" data-review-reset-policy data-saved-value="<%= plan.reset_reviews_on_change %>"> Reset approvals when content changes <span class="review-reset-policy__status" data-coplan--review-tray-target="policyIcon" role="img" aria-hidden="true" aria-label="Saved" title="Saved">✓</span></label>
+      <label class="review-required"><input type="checkbox" <%= "checked" if plan.reset_reviews_on_change %> data-action="change->coplan--review-tray#changeResetPolicy" data-review-reset-policy data-review-sequence="<%= plan.review_sequence %>" data-saved-value="<%= plan.reset_reviews_on_change %>"> Reset approvals when content changes <span class="review-reset-policy__status" data-coplan--review-tray-target="policyIcon" role="img" aria-hidden="true" aria-label="Saved" title="Saved">✓</span></label>
       <p class="text-sm text-muted">Applies to future edits for all reviewers. When off, completed reviews stay completed.</p>
     </div>
     <div id="review-assignment" class="review-assignment" popover="auto" role="dialog" aria-label="Add reviewer" data-coplan--review-tray-target="assignment" data-action="toggle->coplan--review-tray#assignmentToggled keydown.esc->coplan--review-tray#dismissAssignment">
diff --git a/spec/requests/review_requests_spec.rb b/spec/requests/review_requests_spec.rb
index 8ad4e332..9eee249e 100644
--- a/spec/requests/review_requests_spec.rb
+++ b/spec/requests/review_requests_spec.rb
@@ -11,15 +11,26 @@
     sequence = plan.review_sequence
     sign_in_as(author)
     [ false, false, true ].each_with_index do |enabled, index|
-      patch settings_plan_review_requests_path(plan), params: { review_settings: { reset_reviews_on_change: enabled } }, as: :json
+      patch settings_plan_review_requests_path(plan), params: { review_settings: { reset_reviews_on_change: enabled, review_sequence: plan.review_sequence } }, as: :json
       expect(response).to have_http_status(:ok)
-      expect(response.parsed_body).to eq("reset_reviews_on_change" => enabled)
+      expect(response.parsed_body).to eq("reset_reviews_on_change" => enabled, "review_sequence" => sequence + index + 1)
       expect(plan.reload.reset_reviews_on_change).to eq(enabled)
-      expect(plan.review_sequence).to eq(sequence + (index == 2 ? 2 : 1))
+      expect(plan.review_sequence).to eq(sequence + index + 1)
       expect(CoPlan::Reviews::Evidence.call(plan: plan)[:reset_reviews_on_change]).to eq(enabled)
     end
   end
 
+  it "fences an older policy write even when the newer choice keeps the current value", :review_reset_policy do
+    sign_in_as(author)
+    sequence = plan.review_sequence
+    patch settings_plan_review_requests_path(plan), params: { review_settings: { reset_reviews_on_change: true, review_sequence: sequence } }, as: :json
+    expect(response).to have_http_status(:ok)
+    patch settings_plan_review_requests_path(plan), params: { review_settings: { reset_reviews_on_change: false, review_sequence: sequence } }, as: :json
+    expect(response).to have_http_status(:conflict)
+    expect(plan.reload.reset_reviews_on_change).to be(true)
+    expect(plan.review_sequence).to eq(sequence + 1)
+  end
+
   it "does not let a reviewer change the document's reset policy", :review_reset_policy do
     task
     sign_in_as(reviewer)
diff --git a/spec/system/plan_reviews_spec.rb b/spec/system/plan_reviews_spec.rb
index c2f47d99..c2af1a7f 100644
--- a/spec/system/plan_reviews_spec.rb
+++ b/spec/system/plan_reviews_spec.rb
@@ -255,6 +255,47 @@ def open_review_settings
     expect(page.evaluate_script("window.policyWrites")).to eq([ false, false ])
   end
 
+  it "retries the selected policy after a concurrent review sequence change", :review_reset_policy do
+    sign_in_browser(author)
+    open_review_settings
+    plan.reload.update!(review_sequence: plan.review_sequence + 1)
+    uncheck "Reset approvals when content changes"
+    expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+    expect(page).to have_unchecked_field("Reset approvals when content changes")
+    expect(plan.reload.reset_reviews_on_change).to be(false)
+    expect(page).to have_no_text("Review settings changed. Please try again.")
+  end
+
+  it "fences a lost older write before it can override the latest choice", :review_reset_policy do
+    sign_in_browser(author)
+    open_review_settings
+    page.execute_script(<<~JS)
+      const originalFetch = window.fetch.bind(window)
+      let first = true
+      window.fetch = async (url, options) => {
+        if (first && options?.method === 'PATCH' && String(url).endsWith('/settings')) {
+          first = false
+          document.querySelector('[data-review-reset-policy]').dataset.inFlight = 'true'
+          window.deliverOldPolicy = async () => {
+            const result = await originalFetch(url, options)
+            document.querySelector('[data-review-reset-policy]').dataset.oldStatus = String(result.status)
+          }
+          return await new Promise((_, reject) => { window.losePolicy = () => reject(new TypeError('Lost response')) })
+        }
+        return originalFetch(url, options)
+      }
+    JS
+    uncheck "Reset approvals when content changes"
+    expect(page).to have_css("[data-review-reset-policy][data-in-flight='true']")
+    check "Reset approvals when content changes"
+    page.execute_script("window.losePolicy()")
+    expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+    page.execute_script("window.deliverOldPolicy()")
+    expect(page).to have_css("[data-review-reset-policy][data-old-status='409']")
+    expect(page).to have_checked_field("Reset approvals when content changes")
+    expect(plan.reload.reset_reviews_on_change).to be(true)
+  end
+
   it "keeps a review refresh when policy toggles cancel out", :review_reset_policy do
     sign_in_browser(author)
     open_review_settings
@@ -559,13 +600,16 @@ def open_review_settings
     within(".review-tray__discussion") { click_button "Request changes" }
     expect(page).to have_css(".review-tray__discussion [role='alert']", text: "try again")
     first = task.review_responses.last!
+    CoPlan::Reviews::Request.call(plan: plan, reviewer: reviewer, actor: author)
+    expect(page).to have_css(".review-tray", text: "Your review is requested")
     within(".review-tray__discussion") { click_button "Cancel" }
-    within("#footnote-approvals") { click_button "Change decision", enable_aria_label: true }
     within(".review-tray") { click_button "Request changes" }
     expect(page).to have_field("Public review comment", with: "Keep one copy of this feedback", enable_aria_label: true)
     within(".review-tray__discussion") { click_button "Request changes" }
     expect(page).to have_no_css(".review-tray__discussion", visible: true)
     expect(task.review_responses.pluck(:id)).to eq([ first.id ])
+    expect(task.reload.status).to eq("pending")
+    expect(page).to have_content("Your earlier change request was already recorded. Review the current request again.")
     expect(plan.comment_threads.count).to eq(1)
     expect(plan.notifications.where(reason: "review_response").count).to eq(1)
   end

From afea41d836b1c3f7d94def64678540da70917a6e Mon Sep 17 00:00:00 2001
From: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
Date: Thu, 29 Oct 2026 15:55:41 -0400
Subject: [PATCH 10/18] Recover uncertain reset saves and failed delivery

Signed-off-by: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
---
 docs/REVIEWS.md                               |  2 +
 .../coplan/review_tray_controller.js          | 34 ++++++++++-
 .../jobs/coplan/review_reset_delivery_job.rb  | 16 +++++
 .../services/coplan/plans/advance_version.rb  | 24 ++++++--
 .../coplan/review_reset_delivery_job_spec.rb  | 29 +++++++++
 .../services/coplan/versioned_reviews_spec.rb | 20 +++++++
 spec/system/plan_reviews_spec.rb              | 60 ++++++++++---------
 7 files changed, 150 insertions(+), 35 deletions(-)
 create mode 100644 engine/app/jobs/coplan/review_reset_delivery_job.rb
 create mode 100644 spec/jobs/coplan/review_reset_delivery_job_spec.rb

diff --git a/docs/REVIEWS.md b/docs/REVIEWS.md
index c900e375..a0d6fff4 100644
--- a/docs/REVIEWS.md
+++ b/docs/REVIEWS.md
@@ -12,6 +12,8 @@ The approval covers **Markdown source bytes only**. Title, tags, attachments, li
 
 All current-version writers use `Plans::AdvanceVersion`: Create, ReplaceContent (including SaveHumanDraft/web saves), CommitSession, ToggleCheckbox and the direct operations API. They already hold the plan row lock; CommitSession retains session-before-plan lock order. The version pointer, revision and review sequence always advance together. With `reset_reviews_on_change` enabled (the default), active task resets, generation increments and cleared current pointers commit in that same transaction. Withdrawn tasks and all receipts remain intact. Resets broadcast after commit without sending a review-request notification for every edit.
 
+Reset delivery failures do not change the committed save result or prevent other reviewers' events and the controls invalidation. Failed deliveries use the existing job queue with bounded retries; obsolete request generations are skipped. Delivery is at least once. If queueing also fails, the error is reported for operational recovery; there is no transactional outbox guarantee.
+
 An identical normalized ReplaceContent save creates no version and preserves approval. An empty session creates no version. A nonempty session or operations commit creates a new version even if its operations net to identical bytes, and resets reviews when the policy is enabled. Returning A→B→A always produces a distinct version; no older decision becomes exact-current-version evidence. Existing edit leases, human-edit fences and merge guards remain in place.
 
 Editors can toggle **Reset approvals when content changes** in Manage reviewers. The setting applies to future edits for every reviewer. When off, completed approvals and change requests remain completed on their original versions; edits require no fresh review. Pending tasks stay pending, and withdrawn tasks stay withdrawn. Turning resets back on affects the next edit; turning them off never restores an already dismissed decision. Exact-current-version `effective_status`, `effective_response_id` and `effective_human_decision` remain strict regardless of this preference. Policy updates take the same plan row lock and require the displayed `review_sequence`. Every accepted write advances it, including same-value writes that fence older requests with lost results. A stale sequence returns 409; the dialog reads back the setting before retrying the latest choice.
diff --git a/engine/app/javascript/controllers/coplan/review_tray_controller.js b/engine/app/javascript/controllers/coplan/review_tray_controller.js
index cc266742..2a5eab56 100644
--- a/engine/app/javascript/controllers/coplan/review_tray_controller.js
+++ b/engine/app/javascript/controllers/coplan/review_tray_controller.js
@@ -245,6 +245,13 @@ export default class extends Controller {
           policy.checked = incomingPolicy.checked
           policy.dataset.savedValue = String(incomingPolicy.checked)
           policy.dataset.reviewSequence = incomingPolicy.dataset.reviewSequence
+          if (this.policyUncertainSequence != null && Number(policy.dataset.reviewSequence) > this.policyUncertainSequence) {
+            if (this.policyUnresolved) this.managementErrorTarget.textContent = ""
+            this.policyUncertainSequence = null
+            this.policyUnresolved = false
+            this.policyFenceAttempted = false
+            policy.removeAttribute("aria-invalid")
+          }
           this.policyRefreshPending = false
         } else this.policyRefreshPending = true
       }
@@ -299,6 +306,9 @@ export default class extends Controller {
     input.setAttribute("aria-busy", "true")
     this.policyInputGeneration = (this.policyInputGeneration || 0) + 1
     this.policyConflictRetries = 0
+    this.policyFenceAttempted = false
+    this.policyUnresolved = false
+    input.removeAttribute("aria-invalid")
     this.clearPolicyIcon()
     clearTimeout(this.policySaveTimer)
     this.policySaveTimer = setTimeout(() => {
@@ -312,7 +322,8 @@ export default class extends Controller {
     const previous = input.dataset.savedValue === "true"
     const enabled = input.checked
     const generation = this.policyInputGeneration
-    if (previous === enabled && !this.policyMustSave) {
+    const submittedSequence = Number(input.dataset.reviewSequence)
+    if (previous === enabled && !this.policyMustSave && this.policyUncertainSequence == null) {
       input.setAttribute("aria-busy", "false")
       if (this.policyRefreshPending) await this.refresh()
       return
@@ -326,11 +337,18 @@ export default class extends Controller {
       input.dataset.savedValue = String(enabled)
       input.dataset.reviewSequence = String(result.review_sequence)
       this.policyConflictRetries = 0
+      this.policyUncertainSequence = null
+      this.policyFenceAttempted = false
+      this.policyUnresolved = false
+      input.removeAttribute("aria-invalid")
       confirmed = true
     } catch (error) {
       // A lost HTTP result may already have saved. Read back before restoring
       // the checkbox, while preserving clicks made during that request.
       let persisted = previous
+      if (!error.status || error.status >= 500) {
+        this.policyUncertainSequence = Math.max(this.policyUncertainSequence ?? -1, submittedSequence)
+      }
       try {
         persisted = await this.withPolicyDeadline(async signal => {
           const response = await fetch(this.urlValue, { credentials: "same-origin", headers: { Accept: "text/html" }, signal })
@@ -339,16 +357,26 @@ export default class extends Controller {
           input.dataset.reviewSequence = policy.dataset.reviewSequence
           return policy.checked
         })
-        confirmed = persisted === enabled
       } catch { /* Keep the last confirmed value and show the error. */ }
+      this.policyUnresolved = this.policyUncertainSequence != null && Number(input.dataset.reviewSequence) <= this.policyUncertainSequence
+      confirmed = persisted === enabled && !this.policyUnresolved
+      if (!this.policyUnresolved) this.policyUncertainSequence = null
       input.dataset.savedValue = String(persisted)
       if (generation !== this.policyInputGeneration || (error.status === 409 && ++this.policyConflictRetries <= 2)) this.policyMustSave = true
       else input.checked = persisted
+      if (this.policyUnresolved && !this.policyFenceAttempted) {
+        // Readback alone cannot cancel a PATCH still waiting for the row lock.
+        // Fence it once with the reconciled value, even when that is a no-op.
+        this.policyFenceAttempted = true
+        this.policyMustSave = true
+        this.policyUnresolved = false
+      } else if (this.policyUnresolved) input.setAttribute("aria-invalid", "true")
       this.managementErrorTarget.textContent = confirmed ? "" : error.message
+      if (this.policyUnresolved) this.managementErrorTarget.textContent += " A previous save may still be running. Toggle again to retry."
     } finally {
       this.policySaving = false
       // Serialize saves so a slow older request cannot overwrite a newer click.
-      if (this.policyMustSave || input.checked !== (input.dataset.savedValue === "true")) this.saveResetPolicy(input)
+      if (!this.policyUnresolved && (this.policyMustSave || input.checked !== (input.dataset.savedValue === "true"))) this.saveResetPolicy(input)
       else {
         input.setAttribute("aria-busy", "false")
         if (this.policyRefreshPending) await this.refresh()
diff --git a/engine/app/jobs/coplan/review_reset_delivery_job.rb b/engine/app/jobs/coplan/review_reset_delivery_job.rb
new file mode 100644
index 00000000..fc37678a
--- /dev/null
+++ b/engine/app/jobs/coplan/review_reset_delivery_job.rb
@@ -0,0 +1,16 @@
+module CoPlan
+  # A failed reset delivery is an invalidation and may be delivered again.
+  # Skip it when the request has since been removed, decided or reopened.
+  class ReviewResetDeliveryJob < ApplicationJob
+    retry_on StandardError, wait: :polynomially_longer, attempts: 5
+
+    def perform(request_id:, generation:, revision:, actor_token_id: nil)
+      request = ReviewRequest.find_by(id: request_id)
+      return unless request&.pending? && request.generation == generation
+
+      Reviews::Changed.call(request: request, event_type: "review.requested",
+        actor_token_id: actor_token_id, broadcast_controls: false,
+        payload: { "action" => "content_changed", "revision" => revision, "generation" => generation })
+    end
+  end
+end
diff --git a/engine/app/services/coplan/plans/advance_version.rb b/engine/app/services/coplan/plans/advance_version.rb
index f4584494..f526da5e 100644
--- a/engine/app/services/coplan/plans/advance_version.rb
+++ b/engine/app/services/coplan/plans/advance_version.rb
@@ -18,12 +18,26 @@ def self.call(plan:, version:)
         # for a transaction that rolls back.
         ActiveRecord.after_all_transactions_commit do
           requests.each do |request|
-            Reviews::Changed.call(request: request, event_type: "review.requested",
-              actor_token_id: version.api_token_id, broadcast_controls: false,
-              payload: { "action" => "content_changed", "revision" => version.revision,
-                         "generation" => request.generation })
+            begin
+              Reviews::Changed.call(request: request, event_type: "review.requested",
+                actor_token_id: version.api_token_id, broadcast_controls: false,
+                payload: { "action" => "content_changed", "revision" => version.revision,
+                           "generation" => request.generation })
+            rescue StandardError => error
+              Rails.error.report(error)
+              begin
+                ReviewResetDeliveryJob.perform_later(request_id: request.id, generation: request.generation,
+                  revision: version.revision, actor_token_id: version.api_token_id)
+              rescue StandardError => enqueue_error
+                Rails.error.report(enqueue_error)
+              end
+            end
+          end
+          begin
+            Broadcaster.custom_action_to(plan, action: "coplan-review-changed", target: "plan-review-controls", html: "")
+          rescue StandardError => error
+            Rails.error.report(error)
           end
-          Broadcaster.custom_action_to(plan, action: "coplan-review-changed", target: "plan-review-controls", html: "")
         end
         version
       end
diff --git a/spec/jobs/coplan/review_reset_delivery_job_spec.rb b/spec/jobs/coplan/review_reset_delivery_job_spec.rb
new file mode 100644
index 00000000..62edf0fd
--- /dev/null
+++ b/spec/jobs/coplan/review_reset_delivery_job_spec.rb
@@ -0,0 +1,29 @@
+require "rails_helper"
+
+RSpec.describe CoPlan::ReviewResetDeliveryJob, type: :job do
+  let(:plan) { create(:plan, :published) }
+  let!(:task) { CoPlan::Reviews::Request.call(plan: plan, reviewer: create(:coplan_user), actor: plan.created_by_user) }
+
+  it "retries a transient delivery failure for a still-pending request" do
+    allow(CoPlan::Reviews::Changed).to receive(:call).and_raise(IOError, "temporary failure")
+    expect {
+      described_class.perform_now(request_id: task.id, generation: task.generation, revision: 1)
+    }.to have_enqueued_job(described_class)
+  end
+
+  it "ignores deliveries for older generations and removed requests" do
+    allow(CoPlan::Reviews::Changed).to receive(:call)
+    described_class.perform_now(request_id: task.id, generation: task.generation - 1, revision: 1)
+    task.destroy!
+    described_class.perform_now(request_id: task.id, generation: task.generation, revision: 1)
+    expect(CoPlan::Reviews::Changed).not_to have_received(:call)
+  end
+
+  it "ignores a reset delivery after a fresh decision" do
+    CoPlan::Reviews::Respond.call(request: task, actor: task.reviewer, revision: 1,
+      generation: task.generation, decision: "approved")
+    allow(CoPlan::Reviews::Changed).to receive(:call)
+    described_class.perform_now(request_id: task.id, generation: task.generation, revision: 1)
+    expect(CoPlan::Reviews::Changed).not_to have_received(:call)
+  end
+end
diff --git a/spec/services/coplan/versioned_reviews_spec.rb b/spec/services/coplan/versioned_reviews_spec.rb
index 3c7579d4..9b32acfe 100644
--- a/spec/services/coplan/versioned_reviews_spec.rb
+++ b/spec/services/coplan/versioned_reviews_spec.rb
@@ -1,6 +1,7 @@
 require "rails_helper"
 
 RSpec.describe "Version-bound review evidence" do
+  include ActiveJob::TestHelper
   let(:plan) { CoPlan::Plans::Create.call(title: "Reviewed body", content: "# Plan\n\n- [ ] Ship", user: create(:coplan_user)) }
   let(:reviewer) { create(:coplan_user) }
   let(:task) { CoPlan::Reviews::Request.call(plan: plan, reviewer: reviewer, actor: plan.created_by_user) }
@@ -63,6 +64,25 @@ def replace(content)
       action: "coplan-review-changed", target: "plan-review-controls", html: "").once
   end
 
+  it "keeps a committed edit successful and retries one failed reset without blocking other reviewers" do
+    task
+    other = CoPlan::Reviews::Request.call(plan: plan, reviewer: create(:coplan_user), actor: plan.created_by_user)
+    allow(CoPlan::Reviews::Changed).to receive(:call).and_call_original
+    allow(CoPlan::Reviews::Changed).to receive(:call).with(hash_including(request: task)).and_raise(IOError, "temporary delivery failure")
+    allow(CoPlan::Broadcaster).to receive(:custom_action_to)
+    allow(Rails.error).to receive(:report)
+    expect { replace("Committed despite a delivery failure") }.not_to raise_error
+    expect(plan.reload.current_revision).to eq(2)
+    expect(CoPlan::Reviews::Changed).to have_received(:call).with(hash_including(request: other))
+    expect(CoPlan::Broadcaster).to have_received(:custom_action_to).with(plan,
+      action: "coplan-review-changed", target: "plan-review-controls", html: "").once
+    expect(CoPlan::ReviewResetDeliveryJob).to have_been_enqueued.with(
+      request_id: task.id, generation: task.reload.generation, revision: 2, actor_token_id: nil)
+    allow(CoPlan::Reviews::Changed).to receive(:call).and_call_original
+    perform_enqueued_jobs(only: CoPlan::ReviewResetDeliveryJob)
+    expect(CoPlan::Reviews::Changed).to have_received(:call).with(hash_including(request: task)).twice
+  end
+
   it "dismisses on human drafts and checkbox edits" do
     decide
     CoPlan::Plans::ToggleCheckbox.call(plan: plan, old_text: "- [ ] Ship", new_text: "- [x] Ship", base_revision: 1, actor_id: plan.created_by_user_id)
diff --git a/spec/system/plan_reviews_spec.rb b/spec/system/plan_reviews_spec.rb
index c2af1a7f..419747ca 100644
--- a/spec/system/plan_reviews_spec.rb
+++ b/spec/system/plan_reviews_spec.rb
@@ -266,36 +266,42 @@ def open_review_settings
     expect(page).to have_no_text("Review settings changed. Please try again.")
   end
 
-  it "fences a lost older write before it can override the latest choice", :review_reset_policy do
-    sign_in_browser(author)
-    open_review_settings
-    page.execute_script(<<~JS)
-      const originalFetch = window.fetch.bind(window)
-      let first = true
-      window.fetch = async (url, options) => {
-        if (first && options?.method === 'PATCH' && String(url).endsWith('/settings')) {
-          first = false
-          document.querySelector('[data-review-reset-policy]').dataset.inFlight = 'true'
-          window.deliverOldPolicy = async () => {
-            const result = await originalFetch(url, options)
-            document.querySelector('[data-review-reset-policy]').dataset.oldStatus = String(result.status)
+  [ true, false ].each do |newer_choice|
+      it "fences a lost older write with newer input=#{newer_choice}", :review_reset_policy do
+      sign_in_browser(author)
+      open_review_settings
+      page.execute_script(<<~JS, newer_choice)
+        const newerChoice = arguments[0]
+        const originalTimeout = window.setTimeout.bind(window)
+        if (!newerChoice) window.setTimeout = (action, delay, ...args) => originalTimeout(action, delay === 10000 ? 100 : delay, ...args)
+        const originalFetch = window.fetch.bind(window)
+        let first = true
+        window.fetch = async (url, options) => {
+          if (first && options?.method === 'PATCH' && String(url).endsWith('/settings')) {
+            first = false
+            document.querySelector('[data-review-reset-policy]').dataset.inFlight = 'true'
+            window.deliverOldPolicy = async () => {
+              const result = await originalFetch(url, {...options, signal: undefined})
+              document.querySelector('[data-review-reset-policy]').dataset.oldStatus = String(result.status)
+            }
+            return await new Promise((_, reject) => { window.losePolicy = () => reject(new TypeError('Lost response')) })
           }
-          return await new Promise((_, reject) => { window.losePolicy = () => reject(new TypeError('Lost response')) })
+          return originalFetch(url, options)
         }
-        return originalFetch(url, options)
-      }
-    JS
-    uncheck "Reset approvals when content changes"
-    expect(page).to have_css("[data-review-reset-policy][data-in-flight='true']")
-    check "Reset approvals when content changes"
-    page.execute_script("window.losePolicy()")
-    expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
-    page.execute_script("window.deliverOldPolicy()")
-    expect(page).to have_css("[data-review-reset-policy][data-old-status='409']")
-    expect(page).to have_checked_field("Reset approvals when content changes")
-    expect(plan.reload.reset_reviews_on_change).to be(true)
+      JS
+      uncheck "Reset approvals when content changes"
+      expect(page).to have_css("[data-review-reset-policy][data-in-flight='true']")
+      if newer_choice
+        check "Reset approvals when content changes"
+        page.execute_script("window.losePolicy()")
+      end
+      expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+      page.execute_script("window.deliverOldPolicy()")
+      expect(page).to have_css("[data-review-reset-policy][data-old-status='409']")
+      expect(page).to have_checked_field("Reset approvals when content changes")
+      expect(plan.reload.reset_reviews_on_change).to be(true)
+    end
   end
-
   it "keeps a review refresh when policy toggles cancel out", :review_reset_policy do
     sign_in_browser(author)
     open_review_settings

From b705de481d405136d15a967c851b7b887dea944b Mon Sep 17 00:00:00 2001
From: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
Date: Thu, 29 Oct 2026 16:13:28 -0400
Subject: [PATCH 11/18] Retry failed review controls invalidations

Signed-off-by: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
---
 docs/REVIEWS.md                                  |  2 +-
 .../app/jobs/coplan/review_reset_delivery_job.rb |  8 +++++++-
 .../app/services/coplan/plans/advance_version.rb |  5 +++++
 .../coplan/review_reset_delivery_job_spec.rb     |  7 +++++++
 spec/services/coplan/versioned_reviews_spec.rb   | 16 ++++++++++++++++
 5 files changed, 36 insertions(+), 2 deletions(-)

diff --git a/docs/REVIEWS.md b/docs/REVIEWS.md
index a0d6fff4..d5c5b3c9 100644
--- a/docs/REVIEWS.md
+++ b/docs/REVIEWS.md
@@ -12,7 +12,7 @@ The approval covers **Markdown source bytes only**. Title, tags, attachments, li
 
 All current-version writers use `Plans::AdvanceVersion`: Create, ReplaceContent (including SaveHumanDraft/web saves), CommitSession, ToggleCheckbox and the direct operations API. They already hold the plan row lock; CommitSession retains session-before-plan lock order. The version pointer, revision and review sequence always advance together. With `reset_reviews_on_change` enabled (the default), active task resets, generation increments and cleared current pointers commit in that same transaction. Withdrawn tasks and all receipts remain intact. Resets broadcast after commit without sending a review-request notification for every edit.
 
-Reset delivery failures do not change the committed save result or prevent other reviewers' events and the controls invalidation. Failed deliveries use the existing job queue with bounded retries; obsolete request generations are skipped. Delivery is at least once. If queueing also fails, the error is reported for operational recovery; there is no transactional outbox guarantee.
+Reset delivery failures do not change the committed save result or prevent other reviewers' events and the controls invalidation. Failed request deliveries and controls broadcasts use the existing job queue with bounded retries; obsolete request generations and missing plans are skipped. Delivery is at least once. If queueing also fails, the error is reported for operational recovery; there is no transactional outbox guarantee.
 
 An identical normalized ReplaceContent save creates no version and preserves approval. An empty session creates no version. A nonempty session or operations commit creates a new version even if its operations net to identical bytes, and resets reviews when the policy is enabled. Returning A→B→A always produces a distinct version; no older decision becomes exact-current-version evidence. Existing edit leases, human-edit fences and merge guards remain in place.
 
diff --git a/engine/app/jobs/coplan/review_reset_delivery_job.rb b/engine/app/jobs/coplan/review_reset_delivery_job.rb
index fc37678a..8efa7166 100644
--- a/engine/app/jobs/coplan/review_reset_delivery_job.rb
+++ b/engine/app/jobs/coplan/review_reset_delivery_job.rb
@@ -4,7 +4,13 @@ module CoPlan
   class ReviewResetDeliveryJob < ApplicationJob
     retry_on StandardError, wait: :polynomially_longer, attempts: 5
 
-    def perform(request_id:, generation:, revision:, actor_token_id: nil)
+    def perform(request_id: nil, generation: nil, revision: nil, actor_token_id: nil, plan_id: nil)
+      if plan_id
+        plan = Plan.find_by(id: plan_id)
+        return unless plan
+
+        return Broadcaster.custom_action_to(plan, action: "coplan-review-changed", target: "plan-review-controls", html: "")
+      end
       request = ReviewRequest.find_by(id: request_id)
       return unless request&.pending? && request.generation == generation
 
diff --git a/engine/app/services/coplan/plans/advance_version.rb b/engine/app/services/coplan/plans/advance_version.rb
index f526da5e..d6aa4ed3 100644
--- a/engine/app/services/coplan/plans/advance_version.rb
+++ b/engine/app/services/coplan/plans/advance_version.rb
@@ -37,6 +37,11 @@ def self.call(plan:, version:)
             Broadcaster.custom_action_to(plan, action: "coplan-review-changed", target: "plan-review-controls", html: "")
           rescue StandardError => error
             Rails.error.report(error)
+            begin
+              ReviewResetDeliveryJob.perform_later(plan_id: plan.id)
+            rescue StandardError => enqueue_error
+              Rails.error.report(enqueue_error)
+            end
           end
         end
         version
diff --git a/spec/jobs/coplan/review_reset_delivery_job_spec.rb b/spec/jobs/coplan/review_reset_delivery_job_spec.rb
index 62edf0fd..49ab2499 100644
--- a/spec/jobs/coplan/review_reset_delivery_job_spec.rb
+++ b/spec/jobs/coplan/review_reset_delivery_job_spec.rb
@@ -26,4 +26,11 @@
     described_class.perform_now(request_id: task.id, generation: task.generation, revision: 1)
     expect(CoPlan::Reviews::Changed).not_to have_received(:call)
   end
+
+  it "retries controls transport failures and ignores missing plans" do
+    allow(CoPlan::Broadcaster).to receive(:custom_action_to).and_raise(IOError, "temporary transport failure")
+    expect { described_class.perform_now(plan_id: plan.id) }.to have_enqueued_job(described_class).with(plan_id: plan.id)
+    described_class.perform_now(plan_id: SecureRandom.uuid)
+    expect(CoPlan::Broadcaster).to have_received(:custom_action_to).once
+  end
 end
diff --git a/spec/services/coplan/versioned_reviews_spec.rb b/spec/services/coplan/versioned_reviews_spec.rb
index 9b32acfe..e0f9d7ed 100644
--- a/spec/services/coplan/versioned_reviews_spec.rb
+++ b/spec/services/coplan/versioned_reviews_spec.rb
@@ -83,6 +83,22 @@ def replace(content)
     expect(CoPlan::Reviews::Changed).to have_received(:call).with(hash_including(request: task)).twice
   end
 
+  it "retries a failed controls invalidation without changing the committed save result" do
+    task
+    allow(Rails.error).to receive(:report)
+    allow(CoPlan::Broadcaster).to receive(:custom_action_to).and_call_original
+    allow(CoPlan::Broadcaster).to receive(:custom_action_to).with(plan,
+      action: "coplan-review-changed", target: "plan-review-controls", html: "").and_raise(IOError, "temporary transport failure")
+    expect { replace("Committed with a failed controls broadcast") }.not_to raise_error
+    expect(plan.reload.current_revision).to eq(2)
+    expect(CoPlan::ReviewResetDeliveryJob).to have_been_enqueued.with(plan_id: plan.id)
+    allow(CoPlan::Broadcaster).to receive(:custom_action_to).with(plan,
+      action: "coplan-review-changed", target: "plan-review-controls", html: "").and_return(true)
+    perform_enqueued_jobs(only: CoPlan::ReviewResetDeliveryJob)
+    expect(CoPlan::Broadcaster).to have_received(:custom_action_to).with(plan,
+      action: "coplan-review-changed", target: "plan-review-controls", html: "").twice
+  end
+
   it "dismisses on human drafts and checkbox edits" do
     decide
     CoPlan::Plans::ToggleCheckbox.call(plan: plan, old_text: "- [ ] Ship", new_text: "- [x] Ship", base_revision: 1, actor_id: plan.created_by_user_id)

From 75365ed36f5fa3d2aad08d5873c0297239ea43df Mon Sep 17 00:00:00 2001
From: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
Date: Thu, 29 Oct 2026 16:28:55 -0400
Subject: [PATCH 12/18] Keep review errors visible when refresh fails

Signed-off-by: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
---
 .../coplan/review_tray_controller.js          |  8 ++--
 spec/system/plan_reviews_spec.rb              | 48 +++++++++++++++++++
 2 files changed, 53 insertions(+), 3 deletions(-)

diff --git a/engine/app/javascript/controllers/coplan/review_tray_controller.js b/engine/app/javascript/controllers/coplan/review_tray_controller.js
index 2a5eab56..7ee61a5b 100644
--- a/engine/app/javascript/controllers/coplan/review_tray_controller.js
+++ b/engine/app/javascript/controllers/coplan/review_tray_controller.js
@@ -229,14 +229,16 @@ export default class extends Controller {
 
   async refresh() {
     const sequence = ++this.refreshSequence
+    this.policyRefreshPending = false
     const policyBusy = this.policySaving || this.policySaveTimer
     const policyGeneration = this.policyInputGeneration
     try {
       const response = await fetch(this.urlValue, { credentials: "same-origin", headers: { Accept: "text/html" } })
       if (!response.ok) return
       const incoming = new DOMParser().parseFromString(await response.text(), "text/html")
-      if (sequence !== this.refreshSequence || !this.element.isConnected) return
-      this.element.dataset.reviewGeneration = incoming.getElementById("plan-review-controls")?.dataset.reviewGeneration || ""
+      const controls = incoming.getElementById("plan-review-controls")
+      if (sequence !== this.refreshSequence || !this.element.isConnected || !controls) return
+      this.element.dataset.reviewGeneration = controls.dataset.reviewGeneration || ""
       const policy = this.element.querySelector("[data-review-reset-policy]")
       const incomingPolicy = incoming.querySelector("[data-review-reset-policy]")
       if (policy && incomingPolicy) {
@@ -581,7 +583,7 @@ export default class extends Controller {
       // Network failures and lost results keep their original key/generation.
       if (String(url).endsWith("/respond") && [409, 422].includes(response.status)) {
         this.responseIntents = {}
-        await this.refresh()
+        this.refresh()
       }
       const error = new Error(result.error || "Couldn't save. Please try again.")
       error.status = response.status
diff --git a/spec/system/plan_reviews_spec.rb b/spec/system/plan_reviews_spec.rb
index 419747ca..560d9e14 100644
--- a/spec/system/plan_reviews_spec.rb
+++ b/spec/system/plan_reviews_spec.rb
@@ -360,6 +360,54 @@ def open_review_settings
     end
   end
 
+  it "stops a deferred controls refresh when successful HTML is a sign-in page", :review_refresh_failures do
+    sign_in_browser(author)
+    open_review_settings
+    page.execute_script(<<~JS)
+      const root = document.getElementById('plan-review-controls')
+      const controller = window.Stimulus.getControllerForElementAndIdentifier(root, 'coplan--review-tray')
+      const originalFetch = window.fetch.bind(window)
+      window.controlsReads = 0
+      window.fetch = async (url, options) => {
+        if (url === controller.urlValue && !options?.method) {
+          root.dataset.controlsReads = String(++window.controlsReads)
+          if (window.controlsReads > 2) throw new TypeError('Stop the test loop')
+          await new Promise(resolve => setTimeout(resolve, 20))
+          return new Response('<html><body>Sign in</body></html>', {status: 200})
+        }
+        return originalFetch(url, options)
+      }
+      controller.policyRefreshPending = true
+      controller.refresh()
+      setTimeout(() => { root.dataset.refreshSettled = 'true' }, 200)
+    JS
+    expect(page).to have_css("[data-refresh-settled='true']")
+    expect(page.evaluate_script("window.controlsReads")).to eq(1)
+    expect(page).to have_css(".review-management[open]")
+  end
+
+  it "shows a rejected review and releases submission while the controls refresh stalls", :review_refresh_failures do
+    within(".review-tray") { click_button "Approve", exact: true }
+    page.execute_script(<<~JS)
+      const root = document.getElementById('plan-review-controls')
+      const controlsUrl = root.getAttribute('data-coplan--review-tray-url-value')
+      const originalFetch = window.fetch.bind(window)
+      window.fetch = async (url, options) => {
+        if (options?.method === 'POST' && String(url).endsWith('/respond')) {
+          return new Response(JSON.stringify({error: 'The review request changed'}), {status: 409})
+        }
+        if (url === controlsUrl && !options?.method) return new Promise(() => {})
+        return originalFetch(url, options)
+      }
+    JS
+    within(".review-confirmation") do
+      click_button "Approve v1", exact: true
+      expect(page).to have_text("The review request changed")
+      expect(page).to have_button("Approve v1", disabled: false)
+      expect(page).to have_no_css("[aria-busy='true']")
+    end
+  end
+
   it "dismisses an approval after an edit, preserves its snapshot and accepts a fresh review", :version_parity do
     within(".review-tray") { click_button "Approve", exact: true }
     within(".review-confirmation") do

From 2c76d9f038623a9e0482f46c732e5eef87cc5c35 Mon Sep 17 00:00:00 2001
From: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
Date: Thu, 29 Oct 2026 16:45:00 -0400
Subject: [PATCH 13/18] Stop policy retries after navigation

Signed-off-by: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
---
 .../coplan/review_tray_controller.js          | 18 ++++++-
 spec/system/plan_reviews_spec.rb              | 50 +++++++++++++++++++
 2 files changed, 67 insertions(+), 1 deletion(-)

diff --git a/engine/app/javascript/controllers/coplan/review_tray_controller.js b/engine/app/javascript/controllers/coplan/review_tray_controller.js
index 7ee61a5b..cfd70d08 100644
--- a/engine/app/javascript/controllers/coplan/review_tray_controller.js
+++ b/engine/app/javascript/controllers/coplan/review_tray_controller.js
@@ -5,6 +5,10 @@ export default class extends Controller {
   static values = { url: String, searchUrl: String, suggestionsUrl: String, settingsUrl: String }
 
   connect() {
+    this.policyConnection = { active: true }
+    this.policySaving = false
+    this.policyMustSave = false
+    this.policyUncertainSequence = null
     this.searchSequence = 0
     this.suggestionSequence = 0
     this.refreshSequence = 0
@@ -20,6 +24,7 @@ export default class extends Controller {
   }
 
   disconnect() {
+    this.policyConnection.active = false
     clearTimeout(this.searchTimer)
     clearTimeout(this.policySaveTimer)
     if (this.policySaveTimer) {
@@ -321,6 +326,7 @@ export default class extends Controller {
 
   async saveResetPolicy(input) {
     if (this.policySaving) return
+    const connection = this.policyConnection
     const previous = input.dataset.savedValue === "true"
     const enabled = input.checked
     const generation = this.policyInputGeneration
@@ -336,6 +342,7 @@ export default class extends Controller {
     let confirmed = false
     try {
       const result = await this.withPolicyDeadline(signal => this.write(this.settingsUrlValue, "PATCH", { review_settings: { reset_reviews_on_change: enabled, review_sequence: input.dataset.reviewSequence } }, signal))
+      if (connection !== this.policyConnection) return
       input.dataset.savedValue = String(enabled)
       input.dataset.reviewSequence = String(result.review_sequence)
       this.policyConflictRetries = 0
@@ -345,6 +352,7 @@ export default class extends Controller {
       input.removeAttribute("aria-invalid")
       confirmed = true
     } catch (error) {
+      if (connection !== this.policyConnection) return
       // A lost HTTP result may already have saved. Read back before restoring
       // the checkbox, while preserving clicks made during that request.
       let persisted = previous
@@ -356,10 +364,11 @@ export default class extends Controller {
           const response = await fetch(this.urlValue, { credentials: "same-origin", headers: { Accept: "text/html" }, signal })
           const policy = new DOMParser().parseFromString(await response.text(), "text/html").querySelector("[data-review-reset-policy]")
           if (!response.ok || !policy) throw error
-          input.dataset.reviewSequence = policy.dataset.reviewSequence
+          if (connection === this.policyConnection) input.dataset.reviewSequence = policy.dataset.reviewSequence
           return policy.checked
         })
       } catch { /* Keep the last confirmed value and show the error. */ }
+      if (connection !== this.policyConnection) return
       this.policyUnresolved = this.policyUncertainSequence != null && Number(input.dataset.reviewSequence) <= this.policyUncertainSequence
       confirmed = persisted === enabled && !this.policyUnresolved
       if (!this.policyUnresolved) this.policyUncertainSequence = null
@@ -376,7 +385,14 @@ export default class extends Controller {
       this.managementErrorTarget.textContent = confirmed ? "" : error.message
       if (this.policyUnresolved) this.managementErrorTarget.textContent += " A previous save may still be running. Toggle again to retry."
     } finally {
+      if (connection !== this.policyConnection) return
       this.policySaving = false
+      // A detached controller may reconcile a sent write, but must not rebase
+      // its old choice over preferences saved by the new page.
+      if (!connection.active) {
+        input.setAttribute("aria-busy", "false")
+        return
+      }
       // Serialize saves so a slow older request cannot overwrite a newer click.
       if (!this.policyUnresolved && (this.policyMustSave || input.checked !== (input.dataset.savedValue === "true"))) this.saveResetPolicy(input)
       else {
diff --git a/spec/system/plan_reviews_spec.rb b/spec/system/plan_reviews_spec.rb
index 560d9e14..b011465b 100644
--- a/spec/system/plan_reviews_spec.rb
+++ b/spec/system/plan_reviews_spec.rb
@@ -360,6 +360,56 @@ def open_review_settings
     end
   end
 
+  it "does not retry an obsolete policy after Turbo navigation", :review_policy_disconnect do
+    sign_in_browser(author)
+    open_review_settings
+    page.execute_script(<<~JS)
+      const root = document.getElementById('plan-review-controls')
+      const controller = window.Stimulus.getControllerForElementAndIdentifier(root, 'coplan--review-tray')
+      const save = controller.saveResetPolicy.bind(controller)
+      controller.saveResetPolicy = (...args) => {
+        const result = save(...args)
+        window.oldPolicySave ||= result
+        return result
+      }
+      const originalFetch = window.fetch.bind(window)
+      window.policyWrites = []
+      window.fetch = async (url, options) => {
+        if (options?.method === 'PATCH' && String(url).endsWith('/settings')) {
+          window.policyWrites.push(JSON.parse(options.body).review_settings.reset_reviews_on_change)
+          if (window.policyWrites.length === 1) {
+            root.dataset.inFlight = 'true'
+            await new Promise(resolve => { window.releaseOldPolicy = resolve })
+            const response = await originalFetch(url, options)
+            window.oldPolicyStatus = response.status
+            return response
+          }
+        }
+        return originalFetch(url, options)
+      }
+    JS
+    uncheck "Reset approvals when content changes"
+    expect(page).to have_css("[data-in-flight='true']")
+    page.execute_script("Turbo.visit(arguments[0])", library_page_path(author))
+    expect(page).to have_current_path(library_page_path(author))
+    page.execute_script("Turbo.visit(arguments[0])", plan_page_path(plan))
+    expect(page).to have_current_path(plan_page_path(plan))
+    open_review_settings
+    uncheck "Reset approvals when content changes"
+    expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+    check "Reset approvals when content changes"
+    expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+    page.evaluate_async_script(<<~JS)
+      const done = arguments[arguments.length - 1]
+      window.releaseOldPolicy()
+      window.oldPolicySave.then(done)
+    JS
+    expect(page.evaluate_script("window.oldPolicyStatus")).to eq(409)
+    expect(page.evaluate_script("window.policyWrites")).to eq([ false, false, true ])
+    expect(plan.reload.reset_reviews_on_change).to be(true)
+    expect(page).to have_checked_field("Reset approvals when content changes")
+  end
+
   it "stops a deferred controls refresh when successful HTML is a sign-in page", :review_refresh_failures do
     sign_in_browser(author)
     open_review_settings

From 5f6bddbaf55eb8e1e5a693640d381495699177e1 Mon Sep 17 00:00:00 2001
From: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
Date: Mon, 2 Nov 2026 04:35:39 -0500
Subject: [PATCH 14/18] Clarify approvals as decisions on specific versions

Signed-off-by: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
---
 docs/REVIEWS.md                               |  4 +-
 .../guides/comments.text.erb                  |  2 +-
 .../views/coplan/reviews/_controls.html.erb   |  2 +-
 .../views/coplan/reviews/_management.html.erb |  4 +-
 .../app/views/coplan/reviews/_roster.html.erb |  2 +-
 .../app/views/coplan/reviews/_table.html.erb  |  2 +-
 engine/db/demo/content/retained-review.md     |  2 +-
 spec/system/plan_reviews_spec.rb              | 87 ++++++++++---------
 8 files changed, 54 insertions(+), 51 deletions(-)

diff --git a/docs/REVIEWS.md b/docs/REVIEWS.md
index d5c5b3c9..ff395e61 100644
--- a/docs/REVIEWS.md
+++ b/docs/REVIEWS.md
@@ -1,6 +1,6 @@
 # Version-bound reviews
 
-A native review means satisfaction with a specific Markdown source version. It grants no execution authority or permissions. An agent response remains an agent response attributed to its human principal; it is never a human sign-off.
+A native review means satisfaction with a specific Markdown source version. New approvals require the latest version. Older versions remain available as review history, not as targets for new approvals. It grants no execution authority or permissions. An agent response remains an agent response attributed to its human principal; it is never a human sign-off.
 
 ## Content and decision identity
 
@@ -16,7 +16,7 @@ Reset delivery failures do not change the committed save result or prevent other
 
 An identical normalized ReplaceContent save creates no version and preserves approval. An empty session creates no version. A nonempty session or operations commit creates a new version even if its operations net to identical bytes, and resets reviews when the policy is enabled. Returning A→B→A always produces a distinct version; no older decision becomes exact-current-version evidence. Existing edit leases, human-edit fences and merge guards remain in place.
 
-Editors can toggle **Reset approvals when content changes** in Manage reviewers. The setting applies to future edits for every reviewer. When off, completed approvals and change requests remain completed on their original versions; edits require no fresh review. Pending tasks stay pending, and withdrawn tasks stay withdrawn. Turning resets back on affects the next edit; turning them off never restores an already dismissed decision. Exact-current-version `effective_status`, `effective_response_id` and `effective_human_decision` remain strict regardless of this preference. Policy updates take the same plan row lock and require the displayed `review_sequence`. Every accepted write advances it, including same-value writes that fence older requests with lost results. A stale sequence returns 409; the dialog reads back the setting before retrying the latest choice.
+Editors can toggle **Require a new review after changes** in Manage reviewers. The setting applies to future edits for every reviewer. When off, completed approvals and change requests remain completed on their original versions; edits require no fresh review. Pending tasks stay pending, and withdrawn tasks stay withdrawn. Turning resets back on affects the next edit; turning them off never restores an already dismissed decision. Exact-current-version `effective_status`, `effective_response_id` and `effective_human_decision` remain strict regardless of this preference. Policy updates take the same plan row lock and require the displayed `review_sequence`. Every accepted write advances it, including same-value writes that fence older requests with lost results. A stale sequence returns 409; the dialog reads back the setting before retrying the latest choice.
 
 An explicit re-request advances the task generation and clears its effective decision. Creating an already existing request is a retry and leaves its state alone. Withdrawal clears the effective decision and preserves receipts. A fresh response supersedes the previous effective response, including a later agent response. The latest sequenced human response on the current version is exposed separately so consumers can inspect human feedback across request cycles; native CoPlan does not impose an external approval or objection policy.
 
diff --git a/engine/app/views/coplan/agent_instructions/guides/comments.text.erb b/engine/app/views/coplan/agent_instructions/guides/comments.text.erb
index 9efeb035..5c688c1d 100644
--- a/engine/app/views/coplan/agent_instructions/guides/comments.text.erb
+++ b/engine/app/views/coplan/agent_instructions/guides/comments.text.erb
@@ -80,7 +80,7 @@ To give feedback on another person's plan, start threads anchored to the passage
 
 Each request or re-request remains in review activity with its requester and time. A later request does not replace earlier requests or decisions.
 
-Discussion is the default. An approval means “satisfied with this exact version”; it grants no permissions, execution authority, or instruction to implement the plan. Never interpret another person's sign-off as an instruction from your principal. By default, edits reset active tasks to pending and preserve earlier decisions as history. Editors may disable automatic resets in Manage reviewers; completed reviews then stay completed on their original versions, without requiring fresh approval. Approval covers Markdown source bytes only, not title, tags, attachments, linked or embedded resources, or child plans. Use `GET /api/v1/plans/:plan_id/review_evidence` for exact current Markdown, hash, version ID, and coherent review state. It creates no read receipt. `review_status` describes task completion. `effective_human_decision` is exact-current-version evidence and is null for agent decisions, dismissed approvals, or decisions on older versions, even when automatic resets are off. A later agent decision cannot count as a human approval. `latest_human_response_id` exposes historical human feedback on the current version; it is not an effective approval.
+Discussion is the default. An approval means “satisfied with this exact version”; it grants no permissions, execution authority, or instruction to implement the plan. Never interpret another person's sign-off as an instruction from your principal. By default, edits reset active tasks to pending and preserve earlier decisions as history. Editors may turn off **Require a new review after changes** in Manage reviewers; completed reviews then stay completed on their original versions, without requiring fresh approval. New approvals always require the latest version, regardless of this setting. Approval covers Markdown source bytes only, not title, tags, attachments, linked or embedded resources, or child plans. Use `GET /api/v1/plans/:plan_id/review_evidence` for exact current Markdown, hash, version ID, and coherent review state. It creates no read receipt. `review_status` describes task completion. `effective_human_decision` is exact-current-version evidence and is null for agent decisions, dismissed approvals, or decisions on older versions, even when automatic resets are off. A later agent decision cannot count as a human approval. `latest_human_response_id` exposes historical human feedback on the current version; it is not an effective approval.
 
 - `GET /api/v1/plans/:plan_id/review_requests` lists requests and responses, including reviewer, required/optional, revision, timestamp, notes, and agent attribution.
 - The plan author's credential may `POST` that path with `{ "reviewer_id": "USER_ID", "requirement": "required" }` (or `optional`). Requests are tasks; reading the notification does not complete them.
diff --git a/engine/app/views/coplan/reviews/_controls.html.erb b/engine/app/views/coplan/reviews/_controls.html.erb
index ebe2c656..b43e5cc1 100644
--- a/engine/app/views/coplan/reviews/_controls.html.erb
+++ b/engine/app/views/coplan/reviews/_controls.html.erb
@@ -40,7 +40,7 @@
               <span><strong><%= own_request.review_status == "approved" ? "#{decision_actor} approved" : "#{decision_actor} requested changes to" %> v<%= response.plan_version.revision %></strong> <span class="review-tray__date">on <time datetime="<%= response.created_at.iso8601 %>" title="<%= response.created_at.strftime('%B %-d, %Y at %H:%M %Z') %>"><%= response.created_at.strftime("%b %-d, %Y") %></time></span></span>
             <% end %>
           </div>
-          <% if response && response.plan_version_id != plan.current_plan_version_id %><small>Content changed since review; no new review required.</small><% end %>
+          <% if response && response.plan_version_id != plan.current_plan_version_id %><small>Current version: v<%= plan.current_revision %>. No new review required.</small><% end %>
           <% if !own_request.pending? && feedback_thread_ids.include?(response&.comment_thread_id) %><button type="button" class="review-log__link review-feedback-link" data-action="coplan--review-tray#openThread" data-thread-id="<%= response.comment_thread_id %>">View feedback</button><% end %>
           <% if approval && approval.plan_version.revision != plan.current_revision %><button type="button" class="btn btn--ghost btn--sm" data-action="coplan--review-tray#compare" data-url="<%= compare_plan_review_request_path(plan, own_request, response_id: approval.id) %>">Changes since approval</button><% end %>
         </div>
diff --git a/engine/app/views/coplan/reviews/_management.html.erb b/engine/app/views/coplan/reviews/_management.html.erb
index 95407b39..b7bbadf7 100644
--- a/engine/app/views/coplan/reviews/_management.html.erb
+++ b/engine/app/views/coplan/reviews/_management.html.erb
@@ -14,8 +14,8 @@
   </div>
   <% if allowed_to?(plan, :update?) %>
     <div class="review-reset-policy">
-      <label class="review-required"><input type="checkbox" <%= "checked" if plan.reset_reviews_on_change %> data-action="change->coplan--review-tray#changeResetPolicy" data-review-reset-policy data-review-sequence="<%= plan.review_sequence %>" data-saved-value="<%= plan.reset_reviews_on_change %>"> Reset approvals when content changes <span class="review-reset-policy__status" data-coplan--review-tray-target="policyIcon" role="img" aria-hidden="true" aria-label="Saved" title="Saved">✓</span></label>
-      <p class="text-sm text-muted">Applies to future edits for all reviewers. When off, completed reviews stay completed.</p>
+      <label class="review-required"><input type="checkbox" <%= "checked" if plan.reset_reviews_on_change %> data-action="change->coplan--review-tray#changeResetPolicy" data-review-reset-policy data-review-sequence="<%= plan.review_sequence %>" data-saved-value="<%= plan.reset_reviews_on_change %>"> Require a new review after changes <span class="review-reset-policy__status" data-coplan--review-tray-target="policyIcon" role="img" aria-hidden="true" aria-label="Saved" title="Saved">✓</span></label>
+      <p class="text-sm text-muted">Applies to future edits for all reviewers. When off, completed reviews stay on the version reviewed. New approvals always require the latest version.</p>
     </div>
     <div id="review-assignment" class="review-assignment" popover="auto" role="dialog" aria-label="Add reviewer" data-coplan--review-tray-target="assignment" data-action="toggle->coplan--review-tray#assignmentToggled keydown.esc->coplan--review-tray#dismissAssignment">
       <%= form_with url: plan_review_requests_path(plan), class: "review-assignment-form", data: { action: "submit->coplan--review-tray#assign" } do %>
diff --git a/engine/app/views/coplan/reviews/_roster.html.erb b/engine/app/views/coplan/reviews/_roster.html.erb
index 23ea9b77..09eedc69 100644
--- a/engine/app/views/coplan/reviews/_roster.html.erb
+++ b/engine/app/views/coplan/reviews/_roster.html.erb
@@ -10,7 +10,7 @@
             <%= user_avatar(request.reviewer, size: "md") %>
             <div class="review-person__info">
               <strong><%= request.reviewer.name %></strong>
-              <span class="review-person__meta"><span class="review-person__requirement"><%= requirement.humanize %></span> · <% if request.pending? %>Review requested<% elsif request.review_status == "changes_requested" %>Changes requested on v<%= request.recorded_response&.plan_version&.revision %><% else %>Approved v<%= request.recorded_response&.plan_version&.revision %><%= " (agent)" if request.recorded_response&.actor_type == "local_agent" %><% end %></span>
+              <span class="review-person__meta"><span class="review-person__requirement"><%= requirement.humanize %></span> · <% if request.pending? %>Review requested<% elsif request.review_status == "changes_requested" %>Changes requested on v<%= request.recorded_response&.plan_version&.revision %><% else %>Approved v<%= request.recorded_response&.plan_version&.revision %><%= " (agent)" if request.recorded_response&.actor_type == "local_agent" %><% end %><% if request.recorded_response && request.recorded_response.plan_version_id != plan.current_plan_version_id %> · Current: v<%= plan.current_revision %><% end %></span>
             </div>
             <span class="review-state<%= ' review-state--approved' if request.review_status == 'approved' %><%= ' review-state--attention' if request.pending? && request.reviewer_id == current_user.id %>"><span aria-hidden="true"><%= request.pending? ? "◷" : request.review_status == "approved" ? "✓" : "↩" %></span> <%= request.pending? ? "Pending" : request.review_status.humanize %></span>
             <% if manage && allowed_to?(plan, :update?) %>
diff --git a/engine/app/views/coplan/reviews/_table.html.erb b/engine/app/views/coplan/reviews/_table.html.erb
index eba61d10..f1f7dea4 100644
--- a/engine/app/views/coplan/reviews/_table.html.erb
+++ b/engine/app/views/coplan/reviews/_table.html.erb
@@ -9,7 +9,7 @@
           <td><div class="review-table__person"><%= user_avatar(request.reviewer) %><strong><%= request.reviewer.name %></strong></div></td>
           <td><span class="review-table__requirement"><%= request.requirement.humanize %></span></td>
           <td><span class="review-state<%= ' review-state--approved' if request.review_status == 'approved' %><%= ' review-state--attention' if request.pending? && request.reviewer_id == current_user.id %>"><span aria-hidden="true"><%= request.pending? ? "◷" : request.review_status == "approved" ? "✓" : "↩" %></span><span class="review-person__meta"><%= request.pending? ? (request.reset_reason == "content_changed" ? "Content changed; review again" : "Review requested") : request.review_status.humanize %><%= " (agent)" if response&.actor_type == "local_agent" %></span></span></td>
-          <td><% if !request.pending? && response %><span class="review-version">v<%= response.plan_version.revision %></span><% if response.plan_version_id != plan.current_plan_version_id %> <span class="text-muted">Content changed since review</span><% end %><% else %><span class="text-muted" aria-label="Not reviewed yet">—</span><% end %></td>
+          <td><% if !request.pending? && response %><span class="review-version">v<%= response.plan_version.revision %></span><% if response.plan_version_id != plan.current_plan_version_id %> <span class="text-muted">Current: v<%= plan.current_revision %></span><% end %><% else %><span class="text-muted" aria-label="Not reviewed yet">—</span><% end %></td>
           <td class="review-table__actions">
             <% if !request.pending? && request.reviewer_id == current_user.id %><button type="button" class="review-log__link review-reopen" aria-label="Change decision" title="Change decision" data-action="coplan--review-tray#reconsider"><svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M20 7v5h-5M4 17v-5h5"/><path d="M6.1 7a7 7 0 0 1 11.6-1L20 9M4 15l2.3 3A7 7 0 0 0 17.9 17"/></svg></button><% end %>
             <% if approval && approval.plan_version.revision != plan.current_revision %><button type="button" class="review-log__link" data-action="coplan--review-tray#compare" data-url="<%= compare_plan_review_request_path(plan, request, response_id: approval.id) %>">Compare</button><% end %>
diff --git a/engine/db/demo/content/retained-review.md b/engine/db/demo/content/retained-review.md
index 0befe697..04e8bf72 100644
--- a/engine/db/demo/content/retained-review.md
+++ b/engine/db/demo/content/retained-review.md
@@ -2,6 +2,6 @@
 
 Automatic approval resets are off for this document. The v1 reviews remain completed after the v2 edit, without requiring new approvals. Each review still identifies the immutable Markdown version reviewed.
 
-Enable **Reset approvals when content changes** in Manage reviewers, then edit again to return active reviews to Pending.
+Enable **Require a new review after changes** in Manage reviewers, then edit again to return active reviews to Pending.
 
 - [ ] Verify the retry policy
diff --git a/spec/system/plan_reviews_spec.rb b/spec/system/plan_reviews_spec.rb
index b011465b..8e5183fc 100644
--- a/spec/system/plan_reviews_spec.rb
+++ b/spec/system/plan_reviews_spec.rb
@@ -53,8 +53,8 @@ def open_review_settings
       page.execute_script("document.documentElement.dataset.theme = arguments[0]", theme)
       open_review_settings
       within(".review-management[open]") do
-        expect(page).to have_checked_field("Reset approvals when content changes")
-        uncheck "Reset approvals when content changes"
+        expect(page).to have_checked_field("Require a new review after changes")
+        uncheck "Require a new review after changes"
         expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
       end
       expect(page).to have_css(".review-reset-policy__status[data-state='saved']")
@@ -63,8 +63,8 @@ def open_review_settings
       page.execute_script("document.documentElement.dataset.theme = arguments[0]", theme)
       open_review_settings
       within(".review-management[open]") do
-        expect(page).to have_unchecked_field("Reset approvals when content changes")
-        check "Reset approvals when content changes"
+        expect(page).to have_unchecked_field("Require a new review after changes")
+        check "Require a new review after changes"
         expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
       end
       expect(plan.reload.reset_reviews_on_change).to be(true)
@@ -76,7 +76,7 @@ def open_review_settings
     sign_in_browser(author)
     open_review_settings
     within(".review-management[open]") do
-      uncheck "Reset approvals when content changes"
+      uncheck "Require a new review after changes"
       expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
     end
     sign_in_browser(reviewer)
@@ -87,8 +87,8 @@ def open_review_settings
     visit plan_page_path(plan)
     expand_plan_section("footnote-approvals")
     expect(page).to have_css(".review-tray", text: "You approved v1")
-    expect(page).to have_css(".review-tray", text: "no new review required")
-    expect(page).to have_css(".review-person", text: "Content changed since review")
+    expect(page).to have_css(".review-tray", text: "Current version: v2. No new review required.")
+    expect(page).to have_css(".review-person", text: "Current: v2")
     expect(page).to have_no_css(".review-tray", text: "Your review is requested")
     expect(task.reload.effective_human_decision).to be_nil
     [ "light", "dark" ].each do |theme|
@@ -98,7 +98,7 @@ def open_review_settings
     sign_in_browser(author)
     open_review_settings
     within(".review-management[open]") do
-      check "Reset approvals when content changes"
+      check "Require a new review after changes"
       expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
     end
     expect(task.reload.review_status).to eq("approved")
@@ -130,16 +130,16 @@ def open_review_settings
       page.execute_script('const input = document.querySelector("[data-review-reset-policy]"); input.click(); input.click()')
       expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
       expect(page.evaluate_script("window.policyWrites")).to eq([])
-      uncheck "Reset approvals when content changes"
+      uncheck "Require a new review after changes"
       expect(page).to have_css("[data-review-reset-policy][aria-busy='true']")
       expect(page).to have_no_text("Saving…")
       expect(page).to have_no_text("Saved")
       # Wait until the first request is in flight, then change our mind.
       expect(page).to have_selector("[data-review-reset-policy][data-saved-value='true']")
       expect(page).to have_css("[data-review-reset-policy][data-first-policy-write='true']")
-      check "Reset approvals when content changes"
+      check "Require a new review after changes"
       expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
-      expect(page).to have_checked_field("Reset approvals when content changes", disabled: false)
+      expect(page).to have_checked_field("Require a new review after changes", disabled: false)
     end
     expect(plan.reload.reset_reviews_on_change).to be(true)
     expect(page.evaluate_script("window.policyWrites")).to eq([ false, true ])
@@ -161,14 +161,14 @@ def open_review_settings
       }
     JS
     within(".review-management[open]") do
-      uncheck "Reset approvals when content changes"
+      uncheck "Require a new review after changes"
       expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
-      expect(page).to have_unchecked_field("Reset approvals when content changes")
+      expect(page).to have_unchecked_field("Require a new review after changes")
     end
     expect(plan.reload.reset_reviews_on_change).to be(false)
     visit plan_page_path(plan)
     open_review_settings
-    expect(page).to have_unchecked_field("Reset approvals when content changes")
+    expect(page).to have_unchecked_field("Require a new review after changes")
   end
 
   it "restores the saved reset preference after a rejected settings update", :review_reset_policy do
@@ -186,11 +186,11 @@ def open_review_settings
       }
     JS
     within(".review-management[open]") do
-      uncheck "Reset approvals when content changes"
+      uncheck "Require a new review after changes"
       expect(page).to have_text("Unable to save settings")
-      expect(page).to have_checked_field("Reset approvals when content changes", disabled: false)
+      expect(page).to have_checked_field("Require a new review after changes", disabled: false)
       expect(plan.reload.reset_reviews_on_change).to be(true)
-      uncheck "Reset approvals when content changes"
+      uncheck "Require a new review after changes"
       expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
     end
     expect(plan.reload.reset_reviews_on_change).to be(false)
@@ -210,7 +210,7 @@ def open_review_settings
         return result
       }
     JS
-    uncheck "Reset approvals when content changes"
+    uncheck "Require a new review after changes"
     expect(page).to have_css("[data-review-reset-policy][data-committed='true']")
     # Another author tab commits the opposite setting before our response arrives.
     plan.reload.update!(reset_reviews_on_change: true)
@@ -221,7 +221,7 @@ def open_review_settings
     JS
     page.execute_script("window.releasePolicy()")
     expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
-    expect(page).to have_checked_field("Reset approvals when content changes")
+    expect(page).to have_checked_field("Require a new review after changes")
     expect(plan.reload.reset_reviews_on_change).to be(true)
     expect(page).to have_no_css(".review-reset-policy__status[data-state='saved']")
   end
@@ -243,14 +243,14 @@ def open_review_settings
         return originalFetch(url, options)
       }
     JS
-    uncheck "Reset approvals when content changes"
+    uncheck "Require a new review after changes"
     expect(page).to have_css("[data-review-reset-policy][data-in-flight='true']")
     page.execute_script(<<~JS)
       const input = document.querySelector('[data-review-reset-policy]')
       input.click(); input.click(); window.rejectPolicy()
     JS
     expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
-    expect(page).to have_unchecked_field("Reset approvals when content changes")
+    expect(page).to have_unchecked_field("Require a new review after changes")
     expect(plan.reload.reset_reviews_on_change).to be(false)
     expect(page.evaluate_script("window.policyWrites")).to eq([ false, false ])
   end
@@ -259,9 +259,9 @@ def open_review_settings
     sign_in_browser(author)
     open_review_settings
     plan.reload.update!(review_sequence: plan.review_sequence + 1)
-    uncheck "Reset approvals when content changes"
+    uncheck "Require a new review after changes"
     expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
-    expect(page).to have_unchecked_field("Reset approvals when content changes")
+    expect(page).to have_unchecked_field("Require a new review after changes")
     expect(plan.reload.reset_reviews_on_change).to be(false)
     expect(page).to have_no_text("Review settings changed. Please try again.")
   end
@@ -289,16 +289,16 @@ def open_review_settings
           return originalFetch(url, options)
         }
       JS
-      uncheck "Reset approvals when content changes"
+      uncheck "Require a new review after changes"
       expect(page).to have_css("[data-review-reset-policy][data-in-flight='true']")
       if newer_choice
-        check "Reset approvals when content changes"
+        check "Require a new review after changes"
         page.execute_script("window.losePolicy()")
       end
       expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
       page.execute_script("window.deliverOldPolicy()")
       expect(page).to have_css("[data-review-reset-policy][data-old-status='409']")
-      expect(page).to have_checked_field("Reset approvals when content changes")
+      expect(page).to have_checked_field("Require a new review after changes")
       expect(plan.reload.reset_reviews_on_change).to be(true)
     end
   end
@@ -349,12 +349,12 @@ def open_review_settings
         }
         window.restorePolicyNetwork = () => { window.fetch = originalFetch; window.setTimeout = originalTimeout }
       JS
-      uncheck "Reset approvals when content changes"
+      uncheck "Require a new review after changes"
       expect(page).to have_text(/Couldn't confirm|Couldn't reach/)
       expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
-      expect(page).to have_checked_field("Reset approvals when content changes", disabled: false)
+      expect(page).to have_checked_field("Require a new review after changes", disabled: false)
       page.execute_script("window.restorePolicyNetwork()")
-      uncheck "Reset approvals when content changes"
+      uncheck "Require a new review after changes"
       expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
       expect(plan.reload.reset_reviews_on_change).to be(false)
     end
@@ -388,16 +388,16 @@ def open_review_settings
         return originalFetch(url, options)
       }
     JS
-    uncheck "Reset approvals when content changes"
+    uncheck "Require a new review after changes"
     expect(page).to have_css("[data-in-flight='true']")
     page.execute_script("Turbo.visit(arguments[0])", library_page_path(author))
     expect(page).to have_current_path(library_page_path(author))
     page.execute_script("Turbo.visit(arguments[0])", plan_page_path(plan))
     expect(page).to have_current_path(plan_page_path(plan))
     open_review_settings
-    uncheck "Reset approvals when content changes"
+    uncheck "Require a new review after changes"
     expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
-    check "Reset approvals when content changes"
+    check "Require a new review after changes"
     expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
     page.evaluate_async_script(<<~JS)
       const done = arguments[arguments.length - 1]
@@ -407,7 +407,7 @@ def open_review_settings
     expect(page.evaluate_script("window.oldPolicyStatus")).to eq(409)
     expect(page.evaluate_script("window.policyWrites")).to eq([ false, false, true ])
     expect(plan.reload.reset_reviews_on_change).to be(true)
-    expect(page).to have_checked_field("Reset approvals when content changes")
+    expect(page).to have_checked_field("Require a new review after changes")
   end
 
   it "stops a deferred controls refresh when successful HTML is a sign-in page", :review_refresh_failures do
@@ -811,15 +811,18 @@ def open_review_settings
     expect(page).to have_css(".review-tray:popover-open", text: "You approved v1")
   end
 
-  it "refuses sign-off when the viewed version changed and keeps the public note" do
-    within(".review-tray") { click_button "Approve" }
-    fill_in "Public note", with: "An unsent approval note"
-    version = create(:plan_version, plan: plan, revision: 2, content_markdown: "Changed while reviewing")
-    plan.with_lock { CoPlan::Plans::AdvanceVersion.call(plan: plan, version: version) }
-    click_button "Approve v1"
-    expect(page).to have_content("The plan has changed. Review the latest version")
-    expect(page).to have_field("Public note", with: "An unsent approval note")
-    expect(task.review_responses).to be_empty
+  [ true, false ].each do |enabled|
+    it "refuses sign-off on older versions with automatic resets #{enabled ? 'on' : 'off'}", :version_parity do
+      plan.update!(reset_reviews_on_change: enabled)
+      within(".review-tray") { click_button "Approve" }
+      fill_in "Public note", with: "An unsent approval note"
+      version = create(:plan_version, plan: plan, revision: 2, content_markdown: "Changed while reviewing")
+      plan.with_lock { CoPlan::Plans::AdvanceVersion.call(plan: plan, version: version) }
+      click_button "Approve v1"
+      expect(page).to have_content("The plan has changed. Review the latest version")
+      expect(page).to have_field("Public note", with: "An unsent approval note")
+      expect(task.review_responses).to be_empty
+    end
   end
 
   it "keeps feedback tied to the version shown when composition began" do

From 49e574f0318756ab58ee7b27ae66abb9197345d5 Mon Sep 17 00:00:00 2001
From: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
Date: Mon, 2 Nov 2026 04:48:16 -0500
Subject: [PATCH 15/18] Preserve queued review settings across navigation

Signed-off-by: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
---
 .../coplan/review_tray_controller.js          | 12 +++-
 spec/system/plan_reviews_spec.rb              | 56 +++++++++++++++++++
 2 files changed, 65 insertions(+), 3 deletions(-)

diff --git a/engine/app/javascript/controllers/coplan/review_tray_controller.js b/engine/app/javascript/controllers/coplan/review_tray_controller.js
index cfd70d08..91185edc 100644
--- a/engine/app/javascript/controllers/coplan/review_tray_controller.js
+++ b/engine/app/javascript/controllers/coplan/review_tray_controller.js
@@ -340,11 +340,13 @@ export default class extends Controller {
     this.policyMustSave = false
     this.managementErrorTarget.textContent = ""
     let confirmed = false
+    let followupSequence = submittedSequence
     try {
       const result = await this.withPolicyDeadline(signal => this.write(this.settingsUrlValue, "PATCH", { review_settings: { reset_reviews_on_change: enabled, review_sequence: input.dataset.reviewSequence } }, signal))
       if (connection !== this.policyConnection) return
       input.dataset.savedValue = String(enabled)
       input.dataset.reviewSequence = String(result.review_sequence)
+      followupSequence = result.review_sequence
       this.policyConflictRetries = 0
       this.policyUncertainSequence = null
       this.policyFenceAttempted = false
@@ -387,10 +389,14 @@ export default class extends Controller {
     } finally {
       if (connection !== this.policyConnection) return
       this.policySaving = false
-      // A detached controller may reconcile a sent write, but must not rebase
-      // its old choice over preferences saved by the new page.
       if (!connection.active) {
-        input.setAttribute("aria-busy", "false")
+        // Flush a newer unsent choice using only our submitted sequence or its
+        // receipt. A destination-page write wins; never rebase on readback here.
+        if (generation !== this.policyInputGeneration && input.checked !== enabled) {
+          input.dataset.reviewSequence = String(followupSequence)
+          this.policyMustSave = true
+          this.saveResetPolicy(input)
+        } else input.setAttribute("aria-busy", "false")
         return
       }
       // Serialize saves so a slow older request cannot overwrite a newer click.
diff --git a/spec/system/plan_reviews_spec.rb b/spec/system/plan_reviews_spec.rb
index 8e5183fc..e4b697b5 100644
--- a/spec/system/plan_reviews_spec.rb
+++ b/spec/system/plan_reviews_spec.rb
@@ -360,6 +360,62 @@ def open_review_settings
     end
   end
 
+  [ true, false ].each do |destination_changes|
+    it "flushes a queued policy across navigation with destination changes=#{destination_changes}", :review_policy_disconnect do
+      sign_in_browser(author)
+      open_review_settings
+      page.execute_script(<<~JS)
+        const root = document.getElementById('plan-review-controls')
+        const controller = window.Stimulus.getControllerForElementAndIdentifier(root, 'coplan--review-tray')
+        const save = controller.saveResetPolicy.bind(controller)
+        window.policySaves = []
+        controller.saveResetPolicy = (...args) => {
+          const result = save(...args)
+          window.policySaves.push(result)
+          return result
+        }
+        const originalFetch = window.fetch.bind(window)
+        window.policyWrites = []
+        window.fetch = async (url, options) => {
+          if (options?.method === 'PATCH' && String(url).endsWith('/settings')) {
+            const write = {enabled: JSON.parse(options.body).review_settings.reset_reviews_on_change}
+            window.policyWrites.push(write)
+            const response = await originalFetch(url, options)
+            write.status = response.status
+            if (window.policyWrites.length === 1) {
+              root.dataset.committed = 'true'
+              await new Promise(resolve => { window.releaseOldPolicy = resolve })
+            }
+            return response
+          }
+          return originalFetch(url, options)
+        }
+      JS
+      uncheck "Require a new review after changes"
+      expect(page).to have_css("[data-committed='true']")
+      check "Require a new review after changes"
+      page.execute_script("Turbo.visit(arguments[0])", library_page_path(author))
+      expect(page).to have_current_path(library_page_path(author))
+      if destination_changes
+        page.execute_script("Turbo.visit(arguments[0])", plan_page_path(plan))
+        expect(page).to have_current_path(plan_page_path(plan))
+        open_review_settings
+        check "Require a new review after changes"
+        expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+        uncheck "Require a new review after changes"
+        expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+      end
+      page.evaluate_async_script(<<~JS)
+        const done = arguments[arguments.length - 1]
+        window.releaseOldPolicy()
+        window.policySaves[0].then(() => Promise.all(window.policySaves)).then(done)
+      JS
+      writes = page.evaluate_script("window.policyWrites")
+      expect(writes.select { |write| write["status"] == 200 }.map { |write| write["enabled"] }).to eq(destination_changes ? [ false, true, false ] : [ false, true ])
+      expect(plan.reload.reset_reviews_on_change).to eq(!destination_changes)
+    end
+  end
+
   it "does not retry an obsolete policy after Turbo navigation", :review_policy_disconnect do
     sign_in_browser(author)
     open_review_settings

From dc606b7638b8bd13dbce75724fa2dfa49212863b Mon Sep 17 00:00:00 2001
From: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
Date: Mon, 2 Nov 2026 05:00:07 -0500
Subject: [PATCH 16/18] Flush repeated policy choices after failed saves

Signed-off-by: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
---
 .../coplan/review_tray_controller.js          |  2 +-
 spec/system/plan_reviews_spec.rb              | 46 +++++++++++++------
 2 files changed, 33 insertions(+), 15 deletions(-)

diff --git a/engine/app/javascript/controllers/coplan/review_tray_controller.js b/engine/app/javascript/controllers/coplan/review_tray_controller.js
index 91185edc..30721ab2 100644
--- a/engine/app/javascript/controllers/coplan/review_tray_controller.js
+++ b/engine/app/javascript/controllers/coplan/review_tray_controller.js
@@ -392,7 +392,7 @@ export default class extends Controller {
       if (!connection.active) {
         // Flush a newer unsent choice using only our submitted sequence or its
         // receipt. A destination-page write wins; never rebase on readback here.
-        if (generation !== this.policyInputGeneration && input.checked !== enabled) {
+        if (generation !== this.policyInputGeneration && (this.policyMustSave || input.checked !== enabled)) {
           input.dataset.reviewSequence = String(followupSequence)
           this.policyMustSave = true
           this.saveResetPolicy(input)
diff --git a/spec/system/plan_reviews_spec.rb b/spec/system/plan_reviews_spec.rb
index e4b697b5..587ed06c 100644
--- a/spec/system/plan_reviews_spec.rb
+++ b/spec/system/plan_reviews_spec.rb
@@ -360,11 +360,12 @@ def open_review_settings
     end
   end
 
-  [ true, false ].each do |destination_changes|
-    it "flushes a queued policy across navigation with destination changes=#{destination_changes}", :review_policy_disconnect do
+  [ true, false ].product(%w[accepted rejected lost]).each do |destination_changes, outcome|
+    it "flushes a queued policy after a #{outcome} save with destination changes=#{destination_changes}", :review_policy_disconnect do
       sign_in_browser(author)
       open_review_settings
-      page.execute_script(<<~JS)
+      page.execute_script(<<~JS, outcome)
+        const outcome = arguments[0]
         const root = document.getElementById('plan-review-controls')
         const controller = window.Stimulus.getControllerForElementAndIdentifier(root, 'coplan--review-tray')
         const save = controller.saveResetPolicy.bind(controller)
@@ -380,29 +381,41 @@ def open_review_settings
           if (options?.method === 'PATCH' && String(url).endsWith('/settings')) {
             const write = {enabled: JSON.parse(options.body).review_settings.reset_reviews_on_change}
             window.policyWrites.push(write)
-            const response = await originalFetch(url, options)
-            write.status = response.status
+            let response
             if (window.policyWrites.length === 1) {
-              root.dataset.committed = 'true'
+              response = outcome === 'accepted' ? await originalFetch(url, options) : new Response(JSON.stringify({error: 'Rejected'}), {status: 422})
+              root.dataset.requestHeld = 'true'
               await new Promise(resolve => { window.releaseOldPolicy = resolve })
-            }
+              if (outcome === 'lost') throw new TypeError('Lost before saving')
+            } else response = await originalFetch(url, options)
+            write.status = response.status
             return response
           }
           return originalFetch(url, options)
         }
       JS
       uncheck "Require a new review after changes"
-      expect(page).to have_css("[data-committed='true']")
-      check "Require a new review after changes"
+      expect(page).to have_css("[data-request-held='true']")
+      if outcome == "accepted"
+        check "Require a new review after changes"
+      else
+        page.execute_script("const input = document.querySelector('[data-review-reset-policy]'); input.click(); input.click()")
+      end
       page.execute_script("Turbo.visit(arguments[0])", library_page_path(author))
       expect(page).to have_current_path(library_page_path(author))
       if destination_changes
         page.execute_script("Turbo.visit(arguments[0])", plan_page_path(plan))
         expect(page).to have_current_path(plan_page_path(plan))
         open_review_settings
-        check "Require a new review after changes"
-        expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
-        uncheck "Require a new review after changes"
+        if outcome == "accepted"
+          check "Require a new review after changes"
+          expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+          uncheck "Require a new review after changes"
+        else
+          uncheck "Require a new review after changes"
+          expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
+          check "Require a new review after changes"
+        end
         expect(page).to have_no_css("[data-review-reset-policy][aria-busy='true']")
       end
       page.evaluate_async_script(<<~JS)
@@ -411,8 +424,13 @@ def open_review_settings
         window.policySaves[0].then(() => Promise.all(window.policySaves)).then(done)
       JS
       writes = page.evaluate_script("window.policyWrites")
-      expect(writes.select { |write| write["status"] == 200 }.map { |write| write["enabled"] }).to eq(destination_changes ? [ false, true, false ] : [ false, true ])
-      expect(plan.reload.reset_reviews_on_change).to eq(!destination_changes)
+      expected = if outcome == "accepted"
+        destination_changes ? [ false, true, false ] : [ false, true ]
+      else
+        destination_changes ? [ false, true ] : [ false ]
+      end
+      expect(writes.select { |write| write["status"] == 200 }.map { |write| write["enabled"] }).to eq(expected)
+      expect(plan.reload.reset_reviews_on_change).to eq(outcome == "accepted" ? !destination_changes : destination_changes)
     end
   end
 

From 36f618acafc3639b5a4b2d8f169c48050e51773f Mon Sep 17 00:00:00 2001
From: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
Date: Mon, 2 Nov 2026 13:01:14 -0500
Subject: [PATCH 17/18] Pin lint to a supported Ubuntu runner

Signed-off-by: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
---
 .github/workflows/ci.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 94fce7e9..90d97191 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -19,7 +19,8 @@ jobs:
   # test jobs rather than gating them: a bracket-spacing nit should not hide
   # whether the suite passes.
   lint:
-    runs-on: ubuntu-latest
+    # Ruby 3.4.7 has a prebuilt for 24.04, but not the newer ubuntu-latest.
+    runs-on: ubuntu-24.04
 
     steps:
       - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0

From e99c1c587b14babc29fabf645cc2e9e559d7becd Mon Sep 17 00:00:00 2001
From: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
Date: Mon, 2 Nov 2026 13:13:12 -0500
Subject: [PATCH 18/18] Preload current decisions in review readers

Signed-off-by: Sean Prashad <13009507+seanprashad@users.noreply.github.com>
---
 .../coplan/api/v1/plans_controller.rb         |  2 +-
 .../api/v1/review_requests_controller.rb      |  2 +-
 .../views/coplan/reviews/_controls.html.erb   |  2 +-
 spec/requests/review_read_queries_spec.rb     | 58 +++++++++++++++++++
 4 files changed, 61 insertions(+), 3 deletions(-)
 create mode 100644 spec/requests/review_read_queries_spec.rb

diff --git a/engine/app/controllers/coplan/api/v1/plans_controller.rb b/engine/app/controllers/coplan/api/v1/plans_controller.rb
index 29f0bb56..2bf6fdec 100644
--- a/engine/app/controllers/coplan/api/v1/plans_controller.rb
+++ b/engine/app/controllers/coplan/api/v1/plans_controller.rb
@@ -328,7 +328,7 @@ def snapshot
             comment_threads: snapshot_threads_json(threads),
             references: references.map { |r| reference_json(r) },
             collaborators: collaborators.map { |c| collaborator_json(c) },
-            review_requests: @plan.review_requests.includes(:reviewer, :requested_plan_version, review_responses: :plan_version).map { |r| Reviews::Serialize.call(r) }
+            review_requests: @plan.review_requests.includes(:reviewer, :requested_plan_version, current_response: :plan_version, review_responses: :plan_version).map { |r| Reviews::Serialize.call(r) }
           )
         end
 
diff --git a/engine/app/controllers/coplan/api/v1/review_requests_controller.rb b/engine/app/controllers/coplan/api/v1/review_requests_controller.rb
index 015761d5..4fda87e4 100644
--- a/engine/app/controllers/coplan/api/v1/review_requests_controller.rb
+++ b/engine/app/controllers/coplan/api/v1/review_requests_controller.rb
@@ -17,7 +17,7 @@ class ReviewRequestsController < BaseController
         end
 
         def index
-          requests = @plan.review_requests.includes(:reviewer, :requested_plan_version, review_responses: :plan_version)
+          requests = @plan.review_requests.includes(:reviewer, :requested_plan_version, current_response: :plan_version, review_responses: :plan_version)
           render json: { review_requests: requests.map { |request| Reviews::Serialize.call(request) },
                          approval_meaning: "Satisfied with a specific version; grants no execution authority or permissions." }
         end
diff --git a/engine/app/views/coplan/reviews/_controls.html.erb b/engine/app/views/coplan/reviews/_controls.html.erb
index b43e5cc1..8d5bec49 100644
--- a/engine/app/views/coplan/reviews/_controls.html.erb
+++ b/engine/app/views/coplan/reviews/_controls.html.erb
@@ -1,4 +1,4 @@
-<% requests = plan.review_requests.includes(:reviewer, :requested_by_user, :requested_plan_version, review_responses: [ :plan_version, :user ]).order(:requested_at).to_a %>
+<% requests = plan.review_requests.includes(:reviewer, :requested_by_user, :requested_plan_version, current_response: :plan_version, review_responses: [ :plan_version, :user ]).order(:requested_at).to_a %>
 <% request_events = plan.plan_events.where(event_type: %w[review_requested review_withdrawn]).includes(:actor_user).to_a %>
 <% active_requests = requests.reject { |request| request.review_status == "withdrawn" } %>
 <% own_request = active_requests.find { |request| request.reviewer_id == current_user.id } %>
diff --git a/spec/requests/review_read_queries_spec.rb b/spec/requests/review_read_queries_spec.rb
new file mode 100644
index 00000000..89e0f697
--- /dev/null
+++ b/spec/requests/review_read_queries_spec.rb
@@ -0,0 +1,58 @@
+require "rails_helper"
+
+RSpec.describe "Review reader queries", type: :request do
+  let(:author) { create(:coplan_user) }
+  let(:plan) { create(:plan, :published, created_by_user: author, reset_reviews_on_change: false) }
+
+  def add_approval
+    reviewer = create(:coplan_user)
+    request = CoPlan::Reviews::Request.call(plan: plan, reviewer: reviewer, actor: author)
+    CoPlan::Reviews::Respond.call(request: request, actor: reviewer, revision: plan.current_revision, decision: "approved")
+  end
+
+  def advance_version
+    CoPlan::Plans::ReplaceContent.call(plan: plan, new_content: "#{plan.current_content}\nMore detail.\n",
+      base_revision: plan.current_revision, actor_type: "human", actor_id: author.id)
+  end
+
+  def response_queries
+    count = 0
+    subscriber = lambda do |*, payload|
+      count += 1 if !payload[:cached] && payload[:sql].match?(/\bFROM\s+[`"]coplan_review_responses[`"] /i)
+    end
+    ActiveSupport::Notifications.subscribed(subscriber, "sql.active_record") { yield }
+    expect(response).to have_http_status(:ok)
+    count
+  end
+
+  %i[controls api snapshot].each do |reader|
+    it "keeps #{reader} response queries constant as retained reviews grow" do
+      sign_in_as(author)
+      create(:api_token, user: author, raw_token: "query-review-owner", agent_name: "Querybot")
+      add_approval
+      advance_version
+      path = case reader
+      when :controls then plan_review_requests_path(plan)
+      when :api then api_v1_plan_review_requests_path(plan)
+      when :snapshot then snapshot_api_v1_plan_path(plan)
+      end
+      headers = { "Authorization" => "Bearer query-review-owner" }
+      few = response_queries { get path, headers: headers }
+
+      3.times { add_approval }
+      advance_version
+      many = response_queries { get path, headers: headers }
+
+      if reader == :controls
+        expect(Nokogiri::HTML(response.body).css(".review-table tbody .review-person").size).to eq(4)
+        expect(response.body).to include("Current: v3")
+      else
+        reviews = response.parsed_body.fetch("review_requests")
+        expect(reviews.size).to eq(4)
+        expect(reviews).to all(include("review_status" => "approved", "effective_status" => "pending"))
+        expect(reviews.map { |review| review.fetch("recorded_response_id") }).to all(be_present)
+      end
+      expect(many).to eq(few)
+    end
+  end
+end