diff --git a/README.md b/README.md
index bde7b06..c29257f 100644
--- a/README.md
+++ b/README.md
@@ -74,6 +74,12 @@ A lightweight, model-agnostic repository template for agentic software engineeri
    the resulting implementation.
    Approved `DEFER` findings become linked follow-up Issues; `ACCEPT` findings
    retain their rationale in the triage artifact.
-9. Commit, push, and open a PR containing `Closes #12`. After CI and required gates pass, merge the PR and clean up the worktree.
+9. After a new review round confirms the fixes, commit with the closing checks:
+
+   ```bash
+   ./scripts/finish-feature.sh 12 "Implement player movement"
+   ```
+
+   Then push and open a PR containing `Closes #12`. After CI and required gates pass, merge the PR and clean up the worktree.
 
 See `docs/development.md` for commands, `docs/agentic-workflow.md` for the lifecycle, and `.agents/policies/` for boundaries.
diff --git a/docs/agentic-workflow.md b/docs/agentic-workflow.md
index 9a08740..8cb24fc 100644
--- a/docs/agentic-workflow.md
+++ b/docs/agentic-workflow.md
@@ -9,7 +9,7 @@ ready work.
 Roadmap item → GitHub Issue → feature plan (when warranted) → isolated
 branch/worktree → implementation → local verification → independent review
 when required → review triage → approved fix-now application →
-verification/re-review when needed → commit → push/PR → CI → human gate where
+verification/re-review when needed → `finish-feature.sh` → push/PR → CI → human gate where
 required → merge → automatic Issue closure → cleanup.
 
 Independent review happens before the implementation commit so it can include
diff --git a/docs/development.md b/docs/development.md
index b30c009..f40358c 100644
--- a/docs/development.md
+++ b/docs/development.md
@@ -481,12 +481,42 @@ Check a review yourself with:
 
 It exits 0 when the review is current, 1 when it is stale, and 2 on an error.
 
-Verify again after review fixes, then commit and push:
+### Finishing a feature
+
+When the latest review round is resolved, finish the feature from its
+worktree:
+
+```bash
+./scripts/finish-feature.sh 12 "Implement player movement"
+```
+
+The script refuses another branch than `feature/12-*` or a tree without
+changes, runs `./scripts/verify.sh`, and checks the latest review of the
+feature: it must be current and have no critical or major finding. Every
+review round with findings needs an approved triage that was published on the
+Issue (the newest triage of that round counts), and the latest round may have
+no `FIX_NOW` findings left to apply. After fixes, run a new review round first;
+a passed newer round confirms the fixes of earlier rounds. A failed
+publication can be repeated with `./scripts/triage-review.sh --publish
+<triage-json>`.
+
+It then stages all changes (review and triage files are ignored) and opens a
+structured commit message in your editor: the summary, the Issue, a list of
+changes to fill in, the verification, the review round and verdict, and
+`Refs #12`. Emptying the message aborts the commit and leaves the changes
+staged. The script never pushes, opens a PR, or merges.
+
+A change that `.agents/policies/autonomy.md` classifies as low risk may be
+finished without an independent review; the reason is recorded in the commit
+message:
+
+```bash
+./scripts/finish-feature.sh 12 "Fix a typo in the README" --no-review "documentation only"
+```
+
+Then push and open the pull request:
 
 ```bash
-./scripts/verify.sh
-git add .
-git commit -m "Implement player movement"
 git push -u origin feature/12-player-movement
 ```
 
@@ -515,8 +545,5 @@ repository-relative plan path; the detailed plan remains in `.agents/plans/`.
 Roadmap item → GitHub Issue → optional implementation plan → isolated feature
 worktree → implementation → verification → independent review when required →
 triage → apply approved `FIX_NOW` findings → verification/re-review when needed
-→ commit → push/PR → CI and gates → merge → automatic Issue closure → worktree
-cleanup.
-
-Do not use `scripts/finish-feature.sh` as part of this flow until it has been
-redesigned or deprecated; its interface predates the current review script.
+→ `finish-feature.sh` (checks and commit) → push/PR → CI and gates → merge →
+automatic Issue closure → worktree cleanup.
diff --git a/scripts/finish-feature.sh b/scripts/finish-feature.sh
index 60f1263..4e9f8be 100755
--- a/scripts/finish-feature.sh
+++ b/scripts/finish-feature.sh
@@ -1,10 +1,163 @@
 #!/usr/bin/env bash
+
 set -euo pipefail
-./scripts/verify.sh
-if [[ -n "$(git status --porcelain)" ]]; then
-  echo "Working tree has changes. Review them before committing."
-  git status --short
-  exit 2
+
+script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
+source "$script_dir/lib/review-data.sh"
+source "$script_dir/lib/fingerprint.sh"
+
+usage() {
+  echo "Usage: $0 <issue-number> \"<commit summary>\" [--no-review \"<reason>\"]"
+  echo
+  echo "Run in the feature worktree. Checks that verification passes and that the"
+  echo "latest independent review is current and resolved, then commits the feature"
+  echo "with an editable, structured message. It never pushes or merges."
+  echo
+  echo "--no-review is only for changes that .agents/policies/autonomy.md classifies"
+  echo "as low risk; the reason is recorded in the commit message."
+  exit 1
+}
+
+fail() {
+  echo "Error: $*" >&2
+  exit 1
+}
+
+# latest_triage <review-json>: prints the newest triage of a review. The first
+# triage has no number (-triage.json); later ones are numbered (-triage-02.json).
+latest_triage() {
+  local base
+  local number
+  local best=""
+  local best_number=0
+  local candidate
+
+  base="$root/.agents/triage/$(basename "$1" .json)"
+  [[ ! -f "$base-triage.json" ]] || { best="$base-triage.json"; best_number=1; }
+  for candidate in "$base-triage-"[0-9][0-9].json; do
+    [[ -f "$candidate" ]] || continue
+    number="${candidate%.json}"
+    number="${number##*-}"
+    if ((10#$number > best_number)); then
+      best="$candidate"
+      best_number=$((10#$number))
+    fi
+  done
+  printf '%s' "$best"
+}
+
+[[ $# -eq 2 || ( $# -eq 4 && "$3" == "--no-review" ) ]] || usage
+issue="$1"
+summary="$2"
+no_review_reason="${4:-}"
+
+[[ "$issue" =~ ^[0-9]+$ ]] || fail "issue number must be numeric: $issue"
+[[ "$summary" =~ [^[:space:]] ]] || fail "the commit summary is empty."
+[[ $# -eq 2 || "$no_review_reason" =~ [^[:space:]] ]] || fail "--no-review requires a reason."
+
+root="$(git rev-parse --show-toplevel)"
+branch="$(git branch --show-current)"
+[[ "$branch" == feature/${issue}-* ]] ||
+  fail "finish-feature.sh must run on feature/${issue}-*. Current branch: $branch"
+
+[[ -n "$(git -C "$root" status --porcelain)" ]] || fail "there are no changes to commit."
+review_data_require_jq
+
+# 1. Verification passes.
+echo "Running repository verification..."
+(cd "$root" && ./scripts/verify.sh) || fail "verification failed; nothing was committed."
+echo
+
+# 2. The latest review is current and resolved, unless explicitly skipped.
+if [[ -n "$no_review_reason" ]]; then
+  review_line="Review: no independent review (low risk: $no_review_reason)"
+else
+  slug="${branch//\//-}"
+  shopt -s nullglob
+  reviews=("$root/.agents/reviews/${slug}-review-"[0-9][0-9].json)
+  shopt -u nullglob
+  [[ "${#reviews[@]}" -gt 0 ]] ||
+    fail "no review of this feature exists. Run ./scripts/review-feature.sh $issue, or use --no-review for a low-risk change."
+  latest="${reviews[${#reviews[@]}-1]}"
+  latest_relative="${latest#"$root"/}"
+
+  errors="$(review_artifact_errors "$latest")"
+  [[ -z "$errors" ]] || fail "the latest review is invalid: ${errors//$'\n'/; }"
+  [[ "$(jq -r '.kind // "feature"' "$latest")" == "feature" && "$(jq -r '.issue' "$latest")" == "$issue" ]] ||
+    fail "$latest_relative is not a review of Issue #$issue."
+
+  tmp_work="$(mktemp -d "${TMPDIR:-/tmp}/finish-feature.XXXXXX")"
+  trap 'rm -rf "$tmp_work"' EXIT
+  current=0
+  review_is_current "$root" "$tmp_work" "$latest" || current=$?
+  case "$current" in
+    0) ;;
+    1) fail "the latest review ($latest_relative) is stale: the code changed after it. Run ./scripts/review-feature.sh $issue again." ;;
+    *) fail "could not compute the fingerprint of the working tree." ;;
+  esac
+
+  round="$(jq -r '.round' "$latest")"
+  verdict="$(jq -r '.verdict | gsub("_"; " ")' "$latest")"
+  blocking="$(jq '[.findings[] | select(.severity == "critical" or .severity == "major")] | length' "$latest")"
+  [[ "$blocking" -eq 0 ]] ||
+    fail "the latest review (round $round) has $blocking critical or major finding(s). Triage, fix, and review again."
+
+  # Every round with findings needs an approved triage that was published on
+  # the Issue; only the latest round may not have FIX_NOW findings left, since
+  # a newer, current review confirms the fixes of earlier rounds.
+  triage_note=""
+  for review in "${reviews[@]}"; do
+    [[ "$(jq '.findings | length' "$review")" -gt 0 ]] || continue
+    review_round="$(jq -r '.round' "$review")"
+    triage="$(latest_triage "$review")"
+    [[ -n "$triage" ]] ||
+      fail "the findings of round $review_round are not triaged. Run ./scripts/triage-review.sh ${review#"$root"/}."
+    triage_relative="${triage#"$root"/}"
+    errors="$(triage_artifact_errors "$triage" "$review")"
+    [[ -z "$errors" ]] || fail "the triage of round $review_round is invalid: ${errors//$'\n'/; }"
+    [[ "$(jq -r '.published_at // empty' "$triage")" != "" ]] ||
+      fail "the triage of round $review_round was not published on Issue #$issue. Run ./scripts/triage-review.sh --publish $triage_relative."
+    if [[ "$review" == "$latest" ]]; then
+      [[ "$(jq '[.decisions[] | select(.decision == "FIX_NOW")] | length' "$triage")" -eq 0 ]] ||
+        fail "round $review_round has FIX_NOW findings. Apply them with ./scripts/apply-triage.sh $triage_relative and review again."
+    fi
+    triage_note="; triage published on #$issue"
+  done
+  review_line="Review: round $round, $verdict, by $(jq -r '"\(.reviewer.agent) (\(.reviewer.model))"' "$latest")$triage_note"
 fi
-./scripts/review-feature.sh "${1:-main}"
-echo "Stable commit verified. Complete independent review before push/PR."
+
+# 3. Stage everything and commit with an editable, structured message.
+git -C "$root" add -A
+echo "Changes to commit:"
+git -C "$root" status --short
+echo
+
+message_file="$(mktemp "${TMPDIR:-/tmp}/finish-feature-message.XXXXXX")"
+trap 'rm -f "$message_file"; [[ -z "${tmp_work:-}" ]] || rm -rf "$tmp_work"' EXIT
+cat >"$message_file" <<EOF
+$summary
+
+Issue: #$issue
+
+Changes:
+- TODO: summarize the main changes
+
+Verification:
+- ./scripts/verify.sh passed
+
+$review_line
+
+Refs #$issue
+EOF
+
+if ! git -C "$root" commit --edit -F "$message_file"; then
+  echo "Error: the commit was not created. The changes remain staged." >&2
+  exit 1
+fi
+
+echo
+echo "Committed $(git -C "$root" rev-parse --short HEAD) on $branch."
+echo
+echo "Next steps:"
+echo "  git push -u origin $branch"
+echo "  Open a pull request whose description contains: Closes #$issue"
diff --git a/scripts/lib/review-data.sh b/scripts/lib/review-data.sh
index 48dc0ae..d630882 100644
--- a/scripts/lib/review-data.sh
+++ b/scripts/lib/review-data.sh
@@ -301,8 +301,11 @@ triage_artifact_errors() {
     if type != "object" or .schema != "triage/v1" then
       "the file is not a triage/v1 artifact"
     else
-      unexpected(["approved_at", "decisions", "issue", "review_verdict", "reviewed_tree",
+      unexpected(["approved_at", "decisions", "issue", "published_at", "review_verdict", "reviewed_tree",
                   "schema", "source_review", "triage"]; "the triage"),
+      (if .published_at == null or ((.published_at | type) == "string"
+          and (.published_at | test("^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z$"))) then empty
+       else "published_at must be a UTC timestamp" end),
       (if (.approved_at | type) == "string"
           and (.approved_at | test("^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z$")) then empty
        else "the triage has no valid UTC approval timestamp" end),
diff --git a/scripts/triage-review.sh b/scripts/triage-review.sh
index e9cdacd..cf7bbbb 100755
--- a/scripts/triage-review.sh
+++ b/scripts/triage-review.sh
@@ -9,6 +9,7 @@ source "$script_dir/lib/fingerprint.sh"
 
 usage() {
   echo "Usage: $0 <review-json> [--agent <agent>] [--model <model>]"
+  echo "       $0 --publish <triage-json> [--mark-only]"
   echo
   echo "The agent and model come from role 'triage' in .agents/agents.conf"
   echo "unless --agent and --model are given."
@@ -24,7 +25,123 @@ fail() {
   exit 1
 }
 
+# publish_triage: publishes the stored triage <artifact>.json and its source
+# review as a comment on the source Issue and records the publication.
+# The reports are published on the Issue instead of being committed, rendered
+# from the validated JSON. A comment holds at most 65,536 characters: when both
+# reports do not fit in one comment, they are published in numbered parts, so
+# the record is never shortened.
+publish_triage() {
+  round="$(jq -r '.round' "$review_path")"
+  comment_base="$artifact-comment"
+  rm -f "$comment_base"*.md
+  heading="## Independent review and triage — round $round"
+  {
+    echo "Reviewer verdict: $(jq -r '.verdict | gsub("_"; " ")' "$review_path")"
+    echo
+    echo "<details>"
+    echo "<summary>Review report</summary>"
+    echo
+    review_render_markdown "$review_path" "$review_stem.json" | sed '1{/^<!-- Generated/d;}'
+    echo
+    echo "</details>"
+    echo
+    sed '1{/^<!-- Generated/d;}' "$artifact.md"
+  } >"$tmp_work/comment-body.md"
+
+  comment_limit=60000
+  if [[ "$(wc -c <"$tmp_work/comment-body.md")" -le "$comment_limit" ]]; then
+    { echo "$heading"; echo; cat "$tmp_work/comment-body.md"; } >"$comment_base.md"
+  else
+    # Split on line boundaries; a part never ends inside a line.
+    awk -v limit="$comment_limit" -v base="$tmp_work/part-" '
+      BEGIN { part = 1; size = 0 }
+      {
+        line_size = length($0) + 1
+        if (size > 0 && size + line_size > limit) { part++; size = 0 }
+        print > (base part ".md")
+        size += line_size
+      }
+    ' "$tmp_work/comment-body.md"
+    parts="$(find "$tmp_work" -name 'part-*.md' | wc -l | tr -d ' ')"
+    for ((part = 1; part <= parts; part++)); do
+      {
+        echo "$heading (part $part of $parts)"
+        echo
+        cat "$tmp_work/part-$part.md"
+      } >"$comment_base-$part.md"
+    done
+  fi
+
+  comment_files=()
+  if [[ -f "$comment_base.md" ]]; then
+    comment_files=("$comment_base.md")
+  else
+    for ((part = 1; part <= parts; part++)); do
+      comment_files+=("$comment_base-$part.md")
+    done
+  fi
+
+  echo
+  for index in "${!comment_files[@]}"; do
+    if ! gh issue comment "$source_issue" --body-file "${comment_files[$index]}" </dev/null >/dev/null; then
+      echo "Error: publishing the reports on Issue #$source_issue failed. The triage is stored." >&2
+      if [[ "$index" -gt 0 ]]; then
+        echo "Parts 1 to $index of ${#comment_files[@]} were published; publish the rest in this order with:" >&2
+        for ((retry = index; retry < ${#comment_files[@]}; retry++)); do
+          echo "  gh issue comment $source_issue --body-file ${comment_files[$retry]#"$root"/}" >&2
+        done
+        echo "and then record the publication with: ./scripts/triage-review.sh --publish ${artifact#"$root"/}.json --mark-only" >&2
+      else
+        echo "Retry with: ./scripts/triage-review.sh --publish ${artifact#"$root"/}.json" >&2
+      fi
+      exit 1
+    fi
+  done
+  mark_published
+  echo "Published the review and triage reports on Issue #$source_issue (${#comment_files[@]} comment(s))."
+}
+
+# mark_published: records in <artifact>.json when its reports were published.
+mark_published() {
+  jq --arg at "$(date -u +'%Y-%m-%dT%H:%M:%SZ')" '. + {published_at: $at}' "$artifact.json" >"$artifact.json.tmp"
+  mv "$artifact.json.tmp" "$artifact.json"
+}
+
 agent_parse_args "$@"
+
+# --publish <triage-json> [--mark-only]: publish a stored triage again, or only
+# record that it was published by hand.
+if [[ "${AGENT_POSITIONAL[0]:-}" == "--publish" ]]; then
+  [[ "${#AGENT_POSITIONAL[@]}" -eq 2 || ( "${#AGENT_POSITIONAL[@]}" -eq 3 && "${AGENT_POSITIONAL[2]}" == "--mark-only" ) ]] || usage
+  root="$(git rev-parse --show-toplevel)"
+  review_data_require_jq
+  [[ -f "${AGENT_POSITIONAL[1]}" ]] || fail "triage artifact not found: ${AGENT_POSITIONAL[1]}"
+  triage_path="$(cd "$(dirname "${AGENT_POSITIONAL[1]}")" && pwd -P)/$(basename "${AGENT_POSITIONAL[1]}")"
+  [[ "$triage_path" == "$root/.agents/triage/"*.json ]] || fail "triage artifact must match .agents/triage/*.json"
+  source_review_relative="$(triage_source_review "$triage_path")"
+  [[ "$source_review_relative" =~ ^\.agents/reviews/[^/]+\.json$ && -f "$root/$source_review_relative" ]] ||
+    fail "the source review of the triage is missing: $source_review_relative"
+  review_path="$root/$source_review_relative"
+  errors="$(review_artifact_errors "$review_path"; triage_artifact_errors "$triage_path" "$review_path")"
+  [[ -z "$errors" ]] || fail "invalid triage or review: ${errors//$'\n'/; }"
+  artifact="${triage_path%.json}"
+  review_stem="$(basename "$review_path" .json)"
+  source_issue="$(jq -r '.issue' "$triage_path")"
+  if [[ "${AGENT_POSITIONAL[2]:-}" == "--mark-only" ]]; then
+    mark_published
+    echo "Recorded the publication of ${artifact#"$root"/}.json."
+    exit 0
+  fi
+  command -v gh >/dev/null 2>&1 || fail "GitHub CLI 'gh' is not installed."
+  gh auth status >/dev/null 2>&1 || fail "GitHub CLI is not authenticated. Run: gh auth login"
+  tmp_work="$(mktemp -d "${TMPDIR:-/tmp}/triage-review.XXXXXX")"
+  trap 'rm -rf "$tmp_work"' EXIT
+  [[ -f "$artifact.md" ]] || triage_render_markdown "$artifact.json" "$(basename "$artifact").json" >"$artifact.md"
+  publish_triage
+  exit 0
+fi
+
 if [[ "${#AGENT_POSITIONAL[@]}" -ne 1 ]]; then
   usage
 fi
@@ -367,69 +484,4 @@ echo
 jq '.decisions' "$artifact.json" >"$tmp_work/final.json"
 render_proposal "$tmp_work/final.json"
 
-# The reports are published on the Issue instead of being committed, rendered
-# from the validated JSON. A comment holds at most 65,536 characters: when both
-# reports do not fit in one comment, they are published in numbered parts, so
-# the record is never shortened.
-round="$(jq -r '.round' "$review_path")"
-comment_base="$artifact-comment"
-rm -f "$comment_base"*.md
-heading="## Independent review and triage — round $round"
-{
-  echo "Reviewer verdict: $(jq -r '.verdict | gsub("_"; " ")' "$review_path")"
-  echo
-  echo "<details>"
-  echo "<summary>Review report</summary>"
-  echo
-  review_render_markdown "$review_path" "$review_stem.json" | sed '1{/^<!-- Generated/d;}'
-  echo
-  echo "</details>"
-  echo
-  sed '1{/^<!-- Generated/d;}' "$artifact.md"
-} >"$tmp_work/comment-body.md"
-
-comment_limit=60000
-if [[ "$(wc -c <"$tmp_work/comment-body.md")" -le "$comment_limit" ]]; then
-  { echo "$heading"; echo; cat "$tmp_work/comment-body.md"; } >"$comment_base.md"
-else
-  # Split on line boundaries; a part never ends inside a line.
-  awk -v limit="$comment_limit" -v base="$tmp_work/part-" '
-    BEGIN { part = 1; size = 0 }
-    {
-      line_size = length($0) + 1
-      if (size > 0 && size + line_size > limit) { part++; size = 0 }
-      print > (base part ".md")
-      size += line_size
-    }
-  ' "$tmp_work/comment-body.md"
-  parts="$(find "$tmp_work" -name 'part-*.md' | wc -l | tr -d ' ')"
-  for ((part = 1; part <= parts; part++)); do
-    {
-      echo "$heading (part $part of $parts)"
-      echo
-      cat "$tmp_work/part-$part.md"
-    } >"$comment_base-$part.md"
-  done
-fi
-
-comment_files=()
-if [[ -f "$comment_base.md" ]]; then
-  comment_files=("$comment_base.md")
-else
-  for ((part = 1; part <= parts; part++)); do
-    comment_files+=("$comment_base-$part.md")
-  done
-fi
-
-echo
-for index in "${!comment_files[@]}"; do
-  if ! gh issue comment "$source_issue" --body-file "${comment_files[$index]}" </dev/null >/dev/null; then
-    echo "Error: publishing the reports on Issue #$source_issue failed. The triage is stored." >&2
-    echo "Retry the unpublished part(s) in this order with:" >&2
-    for ((retry = index; retry < ${#comment_files[@]}; retry++)); do
-      echo "  gh issue comment $source_issue --body-file ${comment_files[$retry]#"$root"/}" >&2
-    done
-    exit 1
-  fi
-done
-echo "Published the review and triage reports on Issue #$source_issue (${#comment_files[@]} comment(s))."
+publish_triage
diff --git a/scripts/verify.conf b/scripts/verify.conf
index 43d0332..9776f38 100644
--- a/scripts/verify.conf
+++ b/scripts/verify.conf
@@ -33,6 +33,7 @@ review-feature: ./tests/review-feature-test.sh
 review-planning: ./tests/review-planning-test.sh
 revise-planning: ./tests/revise-planning-test.sh
 finish-planning: ./tests/finish-planning-test.sh
+finish-feature: ./tests/finish-feature-test.sh
 triage-review: ./tests/triage-review-test.sh
 apply-triage: ./tests/apply-triage-test.sh
 start-planning: ./tests/start-planning-test.sh
diff --git a/tests/finish-feature-test.sh b/tests/finish-feature-test.sh
new file mode 100755
index 0000000..0753d15
--- /dev/null
+++ b/tests/finish-feature-test.sh
@@ -0,0 +1,216 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+# Run as on CI: without the user's global or system Git configuration, so a
+# test cannot depend on a local Git identity or setting.
+export GIT_CONFIG_GLOBAL=/dev/null GIT_CONFIG_NOSYSTEM=1
+
+source_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd -P)"
+tmp="$(mktemp -d "${TMPDIR:-/tmp}/finish-feature-test.XXXXXX")"
+
+cleanup() {
+  rm -rf "$tmp"
+}
+trap cleanup EXIT
+
+fail() {
+  echo "finish-feature test failed: $*" >&2
+  exit 1
+}
+
+source "$source_root/tests/lib-fakes.sh"
+make_fake_agents "$tmp/bin"
+
+review=".agents/reviews/feature-12-marker-review-01.json"
+triage=".agents/triage/feature-12-marker-review-01-triage.json"
+
+# Creates a feature repository with an uncommitted change and a current review.
+# setup_repo <label> <verdict> <findings-json>
+setup_repo() {
+  local repo="$tmp/$1"
+
+  mkdir -p "$repo/.agents/reviews" "$repo/.agents/triage"
+  copy_workflow "$repo"
+  cp "$source_root/.gitignore" "$repo/.gitignore"
+  printf 'marker: test -f AGENTS.md\n' >"$repo/scripts/verify.conf"
+  printf '# Agents\n' >"$repo/AGENTS.md"
+  git -C "$repo" init -q -b main
+  git -C "$repo" config user.name "Finish Test"
+  git -C "$repo" config user.email "finish-test@example.com"
+  git -C "$repo" add .
+  git -C "$repo" commit -qm "Seed"
+  git -C "$repo" switch -q -c feature/12-marker
+  printf 'feature work\n' >"$repo/feature.txt"
+
+  jq -n --arg verdict "$2" --argjson findings "$3" '{
+    schema: "review/v1", kind: "feature", issue: 12, round: 1,
+    branch: "feature/12-marker", base: "main", merge_base: "aaaa", head: "bbbb",
+    reviewed_tree: "", reviewed_paths: null,
+    reviewer: {agent: "claude", model: "model-r"}, created_at: "2026-01-01T00:00:00Z",
+    verdict: $verdict, limitations: "", findings: $findings
+  }' >"$repo/$review"
+  record_reviewed_tree "$repo" "$repo/$review"
+
+  printf '%s\n' "$repo"
+}
+
+# add_triage <repo> <decision> [published]
+add_triage() {
+  local repo="$1"
+
+  jq --arg decision "$2" --arg published "${3:-yes}" '{
+    schema: "triage/v1", source_review: ".agents/reviews/feature-12-marker-review-01.json", issue,
+    reviewed_tree, review_verdict: .verdict, triage: {agent: "codex", model: "model-t"},
+    approved_at: "2026-01-02T00:00:00Z",
+    decisions: [.findings[] | {finding_id: .id, severity, title, decision: $decision, rationale: "Considered.",
+      followup: (if $decision == "DEFER" then {title: "[#12][R01][\(.id)] Later", recommended_action: "Later.",
+        acceptance_criteria: ["Done."], issue_number: 99, issue_url: "https://github.com/example/project/issues/99"} else null end)}]
+  } + (if $published == "yes" then {published_at: "2026-01-02T00:01:00Z"} else {} end)' "$repo/$review" >"$repo/$triage"
+}
+
+minor='[{"id": "MIN1", "severity": "minor", "title": "Vague name", "evidence": "feature.txt:1", "impact": "Readability.", "recommendation": "Rename."}]'
+major='[{"id": "M1", "severity": "major", "title": "Wrong result", "evidence": "feature.txt:1", "impact": "Bug.", "recommendation": "Fix."}]'
+
+run_finish() {
+  local repo="$1"
+  shift
+
+  (
+    cd "$repo"
+    PATH="$tmp/bin:/usr/bin:/bin" GIT_EDITOR="${EDITOR_COMMAND:-true}" ./scripts/finish-feature.sh "$@"
+  ) >"$repo.out" 2>&1
+}
+
+expect_no_commit() {
+  local repo="$1"
+  local description="$2"
+  shift 2
+
+  if run_finish "$repo" "$@"; then
+    cat "$repo.out" >&2
+    fail "expected refusal: $description"
+  fi
+  [[ "$(git -C "$repo" rev-list --count HEAD)" -eq 1 ]] || fail "a commit was created although: $description"
+}
+
+message() {
+  git -C "$1" log -1 --format=%B
+}
+
+# A feature with a passed, current review is committed with a structured
+# message; review and triage files are not committed.
+repo="$(setup_repo pass PASS "[]")"
+run_finish "$repo" 12 "Add the marker" || {
+  cat "$repo.out" >&2
+  fail "finishing a reviewed feature failed"
+}
+[[ "$(git -C "$repo" rev-list --count HEAD)" -eq 2 ]] || fail "no commit was created"
+for line in "Add the marker" "Issue: #12" "Review: round 1, PASS, by claude (model-r)" "Refs #12"; do
+  message "$repo" | grep -Fqx "$line" || fail "the commit message lacks: $line"
+done
+git -C "$repo" show --name-only --format= HEAD | grep -Fqx "feature.txt" || fail "the feature change was not committed"
+if git -C "$repo" show --name-only --format= HEAD | grep -Fq ".agents/reviews/"; then
+  fail "a review file was committed"
+fi
+grep -Fq "Closes #12" "$repo.out" || fail "the next steps do not mention the pull request"
+
+# Minor findings that were triaged without FIX_NOW and published are fine.
+repo="$(setup_repo minor PASS_WITH_MINOR_FINDINGS "$minor")"
+add_triage "$repo" DEFER
+run_finish "$repo" 12 "Add the marker" || {
+  cat "$repo.out" >&2
+  fail "finishing with published, deferred minor findings failed"
+}
+message "$repo" | grep -Fq "triage published on #12" || fail "the commit message does not mention the published triage"
+
+# add_second_round <repo>: a passed, current review round 2.
+add_second_round() {
+  jq '.round = 2 | .verdict = "PASS" | .findings = []' "$1/$review" >"$1/.agents/reviews/feature-12-marker-review-02.json"
+  record_reviewed_tree "$1" "$1/.agents/reviews/feature-12-marker-review-02.json"
+}
+
+# A newer, passed round confirms the FIX_NOW fixes of an earlier round, but
+# does not excuse an earlier round that was never triaged or published.
+repo="$(setup_repo fixed-in-round-2 CHANGES_REQUIRED "$major")"
+add_triage "$repo" FIX_NOW
+printf 'fixed\n' >>"$repo/feature.txt"
+add_second_round "$repo"
+run_finish "$repo" 12 "Add the marker" || {
+  cat "$repo.out" >&2
+  fail "a passed second round after applied fixes was refused"
+}
+message "$repo" | grep -Fq "Review: round 2, PASS" || fail "the commit message does not name the final round"
+
+repo="$(setup_repo untriaged-round-1 PASS_WITH_MINOR_FINDINGS "$minor")"
+add_second_round "$repo"
+expect_no_commit "$repo" "round 1 was never triaged" 12 "Add the marker"
+
+repo="$(setup_repo unpublished-round-1 PASS_WITH_MINOR_FINDINGS "$minor")"
+add_triage "$repo" ACCEPT no
+add_second_round "$repo"
+expect_no_commit "$repo" "the triage of round 1 was never published" 12 "Add the marker"
+
+# The newest triage of a round counts, by number: -triage-02 after -triage.
+repo="$(setup_repo newest-triage PASS_WITH_MINOR_FINDINGS "$minor")"
+add_triage "$repo" ACCEPT
+cp "$repo/$triage" "${repo}/.agents/triage/feature-12-marker-review-01-triage-02.json"
+jq 'del(.published_at)' "${repo}/.agents/triage/feature-12-marker-review-01-triage-02.json" >"$tmp/triage.tmp"
+mv "$tmp/triage.tmp" "${repo}/.agents/triage/feature-12-marker-review-01-triage-02.json"
+expect_no_commit "$repo" "the newest triage was not published" 12 "Add the marker"
+
+# A low-risk change may be finished without a review; the reason is recorded.
+repo="$(setup_repo no-review PASS "[]")"
+rm "$repo/$review"
+run_finish "$repo" 12 "Fix a typo" --no-review "documentation typo" || {
+  cat "$repo.out" >&2
+  fail "finishing without a review failed"
+}
+message "$repo" | grep -Fqx "Review: no independent review (low risk: documentation typo)" ||
+  fail "the commit message does not record the missing review"
+
+# An emptied commit message creates no commit.
+repo="$(setup_repo abort PASS "[]")"
+EDITOR_COMMAND='sh -c ": > \"\$0\""' expect_no_commit "$repo" "the commit message was emptied" 12 "Add the marker"
+
+# Refusals.
+repo="$(setup_repo wrong-branch PASS "[]")"
+git -C "$repo" switch -q -c feature/13-other
+expect_no_commit "$repo" "the branch belongs to another Issue" 12 "Add the marker"
+
+repo="$(setup_repo nothing PASS "[]")"
+rm "$repo/feature.txt"
+expect_no_commit "$repo" "there are no changes" 12 "Add the marker"
+
+repo="$(setup_repo verification-fails PASS "[]")"
+printf 'broken: false\n' >"$repo/scripts/verify.conf"
+record_reviewed_tree "$repo" "$repo/$review"
+expect_no_commit "$repo" "verification fails" 12 "Add the marker"
+
+repo="$(setup_repo no-review-file PASS "[]")"
+rm "$repo/$review"
+expect_no_commit "$repo" "there is no review" 12 "Add the marker"
+
+repo="$(setup_repo stale PASS "[]")"
+printf 'more work\n' >>"$repo/feature.txt"
+expect_no_commit "$repo" "the review is stale" 12 "Add the marker"
+
+repo="$(setup_repo major CHANGES_REQUIRED "$major")"
+expect_no_commit "$repo" "the review has a major finding" 12 "Add the marker"
+
+repo="$(setup_repo untriaged PASS_WITH_MINOR_FINDINGS "$minor")"
+expect_no_commit "$repo" "the findings are not triaged" 12 "Add the marker"
+
+repo="$(setup_repo unpublished PASS_WITH_MINOR_FINDINGS "$minor")"
+add_triage "$repo" ACCEPT no
+expect_no_commit "$repo" "the triage was not published" 12 "Add the marker"
+grep -Fq -- "--publish" "$repo.out" || fail "an unpublished triage did not point to --publish"
+
+repo="$(setup_repo fix-pending PASS_WITH_MINOR_FINDINGS "$minor")"
+add_triage "$repo" FIX_NOW
+expect_no_commit "$repo" "FIX_NOW findings are not applied" 12 "Add the marker"
+
+repo="$(setup_repo empty-reason PASS "[]")"
+expect_no_commit "$repo" "--no-review has no reason" 12 "Add the marker" --no-review " "
+
+echo "finish-feature tests passed"
diff --git a/tests/triage-review-test.sh b/tests/triage-review-test.sh
index 2b27ab8..8269824 100755
--- a/tests/triage-review-test.sh
+++ b/tests/triage-review-test.sh
@@ -190,7 +190,9 @@ grep -Fq -- "--strict-mcp-config --permission-mode dontAsk --tools Read,Glob,Gre
 grep -Fq -- "--json-schema" "$repo.log" || fail "triage agent was not given the schema"
 grep -Fq "Correctness regression" "$repo.log.stdin" || fail "findings were not supplied to the triage agent"
 
-# One comment with both reports is published on the source Issue.
+# One comment with both reports is published on the source Issue, and the
+# publication is recorded in the triage.
+grep -Eq '"published_at": "[0-9]{4}-' "$artifact.json" || fail "the publication was not recorded in the triage"
 [[ "$(grep -c '^COMMENT ON #5$' "$repo.gh.comments")" -eq 1 ]] || fail "exactly one comment on Issue #5 was expected"
 grep -Fq "C1. Correctness regression" "$repo.gh.comments" || fail "the comment lacks the review report"
 grep -Fq "## Fix now" "$repo.gh.comments" || fail "the comment lacks the triage report"
@@ -251,9 +253,19 @@ if MOCK_GH_COMMENT_EXIT=1 run_triage "$repo" y "$review"; then
 fi
 [[ -f "$repo/.agents/triage/feature-5-test-review-01-triage.json" ]] ||
   fail "a failed publication discarded the stored triage"
-grep -Fq "gh issue comment 5 --body-file .agents/triage/feature-5-test-review-01-triage-comment.md" "$repo.out" ||
+triage_file="$repo/.agents/triage/feature-5-test-review-01-triage.json"
+[[ "$(jq -r '.published_at // "none"' "$triage_file")" == "none" ]] || fail "a failed publication was recorded as published"
+grep -Fq "./scripts/triage-review.sh --publish .agents/triage/feature-5-test-review-01-triage.json" "$repo.out" ||
   fail "a failed publication did not print the retry command"
-[[ -f "$repo/.agents/triage/feature-5-test-review-01-triage-comment.md" ]] || fail "the comment to retry was not kept"
+(
+  cd "$repo"
+  PATH="$tmp/bin:/usr/bin:/bin" MOCK_GH_LOG="$repo.gh" ./scripts/triage-review.sh --publish .agents/triage/feature-5-test-review-01-triage.json
+) >"$repo.retry.out" 2>&1 || {
+  cat "$repo.retry.out" >&2
+  fail "retrying the publication failed"
+}
+[[ "$(grep -c '^COMMENT ON #5$' "$repo.gh.comments")" -eq 1 ]] || fail "the retry did not publish the reports"
+grep -Eq '"published_at": "[0-9]{4}-' "$triage_file" || fail "the retried publication was not recorded"
 
 # When Issue creation fails, no triage artifact is stored.
 repo="$(setup_repo create-fails)"