diff --git a/docs/quota-allocation.md b/docs/quota-allocation.md
index 89a97a8fcd..a102e3aabe 100644
--- a/docs/quota-allocation.md
+++ b/docs/quota-allocation.md
@@ -1571,7 +1571,20 @@ advances through `progression_minutes` only after the applied RRULE has had one
 real interval to run. An immediate post-ACK reconciliation therefore verifies
 the settled target instead of manufacturing the next backoff target in the
 same turn. A changed `reset_policy.reset_token`
-returns to the current profile's initial interval. This gives hosts a compact
+returns to the current profile's initial interval. A deadline-constrained wait
+binds its effective progression buckets into that reset token. For example,
+when the same monitor's remaining horizon shrinks from `[15, 30]` to `[15]`,
+the generated ACK starts a new identity at index zero; it does not bypass the
+native same-identity regression guard. Time passing within the same buckets
+keeps the identity stable. Host readback, receipt freshness, CAS and replay
+checks still apply, including when the host already uses the tighter RRULE.
+
+受截止时间约束的等待会将实际可用的节奏档位纳入重置令牌。同一监控的档位从
+`[15, 30]` 缩为 `[15]` 时，生成的 ACK 以新身份从索引零开始；同档位内的时间流逝
+保持身份稳定。原生同身份防倒退、宿主回读、回执时效、CAS 和重放校验仍然有效，
+包括宿主已经采用较短 RRULE 的情况。
+
+This gives hosts a compact
 post-update ack protocol instead of requiring them to own or diff the whole
 quota state. If `apply_needed=false` and `ack_needed=true`, the same command
 records an exact matching host readback without calling `automation_update`.
diff --git a/loopx/control_plane/scheduler/scheduler_hint.py b/loopx/control_plane/scheduler/scheduler_hint.py
index 5e77275e35..1f4a0d12c8 100644
--- a/loopx/control_plane/scheduler/scheduler_hint.py
+++ b/loopx/control_plane/scheduler/scheduler_hint.py
@@ -772,7 +772,14 @@ def build(
             "local_scheduler_unchanged_poll_limit": cli_limit,
             "claude_code_loop_unchanged_poll_limit": claude_limit,
         }
-        reset_profile_snapshot = reset_profile_snapshot_override or profile_snapshot
+        # A deadline can shrink the allowed buckets without changing the
+        # monitor/phase identity. Bind the effective progression so the typed
+        # commit owner sees an identity reset, rather than an index regression.
+        # Elapsed time within the same buckets must not reset backoff.
+        reset_profile_snapshot = {
+            **(reset_profile_snapshot_override or profile_snapshot),
+            "app_automation_progression_minutes": app_cadence_progression,
+        }
         (
             reset_token,
             identity_signature,
diff --git a/skills/loopx-self-repair/references/repair-patterns.md b/skills/loopx-self-repair/references/repair-patterns.md
index 9ae06b7f2a..5257787d1f 100644
--- a/skills/loopx-self-repair/references/repair-patterns.md
+++ b/skills/loopx-self-repair/references/repair-patterns.md
@@ -5,6 +5,7 @@ teaches a reusable control-plane lesson.
 
 | Pattern | Symptoms | Evidence To Read | Likely Root | Durable Repair |
 | --- | --- | --- | --- | --- |
+| `scheduler_deadline_bucket_reset_gap` | A generated tighter deadline ACK fails with `progression_regression`, even after the host applies the requested RRULE. | Saved failed ACK, originating Turn, prior/current progression buckets and reset tokens, current host readback, and exact generated argv. | The deadline changes the effective progression while an override reset profile omits those buckets, so index zero still carries the old identity. | Bind effective buckets through the existing reset-profile digest; keep time within a bucket stable. Preserve native monotonic, host-readback, receipt-freshness, CAS and replay guards. Reproduce 30-minute/index-one to 15-minute/index-zero through disposable File/SQLite CLI and separately qualify the installed artifact; never edit active scheduler state or infer runtime adoption from source tests. |
 | `quiet_receipt_turn_start_context_loss` | A delegated request is delivered, but a quiet heartbeat reports no required inbox read and leaves it unassessed. | Original inbox delivery and assessment readback, initial hook dispatch, the captured final guard packet, and the automatic no-spend receipt reconstruction path. | The CLI observes pending context, then rebuilds the decision after stall writeback without forwarding that same Turn's hook dispatch. | Forward the original dispatch through the existing live-decision owner during reconstruction; preserve pending, empty and failed observations without re-running hooks or granting delivery/spend. Cover first and replayed stall receipts through final capture and CLI projection, including negative authority checks. Assess and link the original request, execute its admitted work, and report the actual result through its native return route; delivery or adoption alone is not completion. |
 | `benchmark_planning_clock_projection_gap` | A resumed task closes work using an earlier Host deadline even though a continuation was explicitly authorized; readable history and an old ready plan are mistaken for current executable work. | Original task constraints, Host phase receipts, saved model input, current authorized continuation, actual quota/frontier readback and terminal dispositions; keep private trajectories outside public artifacts. | Historical Host timing and closure context survived recovery without the new continuation intent; ordinary planning should not inject Host countdowns. | Keep Host deadlines, remaining time and execution reserves out of ordinary model input; retain external enforcement and task-owned time constraints. At the explicitly authorized archive-recovery boundary, preserve old history and closure records, identify earlier Host clocks as historical in the new continuation request, and reuse Goal/Todo/replan with a stable operation identity. Read back actionable work or review before calling continuation ready; an old plan or exit code zero is insufficient. Do not renew budgets on retry, reopen without authorization, clear a user stop, filter task deadlines or bypass evaluation cooldowns. Cover clock-free fresh/resumed input, idempotent recovery and legitimate stopping; qualify real model adoption and score gains separately. |
 | `cli_json_file_argument_contract_gap` | A `--*-json` option repeatedly rejects inline JSON as an unreadable object; reshaping it does not help, or Markdown shows only an invalid-request status. | The command's current help, file-input loader, structured error, Markdown renderer, and a synthetic valid-file recovery. | The option accepts a file path but help does not say so; file-read, JSON-decode and root-shape failures are conflated, or the renderer omits the error reason. | Clarify the existing file contract without silently adding inline input. Separate read, parse and shape diagnostics without echoing supplied contents or paths; preserve the reason in each output format. Validate missing/inline input, malformed/non-object files, same-path recovery and unchanged typed admission. Repair the owning CLI adapter, not provider readiness or Goal retry authority. |
diff --git a/tests/control_plane/test_scheduler_arbitration_native_cli.py b/tests/control_plane/test_scheduler_arbitration_native_cli.py
index 707df34a25..9248ee043b 100644
--- a/tests/control_plane/test_scheduler_arbitration_native_cli.py
+++ b/tests/control_plane/test_scheduler_arbitration_native_cli.py
@@ -5,6 +5,7 @@
 import os
 import subprocess
 import sys
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 
 import pytest
@@ -23,7 +24,9 @@
 TURN = "turn-scheduler-arbitration"
 
 
-def make_scheduler_fixture(root: Path, provider: str, scenario: str) -> dict:
+def make_scheduler_fixture(
+    root: Path, provider: str, scenario: str, *, monitor_clock: datetime | None = None,
+) -> dict:
     """Keep this synthetic source usable by source and installed-package replay."""
     project, runtime = root / "project", root / "runtime"
     project.mkdir()
@@ -34,13 +37,22 @@ def make_scheduler_fixture(root: Path, provider: str, scenario: str) -> dict:
         f"  <!-- loopx:todo todo_id={TODO} status=open claimed_by={AGENT} "
         "task_class=advancement_task action_kind=validate -->\n"
     )
-    if scenario == "monitor":
+    if scenario == "monitor" or monitor_clock is not None:
         row = (
             "- [ ] [P2-monitor] Observe the bounded source after its deadline.\n"
             f"  <!-- loopx:todo todo_id={TODO} status=open claimed_by={AGENT} "
             "task_class=continuous_monitor action_kind=observe watch_only=true "
             "target_key=synthetic-source cadence=60m next_due_at=2099-01-01T00%3A00%3A00Z -->\n"
         )
+    if monitor_clock is not None:
+        from urllib.parse import quote
+
+        due = quote((monitor_clock + timedelta(minutes=25)).isoformat(), safe="")
+        checked = quote((monitor_clock - timedelta(minutes=30)).isoformat(), safe="")
+        expires = quote((monitor_clock + timedelta(minutes=85)).isoformat(), safe="")
+        row = row.replace("2099-01-01T00%3A00%3A00Z", due).replace(
+            " -->", f" last_checked_at={checked} expires_at={expires} -->",
+        )
     gate = (
         "## User Todo\n\n- [ ] [P0-user] Approve the bounded delivery.\n"
         "  <!-- loopx:todo todo_id=todo_scheduler_gate status=open task_class=user_gate "
@@ -165,3 +177,119 @@ def test_quota_cli_keeps_scheduler_authority_without_premature_effects(
             assert fixture["registry"].read_bytes() == before["registry"]
     finally:
         restart_effect_runtime(wait_for_exit=True)
+
+
+@pytest.mark.parametrize("human_gate", [False, True])
+@pytest.mark.parametrize("provider", ["file", "sqlite"])
+def test_deadline_clamp_generated_ack_commits_and_replays(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    provider: str,
+    human_gate: bool,
+) -> None:
+    from loopx.control_plane.quota.scheduler_ack import (
+        record_quota_scheduler_ack_for_decision,
+    )
+    from loopx.control_plane.scheduler import scheduler_hint as hint_module
+    from loopx.control_plane.scheduler.execution_context import (
+        scheduler_execution_context_for_runtime_profile,
+    )
+    from tests.control_plane.scheduler_arbitration_fixture import (
+        build_native_scheduler_hint,
+    )
+
+    isolate_sqlite_runtime(tmp_path, monkeypatch)
+    now = datetime.now(timezone.utc).replace(microsecond=0)
+    fixture = make_scheduler_fixture(
+        tmp_path,
+        provider,
+        "human_gate" if human_gate else "monitor",
+        monitor_clock=now,
+    )
+    codex_home = tmp_path / "codex-home"
+    monkeypatch.setenv("CODEX_HOME", str(codex_home))
+    monkeypatch.setenv("CODEX_THREAD_ID", "synthetic-thread")
+    automation = codex_home / "automations" / "fixture" / "automation.toml"
+    automation.parent.mkdir(parents=True)
+
+    def host_rrule(minutes: int) -> None:
+        automation.write_text(
+            'version = 1\nid = "fixture"\nkind = "heartbeat"\nstatus = "ACTIVE"\n'
+            f'name = "Synthetic scheduler"\nprompt = "Advance `{GOAL}` from active state. Agent: `{AGENT}`."\n'
+            f'rrule = "FREQ=MINUTELY;INTERVAL={minutes}"\n'
+            'target_thread_id = "synthetic-thread"\n',
+        )
+
+    try:
+        host_rrule(30)
+        packet = call_scheduler_cli(fixture, *fixture["guard"])
+        authority = scheduler_authority_snapshot(fixture)
+        # Establish valid earlier ACKs through the native commit owner. Only
+        # the synthetic projection clock moves; the monitor facts stay fixed.
+        state = None
+        with monkeypatch.context() as clock:
+            for offset, minutes in [(-30, 15), (-15, 30)]:
+                at = now + timedelta(minutes=offset)
+                clock.setattr(hint_module, "now_utc", lambda: at)
+                hint = build_native_scheduler_hint(
+                    packet,
+                    codex_app_scheduler_state=state,
+                    codex_app_current_rrule=f"FREQ=MINUTELY;INTERVAL={minutes}",
+                    scheduler_execution_context=scheduler_execution_context_for_runtime_profile(
+                        "codex_app_heartbeat"
+                    ),
+                )
+                committed = record_quota_scheduler_ack_for_decision(
+                    {"goal_id": GOAL, "scheduler_hint": hint},
+                    runtime_root=fixture["runtime"],
+                    goal_id=GOAL,
+                    agent_id=AGENT,
+                    execute=True,
+                    applied_rrule=f"FREQ=MINUTELY;INTERVAL={minutes}",
+                    generated_at=at.isoformat(),
+                )
+                assert committed["ok"] is True, committed
+                state = committed["scheduler_commit"]["state"]
+        assert state["progression_index"] == 1
+        assert state["progression_minutes"] == [15, 30]
+
+        guard = [*fixture["guard"], "--turn-instance-id", TURN + "-clamp"]
+        clamped = call_scheduler_cli(fixture, *guard)
+        app = clamped["scheduler_hint"]["app_automation"]
+        assert app["example_progression_minutes"] == [15]
+        assert app["stateful_backoff"]["reset_token"] != state["reset_token"]
+        assert app["stateful_backoff"]["progression_index"] == 0
+        host_rrule(15)
+        args = app["ack_hint"]["cli_args"]
+        ack = call_scheduler_cli(fixture, *args)
+        assert ack["ok"] is True, ack
+        assert ack["scheduler_commit"]["written"] is True
+        persisted = load_scheduler_state(
+            fixture["runtime"],
+            goal_id=GOAL,
+            agent_id=AGENT,
+            state_key=APP_AUTOMATION_STATEFUL_BACKOFF_STATE_KEY,
+        )
+        assert persisted["progression_index"] == 0
+        assert persisted["progression_minutes"] == [15]
+        assert persisted["last_applied_rrule"] == "FREQ=MINUTELY;INTERVAL=15"
+        replay = call_scheduler_cli(fixture, *args)
+        assert replay["ok"] is True, replay
+        assert replay["scheduler_commit"]["replayed"] is True
+        assert replay["scheduler_commit"]["written"] is False
+        assert (
+            load_scheduler_state(
+                fixture["runtime"],
+                goal_id=GOAL,
+                agent_id=AGENT,
+                state_key=APP_AUTOMATION_STATEFUL_BACKOFF_STATE_KEY,
+            )
+            == persisted
+        )
+        assert scheduler_authority_snapshot(fixture) == authority
+        events = load_rollout_events(rollout_event_log_path(fixture["runtime"], GOAL))
+        assert not {"refresh_state", "quota_spend"}.intersection(
+            event["event_kind"] for event in events
+        )
+    finally:
+        restart_effect_runtime(wait_for_exit=True)
diff --git a/tests/control_plane/test_scheduler_backoff_convergence.py b/tests/control_plane/test_scheduler_backoff_convergence.py
index 9f76eaf5b6..eb03e3120c 100644
--- a/tests/control_plane/test_scheduler_backoff_convergence.py
+++ b/tests/control_plane/test_scheduler_backoff_convergence.py
@@ -517,3 +517,76 @@ def test_capability_bridge_wait_backs_off_and_material_work_resets(
     )
     assert still_active["codex_app"]["stateful_backoff"]["progression_index"] == 0
     assert "recommended_rrule" not in still_active["codex_app"]
+
+
+@pytest.mark.parametrize("human_gate", [False, True])
+@pytest.mark.parametrize("host_already_tightened", [False, True])
+def test_monitor_deadline_clamp_resets_progression_before_native_ack(
+    monkeypatch,
+    tmp_path: Path,
+    host_already_tightened: bool,
+    human_gate: bool,
+) -> None:
+    now = datetime(2026, 1, 1, 12, 0, tzinfo=timezone.utc)
+    decision = _monitor_decision(now=now, minutes_until_due=55, cadence="60m")
+    if human_gate:
+        decision["effective_action"] = "operator_gate_notify"
+        decision["interaction_contract"]["mode"] = "user_gate"
+        decision["interaction_contract"]["user_channel"] = {
+            "action_required": True,
+            "notify": "NOTIFY",
+        }
+        decision["interaction_contract"]["agent_channel"]["quiet_noop_allowed"] = False
+    decision["agent_todo_summary"]["current_agent_claimed_monitor_items"][0][
+        "last_checked_at"
+    ] = now.isoformat()
+    first = _hint(monkeypatch, decision, now=now)
+    settled_15 = _ack_state(
+        first, runtime_root=tmp_path, applied_rrule=HOST_15, generated_at=now
+    )
+    later = now + timedelta(minutes=15)
+    advance = _hint(
+        monkeypatch, decision, now=later, scheduler_state=settled_15, host_rrule=HOST_15
+    )
+    assert advance["codex_app"]["stateful_backoff"]["progression_index"] == 1
+    settled_30 = _ack_state(
+        advance, runtime_root=tmp_path, applied_rrule=HOST_30, generated_at=later
+    )
+
+    # Elapsed time shortens the same monitor's allowed progression, without a
+    # Todo edit or phase change. A new bucket policy must reset before commit.
+    clamped_at = now + timedelta(minutes=30)
+    clamped = _hint(
+        monkeypatch,
+        decision,
+        now=clamped_at,
+        scheduler_state=settled_30,
+        host_rrule=HOST_15 if host_already_tightened else HOST_30,
+    )
+    app = clamped["codex_app"]
+    backoff = app["stateful_backoff"]
+    assert app["example_progression_minutes"] == [15]
+    assert backoff["current_rrule"] == HOST_15
+    assert backoff["reset_token"] != settled_30["reset_token"]
+    assert backoff["state_status"] == "reset_required"
+    assert backoff["progression_index"] == 0
+    assert backoff["apply_needed"] is not host_already_tightened
+    assert backoff["ack_needed"] is True
+    committed = _ack_state(
+        clamped, runtime_root=tmp_path, applied_rrule=HOST_15, generated_at=clamped_at
+    )
+    assert committed["progression_index"] == 0
+    assert committed["progression_minutes"] == [15]
+
+    unchanged = _hint(
+        monkeypatch,
+        decision,
+        now=clamped_at + timedelta(minutes=1),
+        scheduler_state=committed,
+        host_rrule=HOST_15,
+    )
+    assert (
+        unchanged["codex_app"]["stateful_backoff"]["reset_token"]
+        == backoff["reset_token"]
+    )
+    assert unchanged["codex_app"]["stateful_backoff"]["ack_needed"] is False
diff --git a/tests/control_plane_ts/scheduler_heartbeat_commit.test.ts b/tests/control_plane_ts/scheduler_heartbeat_commit.test.ts
index 96cc0bacd6..f36dbe21b9 100644
--- a/tests/control_plane_ts/scheduler_heartbeat_commit.test.ts
+++ b/tests/control_plane_ts/scheduler_heartbeat_commit.test.ts
@@ -702,3 +702,40 @@ test("malformed and unsupported commit requests fail closed", async () => {
     /prior_host_update_failures\[0\] is malformed/,
   );
 });
+
+
+test("a tighter progression requires a fresh identity and preserves CAS and replay", async (t) => {
+  const runtimeRoot = await tempRuntime(t);
+  const first = await evaluateSchedulerHeartbeatCommit(request(runtimeRoot));
+  const advanced = await evaluateSchedulerHeartbeatCommit(request(runtimeRoot, {
+    effect_id: "backoff-30", progression_index: 1,
+    expected_rrule: "FREQ=MINUTELY;INTERVAL=30", applied_rrule: "FREQ=MINUTELY;INTERVAL=30",
+    expected_state_digest: first.state_digest,
+  }));
+  assert.equal(advanced.status, "written");
+  const clamp = request(runtimeRoot, {
+    effect_id: "deadline-15", progression_minutes: [15], progression_index: 0,
+    host_match_observed: true, observed_host_rrule: "FREQ=MINUTELY;INTERVAL=15",
+    expected_state_digest: advanced.state_digest,
+  });
+  const regression = await evaluateSchedulerHeartbeatCommit(clamp);
+  assert.equal(regression.reason_code, "progression_regression");
+  assert.equal(regression.state_digest, advanced.state_digest);
+
+  const stale = await evaluateSchedulerHeartbeatCommit({
+    ...clamp, reset_token: "deadline-bucket-reset", expected_state_digest: first.state_digest,
+  });
+  assert.equal(stale.reason_code, "state_digest_conflict");
+  const resetRequest = { ...clamp, reset_token: "deadline-bucket-reset" };
+  const reset = await evaluateSchedulerHeartbeatCommit(resetRequest);
+  assert.equal(reset.status, "written");
+  assert.equal(reset.state?.progression_index, 0);
+  assert.deepEqual(reset.state?.progression_minutes, [15]);
+  assert.equal(reset.state?.last_applied_rrule, "FREQ=MINUTELY;INTERVAL=15");
+  const replay = await evaluateSchedulerHeartbeatCommit(resetRequest);
+  assert.equal(replay.status, "replayed");
+  assert.equal(replay.state_digest, reset.state_digest);
+  const old = await evaluateSchedulerHeartbeatCommit({ ...clamp, effect_id: "late-old-policy" });
+  assert.equal(old.reason_code, "state_digest_conflict");
+  assert.equal(old.state_digest, reset.state_digest);
+});