@@ -13,9 +13,11 @@
 if str(REPO_ROOT) not in sys.path:
     sys.path.insert(0, str(REPO_ROOT))
 
+from loopx.control_plane.todos.completed_archive import (  # noqa: E402
+    completed_todo_archive_warning,
+    completed_todo_count,
+)
 from loopx.status import parse_active_state_todos  # noqa: E402
-from loopx.control_plane.todos.completed_archive import completed_todo_archive_warning  # noqa: E402
-
 
 GOAL_ID = "todo-archive-completed-goal"
 
@@ -39,6 +41,9 @@ def state_text() -> str:
         "## Agent Todo\n\n"
         "- [ ] [P1] Keep current open benchmark validation work visible.\n"
         + "".join(done_lines)
+        + "- [-] [P0] Resume deferred acceptance after its dependency.\n"
+        + "  <!-- loopx:todo todo_id=todo_deferred_acceptance status=deferred "
+        + "task_class=advancement_task resume_when=todo_done:todo_dependency -->\n"
         + "- [ ] [P2] Keep monitor work after completed items visible.\n\n"
         "## Completed Work Archive\n\n"
         "- [x] [P1] Previously archived completed work.\n"
@@ -114,7 +119,8 @@ def main() -> int:
         registry_path, runtime, state_path = write_fixture(Path(tmp))
         original = state_path.read_text(encoding="utf-8")
         parsed = parse_active_state_todos(original)
-        assert parsed["agent_todos"]["done_count"] == 14, parsed
+        assert parsed["agent_todos"]["done_count"] == 15, parsed
+        assert parsed["agent_todos"]["deferred_count"] == 1, parsed
         assert parsed["agent_todos"]["open_count"] == 2, parsed
         warning = completed_todo_archive_warning(parsed["agent_todos"])
         assert warning is not None, parsed
@@ -181,7 +187,8 @@ def main() -> int:
 
         updated = state_path.read_text(encoding="utf-8")
         parsed_after = parse_active_state_todos(updated)
-        assert parsed_after["agent_todos"]["done_count"] == 12, parsed_after
+        assert parsed_after["agent_todos"]["done_count"] == 13, parsed_after
+        assert parsed_after["agent_todos"]["deferred_count"] == 1, parsed_after
         assert parsed_after["agent_todos"]["open_count"] == 2, parsed_after
         assert completed_todo_archive_warning(parsed_after["agent_todos"]) is None, parsed_after
         assert updated.index("## Completed Work Archive") < updated.index("[P1] Completed implementation lane 1.")
@@ -195,7 +202,7 @@ def main() -> int:
         assert status_after["ok"] is True, status_after
         assert status_after["contract_errors"] == [], status_after
 
-        done_before_completion = parsed_after["agent_todos"]["done_count"]
+        done_before_completion = completed_todo_count(parsed_after["agent_todos"])
         lineage_source_text = "Complete work whose successor lineage must survive archiving."
         lineage_successor_text = "Continue the public archive interplay validation."
         lineage_source = run_cli(
@@ -286,6 +293,29 @@ def main() -> int:
         )
         assert successor_item["status"] == "open", successor_item
         assert successor_item["claimed_by"] == "codex-reviewer", successor_item
+        deferred_item = next(
+            item
+            for item in active_after_archive["items"]
+            if item["todo_id"] == "todo_deferred_acceptance"
+        )
+        assert deferred_item["status"] == "deferred", deferred_item
+        assert deferred_item["archive_state"] == "active", deferred_item
+        deferred_update = run_cli(
+            registry_path,
+            runtime,
+            "todo",
+            "update",
+            "--goal-id",
+            GOAL_ID,
+            "--todo-id",
+            "todo_deferred_acceptance",
+            "--agent-id",
+            "codex-reviewer",
+            "--note",
+            "Deferred acceptance remains lifecycle-addressable after archive compaction.",
+        )
+        assert deferred_update["ok"] is True, deferred_update
+        assert deferred_update["changed"] is True, deferred_update
         assert completed_todo_archive_warning(active_after_archive) is None, active_after_archive
 
         lineage_status = run_cli(registry_path, runtime, "status")
 
@@ -9,6 +9,7 @@
     section_bounds,
     todo_blocks,
 )
+from .contract import TODO_STATUS_DONE, normalize_todo_status
 from .decision_scope import is_standing_decision_receipt_item
 
 DEFAULT_MAX_ACTIVE_DONE_TODOS_BEFORE_ARCHIVE = 12
@@ -23,17 +24,37 @@ def completed_todo_archive_command_template(max_active_done: int) -> str:
     return COMPLETED_TODO_ARCHIVE_COMMAND_TEMPLATE.format(max_active_done=max_active_done)
 
 
+def completed_todo_count(todo_summary: dict[str, Any] | None) -> int:
+    """Decode explicit completions from the v0 terminal-count projection.
+
+    ``todo_summary_v0.done_count`` intentionally includes deferred Todos because
+    both states are terminal for scheduling.  Completed-work compaction has a
+    narrower contract and must remove the deferred lane before applying archive
+    pressure.
+    """
+
+    if not isinstance(todo_summary, dict):
+        return 0
+    try:
+        terminal_count = int(todo_summary["done_count"])
+        deferred_count = int(todo_summary["deferred_count"])
+    except (KeyError, TypeError, ValueError):
+        return 0
+    return max(0, terminal_count - deferred_count)
+
+
+def _is_explicitly_completed_todo(block: dict[str, Any]) -> bool:
+    return bool(normalize_todo_status(block.get("status")) == TODO_STATUS_DONE)
+
+
 def completed_todo_archive_warning(
     agent_todos: dict[str, Any] | None,
     *,
     max_active_done_todos: int = DEFAULT_MAX_ACTIVE_DONE_TODOS_BEFORE_ARCHIVE,
 ) -> dict[str, Any] | None:
     if not isinstance(agent_todos, dict):
         return None
-    try:
-        done_count = int(agent_todos.get("done_count") or 0)
-    except (TypeError, ValueError):
-        done_count = 0
+    done_count = completed_todo_count(agent_todos)
     if done_count <= max_active_done_todos:
         return None
     try:
@@ -82,7 +103,11 @@ def archive_completed_todo_lines(
 
     if bounds:
         blocks = todo_blocks(updated_lines, bounds[0], bounds[1], role=role, source_section=section)
-        done_blocks = [block for block in blocks if block.get("done") is True]
+        done_blocks = [
+            block
+            for block in blocks
+            if _is_explicitly_completed_todo(block)
+        ]
         active_done_count = len(done_blocks)
         standing_receipts = (
             [block for block in done_blocks if is_standing_decision_receipt_item(block)]
 
@@ -10,6 +10,7 @@ teaches a reusable control-plane lesson.
 | `task_session_projection_gap` | The UI says work is running while the linked Session has no active Turn, or a monitor opens an unrelated task Session. | Goal state, Todo id, Session `channel_id`, active Turn, and typed-action receipt resource ids. | Generic Goal activity was counted as active execution, or the UI joined Sessions by Goal id without the Todo id. | Count execution only from an active Turn, join task Sessions by Todo id, and create or resume a dedicated `task.<todo_id>` Session before an immediate monitor run. Cover idle resumable Sessions and multiple Todos under one Goal. |
 | `author_owned_blocking_review_unrepresentable` | An author-owned PR receives a complete exact-head blocking review, but GitHub rejects self-`REQUEST_CHANGES` and the PR queue continues to classify the `COMMENTED` fallback as missing or malformed. | Published review state/body/title, exact review commit, machine English verdict, five required Chinese headings, and `review_conclusion.invalid_reasons`. | The review contract defined an author-owned no-blocker fallback only, so the GitHub identity restriction made a blocking conclusion impossible to encode; loose English verdict prose could also disagree with formal state. | Define separate exact `COMMENTED` titles for author-owned approval and request-changes outcomes, require a line-starting typed English verdict, validate title/verdict/state alignment, read the rendered review back at the exact head, and cover approval, blocker, untitled, and mismatched-state cases. |
 | `state_projection_gap` | `quota should-run` says `should_run=true` or `must_attempt=true`, but user and agent open todo counts are both zero while `Next Action` still contains executable work. | quota payload, active state `## Agent Todo`, `## User Todo`, `Next Action`, `refresh-state` warnings. | Active state prose has drifted away from machine todo projection. | Expand executable prose into `- [ ]` agent todos, add refresh-state warning/smoke if projection missed it. |
+| `deferred_todo_archive_projection_gap` | A deferred Todo appears under `Completed Work Archive`; `todo list` still projects it as deferred, but lifecycle update or resume reports that the Todo does not exist. | Active Todo and archive sections, marker plus explicit status, archive command receipt, `done_count` and `deferred_count`, lifecycle lookup result. | Completed-work compaction used the shared terminal/done projection, which intentionally includes deferred Todos, instead of selecting explicit `status=done`. | Make archive warnings subtract deferred from terminal counts, move only explicit done blocks, and prove a deferred Todo remains in the active section and lifecycle-addressable after archive compaction. |
 | `selected_todo_continuation_projection_gap` | Quota selects the correct runnable Todo, but a later turn repeats completed implementation or follows a stale global `Next Action` instead of the Todo's latest bounded continuation. | `selected_todo`, selected Todo metadata, active-state `Next Action`, evaluator feedback, next-turn tool trace. | Compact Todo projections retained identity and routing fields but discarded the current note before selection, or kept stale durable action prose beside the selected Todo on the hot path. | Project one bounded, secret-screened `continuation_hint` from the selected open advancement Todo's current note or explicit suggested action. When that selection supersedes durable action prose, omit the shadowed prose from the default CLI packet and retain it behind the explicit detail path; do not copy raw evidence or require every intermediate step to write state. |
 | `user_todo_projection_gap` | `interaction_contract.user_channel.action_required=true` or open user todos exist, but heartbeat/final message only says "owner gate" or does not name the concrete decision. | quota payload `interaction_contract`, `user_todo_summary`, active state user todos, recent final messages. | User-channel projection or agent final-response rule is too vague. | Fix prompt/projection so required user todo/question is surfaced; only say "具体 user todo 未投影" when action is required but absent. |
 | `lark_inbox_priority_projection_gap` | A configured bot has a pending direct question or mention, but quota/status exposes only a static drain command and ordinary monitor/advancement work runs first. | local-private inbox counts, content-free oldest-pending age, `goal_boundary.capabilities.lark_event_inbox`, `work_lane_contract`, source-thread reply/readback receipt. | Inbox availability was modeled as a prompt reminder instead of a schedulable urgency read model and priority lane. | Project content-free pending/question/mention counts plus oldest age; make `reply_due` preempt ordinary work, then require durable effect, exactly one idempotent source-thread reply with readback, and ACK. Never project message bodies, ids, senders, or private paths into quota/status. |
 
@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from loopx.control_plane.todos.completed_archive import (
+    archive_completed_todo_lines,
+    completed_todo_archive_warning,
+    completed_todo_count,
+)
+from loopx.status import parse_active_state_todos
+
+
+def _fixture_text() -> str:
+    return (
+        "# Goal\n\n"
+        "## Agent Todo\n\n"
+        "- [x] Completed work.\n"
+        "  <!-- loopx:todo todo_id=todo_done status=done -->\n"
+        "- [-] Deferred work.\n"
+        "  <!-- loopx:todo todo_id=todo_deferred status=deferred "
+        "resume_when=todo_done:todo_done -->\n\n"
+        "## Completed Work Archive\n"
+    )
+
+
+def test_completed_archive_keeps_deferred_todo_active() -> None:
+    original = _fixture_text()
+    parsed = parse_active_state_todos(original)["agent_todos"]
+
+    assert parsed["done_count"] == 2
+    assert parsed["deferred_count"] == 1
+    assert completed_todo_count(parsed) == 1
+    warning = completed_todo_archive_warning(parsed, max_active_done_todos=0)
+    assert warning is not None
+    assert warning["active_done_count"] == 1
+
+    result = archive_completed_todo_lines(original.splitlines(), max_active_done=0)
+    updated = "\n".join(result["lines"])
+
+    assert result["moved_count"] == 1
+    assert updated.index("Deferred work.") < updated.index("## Completed Work Archive")
+    assert updated.index("## Completed Work Archive") < updated.index("Completed work.")
+    projected = parse_active_state_todos(updated)["agent_todos"]
+    deferred = next(
+        item for item in projected["items"] if item["todo_id"] == "todo_deferred"
+    )
+    assert deferred["status"] == "deferred"
+    assert deferred["archive_state"] == "active"
+
+
+def test_completed_todo_count_fails_closed_for_invalid_summary_counts() -> None:
+    assert completed_todo_count(None) == 0
+    assert completed_todo_count({"done_count": 1}) == 0
+    assert completed_todo_count({"done_count": "invalid", "deferred_count": 1}) == 0
+    assert completed_todo_count({"done_count": 1, "deferred_count": 2}) == 0