diff --git a/bin/fm-backlog-transition-lib.sh b/bin/fm-backlog-transition-lib.sh
index 6a27558a2b3..87fedd947cf 100644
--- a/bin/fm-backlog-transition-lib.sh
+++ b/bin/fm-backlog-transition-lib.sh
@@ -53,16 +53,16 @@
 # the preserved task. The writer and replay share one complete-record validator,
 # so teardown never publishes or acts on a close replay would reject.
 # The validator pins the data path to this home's configured root before any
-# recovery mutation, then re-runs exactly that close.
+# recovery mutation; replay then selects the transition from the current row.
 # `tasks-axi done` on an already-closed task backfills links
 # without moving the close date, so replay is idempotent. Ordinary dispatch needs
 # no marker: it publishes the meta first, so a crash leaves the meta itself as
 # the evidence that the row is owed a start.
-# A captain-held row uses the same record with a `mode=retain` line: replay then
-# records the deliverable and reopens the row instead of closing it, and never
-# closes a row that reads as an open captain call. An answer that closes the row
-# first applies any supported retained artifact from the validated record, then
-# replay simply retires the record.
+# A captain-held row uses the same record with a `mode=retain` line. Replay
+# records the deliverable and reopens the row only while it remains an open
+# captain call, never closing it. If the hold was released before replay, the
+# finished row closes instead of reopening unheld work. If an answer already
+# closed a retained row, replay simply retires the satisfied record.
 
 # Set by fm_backlog_transition_applies for a return-1 exemption.
 # shellcheck disable=SC2034 # Output global, read by the sourcing caller.
@@ -1396,6 +1396,12 @@ fm_backlog_close_marker_replay() {  # <state-dir> <marker-path> <authorized-data
     row_state=$FM_BACKLOG_ROW_STATE
     if [ "${row_state%% *}" != "done" ] && [ "$FM_BACKLOG_ROW_HOLD_KIND" = captain ]; then
       mode=retain
+    elif [ "${row_state%% *}" != "done" ]; then
+      if [ "$mode" = retain ] && [ "${args[0]-}" = --report ] \
+        && ! fm_backlog_row_artifact_supported "$id" "${args[@]}"; then
+        args=()
+      fi
+      mode=close
     fi
   else
     if [ "$FM_BACKLOG_ROW_RESULT" != not_found ]; then
diff --git a/bin/fm-captain-hold.sh b/bin/fm-captain-hold.sh
index 00cec495f01..6709dbf5693 100755
--- a/bin/fm-captain-hold.sh
+++ b/bin/fm-captain-hold.sh
@@ -65,10 +65,10 @@
 # tasks-axi --archive-body). It closes a question with `tasks-axi done` - or,
 # with `--release`, lifts the hold with `tasks-axi unhold` so a captain-gated
 # WORK item resumes without closing - and restores resolution-first body
-# ordering. An exact retry also completes unfinished ordering normalization and
-# is idempotent only when its requested close mode
-# matches the newest record; a changed decision or a mode mismatch is rejected.
-# A re-held task may record a new answer on top. On a task already closed outside this script,
+# ordering. For direct callers, an exact retry also completes unfinished ordering
+# normalization and requires the requested close mode to match the newest record;
+# a changed decision or a mode mismatch is rejected. A re-held task may record
+# a new answer on top. On a task already closed outside this script,
 # `answer` records the missing resolution block (the old `repair` path) only
 # when the task still carries the captain-hold provenance tasks-axi preserves
 # through a close, so an ordinary finished task cannot be dressed up as an
@@ -83,12 +83,19 @@
 # task through the very same `answer` path above, so every guard applies
 # identically no matter which channel the answer arrived on. The key IS the
 # task id - no identity arithmetic. The optional fourth field selects the close:
-# empty or `done` completes the task, `release` lifts the hold so held work
-# resumes; anything else is skipped. A key that names no task, a task that is
-# not held for the captain, or a task already closed is reported as `skipped:`
-# and feeds nothing. A replayed delivery whose answer digest and requested
-# close mode both match the newest record is reported `closed:` and is a no-op;
-# a mode mismatch is skipped. The command exits nonzero when any key was
+# empty or `done` selects automatic resolution through the internal
+# `answer --auto-release` path; `release` explicitly lifts the hold so held work
+# resumes; anything else is skipped. Automatic resolution never completes work
+# still owned by a worker. docs/captain-hold-lifecycle.md#answer-time-resolution
+# owns fresh-state selection, interrupted-release recovery, and replay safety.
+# A successful resolution, including a release or compatible replay, is reported
+# as `closed:`. An exact released-record replay is compatible on an unheld open
+# task in either mode, and on a Done task only in automatic mode. Other Done
+# replays require an automatic mode and a compatible recorded close. Missing,
+# unheld, or already-closed keys outside those replay cases, and incompatible
+# replays, are reported as `skipped:` and feed nothing. These Done/unheld replay
+# paths preserve the recorded decision and task state but can finish parent
+# publication and pending reconcile-request retirement. The command exits nonzero when any key was
 # skipped. `--source` is provenance text recorded in the
 # durable decision, never a behavior switch: this command has no per-channel
 # branch and no knowledge of chat, review decks, or any transport.
@@ -209,6 +216,7 @@
 # reconciled. Records written by the retired fm-decision-hold.sh (routed,
 # declined, answered, repaired) are recognized everywhere a record is read, so
 # nothing already closed needs rewriting.
+# `Resolves hold set:` associates a resolution with its hold-set stamp.
 #
 # Parent channel: inside a secondmate home a task held for the captain, and its
 # answer, are captain-facing facts the moment they are recorded, so `hold`
@@ -515,6 +523,20 @@ recorded_resolution_mode() {  # <task-body>
   printf '%s' "$rest"
 }
 
+recorded_resolved_hold_set() {
+  local body
+  body=$(decode_shown_value "$1") || return 1
+  printf '%s\n' "$body" | awk '
+    /^Resolution mode: / {
+      if (getline > 0 && /^Resolves hold set: /) {
+        sub(/^Resolves hold set: /, "")
+        print
+      }
+      exit
+    }
+  '
+}
+
 closed_answer_replay_mode_compatible() {  # <mode> <task-body>
   case "$1" in
     answered|repaired|routed) return 0 ;;
@@ -525,11 +547,13 @@ closed_answer_replay_mode_compatible() {  # <mode> <task-body>
 # The record's label is what keeps an evidence-backed reconciliation from
 # reading as the captain's own words. `reconciled` closes a call that went moot
 # and carries verified evidence; every other mode carries what the captain said.
-resolution_block() {  # <mode>
+resolution_block() {
   local label='Captain decision:'
   [ "$1" != reconciled ] || label='Reconciliation evidence:'
-  printf 'Resolution recorded by fm-captain-hold.\nDecision digest: %s\nResolution mode: %s\n\n%s\n%s\n' \
-    "$DECISION_DIGEST" "$1" "$label" "$DECISION_TEXT"
+  printf 'Resolution recorded by fm-captain-hold.\nDecision digest: %s\nResolution mode: %s\n' \
+    "$DECISION_DIGEST" "$1"
+  [ -z "$2" ] || printf 'Resolves hold set: %s\n' "$2"
+  printf '\n%s\n%s\n' "$label" "$DECISION_TEXT"
 }
 
 # Durable state of one captain call: an active captain hold (annotations
@@ -925,7 +949,7 @@ verify_entry_durable() {  # <origin-or-empty> <entry>; prints "<id> <how> <origi
 
 command_hold() {
   local id=${1:-} title='' reason='' repo='' origin='' until='' show state existing_title body='' hold_kind hold_set occurrence
-  local existing_hold_kind='' existing_held='' preserve_hold_set=0 stored_reason previous_origin='' hold_status=0
+  local existing_hold_kind='' existing_held='' preserve_hold_set=0 stored_reason previous_origin='' hold_status=0 resolved_hold_set
   [ "$#" -ge 1 ] || { usage >&2; exit 2; }
   shift
   while [ "$#" -gt 0 ]; do
@@ -952,12 +976,12 @@ command_hold() {
       *) fail "--until must be a YYYY-MM-DD date: $until" ;;
     esac
   fi
+  acquire_task_control_lock "$id"
   hold_set=${FM_CAPTAIN_HOLD_NOW:-$(date -u +%Y-%m-%dT%H:%M:%SZ)}
   case "$hold_set" in
     [0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]T[0-9][0-9]:[0-9][0-9]:[0-9][0-9]Z) : ;;
     *) fail "FM_CAPTAIN_HOLD_NOW must be a UTC YYYY-MM-DDTHH:MM:SSZ timestamp" ;;
   esac
-  acquire_task_control_lock "$id"
   require_tasks_axi
   if task_show "$id"; then
     show=$TASK_SHOW_OUTPUT
@@ -999,6 +1023,16 @@ command_hold() {
   # snapshot may see the harmless stamp by itself, but can never see a newly
   # held task without the timestamp that defines this hold lifecycle's age.
   task_show_or_fail "$id" "task $id disappeared before recording its hold-set stamp"
+  if [ "$preserve_hold_set" = 0 ] \
+    || [ -z "$(body_hold_set_timestamp "$(show_field_value "$show" body)")" ]; then
+    resolved_hold_set=$(recorded_resolved_hold_set "$(show_field "$show" body)")
+    while [ "$hold_set" = "$resolved_hold_set" ]; do
+      [ -z "${FM_CAPTAIN_HOLD_NOW:-}" ] \
+        || fail "FM_CAPTAIN_HOLD_NOW collides with the newest resolved hold for task $id; choose a later timestamp"
+      sleep 1
+      hold_set=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+    done
+  fi
   write_hold_set_stamp "$id" "$(show_field "$show" body)" "$hold_set" "$preserve_hold_set"
   task_show_or_fail "$id" "task $id disappeared while recording its hold-set stamp"
   [ -n "$(body_hold_set_timestamp "$(show_field_value "$show" body)")" ] \
@@ -1039,10 +1073,10 @@ command_hold() {
 # Successful closure removes the stamp to restore resolution-first ordering.
 write_resolution_record() {  # <task-id> <mode> <shown-body>
   local id=$1 mode=$2 body=$3 new_body tmp hold_set
-  new_body=$(resolution_block "$mode")
   body=$(decode_shown_value "$body") \
     || fail "could not decode the existing body for $id"
   hold_set=$(body_hold_set_timestamp "$body")
+  new_body=$(resolution_block "$mode" "$hold_set")
   if [ -n "$hold_set" ]; then
     body=${body#"Captain hold set: $hold_set"}
     case "$body" in
@@ -1095,6 +1129,13 @@ apply_pending_retained_artifact() {  # <task-id>
   esac
 }
 
+# True while a worker still owns the work item: its runtime record exists or the
+# backlog still lists it In flight. Completing such an item would record a
+# landing that has not happened, so a keyed answer only ever releases it.
+live_work_item() {  # <task-id> <backlog-state>
+  [ "$2" = in_flight ] || [ -f "$STATE/$1.meta" ]
+}
+
 close_answered() {  # <task-id> <release-0-or-1>
   if [ "$2" = 1 ]; then
     tasks_axi unhold "$1" >/dev/null
@@ -1127,13 +1168,15 @@ remove_interrupted_answer_stamp() {  # <task-id>
 }
 
 command_answer() {
-  local id=${1:-} decision_file='' release=0 show state hold_kind body outcome recorded_mode occurrence
+  local id=${1:-} decision_file='' release=0 auto_release=0 show state hold_kind body outcome recorded_mode occurrence
+  local cur resolved_hold_set
   [ "$#" -ge 1 ] || { usage >&2; exit 2; }
   shift
   while [ "$#" -gt 0 ]; do
     case "$1" in
       --decision-file) shift; decision_file=${1:-} ;;
       --release) release=1 ;;
+      --auto-release) auto_release=1 ;;
       *) usage >&2; exit 2 ;;
     esac
     shift
@@ -1147,6 +1190,13 @@ command_answer() {
   state=$(show_field "$show" state)
   hold_kind=$(show_field_value "$show" hold_kind)
   body=$(show_field "$show" body)
+  if [ "$auto_release" = 1 ] && [ "$state" != "done" ] \
+    && { live_work_item "$id" "$state" \
+      || { [ "$hold_kind" != captain ] \
+        && [ "$(recorded_decision_digest "$body" || true)" = "$DECISION_DIGEST" ] \
+        && [ "$(recorded_resolution_mode "$body" || true)" = released ]; }; }; then
+    release=1
+  fi
   if [ "$release" = 1 ]; then outcome=released; else outcome=answered; fi
   # The occurrence the parent line names: the record about to be written is
   # one past those already in the body, and a retry names the newest one.
@@ -1158,16 +1208,17 @@ command_answer() {
       [ "$(recorded_decision_digest "$body" || true)" = "$DECISION_DIGEST" ] \
         || fail "captain-held task $id records a different captain decision"
       recorded_mode=$(recorded_resolution_mode "$body" || true)
-      closed_answer_replay_mode_compatible "$recorded_mode" "$body" \
+      { closed_answer_replay_mode_compatible "$recorded_mode" "$body" \
+        || { [ "$auto_release" = 1 ] && [ "$recorded_mode" = released ]; }; } \
         || fail "task $id records this resolution with mode ${recorded_mode:-unknown}; it is not a captain-answer replay"
       [ "$release" = 0 ] \
         || fail "task $id records this answer with mode ${recorded_mode:-unknown}; --release cannot reopen a closed task"
       remove_interrupted_answer_stamp "$id"
-      if [ "$recorded_mode" = repaired ]; then
-        publish_parent_resolution_then_retire "$id" $((occurrence - 1)) "answered (repaired)"
-      else
-        publish_parent_resolution_then_retire "$id" $((occurrence - 1)) answered
-      fi
+      case "$recorded_mode" in
+        repaired) publish_parent_resolution_then_retire "$id" $((occurrence - 1)) "answered (repaired)" ;;
+        released) publish_parent_resolution_then_retire "$id" $((occurrence - 1)) released ;;
+        *) publish_parent_resolution_then_retire "$id" $((occurrence - 1)) answered ;;
+      esac
       printf 'answered: %s\n' "$id"
       return 0
     fi
@@ -1190,17 +1241,22 @@ command_answer() {
   fi
 
   if [ "$hold_kind" = captain ]; then
-    # Actively the captain's item (a date-expired hold keeps its annotations
-    # and stays answerable). A matching record means an interrupted close to
-    # finish; a different digest is a NEW answer on a re-held task and gets
-    # its own record on top. Either way the close mode is the caller's flag,
-    # checked against an interrupted close's recorded mode so a retry cannot
-    # silently flip a release into a close.
+    cur=$(body_hold_set_timestamp "$(decode_shown_value "$body")")
+    resolved_hold_set=$(recorded_resolved_hold_set "$body")
     if body_has_resolution_record "$body" \
-      && [ "$(recorded_decision_digest "$body" || true)" = "$DECISION_DIGEST" ]; then
+      && [ "$(recorded_decision_digest "$body" || true)" = "$DECISION_DIGEST" ] \
+      && { [ -z "$resolved_hold_set" ] \
+        || { [ -n "$cur" ] && [ "$resolved_hold_set" = "$cur" ]; }; }; then
       recorded_mode=$(recorded_resolution_mode "$body" || true)
       case "$recorded_mode" in
-        released) [ "$release" = 1 ] || fail "task $id records this answer as a release; retry with --release" ;;
+        released)
+          if [ "$release" = 0 ]; then
+            [ "$auto_release" = 1 ] || fail "task $id records this answer as a release; retry with --release"
+            if [ -z "$resolved_hold_set" ]; then
+              fail "task $id records this answer as a release; close it with reconcile or a direct answer"
+            fi
+          fi
+          ;;
         answered|routed) [ "$release" = 0 ] || fail "task $id records this answer as a close; retry without --release" ;;
         *) fail "task $id records this resolution with mode ${recorded_mode:-unknown}; it is not a captain-answer replay" ;;
       esac
@@ -1208,7 +1264,10 @@ command_answer() {
         fail "could not close answered captain-held task $id"
       fi
       remove_interrupted_answer_stamp "$id"
-      publish_parent_resolution_then_retire "$id" $((occurrence - 1)) "$outcome"
+      case "$recorded_mode" in
+        released) publish_parent_resolution_then_retire "$id" $((occurrence - 1)) released ;;
+        *) publish_parent_resolution_then_retire "$id" $((occurrence - 1)) "$outcome" ;;
+      esac
       printf '%s: %s\n' "$outcome" "$id"
       return 0
     fi
@@ -1397,7 +1456,7 @@ command_answers() {
       skipped=$((skipped + 1))
       continue
     fi
-    release_flag=''
+    release_flag=--auto-release
     case "${mode:-}" in
       ''|done) : ;;
       release) release_flag=--release ;;
@@ -1449,16 +1508,39 @@ command_answers() {
       && { [ "$recorded_digest" = "$digest" ] \
         || { case "$body" in *"Resolution recorded by fm-decision-hold."*) true ;; *) false ;; esac \
           && [ -n "$legacy_digest" ] && [ "$recorded_digest" = "$legacy_digest" ]; }; }; then
-      if { [ -z "$release_flag" ] && [ "$state" = "done" ] \
-          && closed_answer_replay_mode_compatible "$recorded_mode" "$body"; } \
-        || { [ "$release_flag" = --release ] && [ "$state" != "done" ] \
-          && [ "$hold_kind" != captain ] && [ "$recorded_mode" = released ]; }; then
+      if { [ "$release_flag" = --auto-release ] && [ "$state" = "done" ] \
+          && { closed_answer_replay_mode_compatible "$recorded_mode" "$body" \
+            || [ "$recorded_mode" = released ]; }; } \
+        || { [ "$state" != "done" ] && [ "$hold_kind" != captain ] \
+          && [ "$recorded_mode" = released ]; }; then
+        acquire_task_control_lock "$id"
+        if ! task_show "$id"; then
+          release_task_control_lock || fail "cannot release task control for $id"
+          printf 'skipped: %s (absent)\n' "$id"
+          skipped=$((skipped + 1))
+          continue
+        fi
+        show=$TASK_SHOW_OUTPUT
+        state=$(show_field "$show" state)
+        hold_kind=$(show_field_value "$show" hold_kind)
+        if [ "$(show_field "$show" body)" != "$body" ] \
+          || ! { { [ "$release_flag" = --auto-release ] && [ "$state" = "done" ] \
+              && { closed_answer_replay_mode_compatible "$recorded_mode" "$body" \
+                || [ "$recorded_mode" = released ]; }; } \
+            || { [ "$state" != "done" ] && [ "$hold_kind" != captain ] \
+              && [ "$recorded_mode" = released ]; }; }; then
+          release_task_control_lock || fail "cannot release task control for $id"
+          printf 'skipped: %s (task changed before answer replay)\n' "$id"
+          skipped=$((skipped + 1))
+          continue
+        fi
         occurrence=$(resolution_record_count "$body")
         case "$recorded_mode" in
           repaired) publish_parent_resolution_then_retire "$id" "$occurrence" "answered (repaired)" ;;
           released) publish_parent_resolution_then_retire "$id" "$occurrence" released ;;
           *) publish_parent_resolution_then_retire "$id" "$occurrence" answered ;;
         esac
+        release_task_control_lock || fail "cannot release task control for $id"
         printf 'closed: %s\n' "$id"
         closed=$((closed + 1))
         continue
@@ -1474,8 +1556,7 @@ command_answers() {
       skipped=$((skipped + 1))
       continue
     fi
-    # shellcheck disable=SC2086  # release_flag is empty or a single literal flag.
-    if "$0" answer "$id" --decision-file "$tmp" $release_flag </dev/null >/dev/null 2>"$err"; then
+    if "$0" answer "$id" --decision-file "$tmp" "$release_flag" </dev/null >/dev/null 2>"$err"; then
       # A parent-channel delivery problem is reported on stderr by the answer
       # path even when the close succeeded; keep it visible.
       [ ! -s "$err" ] || cat "$err" >&2
diff --git a/docs/captain-hold-lifecycle.md b/docs/captain-hold-lifecycle.md
index 1770201ef16..023d672aef7 100644
--- a/docs/captain-hold-lifecycle.md
+++ b/docs/captain-hold-lifecycle.md
@@ -90,9 +90,7 @@ A matching retry also completes any resolution-first normalization left unfinish
 
 ### Answer retries and tasks closed elsewhere
 
-- An exact retry is idempotent only when the requested close mode matches the newest record.
-- A drifted answer or a mode mismatch is rejected.
-- A re-held task accepts a new answer as a new record on top.
+[`bin/fm-captain-hold.sh --help`](../bin/fm-captain-hold.sh) owns direct-answer retry compatibility; [answer-time resolution](#answer-time-resolution) explains automatic recovery.
 
 On a task closed outside the script, `answer` records the missing block only when the captain-hold annotations tasks-axi preserves through a close prove the captain owned it.
 It also verifies the task stays closed.
@@ -160,7 +158,7 @@ It remains on the appropriate Captain's Call or Charted Next decision surface in
 
 The interrupted close/retention marker's publication and replay safety gates are owned by [`bin/fm-backlog-transition-lib.sh`](../bin/fm-backlog-transition-lib.sh)'s CRASH RECOVERY header.
 
-If the captain answers before replay, `answer` validates that record and copies any supported retained pull request or report into the row before closing it.
+If a direct answer closes the row before replay, `answer` validates that record and copies any supported retained pull request or report into the row before closing it.
 A retained Gerrit change URL is instead recorded as a `Gerrit change <url>` note on that close.
 Replay then retires the record.
 
@@ -174,7 +172,7 @@ They are recorded for separate upstream work rather than representing defects in
 - A relocated retained report cannot reach the row, because tasks-axi accepts only `data/<id>/report.md`.
   `done` reports `Task report link must be a data/<id>/report.md path`, and `update` reports `--report must be a data/<id>/report.md path`.
 
-When an interrupted retention leaves such a relocated report in the validated pending-close record, `answer` skips only that known-unsupported row artifact and closes normally.
+When an interrupted retention leaves such a relocated report in the validated pending-close record, `answer`, or cleanup replay converting retention to completion after a release, skips only that known-unsupported row artifact and closes normally.
 The delivery then remains absent from Recently Landed instead of wedging the captain's answer.
 
 A pending-close record that fails validation outright is a different case, and it still refuses the answer.
@@ -190,26 +188,24 @@ Only `answer` with the captain's words or evidence-backed `reconcile close` reso
 
 "A keyed answer resolves its matching captain-held task" is one capability with one owner.
 `answers` is its channel-agnostic entry point.
-It reads `<task-id>\t<answer>\t<label>[\t<mode>]` lines and resolves each named task through the same `answer` path.
+[`bin/fm-captain-hold.sh --help`](../bin/fm-captain-hold.sh) owns keyed input syntax, card-declared modes, replay compatibility, per-key output, and exit status.
 Every guard therefore applies identically no matter which channel the answer arrived on.
 
-The optional mode column carries a card-declared close:
+Automatic resolution chooses whether to release or complete from fresh state under the task control lock shared with teardown.
+A task whose worker still owns it, shown by an existing runtime record or an In flight backlog row, is released rather than completed.
+If teardown finishes first and returns the held item to Queued without a runtime record, the answer closes it.
+Completing live work would record a landing that has not happened, so cleanup remains responsible for completion; its [recovery owner](../bin/fm-backlog-transition-lib.sh) describes replay after a resolved hold.
+A replay of that answer on an unheld, open item after the worker has ended stays a release.
+Resolution records are never changed after they are written.
+If a release was recorded but interrupted before lifting the hold, an automatic retry after teardown completes the finished held item without unholding it, leaving the record as `released`, only when its `Resolves hold set:` stamp identifies the currently open hold; the occurrence and parent decision key stay unchanged across retries.
+A new hold receives its stamp under the task control lock and cannot reuse the newest resolution's associated stamp; a colliding `FM_CAPTAIN_HOLD_NOW` is refused.
+A repeated answer on a re-held task is recorded as that hold's own answer, preserving prior resolution records.
+An exact automatic answer replay after cleanup reaches Done preserves the recorded release and completed state while finishing parent publication and reconcile-request retirement.
+An ambiguous legacy release without a hold association on finished, still-held work must be closed through reconciliation or a fresh direct answer rather than automatically completed.
+Explicit direct-answer callers retain their strict mode checks.
+Replay classification, parent publication, and reconcile-request retirement share the task control lock.
+A released-row snapshot invalidated by a concurrent hold is skipped without resolving that hold or retiring its reconcile request.
 
-| Mode | Effect |
-| --- | --- |
-| `done` (default) | Completes the task. |
-| `release` | Lifts the hold so held work resumes. |
-| Any other value | Skipped. |
-
-Each key is reported as follows:
-
-| Key | Result |
-| --- | --- |
-| Names no task, names a task that is not captain-held, or names a task already closed | Reported as `skipped:` and feeds nothing. |
-| A replay whose answer and requested close mode match the newest record | An idempotent `closed:`. |
-| A replay with a mode mismatch | Skipped. |
-
-The command exits nonzero when any key was skipped.
 `--source` is provenance text recorded in the durable decision, never a behavior switch, and the command carries no per-channel branch.
 
 ### Source bindings
@@ -504,7 +500,7 @@ The suite does not test the accepted merge-to-cleanup re-hold window or asynchro
   An ordinary finished task in the same home still closes with its report link.
 - An interrupted cleanup leaves the row In flight and untouched with its pending record.
   When the row remains unanswered, the next session start retains it as queued and held with the deliverable recorded.
-  An answer before replay preserves that record's completed report while closing the call, so the next session start retires the satisfied record without losing the delivery from Recently Landed.
+  `test_answer_before_cleanup_replay_preserves_the_retained_report` covers direct and keyed answers before [cleanup recovery](#interrupted-cleanup), including loss of runtime metadata, without losing the completed report from Recently Landed.
   The Gerrit answer-before-replay case uses ordinary cleanup of already-landed Git work, preserving the change URL rather than recording a forced ship discard as `dropped`.
 - A pending-close record that cannot be validated refuses the answer while naming the record and the reason.
 - A relocated data directory keeps the retention in its one configured backlog.
@@ -533,8 +529,11 @@ The suite does not test the accepted merge-to-cleanup re-hold window or asynchro
 
 ### Answers, stamps, and deferral
 
-- Answer-time resolution works through a bound channel with task-id keys.
-  This includes the `release` mode, mode-matched replay idempotence, and the refusal of drifted, mode-mismatched, absent, unheld, and already-closed keys.
+- [`tests/fm-captain-hold-lifecycle.test.sh`](../tests/fm-captain-hold-lifecycle.test.sh) covers bound-channel answer-time resolution and the intake's invalid-key and incompatible-replay refusals.
+  Its `test_keyed_answer_releases_a_live_work_item` and `test_keyed_answer_waits_for_cleanup_before_selecting_its_mode` cover [automatic mode selection](#answer-time-resolution).
+  `test_interrupted_keyed_release_closes_after_teardown` and `test_completed_keyed_release_replays_after_publication_failure` cover interrupted and completed release recovery.
+  `test_stale_keyed_replay_preserves_a_concurrent_hold` covers replay invalidated by a concurrent hold.
+  `test_repeated_keyed_answer_resolves_its_own_hold` and `test_legacy_keyed_release_requires_explicit_closure` cover hold association and the legacy refusal boundary.
 - The chat channel reaches the same intake.
 - Hold-set stamping precedes visible hold state, preserves an active lifecycle's timestamp, and resets after release.
 - Interrupted answer closure retains the stamp until close and restores resolution-first ordering on retry.
@@ -580,7 +579,7 @@ It uses a stubbed tasks-axi that fails any markdown file override, and proves th
 
 The reconcile path is pinned in the same suite:
 
-- A reconcile answer arriving through the keyed-answer intake is refused, in the default close mode and in the `release` mode a captain-gated work card declares.
+- A reconcile answer arriving through the keyed-answer intake is refused, in the default automatic-resolution mode and in the `release` mode a captain-gated work card declares.
   It leaves both tasks held with no resolution record or request.
 - Only the separately bound captured-source intake records one durable request per task, idempotently across a replay.
 
diff --git a/docs/verification/process-event-sources.md b/docs/verification/process-event-sources.md
index 9483283d79f..231289fb38c 100644
--- a/docs/verification/process-event-sources.md
+++ b/docs/verification/process-event-sources.md
@@ -90,7 +90,7 @@ Exercised by `tests/fm-procevent.test.sh` against a fake blocking source whose c
 | proactive-delivery crash and drain boundaries | dotted and underscored source ids at the same sequence receive distinct markers; a concurrent drain cannot consume between queue revalidation and marker commit; failed output, failed marker commit, and a crash before marker commit leave replay available, while successful output still ends the actionable cycle and a crash after marker commit suppresses a duplicate |
 | adapter-owned terminal verdict | two fixture adapters - one that ends on any result, one with no terminal knowledge - decide the outcome alone: the first has its registration and claim retired automatically after one capture and is never restarted, the second stays armed |
 | adapter-owned application of a captured result | a remote-secondmate reply captured through the real relay in an isolated home reaches that secondmate's local status mirror, settles its correlated pending-reply expectation, re-arms the next cursor-anchored source, and is acknowledged, with no handler step or duplicate `check` wake; its new mirrored bytes remain visible to the watcher's signal gate, while exact source-line replay identity keeps a commit-failure retry or cursor-loss whole-log recapture from duplicating a decision when document availability changes, and a recapture that adds no bytes is acknowledged quietly; for an already-escalated request, the same path closes the exact decision so the open-decision fold clears and remains clear; a capture whose adapter application fails because local storage for a referenced remote document is obstructed is left unacknowledged and receives the fallback `check` wake, and the handler's own `handle` still applies it in full after storage recovers; a document offered through a structured `report=` pointer that the reader cannot deliver fails open, mirroring its line with the original pointer, advancing the cursor, and appending one unkeyed note with the reader's own reason that opens no decision, while a path merely mentioned in prose is never fetched and the reported announce-then-explain incident leaves no standing decision yet still delivers its report through the later structured offer |
-| generic built-in keyed-answer feed | `tests/fm-captain-hold-lifecycle.test.sh` drives a bound built-in source through the real runner with a fixture adapter that only prints keyed lines, proving any bound built-in channel reaches the one keyed-answer intake: named captain-held tasks close at capture time, a card-declared release mode frees held work, keys naming no captain-held task skip, freeform prose forges nothing, matching answer-and-mode replays are idempotent while mode mismatches refuse, an unbound source closes nothing, and capture remains independent of the handler wake. |
+| generic built-in keyed-answer feed | `tests/fm-captain-hold-lifecycle.test.sh` drives a bound built-in source through the real runner with a fixture adapter that only prints keyed lines, proving any bound built-in channel reaches the one keyed-answer intake, an unbound source feeds nothing, freeform prose forges nothing, and capture remains independent of the handler wake; [captain-hold lifecycle](../captain-hold-lifecycle.md#answer-time-resolution) owns resolution semantics and its [answer regressions](../captain-hold-lifecycle.md#answers-stamps-and-deferral) cover mode selection and replay. |
 | structured reconcile feed | `tests/fm-captain-hold-lifecycle.test.sh` covers the [captured-choice and reconcile contract](../captain-hold-lifecycle.md#how-a-board-selection-creates-a-request); its [reconcile coverage index](../captain-hold-lifecycle.md#reconcile-coverage) names the focused legacy-format and last-choice regressions. |
 | finished-board sweep | `test_sweep_retires_only_finished_board_listeners` in `tests/fm-captain-hold-lifecycle.test.sh` proves keep guards precede retirement: the standing Bearings board (including a symlink), every board under an unreadable Lavish store (including a missing file), queued feedback, and worker ownership (including ended sessions). After those guards, missing files retire; present boards with missing/ended sessions or past-window idleness retire only with no open or uncheckable captain card. Quoted, unquoted, case-insensitive and entity-encoded keys preserve open holds across all three present-board paths; unreadable files, valueless question attributes and invalid decoded keys keep listeners. Unacknowledged captures and recent activity also keep listeners; dry runs do not retire registrations, the Lavish store remains byte-identical, repeated sweeps are idempotent, and unusable idle windows are refused. `test_sweep_stops_a_live_listener_of_a_finished_board` proves the resident poll of a finished board's armed listener is gone after the sweep |
 | sweep card discovery and bound routing | `test_sweep_keeps_unknown_card_discovery` executes dry-run and actual sweeps across ended, sessionless and idle boards: zero static keys, dynamic and mixed decks, scripts, handlers, embedded surfaces, unkeyed forms and malformed markup keep listeners; complete static closed-card sets retire. `test_sweep_resolves_bound_captain_keys` exercises exact-before-legacy resolution, concrete and any-origin bindings, unresolved and corrupt-binding evidence, and retirement after a legacy answer reaches its derived task. `test_sweep_resolves_migrated_captain_keys` uses isolated Beads backend fixtures to exercise note and prefix resolution for raw and derived keys, marker precedence over a held prefix namesake, ambiguity, and exact/derived/prefix read errors; binding-directory lookup failures keep idle, ended and sessionless listeners, unreadable binding files keep listeners, and confirmed binding absence preserves ordinary unbound resolution. |
diff --git a/tests/fm-captain-hold-lifecycle.test.sh b/tests/fm-captain-hold-lifecycle.test.sh
index 4f081e129f6..59398585004 100755
--- a/tests/fm-captain-hold-lifecycle.test.sh
+++ b/tests/fm-captain-hold-lifecycle.test.sh
@@ -1752,6 +1752,688 @@ SH
   pass "a bound channel's captured answers close their captain-held tasks at answer time"
 }
 
+# A keyed answer on a work item whose worker is still running must release the
+# item, never complete it: the board answered four calls held on live ships and
+# each was closed to Done while its worker was still validating. The intake
+# decides from the live task record, so a card that declares no close mode, or
+# declares `done`, cannot complete work that has not landed. A question-shaped
+# call with no worker keeps closing.
+test_keyed_answer_releases_a_live_work_item() {
+  local home id out show rc
+  home=$(make_home keyed-live-work)
+  id=sample-live-scout
+  tasks_in "$home" add "$id" "Review the live sample" --kind scout --repo sample --start >/dev/null \
+    || fail "could not create the in-flight work item"
+  write_origin_meta "$home" "$id"
+  run_captain "$home" hold "$id" --reason "captain design pick needed" >/dev/null \
+    || fail "could not hold the live work item for the captain"
+  tasks_in "$home" add sample-live-done-ship "Ship the second live sample" --kind ship --repo sample >/dev/null \
+    || fail "could not create the second work item"
+  write_origin_meta "$home" sample-live-done-ship ship
+  run_captain "$home" hold sample-live-done-ship --reason "captain design pick needed" >/dev/null \
+    || fail "could not hold the second live work item"
+  tasks_in "$home" add sample-live-row-only "Ship the row-only sample" --kind ship --repo sample --start >/dev/null \
+    || fail "could not create the in-flight row-only work item"
+  run_captain "$home" hold sample-live-row-only --reason "captain design pick needed" >/dev/null \
+    || fail "could not hold the row-only work item"
+  run_captain "$home" hold sample-plain-question --title "Captain call: plain" \
+    --reason "captain choice pending" --repo sample >/dev/null \
+    || fail "could not hold the plain question"
+
+  out=$(printf '%s\tgo-b\tOption B\n%s\tgo-b\tOption B\tdone\nsample-live-row-only\tgo-b\tOption B\tdone\nsample-plain-question\tyes\tYes\n' \
+    "$id" sample-live-done-ship \
+    | run_captain "$home" answers --source "live work fixture" 2>&1) \
+    || fail "answers on live work items failed: $out"
+  for id in "$id" sample-live-done-ship; do
+    show=$(tasks_in "$home" show "$id" --full)
+    assert_not_contains "$show" "state: done" "a keyed answer completed the live work item $id"
+    assert_contains "$show" "held: no" "a keyed answer left the live work item $id held"
+    assert_contains "$show" "Resolution mode: released" "the answer on $id did not record a release"
+    assert_contains "$show" "Option B" "the answer on $id lost the captain's words"
+    assert_present "$home/state/$id.meta" "the answer removed the live task record for $id"
+  done
+  show=$(tasks_in "$home" show sample-live-row-only --full)
+  assert_contains "$show" "state: in_flight" "a keyed answer completed row-only in-flight work"
+  assert_contains "$show" "held: no" "a keyed answer left row-only work held"
+  assert_contains "$show" "Resolution mode: released" "row-only work did not record a release"
+  show=$(tasks_in "$home" show sample-plain-question --full)
+  assert_contains "$show" "state: done" "a question with no worker stopped closing"
+
+  out=$(printf 'sample-live-scout\tgo-b\tOption B\n' \
+    | run_captain "$home" answers --source "live work fixture" 2>&1) \
+    || fail "an identical live-work answer was not idempotent: $out"
+  mkdir -p "$home/data/sample-live-scout"
+  printf '# Live sample report\n' > "$home/data/sample-live-scout/report.md"
+  printf 'done: report complete\n' > "$home/state/sample-live-scout.status"
+  run_captain "$home" complete sample-live-scout --none >/dev/null \
+    || fail "could not complete the released work item's inventory"
+  run_teardown "$home" sample-live-scout > "$home/teardown.out" 2> "$home/teardown.err" \
+    || fail "could not tear down the released work item: $(cat "$home/teardown.err")"
+  show=$(tasks_in "$home" show sample-live-scout --full)
+  assert_contains "$show" "state: done" "cleanup did not complete the released work item"
+  assert_contains "$show" "held: no" "the late replay fixture is still held"
+  assert_absent "$home/state/sample-live-scout.meta" "cleanup left the worker record behind"
+  set +e
+  out=$(printf 'sample-live-scout\tgo-b\tOption B\n' \
+    | run_captain "$home" answers --source "live work fixture" 2>&1)
+  rc=$?
+  set -e
+  [ "$rc" -eq 0 ] || fail "replaying a release after the worker ended was refused: $out"
+  assert_contains "$out" "closed: sample-live-scout" "the completed release replay was not reported closed"
+  show=$(tasks_in "$home" show sample-live-scout --full)
+  assert_contains "$show" "state: done" "a late replay reopened completed work"
+  assert_contains "$show" "held: no" "a late replay re-held the released work item"
+  assert_contains "$show" "Resolution mode: released" "a late replay lost its recorded release"
+  pass "a keyed answer releases a live work item and still closes a question"
+}
+
+test_keyed_answer_waits_for_cleanup_before_selecting_its_mode() {
+  local home id mode teardown_pid answer_pid teardown_rc answer_rc show
+  local real_perl real_sleep
+  real_perl=$(command -v perl)
+  real_sleep=$(command -v sleep)
+  for mode in default "done"; do
+    home=$(make_home "answer-waits-for-cleanup-$mode")
+    id=sample-answer-cleanup-race
+    mkdir -p "$home/data/$id" "$home/projects/$id" "$home/projects/sample"
+    tasks_in "$home" add "$id" "Investigate the cleanup race" --kind scout \
+      --repo sample --start >/dev/null || fail "could not create the cleanup-race task"
+    fm_write_meta "$home/state/$id.meta" \
+      "window=firstmate:fm-$id" "worktree=$home/projects/$id" \
+      "project=$home/projects/sample" "harness=codex" "kind=scout" \
+      "mode=scout" "spawn_gen=fixture-$id"
+    printf 'done: report complete\n' > "$home/state/$id.status"
+    printf '# Cleanup race report\n' > "$home/data/$id/report.md"
+    run_captain "$home" hold "$id" --reason "captain report choice pending" >/dev/null \
+      || fail "could not hold the cleanup-race task"
+    install_reused_task_barriers "$home"
+    cat > "$home/fakebin/treehouse" <<'SH'
+#!/usr/bin/env bash
+: > "$FM_HOME/teardown-ready"
+while [ ! -e "$FM_HOME/teardown-release" ] \
+    && [ "$SECONDS" -lt "${FM_TEST_STUB_MAX_BLOCK_SECONDS:-120}" ]; do
+  sleep 0.01
+done
+exit 0
+SH
+    chmod +x "$home/fakebin/treehouse"
+    PATH="$home/fakebin:$PATH" FM_ROOT_OVERRIDE="$ROOT" FM_HOME="$home" \
+      FM_STATE_OVERRIDE="$home/state" FM_DATA_OVERRIDE="$home/data" \
+      FM_CONFIG_OVERRIDE="$home/config" FM_TEST_REAL_PERL="$real_perl" FM_TEST_REAL_SLEEP="$real_sleep" \
+      "$TEARDOWN" "$id" --force --drop-file "$(fm_test_drop_file)" \
+      > "$home/teardown.out" 2> "$home/teardown.err" &
+    teardown_pid=$!
+    if ! wait_for_test_file "$home/teardown-ready" "$teardown_pid"; then
+      : > "$home/teardown-release"
+      wait "$teardown_pid" 2>/dev/null || true
+      fail "cleanup did not reach its locked worktree return: $(cat "$home/teardown.err")"
+    fi
+    (
+      if [ "$mode" = default ]; then
+        printf '%s\tgo\tProceed\n' "$id"
+      else
+        printf '%s\tgo\tProceed\tdone\n' "$id"
+      fi | FM_TEST_REUSE_MERGE=1 FM_TEST_REUSE_MERGE_ONCE="$home/answer-once" \
+        FM_TEST_REUSE_MERGE_READY="$home/answer-ready" \
+        FM_TEST_REUSE_MERGE_RELEASE="$home/answer-release" \
+        FM_TEST_REAL_PERL="$real_perl" FM_TEST_REAL_SLEEP="$real_sleep" \
+        run_captain "$home" answers --source "cleanup race fixture"
+    ) > "$home/answer.out" 2> "$home/answer.err" &
+    answer_pid=$!
+    if ! wait_for_test_file "$home/answer-ready" "$answer_pid"; then
+      : > "$home/teardown-release"
+      : > "$home/answer-release"
+      wait "$teardown_pid" 2>/dev/null || true
+      wait "$answer_pid" 2>/dev/null || true
+      fail "the keyed answer did not wait behind cleanup"
+    fi
+    : > "$home/teardown-release"
+    teardown_rc=0
+    wait "$teardown_pid" || teardown_rc=$?
+    show=$(tasks_in "$home" show "$id" --full)
+    : > "$home/answer-release"
+    answer_rc=0
+    wait "$answer_pid" || answer_rc=$?
+    [ "$teardown_rc" -eq 0 ] || fail "cleanup failed: $(cat "$home/teardown.err")"
+    assert_contains "$show" "state: queued" "cleanup did not queue its finished held task"
+    assert_contains "$show" "held: yes" "cleanup released its finished held task"
+    assert_absent "$home/state/$id.meta" "cleanup left the worker record behind"
+    [ "$answer_rc" -eq 0 ] || fail "the waiting keyed answer failed: $(cat "$home/answer.err")"
+    show=$(tasks_in "$home" show "$id" --full)
+    assert_contains "$show" "state: done" "a stale release reopened finished work"
+    assert_contains "$show" "Resolution mode: answered" "the answer recorded a stale release"
+    assert_contains "$show" "Answer: go" "the waiting answer lost the captain's words"
+    assert_contains "$show" "Deliverable of the finished work: report data/$id/report.md" \
+      "the waiting answer lost cleanup's report"
+  done
+  pass "default and done keyed answers choose their mode after cleanup releases the lock"
+}
+
+test_interrupted_keyed_release_closes_after_teardown() {
+  local home parent channel id mode row show out open published body
+  for mode in default "done"; do
+    home=$(make_home "interrupted-keyed-release-$mode")
+    parent=$(make_home "interrupted-keyed-release-parent-$mode")
+    printf 'interrupted-release-mate\n' > "$home/.fm-secondmate-home"
+    printf 'schema=fm-secondmate-parent.v1\nroute=local\nparent_home=%s\n' "$parent" \
+      > "$home/.fm-secondmate-parent"
+    printf -- '- interrupted-release-mate - synthetic scope (home: %s; scope: sample reviews; projects: sample; added 2026-07-14)\n' \
+      "$home" > "$parent/data/secondmates.md"
+    fm_write_secondmate_meta "$parent/state/interrupted-release-mate.meta" "$home" \
+      "firstmate:fm-interrupted-release-mate" sample
+    channel="$parent/state/interrupted-release-mate.status"
+    id=sample-interrupted-keyed-release
+    tasks_in "$home" add "$id" "Investigate interrupted answer recovery" \
+      --kind scout --repo sample --start >/dev/null || fail "could not create the interrupted release task"
+    write_origin_meta "$home" "$id"
+    mkdir -p "$home/data/$id"
+    printf 'done: report complete\n' > "$home/state/$id.status"
+    printf '# Interrupted answer report\n' > "$home/data/$id/report.md"
+    run_captain "$home" hold "$id" --reason "captain report choice pending" >/dev/null \
+      || fail "could not hold the interrupted release task"
+    complete_through_sibling "$home" "$id" >/dev/null \
+      || fail "could not complete the interrupted release task's inventory"
+    open=$(bash -c '. "$1"; status_open_decisions "$2" secondmate' \
+      _ "$ROOT/bin/fm-status-decision-lib.sh" "$channel")
+    assert_contains "$open" "captain-hold-$id-1" "the original parent decision did not open"
+    cat > "$home/fakebin/tasks-axi" <<'SH'
+#!/usr/bin/env bash
+if [ "${1:-}" = unhold ] && [ "${2:-}" = sample-interrupted-keyed-release ] \
+  && [ ! -e "$FM_HOME/unhold-failed-once" ]; then
+  : > "$FM_HOME/unhold-failed-once"
+  exit 93
+fi
+if [ "${1:-}" = done ] && [ "${2:-}" = sample-interrupted-keyed-release ] \
+  && [ ! -e "$FM_HOME/done-failed-once" ]; then
+  : > "$FM_HOME/done-failed-once"
+  exit 94
+fi
+exec "$REAL_TASKS_AXI" "$@"
+SH
+    chmod +x "$home/fakebin/tasks-axi"
+    row=$(printf '%s\tgo\tProceed' "$id")
+    [ "$mode" != "done" ] || row=$(printf '%s\tdone' "$row")
+    if printf '%s\n' "$row" | run_captain "$home" answers \
+      --source "interrupted release fixture" > "$home/answer.out" 2> "$home/answer.err"; then
+      fail "the interrupted unhold reported success"
+    fi
+    show=$(tasks_in "$home" show "$id" --full)
+    assert_contains "$show" "state: in_flight" "the failed release completed live work"
+    assert_contains "$show" "held: yes" "the failed release lost its hold"
+    assert_contains "$show" "Resolution mode: released" "the failure did not persist its release"
+    REAL_TASKS_AXI="$TASKS_AXI_BIN" run_teardown "$home" "$id" \
+      > "$home/teardown.out" 2> "$home/teardown.err" \
+      || fail "cleanup after interrupted release failed: $(cat "$home/teardown.err")"
+    show=$(tasks_in "$home" show "$id" --full)
+    assert_contains "$show" "state: queued" "cleanup did not queue the held finished work"
+    assert_contains "$show" "held: yes" "cleanup released the unresolved hold"
+    assert_absent "$home/state/$id.meta" "cleanup left the worker record behind"
+    printf 'Captain answered this call through interrupted release fixture.\nTask: %s\nAnswer: go\nAnswer as shown to the captain: Proceed\n' \
+      "$id" > "$home/decision.txt"
+    if run_captain "$home" answer "$id" --decision-file "$home/decision.txt" \
+      > "$home/direct.out" 2> "$home/direct.err"; then
+      fail "an explicit close accepted a recorded release"
+    fi
+    assert_contains "$(cat "$home/direct.err")" "retry with --release" \
+      "the explicit close lost its strict mode check"
+    if printf '%s\n' "$row" | run_captain "$home" answers \
+      --source "interrupted release fixture" > "$home/retry.out" 2> "$home/retry.err"; then
+      fail "the interrupted completion reported success"
+    fi
+    show=$(tasks_in "$home" show "$id" --full)
+    assert_contains "$show" "state: queued" "the failed completion changed the finished work's state"
+    assert_contains "$show" "held: yes" "the failed completion released the finished work"
+    assert_contains "$show" 'Resolution mode: released\n' "the failed completion changed the recorded release"
+    assert_not_contains "$show" "Resolution mode: answered" "the failed completion rewrote the release"
+    open=$(bash -c '. "$1"; status_open_decisions "$2" secondmate' \
+      _ "$ROOT/bin/fm-status-decision-lib.sh" "$channel")
+    assert_contains "$open" "captain-hold-$id-1" "the failed completion resolved the parent decision early"
+    out=$(printf '%s\n' "$row" | run_captain "$home" answers \
+      --source "interrupted release fixture" 2>&1) \
+      || fail "the automatic retry did not close finished held work: $out"
+    show=$(tasks_in "$home" show "$id" --full)
+    assert_contains "$show" "state: done" "the automatic retry made finished work runnable"
+    assert_contains "$show" "held: no" "the automatic retry left finished work held"
+    assert_contains "$show" 'Resolution mode: released\n' "the retry changed the recorded release"
+    assert_contains "$show" "Answer: go" "the retry lost the captain's answer"
+    assert_contains "$show" "Deliverable of the finished work: report data/$id/report.md" \
+      "the retry lost the finished report"
+    body=$(printf '%s\n' "$show" | sed -n 's/^  body: //p')
+    assert_equals 1 "$(printf '%s\n' "$body" | jq 'split("Resolution recorded by fm-captain-hold.") | length - 1')" \
+      "the interrupted retry invented another resolution record"
+    open=$(bash -c '. "$1"; status_open_decisions "$2" secondmate' \
+      _ "$ROOT/bin/fm-status-decision-lib.sh" "$channel")
+    assert_not_contains "$open" "captain-hold-$id-1"$'\t' "the original parent decision remained unresolved"
+    published=$(cat "$channel")
+    assert_contains "$published" "resolved [key=captain-hold-$id-1]" \
+      "the interrupted retry did not resolve the original occurrence"
+    assert_not_contains "$published" "captain-hold-$id-2" "the interrupted retry invented a second occurrence"
+    if run_captain "$home" answer "$id" --decision-file "$home/decision.txt" \
+      > "$home/direct-done.out" 2> "$home/direct-done.err"; then
+      fail "a direct answer accepted a completed release"
+    fi
+    assert_contains "$(cat "$home/direct-done.err")" "not a captain-answer replay" \
+      "the completed release lost its direct-answer mode check"
+    run_captain "$home" answer "$id" --decision-file "$home/decision.txt" --auto-release >/dev/null \
+      || fail "the locked automatic replay of the completed release failed"
+    assert_equals "$published" "$(cat "$channel")" "the locked automatic replay changed the parent resolution"
+    out=$(printf '%s\n' "$row" | run_captain "$home" answers \
+      --source "interrupted release fixture" 2>&1) \
+      || fail "the closed automatic retry was not idempotent: $out"
+    assert_equals "$show" "$(tasks_in "$home" show "$id" --full)" \
+      "replaying the reconciled close changed the finished work"
+    assert_equals "$published" "$(cat "$channel")" "the keyed replay changed the parent resolution"
+  done
+  pass "interrupted default and done releases close finished work while explicit mode checks stay strict"
+}
+
+test_completed_keyed_release_replays_after_publication_failure() {
+  local home parent channel id mode failure row out show published open request body before rc
+  for mode in default "done"; do
+    for failure in ordinary failed-publication; do
+      home=$(make_home "completed-keyed-release-$mode-$failure")
+      parent=$(make_home "completed-keyed-release-parent-$mode-$failure")
+      printf 'completed-release-mate\n' > "$home/.fm-secondmate-home"
+      printf 'schema=fm-secondmate-parent.v1\nroute=local\nparent_home=%s\n' "$parent" \
+        > "$home/.fm-secondmate-parent"
+      printf -- '- completed-release-mate - synthetic scope (home: %s; scope: sample reviews; projects: sample; added 2026-07-14)\n' \
+        "$home" > "$parent/data/secondmates.md"
+      fm_write_secondmate_meta "$parent/state/completed-release-mate.meta" "$home" \
+        "firstmate:fm-completed-release-mate" sample
+      channel="$parent/state/completed-release-mate.status"
+      id=sample-completed-keyed-release
+      tasks_in "$home" add "$id" "Review completed answer recovery" \
+        --kind scout --repo sample --start >/dev/null || fail "could not create the completed release task"
+      write_origin_meta "$home" "$id"
+      mkdir -p "$home/data/$id"
+      printf 'done: report complete\n' > "$home/state/$id.status"
+      printf '# Completed answer report\n' > "$home/data/$id/report.md"
+      run_captain "$home" hold "$id" --reason "captain report choice pending" >/dev/null \
+        || fail "could not hold the completed release task"
+      complete_through_sibling "$home" "$id" >/dev/null \
+        || fail "could not complete the completed release task's inventory"
+      request_reconciles "$home" completed-release-source "$id" \
+        || fail "could not create the release's reconcile request"
+      request="$home/state/reconcile-requests/$id.request"
+      if [ "$failure" = failed-publication ]; then
+        mv "$channel" "$channel.saved"
+        mkdir "$channel"
+      fi
+      row=$(printf '%s\tgo\tProceed' "$id")
+      [ "$mode" != "done" ] || row=$(printf '%s\tdone' "$row")
+      rc=0
+      out=$(printf '%s\n' "$row" | run_captain "$home" answers \
+        --source "completed release fixture" 2>&1) || rc=$?
+      if [ "$failure" = failed-publication ]; then
+        [ "$rc" -ne 0 ] || fail "a failed publication with a pending request reported success"
+        assert_contains "$out" "could not publish" "the failed publication was not actionable"
+        assert_present "$request" "the failed publication retired its reconcile request"
+        rmdir "$channel"
+        mv "$channel.saved" "$channel"
+      else
+        [ "$rc" -eq 0 ] || fail "the ordinary live release failed: $out"
+        assert_absent "$request" "the successful release left its reconcile request pending"
+      fi
+      show=$(tasks_in "$home" show "$id" --full)
+      assert_contains "$show" "state: in_flight" "publication completed the live work"
+      assert_contains "$show" "held: no" "publication failure reversed the release"
+      assert_contains "$show" "Resolution mode: released" "the live release lost its record"
+      body=$(printf '%s\n' "$show" | sed -n 's/^  body: //p')
+      printf '%s\n' "$body" | jq -j 'split("\n\n")[0:2] | join("\n\n")' > "$home/release-record.txt"
+      run_teardown "$home" "$id" > "$home/teardown.out" 2> "$home/teardown.err" \
+        || fail "cleanup of the released task failed: $(cat "$home/teardown.err")"
+      before=$(tasks_in "$home" show "$id" --full)
+      assert_contains "$before" "state: done" "cleanup did not complete the released task"
+      assert_absent "$home/state/$id.meta" "cleanup left the worker record behind"
+      if [ "$failure" = failed-publication ]; then
+        assert_present "$request" "cleanup retired the unpublished reconcile request"
+        open=$(bash -c '. "$1"; status_open_decisions "$2" secondmate' \
+          _ "$ROOT/bin/fm-status-decision-lib.sh" "$channel")
+        assert_contains "$open" "captain-hold-$id-1" "cleanup resolved the unpublished hold"
+      fi
+      out=$(printf '%s\n' "$row" | run_captain "$home" answers \
+        --source "completed release fixture" 2>&1) || fail "the completed release replay failed: $out"
+      assert_contains "$out" "closed: $id" "the completed release replay was not reported closed"
+      assert_absent "$request" "the completed release replay left its reconcile request pending"
+      show=$(tasks_in "$home" show "$id" --full)
+      assert_equals "$before" "$show" "the completed release replay changed the row"
+      body=$(printf '%s\n' "$show" | sed -n 's/^  body: //p')
+      assert_equals 1 "$(printf '%s\n' "$body" | jq 'split("Resolution recorded by fm-captain-hold.") | length - 1')" \
+        "the completed release replay duplicated its record"
+      printf '%s\n' "$body" | jq -j 'split("\n\n")[0:2] | join("\n\n")' > "$home/replayed-record.txt"
+      cmp -s "$home/release-record.txt" "$home/replayed-record.txt" \
+        || fail "cleanup or replay changed the released record's bytes"
+      open=$(bash -c '. "$1"; status_open_decisions "$2" secondmate' \
+        _ "$ROOT/bin/fm-status-decision-lib.sh" "$channel")
+      assert_not_contains "$open" "captain-hold-$id-1"$'\t' "the completed release's parent key remained open"
+      published=$(cat "$channel")
+      assert_equals 1 "$(grep -c "resolved \[key=captain-hold-$id-1\]" "$channel")" \
+        "the completed release did not publish exactly one resolution"
+      assert_not_contains "$published" "captain-hold-$id-2" "the completed replay invented a parent key"
+      printf 'Captain answered this call through completed release fixture.\nTask: %s\nAnswer: go\nAnswer as shown to the captain: Proceed\n' \
+        "$id" > "$home/decision.txt"
+      if run_captain "$home" answer "$id" --decision-file "$home/decision.txt" \
+        > "$home/direct.out" 2> "$home/direct.err"; then
+        fail "a direct answer accepted a completed release"
+      fi
+      assert_contains "$(cat "$home/direct.err")" "not a captain-answer replay" \
+        "the direct completed-release refusal lost its mode check"
+      if printf '%s\tgo\tProceed\trelease\n' "$id" | run_captain "$home" answers \
+        --source "completed release fixture" > "$home/explicit.out" 2> "$home/explicit.err"; then
+        fail "an explicit release card accepted a completed release"
+      fi
+      assert_contains "$(cat "$home/explicit.out")" "already closed" \
+        "the explicit release card did not keep its completed-state refusal"
+      run_captain "$home" answer "$id" --decision-file "$home/decision.txt" --auto-release >/dev/null \
+        || fail "the locked automatic Done replay failed"
+      out=$(printf '%s\n' "$row" | run_captain "$home" answers \
+        --source "completed release fixture" 2>&1) || fail "the second completed replay failed: $out"
+      assert_contains "$out" "closed: $id" "the second completed replay was not idempotent"
+      assert_equals "$show" "$(tasks_in "$home" show "$id" --full)" "the replay or refusals changed Done work"
+      assert_equals "$published" "$(cat "$channel")" "the replay or refusals duplicated parent publication"
+    done
+  done
+  pass "completed default and done releases replay and recover failed publication without rewriting history"
+}
+
+test_stale_keyed_replay_preserves_a_concurrent_hold() {
+  local home parent channel id mode row replay_pid replay_rc show open published request
+  for mode in default "done" release; do
+    home=$(make_home "stale-keyed-replay-$mode")
+    parent=$(make_home "stale-keyed-replay-parent-$mode")
+    printf 'stale-replay-mate\n' > "$home/.fm-secondmate-home"
+    printf 'schema=fm-secondmate-parent.v1\nroute=local\nparent_home=%s\n' "$parent" \
+      > "$home/.fm-secondmate-parent"
+    printf -- '- stale-replay-mate - synthetic scope (home: %s; scope: sample reviews; projects: sample; added 2026-07-14)\n' \
+      "$home" > "$parent/data/secondmates.md"
+    fm_write_secondmate_meta "$parent/state/stale-replay-mate.meta" "$home" \
+      "firstmate:fm-stale-replay-mate" sample
+    channel="$parent/state/stale-replay-mate.status"
+    id=sample-stale-keyed-replay
+    tasks_in "$home" add "$id" "Review the stale replay race" \
+      --kind scout --repo sample --start >/dev/null || fail "could not create the replay-race task"
+    write_origin_meta "$home" "$id"
+    FM_CAPTAIN_HOLD_NOW=2026-07-14T12:00:00Z run_captain "$home" hold "$id" \
+      --reason "captain initial choice pending" >/dev/null || fail "could not open the first hold"
+    row=$(printf '%s\tgo\tProceed' "$id")
+    [ "$mode" = default ] || row=$(printf '%s\t%s' "$row" "$mode")
+    printf '%s\n' "$row" | run_captain "$home" answers --source "stale replay fixture" \
+      > "$home/release.out" 2> "$home/release.err" || fail "could not release the first hold"
+    show=$(tasks_in "$home" show "$id" --full)
+    assert_contains "$show" "state: in_flight" "the first answer completed live work"
+    assert_contains "$show" "held: no" "the first answer did not release its hold"
+    cat > "$home/fakebin/tasks-axi" <<'SH'
+#!/usr/bin/env bash
+if [ "${FM_TEST_STALE_REPLAY:-}" = 1 ] && [ "${1:-}" = show ] \
+  && [ "${2:-}" = sample-stale-keyed-replay ]; then
+  count=0
+  [ ! -f "$FM_HOME/replay-reads" ] || read -r count < "$FM_HOME/replay-reads"
+  count=$((count + 1))
+  printf '%s\n' "$count" > "$FM_HOME/replay-reads"
+  if [ "$count" -eq 2 ]; then
+    "$REAL_TASKS_AXI" "$@" > "$FM_HOME/replay-snapshot" || exit "$?"
+    : > "$FM_HOME/replay-ready"
+    while [ ! -e "$FM_HOME/replay-release" ] \
+      && [ "$SECONDS" -lt "${FM_TEST_STUB_MAX_BLOCK_SECONDS:-120}" ]; do
+      sleep 0.01
+    done
+    cat "$FM_HOME/replay-snapshot"
+    exit 0
+  fi
+fi
+exec "$REAL_TASKS_AXI" "$@"
+SH
+    chmod +x "$home/fakebin/tasks-axi"
+    (
+      printf '%s\n' "$row" | FM_TEST_STALE_REPLAY=1 FM_BACKLOG_ROW_TIMEOUT_SECS=120 \
+        run_captain "$home" answers --source "stale replay fixture"
+    ) > "$home/replay.out" 2> "$home/replay.err" &
+    replay_pid=$!
+    if ! wait_for_test_file "$home/replay-ready" "$replay_pid"; then
+      : > "$home/replay-release"
+      wait "$replay_pid" 2>/dev/null || true
+      fail "the replay did not snapshot the released first hold: $(cat "$home/replay.err")"
+    fi
+    FM_CAPTAIN_HOLD_NOW=2026-07-14T12:00:01Z run_captain "$home" hold "$id" \
+      --reason "captain revised choice pending" >/dev/null || fail "could not open the concurrent hold"
+    request_reconciles "$home" stale-replay-source "$id" \
+      || fail "could not create the concurrent hold's reconcile request"
+    request="$home/state/reconcile-requests/$id.request"
+    cp "$request" "$home/request-before"
+    show=$(tasks_in "$home" show "$id" --full)
+    published=$(cat "$channel")
+    open=$(bash -c '. "$1"; status_open_decisions "$2" secondmate' \
+      _ "$ROOT/bin/fm-status-decision-lib.sh" "$channel")
+    assert_contains "$open" "captain-hold-$id-2" "the concurrent parent decision did not open"
+    : > "$home/replay-release"
+    replay_rc=0
+    wait "$replay_pid" || replay_rc=$?
+    [ "$replay_rc" -ne 0 ] || fail "the stale replay reported success for the concurrent hold"
+    assert_not_contains "$(cat "$home/replay.out")" "closed: $id" \
+      "the stale replay reported the concurrent hold closed"
+    assert_contains "$(cat "$home/replay.out")" "answers: closed=0 skipped=1" \
+      "the stale replay failed before classifying the answer: $(cat "$home/replay.err")"
+    assert_present "$request" "the stale replay retired the concurrent hold's reconcile request"
+    cmp -s "$request" "$home/request-before" || fail "the stale replay changed the reconcile request"
+    assert_equals "$show" "$(tasks_in "$home" show "$id" --full)" \
+      "the stale replay changed the concurrent held task"
+    assert_equals "$published" "$(cat "$channel")" "the stale replay published a parent resolution"
+    open=$(bash -c '. "$1"; status_open_decisions "$2" secondmate' \
+      _ "$ROOT/bin/fm-status-decision-lib.sh" "$channel")
+    assert_contains "$open" "captain-hold-$id-2" "the stale replay resolved the concurrent parent decision"
+    assert_not_contains "$open" "captain-hold-$id-1"$'\t' "the first parent decision reopened"
+    printf '%s\n' "$row" | run_captain "$home" answers --source "stale replay fixture" \
+      > "$home/fresh.out" 2> "$home/fresh.err" || fail "a fresh answer could not resolve the concurrent hold"
+    assert_contains "$(cat "$home/fresh.out")" "closed: $id" "the fresh answer was not reported closed"
+    assert_absent "$request" "the fresh answer left the reconcile request pending"
+    show=$(tasks_in "$home" show "$id" --full)
+    assert_contains "$show" "state: in_flight" "the fresh answer completed live work"
+    assert_contains "$show" "held: no" "the fresh answer did not release the concurrent hold"
+    open=$(bash -c '. "$1"; status_open_decisions "$2" secondmate' \
+      _ "$ROOT/bin/fm-status-decision-lib.sh" "$channel")
+    assert_not_contains "$open" "captain-hold-$id-2"$'\t' "the fresh answer left the parent decision open"
+  done
+  pass "stale default, done and release replays preserve a concurrent hold until a fresh answer"
+}
+
+test_repeated_keyed_answer_resolves_its_own_hold() {
+  local home parent channel id mode interruption row show out open published body
+  local first_stamp=2026-07-14T12:00:00Z second_stamp=2026-07-14T12:00:01Z expected_mode
+  for mode in default "done"; do
+    for interruption in interrupted ordinary; do
+      home=$(make_home "reheld-keyed-answer-$mode-$interruption")
+      parent=$(make_home "reheld-keyed-answer-parent-$mode-$interruption")
+      printf 'reheld-answer-mate\n' > "$home/.fm-secondmate-home"
+      printf 'schema=fm-secondmate-parent.v1\nroute=local\nparent_home=%s\n' "$parent" \
+        > "$home/.fm-secondmate-parent"
+      printf -- '- reheld-answer-mate - synthetic scope (home: %s; scope: sample reviews; projects: sample; added 2026-07-14)\n' \
+        "$home" > "$parent/data/secondmates.md"
+      fm_write_secondmate_meta "$parent/state/reheld-answer-mate.meta" "$home" \
+        "firstmate:fm-reheld-answer-mate" sample
+      channel="$parent/state/reheld-answer-mate.status"
+      id=sample-reheld-keyed-answer
+      tasks_in "$home" add "$id" "Investigate repeated answer recovery" \
+        --kind scout --repo sample --start >/dev/null || fail "could not create the re-held task"
+      write_origin_meta "$home" "$id"
+      mkdir -p "$home/data/$id"
+      printf 'done: report complete\n' > "$home/state/$id.status"
+      printf '# Re-held answer report\n' > "$home/data/$id/report.md"
+      FM_CAPTAIN_HOLD_NOW="$first_stamp" run_captain "$home" hold "$id" \
+        --reason "captain initial report choice pending" >/dev/null \
+        || fail "could not open the first hold"
+      complete_through_sibling "$home" "$id" >/dev/null \
+        || fail "could not complete the re-held task's inventory"
+      open=$(bash -c '. "$1"; status_open_decisions "$2" secondmate' \
+        _ "$ROOT/bin/fm-status-decision-lib.sh" "$channel")
+      assert_contains "$open" "captain-hold-$id-1" "the first parent decision did not open"
+      row=$(printf '%s\tgo\tProceed' "$id")
+      [ "$mode" != "done" ] || row=$(printf '%s\tdone' "$row")
+      out=$(printf '%s\n' "$row" | run_captain "$home" answers --source "reheld answer fixture" 2>&1) \
+        || fail "the first keyed answer failed: $out"
+      show=$(tasks_in "$home" show "$id" --full)
+      assert_contains "$show" "state: in_flight" "the first answer completed live work"
+      assert_contains "$show" "held: no" "the first answer did not release live work"
+      body=$(printf '%s\n' "$show" | sed -n 's/^  body: //p')
+      printf '%s\n' "$body" | jq -j 'split("\n\n")[0:2] | join("\n\n")' > "$home/first-resolution.txt"
+      assert_equals 1 "$(printf '%s\n' "$body" | jq 'split("Resolution recorded by fm-captain-hold.") | length - 1')" \
+        "the first answer wrote duplicate records"
+      assert_contains "$show" "Resolution mode: released\\nResolves hold set: $first_stamp" \
+        "the first release did not identify its hold"
+      open=$(bash -c '. "$1"; status_open_decisions "$2" secondmate' \
+        _ "$ROOT/bin/fm-status-decision-lib.sh" "$channel")
+      assert_not_contains "$open" "captain-hold-$id-1"$'\t' "the first parent decision remained open"
+      assert_contains "$(cat "$channel")" "resolved [key=captain-hold-$id-1]" \
+        "the first release did not publish its resolution"
+      published=$(cat "$channel")
+      if FM_CAPTAIN_HOLD_NOW="$first_stamp" run_captain "$home" hold "$id" \
+        --reason "captain revised report choice pending" > "$home/collision.out" 2> "$home/collision.err"; then
+        fail "a same-second re-hold reused the first resolution's association"
+      fi
+      assert_contains "$(cat "$home/collision.err")" "FM_CAPTAIN_HOLD_NOW collides" \
+        "a pinned timestamp collision did not explain the refusal"
+      assert_equals "$show" "$(tasks_in "$home" show "$id" --full)" \
+        "a refused same-second re-hold changed the work item"
+      assert_equals "$published" "$(cat "$channel")" "a refused re-hold opened another parent key"
+      FM_CAPTAIN_HOLD_NOW="$second_stamp" run_captain "$home" hold "$id" \
+        --reason "captain revised report choice pending" >/dev/null \
+        || fail "could not open the second hold"
+      open=$(bash -c '. "$1"; status_open_decisions "$2" secondmate' \
+        _ "$ROOT/bin/fm-status-decision-lib.sh" "$channel")
+      assert_contains "$open" "captain-hold-$id-2" "the second parent decision did not open"
+      if [ "$interruption" = interrupted ]; then
+        cat > "$home/fakebin/tasks-axi" <<'SH'
+#!/usr/bin/env bash
+if [ "${1:-}" = unhold ] && [ "${2:-}" = sample-reheld-keyed-answer ] \
+  && [ ! -e "$FM_HOME/unhold-failed-once" ]; then
+  : > "$FM_HOME/unhold-failed-once"
+  exit 93
+fi
+exec "$REAL_TASKS_AXI" "$@"
+SH
+        chmod +x "$home/fakebin/tasks-axi"
+        if printf '%s\n' "$row" | run_captain "$home" answers \
+          --source "reheld answer fixture" > "$home/answer.out" 2> "$home/answer.err"; then
+          fail "the interrupted second release reported success"
+        fi
+        show=$(tasks_in "$home" show "$id" --full)
+        assert_contains "$show" "state: in_flight" "the failed second release completed live work"
+        assert_contains "$show" "held: yes" "the failed second release lost its hold"
+        body=$(printf '%s\n' "$show" | sed -n 's/^  body: //p')
+        assert_equals 2 "$(printf '%s\n' "$body" | jq 'split("Resolution recorded by fm-captain-hold.") | length - 1')" \
+          "the repeated live answer did not record the second hold's own answer"
+        assert_contains "$show" "Resolution mode: released\\nResolves hold set: $second_stamp" \
+          "the second release did not identify its hold"
+      fi
+      REAL_TASKS_AXI="$TASKS_AXI_BIN" run_teardown "$home" "$id" \
+        > "$home/teardown.out" 2> "$home/teardown.err" \
+        || fail "cleanup of the re-held task failed: $(cat "$home/teardown.err")"
+      show=$(tasks_in "$home" show "$id" --full)
+      assert_contains "$show" "state: queued" "cleanup did not queue the re-held finished work"
+      assert_contains "$show" "held: yes" "cleanup released the second hold"
+      assert_absent "$home/state/$id.meta" "cleanup left the worker record behind"
+      out=$(printf '%s\n' "$row" | run_captain "$home" answers --source "reheld answer fixture" 2>&1) \
+        || fail "the repeated answer did not complete the second hold: $out"
+      assert_contains "$out" "closed: $id" "the second hold was not reported resolved"
+      show=$(tasks_in "$home" show "$id" --full)
+      assert_contains "$show" "state: done" "the repeated answer made finished work runnable"
+      assert_contains "$show" "held: no" "the repeated answer left the second hold active"
+      body=$(printf '%s\n' "$show" | sed -n 's/^  body: //p')
+      assert_equals 2 "$(printf '%s\n' "$body" | jq 'split("Resolution recorded by fm-captain-hold.") | length - 1')" \
+        "the completed second hold did not keep exactly two resolution records"
+      expected_mode=answered
+      [ "$interruption" != interrupted ] || expected_mode=released
+      printf '%s\n' "$body" | jq -e --arg stamp "$second_stamp" --arg mode "$expected_mode" \
+        'startswith("Resolution recorded by fm-captain-hold.\n") and
+         (split("\n")[2:4] == ["Resolution mode: " + $mode, "Resolves hold set: " + $stamp])' \
+        >/dev/null || fail "the newest record did not preserve the second hold's resolution"
+      printf '%s\n' "$body" | jq -j \
+        '("Resolution recorded by fm-captain-hold." + (split("Resolution recorded by fm-captain-hold.")[2])) | split("\n\n")[0:2] | join("\n\n")' \
+        > "$home/preserved-resolution.txt"
+      cmp -s "$home/first-resolution.txt" "$home/preserved-resolution.txt" \
+        || fail "the second hold changed the first resolution's bytes"
+      open=$(bash -c '. "$1"; status_open_decisions "$2" secondmate' \
+        _ "$ROOT/bin/fm-status-decision-lib.sh" "$channel")
+      assert_not_contains "$open" "captain-hold-$id-1"$'\t' "the first parent decision reopened"
+      assert_not_contains "$open" "captain-hold-$id-2"$'\t' "the second parent decision remained open"
+      published=$(cat "$channel")
+      assert_contains "$published" "resolved [key=captain-hold-$id-2]" \
+        "the second hold did not resolve its own parent key"
+      assert_not_contains "$published" "captain-hold-$id-3" "the second hold invented a third parent key"
+      out=$(printf '%s\n' "$row" | run_captain "$home" answers --source "reheld answer fixture" 2>&1) \
+        || fail "the completed second hold could not replay: $out"
+      assert_contains "$out" "closed: $id" "the completed replay was not idempotent"
+      assert_equals "$show" "$(tasks_in "$home" show "$id" --full)" \
+        "the completed replay changed resolution history"
+      assert_equals "$published" "$(cat "$channel")" "the completed replay changed parent keys"
+    done
+  done
+  pass "repeated default and done answers preserve prior holds and resolve the current parent decision"
+}
+
+test_legacy_keyed_release_requires_explicit_closure() {
+  local home id mode row show body out
+  for mode in default "done"; do
+    home=$(make_home "legacy-keyed-release-$mode")
+    id=sample-legacy-keyed-release
+    tasks_in "$home" add "$id" "Investigate legacy answer recovery" \
+      --kind scout --repo sample --start >/dev/null || fail "could not create the legacy release task"
+    write_origin_meta "$home" "$id"
+    mkdir -p "$home/data/$id"
+    printf 'done: report complete\n' > "$home/state/$id.status"
+    printf '# Legacy answer report\n' > "$home/data/$id/report.md"
+    FM_CAPTAIN_HOLD_NOW=2026-07-14T12:00:00Z run_captain "$home" hold "$id" \
+      --reason "captain initial report choice pending" >/dev/null || fail "could not open the legacy first hold"
+    complete_through_sibling "$home" "$id" >/dev/null || fail "could not complete the legacy task inventory"
+    row=$(printf '%s\tgo\tProceed' "$id")
+    [ "$mode" != "done" ] || row=$(printf '%s\tdone' "$row")
+    printf '%s\n' "$row" | run_captain "$home" answers --source "legacy release fixture" >/dev/null \
+      || fail "could not release the legacy first hold"
+    FM_CAPTAIN_HOLD_NOW=2026-07-15T12:00:00Z run_captain "$home" hold "$id" \
+      --reason "captain revised report choice pending" >/dev/null || fail "could not open the legacy second hold"
+    cat > "$home/fakebin/tasks-axi" <<'SH'
+#!/usr/bin/env bash
+if [ "${1:-}" = unhold ] && [ "${2:-}" = sample-legacy-keyed-release ] \
+  && [ ! -e "$FM_HOME/unhold-failed-once" ]; then
+  : > "$FM_HOME/unhold-failed-once"
+  exit 93
+fi
+exec "$REAL_TASKS_AXI" "$@"
+SH
+    chmod +x "$home/fakebin/tasks-axi"
+    if printf '%s\n' "$row" | run_captain "$home" answers --source "legacy release fixture" \
+      > "$home/answer.out" 2> "$home/answer.err"; then
+      fail "the interrupted legacy release reported success"
+    fi
+    show=$(tasks_in "$home" show "$id" --full)
+    body=$(printf '%s\n' "$show" | sed -n 's/^  body: //p')
+    printf '%s\n' "$body" | jq -j 'sub("Resolves hold set: 2026-07-15T12:00:00Z\n"; "")' \
+      > "$home/legacy-body.txt"
+    tasks_in "$home" update "$id" --body-file "$home/legacy-body.txt" >/dev/null \
+      || fail "could not install the persisted legacy record"
+    REAL_TASKS_AXI="$TASKS_AXI_BIN" run_teardown "$home" "$id" \
+      > "$home/teardown.out" 2> "$home/teardown.err" \
+      || fail "cleanup of the legacy release failed: $(cat "$home/teardown.err")"
+    show=$(tasks_in "$home" show "$id" --full)
+    assert_contains "$show" "state: queued" "cleanup did not retain legacy finished work"
+    assert_contains "$show" "held: yes" "cleanup released the legacy hold"
+    assert_absent "$home/state/$id.meta" "cleanup left the legacy worker record behind"
+    if out=$(printf '%s\n' "$row" | run_captain "$home" answers --source "legacy release fixture" 2>&1); then
+      fail "an ambiguous legacy release was automatically completed"
+    fi
+    assert_contains "$out" "close it with reconcile or a direct answer" \
+      "the legacy retry did not give safe closure guidance"
+    assert_not_contains "$out" "retry with --release" "the legacy retry advised reopening finished work"
+    assert_equals "$show" "$(tasks_in "$home" show "$id" --full)" \
+      "the legacy retry rewrote history or changed task state"
+    printf 'Captain explicitly closes this finished report.\n' > "$home/close.txt"
+    run_captain "$home" answer "$id" --decision-file "$home/close.txt" >/dev/null \
+      || fail "a fresh direct answer could not close the legacy hold"
+    assert_contains "$(tasks_in "$home" show "$id" --full)" "state: done" \
+      "the explicit legacy closure did not complete finished work"
+  done
+  pass "ambiguous legacy default and done releases require explicit closure without rewriting history"
+}
+
 # Decks that carry no schema marker are not all the bare question/answer pair:
 # lane-composed decision decks add `note` and bookkeeping fields (`task`,
 # `owner`, `recommended`, `decision_key`), and some name the picked option
@@ -3103,58 +3785,74 @@ SH
 }
 
 test_answer_before_cleanup_replay_preserves_the_retained_report() {
-  local home id wt rc bootstrap json
-  home=$(make_home answer-before-cleanup-replay)
-  id=sample-answer-before-cleanup-replay
-  wt="$home/projects/$id"
-  mkdir -p "$home/data/$id" "$wt" "$home/projects/sample"
-  tasks_in "$home" add "$id" "Investigate answer before cleanup replay" --kind scout \
-    --repo sample --start >/dev/null || fail "could not create the answer-before-replay fixture"
-  fm_write_meta "$home/state/$id.meta" \
-    "window=firstmate:fm-$id" "worktree=$wt" "project=$home/projects/sample" \
-    "harness=codex" "kind=scout" "mode=scout" "spawn_gen=fixture-$id"
-  printf 'done: report complete\n' > "$home/state/$id.status"
-  printf '# Interrupted cleanup\n\nThe captain call remains open.\n' > "$home/data/$id/report.md"
-  run_captain "$home" hold "$id" --reason "captain must choose after interrupted cleanup" \
-    >/dev/null || fail "could not hold the answer-before-replay fixture"
-  complete_through_sibling "$home" "$id" >/dev/null \
-    || fail "completion gate failed for the answer-before-replay fixture"
-  cat > "$home/fakebin/treehouse" <<'SH'
+  local home id wt rc bootstrap json intake show
+  for intake in direct keyed keyed-without-meta; do
+    home=$(make_home "answer-before-cleanup-replay-$intake")
+    id=sample-answer-before-cleanup-replay
+    wt="$home/projects/$id"
+    mkdir -p "$home/data/$id" "$wt" "$home/projects/sample"
+    tasks_in "$home" add "$id" "Investigate answer before cleanup replay" --kind scout \
+      --repo sample --start >/dev/null || fail "could not create the answer-before-replay fixture"
+    fm_write_meta "$home/state/$id.meta" \
+      "window=firstmate:fm-$id" "worktree=$wt" "project=$home/projects/sample" \
+      "harness=codex" "kind=scout" "mode=scout" "spawn_gen=fixture-$id"
+    printf 'done: report complete\n' > "$home/state/$id.status"
+    printf '# Interrupted cleanup\n\nThe captain call remains open.\n' > "$home/data/$id/report.md"
+    run_captain "$home" hold "$id" --reason "captain must choose after interrupted cleanup" \
+      >/dev/null || fail "could not hold the answer-before-replay fixture"
+    complete_through_sibling "$home" "$id" >/dev/null \
+      || fail "completion gate failed for the answer-before-replay fixture"
+    cat > "$home/fakebin/treehouse" <<'SH'
 #!/usr/bin/env bash
 exit 1
 SH
-  chmod +x "$home/fakebin/treehouse"
-
-  set +e
-  PATH="$home/fakebin:$PATH" FM_ROOT_OVERRIDE="$ROOT" FM_HOME="$home" \
-    FM_STATE_OVERRIDE="$home/state" FM_DATA_OVERRIDE="$home/data" \
-    FM_CONFIG_OVERRIDE="$home/config" "$TEARDOWN" "$id" --force --drop-file "$(fm_test_drop_file)" \
-    > "$home/teardown.out" 2> "$home/teardown.err"
-  rc=$?
-  set -e
-  [ "$rc" -ne 0 ] || fail "cleanup succeeded despite the failed worktree return"
-  assert_contains "$(cat "$home/teardown.err")" "treehouse return failed for worktree $wt" \
-    "cleanup failed before the injected worktree return failure"
-  assert_present "$home/state/$id.backlog-close" \
-    "the interrupted cleanup lost its retained-artifact record"
+    chmod +x "$home/fakebin/treehouse"
 
-  printf 'Proceed with the reported result.\n' > "$home/answer.txt"
-  run_captain "$home" answer "$id" --decision-file "$home/answer.txt" >/dev/null \
-    || fail "the captain could not answer before cleanup replay"
-  fm_fake_exit0 "$home/fakebin" treehouse
-  bootstrap=$(PATH="$home/fakebin:$PATH" FM_ROOT_OVERRIDE="$ROOT" FM_HOME="$home" \
-    FM_STATE_OVERRIDE="$home/state" FM_DATA_OVERRIDE="$home/data" \
-    FM_CONFIG_OVERRIDE="$home/config" FM_BOOTSTRAP_NETWORK=skip \
-    "$ROOT/bin/fm-bootstrap.sh" 2>&1) \
-    || fail "session start could not replay cleanup after the answer: $bootstrap"
-  assert_absent "$home/state/$id.meta" "session start left the interrupted task record behind"
-  assert_absent "$home/state/$id.backlog-close" "session start left the pending record behind"
-  json=$(run_bearings "$home") || fail "Bearings failed after the answer-before-replay lifecycle"
-  printf '%s' "$json" | jq -e \
-    --arg id "$id" --arg report "data/$id/report.md" \
-    '.landed | any(.id == $id and .artifact == $report)' >/dev/null \
-    || fail "the retained report disappeared when the captain answered before replay: $json"
-  pass "an answer before cleanup replay preserves the retained report"
+    set +e
+    PATH="$home/fakebin:$PATH" FM_ROOT_OVERRIDE="$ROOT" FM_HOME="$home" \
+      FM_STATE_OVERRIDE="$home/state" FM_DATA_OVERRIDE="$home/data" \
+      FM_CONFIG_OVERRIDE="$home/config" "$TEARDOWN" "$id" --force --drop-file "$(fm_test_drop_file)" \
+      > "$home/teardown.out" 2> "$home/teardown.err"
+    rc=$?
+    set -e
+    [ "$rc" -ne 0 ] || fail "cleanup succeeded despite the failed worktree return"
+    assert_contains "$(cat "$home/teardown.err")" "treehouse return failed for worktree $wt" \
+      "cleanup failed before the injected worktree return failure"
+    assert_present "$home/state/$id.backlog-close" \
+      "the interrupted cleanup lost its retained-artifact record"
+
+    if [ "$intake" = direct ]; then
+      printf 'Proceed with the reported result.\n' > "$home/answer.txt"
+      run_captain "$home" answer "$id" --decision-file "$home/answer.txt" >/dev/null \
+        || fail "the captain could not answer before cleanup replay"
+    else
+      printf '%s\tgo\tProceed with the reported result.\n' "$id" \
+        | run_captain "$home" answers --source "interrupted cleanup fixture" >/dev/null \
+        || fail "the captain could not release work before cleanup replay"
+      show=$(tasks_in "$home" show "$id" --full)
+      assert_contains "$show" "state: in_flight" "the keyed answer completed work before replay"
+      assert_contains "$show" "held: no" "the keyed answer left the work held before replay"
+      assert_contains "$show" "Resolution mode: released" "the keyed answer did not record its release"
+      [ "$intake" != keyed-without-meta ] || rm -f "$home/state/$id.meta"
+    fi
+    fm_fake_exit0 "$home/fakebin" treehouse
+    bootstrap=$(PATH="$home/fakebin:$PATH" FM_ROOT_OVERRIDE="$ROOT" FM_HOME="$home" \
+      FM_STATE_OVERRIDE="$home/state" FM_DATA_OVERRIDE="$home/data" \
+      FM_CONFIG_OVERRIDE="$home/config" FM_BOOTSTRAP_NETWORK=skip \
+      "$ROOT/bin/fm-bootstrap.sh" 2>&1) \
+      || fail "session start could not replay cleanup after the answer: $bootstrap"
+    assert_absent "$home/state/$id.meta" "session start left the interrupted task record behind"
+    assert_absent "$home/state/$id.backlog-close" "session start left the pending record behind"
+    show=$(tasks_in "$home" show "$id" --full)
+    assert_contains "$show" "state: done" "cleanup replay reopened finished, answered work"
+    assert_contains "$show" "Proceed with the reported result." "cleanup replay lost the captain's words"
+    json=$(run_bearings "$home") || fail "Bearings failed after the answer-before-replay lifecycle"
+    printf '%s' "$json" | jq -e \
+      --arg id "$id" --arg report "data/$id/report.md" \
+      '.landed | any(.id == $id and .artifact == $report)' >/dev/null \
+      || fail "the retained report disappeared when the captain answered before replay: $json"
+  done
+  pass "cleanup replay closes answered work and preserves the report after direct or keyed answers"
 }
 
 test_answer_before_cleanup_replay_notes_a_retained_gerrit_change() {
@@ -3269,9 +3967,10 @@ SH
 }
 
 test_relocated_report_does_not_wedge_an_answer_before_replay() {
-  local home data id wt rc show bootstrap json
-  home=$(make_home relocated-answer-before-replay)
-  data="$home/données"
+  local home data id wt rc show bootstrap json intake=${1:-close}
+  local -a release_args=()
+  home=$(make_home "relocated-answer-before-replay-$intake")
+  if [ "$intake" = close ]; then data="$home/données"; else data="$home/records"; fi
   mv "$home/data" "$data"
   id=sample-relocated-answer-before-replay
   wt="$home/projects/$id"
@@ -3325,13 +4024,28 @@ SH
     "the interrupted relocated cleanup lost its pending record"
 
   printf 'Proceed despite the reporting limitation.\n' > "$home/answer.txt"
-  PATH="$home/fakebin:$PATH" FM_HOME="$home" FM_STATE_OVERRIDE="$home/state" \
-    FM_DATA_OVERRIDE="$data" FM_CONFIG_OVERRIDE="$home/config" \
-    "$ROOT/bin/fm-captain-hold.sh" answer "$id" --decision-file "$home/answer.txt" \
-    >/dev/null || fail "the unsupported relocated report wedged the captain's answer"
+  if [ "$intake" = keyed ]; then
+    printf '%s\tgo\tProceed despite the reporting limitation.\n' "$id" \
+      | PATH="$home/fakebin:$PATH" FM_HOME="$home" FM_STATE_OVERRIDE="$home/state" \
+        FM_DATA_OVERRIDE="$data" FM_CONFIG_OVERRIDE="$home/config" \
+        "$ROOT/bin/fm-captain-hold.sh" answers --source "relocated cleanup fixture" \
+        >/dev/null || fail "the relocated task could not be released by a keyed answer"
+  else
+    [ "$intake" != release ] || release_args=(--release)
+    PATH="$home/fakebin:$PATH" FM_HOME="$home" FM_STATE_OVERRIDE="$home/state" \
+      FM_DATA_OVERRIDE="$data" FM_CONFIG_OVERRIDE="$home/config" \
+      "$ROOT/bin/fm-captain-hold.sh" answer "$id" --decision-file "$home/answer.txt" \
+      "${release_args[@]+"${release_args[@]}"}" \
+      >/dev/null || fail "the unsupported relocated report wedged the captain's answer"
+  fi
   show=$(cd "$home" && tasks-axi show "$id" --full --file "$data/backlog.md") \
     || fail "the answered relocated row disappeared"
-  assert_contains "$show" "state: done" "the relocated report kept the answered call open"
+  if [ "$intake" = close ]; then
+    assert_contains "$show" "state: done" "the relocated report kept the answered call open"
+  else
+    assert_contains "$show" "state: in_flight" "the release completed work before cleanup replay"
+    assert_contains "$show" "Resolution mode: released" "the answer did not record its release"
+  fi
   assert_contains "$show" "held: no" "the relocated report kept the answered call held"
 
   fm_fake_exit0 "$home/fakebin" treehouse
@@ -3342,6 +4056,10 @@ SH
     || fail "session start could not replay relocated cleanup after the answer: $bootstrap"
   assert_absent "$home/state/$id.meta" "session start left the relocated task record behind"
   assert_absent "$home/state/$id.backlog-close" "session start left the relocated pending record behind"
+  show=$(cd "$home" && tasks-axi show "$id" --full --file "$data/backlog.md") \
+    || fail "the relocated row disappeared after replay"
+  assert_contains "$show" "state: done" "the relocated report blocked cleanup completion"
+  assert_contains "$show" "held: no" "cleanup replay left the answered task held"
   json=$(PATH="$home/fakebin:$PATH" FM_HOME="$home" FM_DATA_OVERRIDE="$data" \
     FM_BEARINGS_NOW=2026-07-14T12:00:00Z "$BEARINGS" --json) \
     || fail "Bearings failed after the relocated answer-before-replay lifecycle"
@@ -3351,6 +4069,11 @@ SH
   pass "an unsupported relocated report does not wedge the captain's answer"
 }
 
+test_relocated_report_does_not_wedge_released_cleanup_replay() {
+  test_relocated_report_does_not_wedge_an_answer_before_replay keyed
+  test_relocated_report_does_not_wedge_an_answer_before_replay release
+}
+
 # A home whose data directory is relocated keeps one backlog; the predicate and
 # the retention must address it the way teardown does, not FM_HOME/data.
 test_teardown_retains_captain_calls_in_a_relocated_backlog() {
@@ -5805,6 +6528,13 @@ test_secondmate_hold_stays_in_authoritative_home
 test_secondmate_home_publishes_holds_and_answers
 test_secondmate_reconcile_publishes_before_request_retirement
 test_bound_channel_answers_close_at_answer_time
+test_keyed_answer_releases_a_live_work_item
+test_keyed_answer_waits_for_cleanup_before_selecting_its_mode
+test_interrupted_keyed_release_closes_after_teardown
+test_completed_keyed_release_replays_after_publication_failure
+test_stale_keyed_replay_preserves_a_concurrent_hold
+test_repeated_keyed_answer_resolves_its_own_hold
+test_legacy_keyed_release_requires_explicit_closure
 test_unversioned_deck_shapes_with_extra_fields_still_route
 test_legacy_reconcile_replaces_previous_choices
 test_reconcile_never_closes_through_the_keyed_answer_intake
@@ -5825,6 +6555,7 @@ test_answer_before_cleanup_replay_preserves_the_retained_report
 test_answer_before_cleanup_replay_notes_a_retained_gerrit_change
 test_unusable_pending_close_record_names_its_reason
 test_relocated_report_does_not_wedge_an_answer_before_replay
+test_relocated_report_does_not_wedge_released_cleanup_replay
 test_teardown_retains_captain_calls_in_a_relocated_backlog
 test_teardown_retains_a_gerrit_captain_call_with_its_change_url
 test_merge_approval_releases_before_zero_done_retention