From 028d7706e7cd2f362717056cac8950f3fad4dde1 Mon Sep 17 00:00:00 2001
From: Josh Vaughen <josh@vaughen.net>
Date: Wed, 23 Sep 2026 16:13:15 -0700
Subject: [PATCH] feat(reconcile): walk Proton once the last walk is a week old

The Proton walk ran on the first run of a configured UTC weekday, tying
it to when a run is dispatched, and a walk left partial waited for the
next such day. lib v2.2.0's toolbox now decides: `due` leaves
.run/reconcile once the last complete walk, at .state/reconciled, is
RECONCILE_HOURS old, and this mirror sets 168.

The run row takes the flag; a complete walk leaves .run/walked, and
record-walk then runs the toolbox's `reconciled`, so a partial walk
stays due and the next run resumes it. pull and push over the image's
s3 are what due and reconciled keep the key through. reconcile.weekday,
the RECONCILE environment variable and is_reconcile_run are gone.
---
 CLAUDE.md                            | 13 ++++---
 README.md                            | 12 +++---
 Taskfile.yml                         | 41 ++++++++++++++++----
 config/mirror.toml                   |  3 --
 render.txt                           | 21 +++++++++-
 src/migrator/commands.py             | 29 +++-----------
 src/migrator/config.py               | 11 +-----
 src/migrator/env.py                  |  2 -
 src/migrator/paths.py                | 10 +++++
 src/migrator/phases/p60_reconcile.py |  1 +
 tests/conftest.py                    |  3 +-
 tests/test_commands.py               | 57 +++++++++-------------------
 tests/test_config.py                 |  3 --
 tests/test_env.py                    |  3 --
 tests/test_reconcile.py              |  2 +
 15 files changed, 105 insertions(+), 106 deletions(-)

diff --git a/CLAUDE.md b/CLAUDE.md
index b9c265f..618789b 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -8,9 +8,10 @@ this mirror includes. This file is what a change must not break.
 
 Nothing in this repo starts a run: an external scheduler dispatches `sync.yml` nightly.
 This mirror includes the toolbox alone: `Taskfile.yml` owns the order, one
-`python -m migrator <command>` per step, and `src/migrator/` owns every decision. The
-infrastructure modules there are from donphi/dropbox_proton at `cfd0e57`, MIT; the phases
-under `src/migrator/phases/` and the Taskfile are this repository's own.
+`python -m migrator <command>` per step, and `src/migrator/` owns every decision but when
+to walk Proton, which is lib's `due`. The infrastructure modules there are from
+donphi/dropbox_proton at `cfd0e57`, MIT; the phases under `src/migrator/phases/` and the
+Taskfile are this repository's own.
 
 ## Must knows
 
@@ -42,8 +43,10 @@ under `src/migrator/phases/` and the Taskfile are this repository's own.
 - **The logs are public.** The report is built from the state and carries counts only;
   errors print as their class unless `MIRROR_VERBOSE=1`; `op run` masks every value.
 - **Run flags go after the double dash** (`task sync -- RUN_BUDGET_MIN=30 RECONCILE=true`,
-  or the workflow's `vars` input); the Taskfile maps them to the environment the migrator
-  reads. `RECONCILE` takes the literal word `true`.
+  or the workflow's `vars` input). The Taskfile maps `RUN_BUDGET_MIN` to the environment
+  the migrator reads; `RECONCILE` (`true`, `false` or `auto`) is lib's `due`'s, which
+  leaves `.run/reconcile` for the migrator when the last complete walk is
+  `RECONCILE_HOURS` (168) old.
 - **`config/mirror.toml` is strict** and rejects unknown keys; the three account
   identifiers come from the environment and override its keys.
 
diff --git a/README.md b/README.md
index 347b370..61d2ab9 100644
--- a/README.md
+++ b/README.md
@@ -76,7 +76,7 @@ flowchart LR
 | `confirm` | The upload summary must account for every verified file plus every folder, and every failure must name a file in the batch. Those alone are recorded as failed; the rest confirm |
 | `checkpoint` | Merges the confirmed rows into `mirror_objects` and pushes the state to the bucket, a dated copy first and then the canonical key. Always the last step of a batch, so a killed run repeats at most one |
 | `trash` | Only when every planned batch landed. A topmost folder the mirror holds nothing live under goes in one `filesystem trash` call, subtree and all; a folder still holding live files gets its deleted files trashed by name, 50 paths per call. Each unit's `mirror_objects` rows are dropped as it lands. Checkpoints every 50 units, stops at the run budget and chains the next run for the rest |
-| `reconcile` | On the first run of the configured weekday, or with `RECONCILE=true`: a full Proton walk compared against `mirror_objects`. Rows Proton lacks or mis-sizes are dropped so they re-upload; nodes neither Dropbox nor the state knows are trashed. A walk that does not fit one run resumes on the next, and a partial walk drops and trashes nothing |
+| `reconcile` | Once the last complete walk is `RECONCILE_HOURS` (168, a week) old, by lib's `due`, or with `RECONCILE=true`: a full Proton walk compared against `mirror_objects`. Rows Proton lacks or mis-sizes are dropped so they re-upload; nodes neither Dropbox nor the state knows are trashed. A walk that does not fit one run resumes on the next, and a partial walk drops and trashes nothing |
 | `report` | Builds the step summary from the state alone, finishes the run row, writes the chain marker, and returns the run's status |
 
 Every step is plan-by-default: `batches`, `trash`, `reconcile`, `report` and
@@ -107,6 +107,7 @@ The bucket holds the state and the session, nothing of the mirrored tree.
 .state/state.sqlite.xz.age                     the state: evidence tables, mirror_objects, runs, batches, deletions
 .state/history/<epoch>-<label>.sqlite.xz.age   one copy per checkpoint; label is the batch number, trash or trash-<folders>, reconcile or report
 .state/session.tar.age                         the Proton CLI session; no history, a stale copy cannot be restored
+.state/reconciled                              the start epoch of the run that last completed a Proton walk, plain text
 ```
 
 | What | Why |
@@ -196,7 +197,7 @@ task status                        # counts and the last run's figures from the
 task test && task lint             # pytest; ruff check and format check
 task sync                          # one budgeted run, the same thing Actions runs
 task sync -- RUN_BUDGET_MIN=30     # a shorter budget
-task sync -- RECONCILE=true        # force the weekly Proton walk (the literal word true)
+task sync -- RECONCILE=true        # force the weekly Proton walk (true, false or auto)
 task state-rollback                # list the dated history objects
 task state-rollback -- <key>       # copy one of them over the canonical state
 task session-seal -- .run/pd       # encrypt a laptop Proton CLI session into the bucket
@@ -234,10 +235,10 @@ older than seven days are pruned, the same clock as the bucket's history copies.
 - **A run stops on budget every night.** Lower `batch_files` or `batch_gb`; the throughput
   rows say which. A run that checkpointed nothing does not chain and fails instead.
 - **Proton 429s.** The throttling table is the gauge; lower `batch_gb`.
-- **A weekly reconcile does not finish in one run.** Normal on a large tree; it resumes on
-  the next run that reconciles.
+- **A weekly reconcile does not finish in one run.** Normal on a large tree; only a
+  complete walk is recorded, so the next run is due again and resumes it.
 - **A flag seems ignored.** Flags go after the double dash; before it they set a host-side
-  var that never reaches the container. `RECONCILE` takes the literal word `true`.
+  var that never reaches the container. `RECONCILE` takes `true`, `false` or `auto`.
 - **A case-only rename in Dropbox does not reach Proton.** Files are keyed by lowercased
   path. Rename to something else and back if the case matters.
 - **Move the folder in Proton.** Move it anywhere under My files and change the vault's
@@ -264,7 +265,6 @@ unknown keys. It names no account.
 | `budget.disk_headroom_gb` | Free disk the runner must keep beyond a batch's staging |
 | `budget.listing_floor_ratio` | Refuse a listing smaller than this share of the mirrored file count |
 | `proton.walk_workers` | Folder listings in flight during the reconcile walk, each from its own copy of the session |
-| `reconcile.weekday` | UTC weekday (0 is Monday) whose first run does the Proton walk |
 
 The three account identifiers in `op.env` override the TOML keys
 `dropbox.expected_account_id`, `proton.destination` and `proton.expected_destination_uid`,
diff --git a/Taskfile.yml b/Taskfile.yml
index d0761b9..b661f21 100644
--- a/Taskfile.yml
+++ b/Taskfile.yml
@@ -14,16 +14,17 @@ version: '3'
 vars:
   RUN_EPOCH:
     sh: date +%s
+  RECONCILE_HOURS: 168   # the full Proton walk, weekly; lib's toolbox `due` counts from the last complete one
 
-# Run-scoped environment for every migrator command. RECONCILE and RUN_BUDGET_MIN are
-# task vars a run sets after the double dash (task sync -- RECONCILE=true
-# RUN_BUDGET_MIN=30, or the workflow's vars input), mapped to the names the migrator
-# reads; unset, they render empty, which it reads as unset. The migrator's work
-# directory and config path are its own defaults, .run and config/mirror.toml, and
-# AWS_REGION is an ENV line in the image, so every in-toolbox command sees it.
+# Run-scoped environment for every migrator command. RUN_BUDGET_MIN is a task var a run
+# sets after the double dash (task sync -- RUN_BUDGET_MIN=30, or the workflow's vars
+# input), mapped to the name the migrator reads; unset, it renders empty, which it reads
+# as unset. RECONCILE, set the same way, is read by the toolbox's `due`, not the
+# migrator. The migrator's work directory and config path are its own defaults, .run and
+# config/mirror.toml, and AWS_REGION is an ENV line in the image, so every in-toolbox
+# command sees it.
 env:
   MIRROR_RUN_EPOCH: '{{.RUN_EPOCH}}'
-  RECONCILE: '{{.RECONCILE}}'
   RUN_BUDGET_MIN: '{{.RUN_BUDGET_MIN}}'
   PROTON_DRIVE_LOG_LEVEL: INFO   # the Proton CLI's own log level; its lines reach the public job log
 
@@ -61,6 +62,7 @@ tasks:
     desc: The full budgeted run, inside the toolbox
     cmds:
       - task: clock
+      - task: due
       - task: clock-phase
       - task: session
       - task: state
@@ -78,6 +80,7 @@ tasks:
     desc: Read-only half of the pipeline, inside the toolbox; prints the report it would make
     cmds:
       - task: clock
+      - task: due
       - task: clock-phase
       - task: session
       - task: state
@@ -97,7 +100,29 @@ tasks:
   plan-phase: { internal: true, cmds: ['python -m migrator plan'] }
   batches:    { internal: true, cmds: ['python -m migrator --apply batches'] }
   trash:      { internal: true, cmds: ['python -m migrator --apply trash'] }
-  reconcile:  { internal: true, cmds: ['python -m migrator --apply reconcile'] }
+  reconcile:
+    internal: true
+    cmds:
+      - python -m migrator --apply reconcile
+      - task: record-walk
+  # Only a complete walk is recorded; a partial one leaves the next run due, and it resumes.
+  record-walk:
+    internal: true
+    status: ['test ! -f {{.RUN}}/walked']
+    cmds: [{ task: reconciled }]
+  # What lib's toolbox `due` and `reconciled` keep .state/reconciled through, as an engine's
+  # pull and push would: one plain object of the bucket, over the image's s3.
+  pull:
+    internal: true
+    requires: { vars: [KEY, OUT, MISSING] }
+    cmds:
+      - |
+        rc=0; s3 get {{.KEY}} {{.OUT}} || rc=$?
+        case $rc in 0) ;; 3) {{.MISSING}} ;; *) exit $rc ;; esac
+  push:
+    internal: true
+    requires: { vars: [FILE, KEY] }
+    cmds: ['s3 put {{.FILE}} {{.KEY}}']
   # Builds .run/report.md from the state, closes the run row, writes the chain marker.
   report-phase: { internal: true, cmds: ['python -m migrator --apply report'] }
   empty-trash-pipeline:
diff --git a/config/mirror.toml b/config/mirror.toml
index 1f5b1fd..ac6f069 100644
--- a/config/mirror.toml
+++ b/config/mirror.toml
@@ -35,6 +35,3 @@ listing_floor_ratio = 0.5
 # The reconcile walk is one `filesystem list` process per folder; this many run at once,
 # each from its own copy of the CLI session. Eight matches dropbox.download_workers.
 walk_workers = 8
-
-[reconcile]
-weekday = 0
diff --git a/render.txt b/render.txt
index 037e431..482d1c2 100644
--- a/render.txt
+++ b/render.txt
@@ -1,4 +1,21 @@
-task: [clock] mkdir -p /work/.run && rm -f /work/.run/chain && date -u '+%s %H %u' > /work/.run/start.txt
+task: [clock] mkdir -p /work/.run && rm -f /work/.run/chain /work/.run/reconcile && date -u +%s > /work/.run/start.txt
+task: [pull] rc=0; s3 get .state/reconciled /work/.run/reconciled || rc=$?
+case $rc in 0) ;; 3) : > /work/.run/reconciled ;; *) exit $rc ;; esac
+
+task: [due-rule] rm -f /work/.run/reconcile
+r=auto; h=168
+now=$(cat /work/.run/start.txt); last=$(cat /work/.run/reconciled 2>/dev/null || true)
+case $last in ''|0?*|*[!0-9]*) last=0 ;; esac
+case $h in ''|0*|*[!0-9]*) echo "due: RECONCILE_HOURS is a whole number of hours from 1, not $h" >&2; exit 1 ;; esac
+case $r in
+  true) touch /work/.run/reconcile ;;
+  false) ;;
+  auto) test $(( now - last )) -lt $(( h * 3600 - 1800 )) || touch /work/.run/reconcile ;;
+  *) echo "due: RECONCILE is true, false or auto" >&2; exit 1 ;;
+esac
+test "$last" = 0 && ago="none on record" || ago="$(( (now - last) / 3600 )) h ago"
+echo "due: RECONCILE=$r RECONCILE_HOURS=$h, last reconcile $ago: $(test -f /work/.run/reconcile && echo reconciling || echo not this run)"
+
 task: [clock-phase] python -m migrator clock
 task: [session] python -m migrator session
 task: [state] python -m migrator state
@@ -8,6 +25,8 @@ task: [plan-phase] python -m migrator plan
 task: [batches] python -m migrator --apply batches
 task: [trash] python -m migrator --apply trash
 task: [reconcile] python -m migrator --apply reconcile
+task: [reconciled] cp /work/.run/start.txt /work/.run/reconciled
+task: [push] s3 put /work/.run/reconciled .state/reconciled
 task: [report-phase] python -m migrator --apply report
 task: [report-mirror] test -f /work/.run/report.md || python -m migrator --apply report || true
 task: [report-mirror] test ! -f /work/.run/report.md || cat /work/.run/report.md >> "${GITHUB_STEP_SUMMARY:-/dev/stdout}"
diff --git a/src/migrator/commands.py b/src/migrator/commands.py
index 23e942d..3524242 100644
--- a/src/migrator/commands.py
+++ b/src/migrator/commands.py
@@ -6,7 +6,7 @@
 from pathlib import Path
 
 from . import session, statefile
-from .config import Config, load_config
+from .config import load_config
 from .env import Runtime
 from .paths import WorkPaths
 from .state import State
@@ -25,7 +25,7 @@ def clock(runtime: Runtime, args: list[str]) -> int:
     paths = _paths(runtime)
     shutil.rmtree(paths.staging, ignore_errors=True)
     paths.staging.mkdir()
-    for stale in (paths.report, paths.chain):
+    for stale in (paths.report, paths.chain, paths.walked):
         stale.unlink(missing_ok=True)
     started = datetime.fromtimestamp(runtime.run_epoch, UTC)
     stamp = {
@@ -42,23 +42,6 @@ def read_clock(paths: WorkPaths) -> dict[str, int]:
     return json.loads(paths.clock.read_text(encoding="utf-8"))
 
 
-def is_reconcile_run(
-    cfg: Config, runtime: Runtime, db: State, *, start_epoch: int, weekday: int
-) -> bool:
-    """RECONCILE=true, or the first run that starts on the configured UTC weekday. Keyed
-    on the day, not an hour: chained and queued runs start at any hour."""
-    if runtime.reconcile:
-        return True
-    if weekday != cfg.reconcile.weekday:
-        return False
-    day_start = start_epoch - start_epoch % 86400
-    earlier = db.connection.execute(
-        "SELECT COUNT(*) FROM runs WHERE start_epoch >= ? AND start_epoch < ?",
-        (day_start, start_epoch),
-    ).fetchone()[0]
-    return int(earlier) == 0
-
-
 def session_restore(runtime: Runtime, args: list[str]) -> int:
     paths = _paths(runtime)
     session.restore(runtime, paths, Store(runtime, paths))
@@ -81,17 +64,15 @@ def state(runtime: Runtime, args: list[str]) -> int:
     db = State(paths.state_db, cfg.mirror.id)
     try:
         db.initialize_migration(cfg.source_file, cfg.source_sha256)
-        # Decided before this run's row exists, so the row itself cannot count as "earlier".
-        reconcile = is_reconcile_run(
-            cfg, runtime, db, start_epoch=stamp["start_epoch"], weekday=stamp["weekday"]
-        )
         run_id = db.start_run(
             start_epoch=stamp["start_epoch"],
             hour_utc=stamp["hour_utc"],
             weekday=stamp["weekday"],
             budget_minutes=runtime.budget_override or cfg.budget.run_budget_minutes,
             host=runtime.host,
-            reconcile=reconcile,
+            # lib's toolbox `due` decided before this command, by the age of the last
+            # complete walk.
+            reconcile=paths.reconcile.exists(),
         )
         files, size = db.mirror_totals()
     finally:
diff --git a/src/migrator/config.py b/src/migrator/config.py
index e3bf28d..42697aa 100644
--- a/src/migrator/config.py
+++ b/src/migrator/config.py
@@ -168,24 +168,18 @@ def headroom_bytes(self) -> int:
         return round(self.disk_headroom_gb * 1024**3)
 
 
-@dataclass(frozen=True)
-class Reconcile:
-    weekday: int = 0  # the first run that starts on this UTC weekday walks Proton
-
-
 @dataclass(frozen=True)
 class Config:
     mirror: Mirror
     dropbox: Dropbox
     proton: Proton
     budget: Budget
-    reconcile: Reconcile
     source_file: Path
     source_sha256: str
 
 
 _MIRROR_ID = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$")
-SECTIONS = {"mirror", "dropbox", "proton", "budget", "reconcile"}
+SECTIONS = {"mirror", "dropbox", "proton", "budget"}
 # Account-specific values live in the vault (op.env) and override the file, so
 # the committed configuration names no account.
 ENV_OVERRIDES = {
@@ -216,7 +210,6 @@ def load_config(path: str | Path, environ: Mapping[str, str] | None = None) -> C
         dropbox=_section(Dropbox, data.get("dropbox", {}), base, "dropbox"),
         proton=_section(Proton, data.get("proton", {}), base, "proton"),
         budget=_section(Budget, data.get("budget", {}), base, "budget"),
-        reconcile=_section(Reconcile, data.get("reconcile", {}), base, "reconcile"),
         source_file=source,
         source_sha256=sha256_file(source),
     )
@@ -276,5 +269,3 @@ def validate_config(cfg: Config) -> None:
     _nonnegative(cfg.budget.disk_headroom_gb, "budget.disk_headroom_gb")
     if not 0 < cfg.budget.listing_floor_ratio <= 1:
         raise ConfigError("budget.listing_floor_ratio must be in (0, 1]")
-    if type(cfg.reconcile.weekday) is not int or not 0 <= cfg.reconcile.weekday <= 6:
-        raise ConfigError("reconcile.weekday must be 0 (Monday) to 6 (Sunday)")
diff --git a/src/migrator/env.py b/src/migrator/env.py
index 6270101..8034a1d 100644
--- a/src/migrator/env.py
+++ b/src/migrator/env.py
@@ -23,7 +23,6 @@ class Runtime:
     config_path: Path
     run_epoch: int | None
     budget_override: int | None
-    reconcile: bool
     verbose: bool
     r2_bucket: str
     age_identity: str
@@ -46,7 +45,6 @@ def from_environ(cls, environ: Mapping[str, str] | None = None) -> Runtime:
             config_path=Path(env.get("MIRROR_CONFIG", "config/mirror.toml")),
             run_epoch=_int(env, "MIRROR_RUN_EPOCH"),
             budget_override=_int(env, "RUN_BUDGET_MIN"),
-            reconcile=env.get("RECONCILE", "").lower() == "true",
             verbose=env.get("MIRROR_VERBOSE", "") == "1",
             r2_bucket=env.get("MIRROR_R2_BUCKET", ""),
             age_identity=env.get("MIRROR_AGE_IDENTITY", ""),
diff --git a/src/migrator/paths.py b/src/migrator/paths.py
index 1284d37..5958458 100644
--- a/src/migrator/paths.py
+++ b/src/migrator/paths.py
@@ -42,6 +42,16 @@ def report(self) -> Path:
     def chain(self) -> Path:
         return self.root / "chain"
 
+    @property
+    def reconcile(self) -> Path:
+        # lib's toolbox `due` leaves it when this run is to walk Proton.
+        return self.root / "reconcile"
+
+    @property
+    def walked(self) -> Path:
+        # A complete walk leaves it, and the Taskfile then records the reconcile in R2.
+        return self.root / "walked"
+
     @property
     def age_key(self) -> Path:
         return self.root / "age.key"
diff --git a/src/migrator/phases/p60_reconcile.py b/src/migrator/phases/p60_reconcile.py
index c244222..bd79351 100644
--- a/src/migrator/phases/p60_reconcile.py
+++ b/src/migrator/phases/p60_reconcile.py
@@ -220,6 +220,7 @@ def run(ctx: PhaseContext) -> PhaseResult:
     if stray_folders:
         proton.trash(stray_folders, PHASE)
     statefile.push(ctx.state, ctx.runtime, ctx.paths, store, label=label)
+    ctx.paths.walked.touch()
     ctx.logger.info(
         PHASE,
         "figures",
diff --git a/tests/conftest.py b/tests/conftest.py
index f17c915..5f8f253 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -7,7 +7,7 @@
 import pytest
 
 from migrator import crypt, session
-from migrator.config import Budget, Config, Dropbox, Mirror, Proton, Reconcile
+from migrator.config import Budget, Config, Dropbox, Mirror, Proton
 from migrator.env import Runtime
 from migrator.logging import RunLogger
 from migrator.paths import WorkPaths
@@ -66,7 +66,6 @@ def make(tmp_path: Path, **overrides) -> Config:
                 ),
             ),
             budget=overrides.get("budget", Budget()),
-            reconcile=overrides.get("reconcile", Reconcile()),
             source_file=source,
             source_sha256="test-config-hash",
         )
diff --git a/tests/test_commands.py b/tests/test_commands.py
index 400c659..4338634 100644
--- a/tests/test_commands.py
+++ b/tests/test_commands.py
@@ -18,10 +18,12 @@ def test_clock_writes_stamp_and_clears_outputs(runtime_factory, tmp_path):
     paths.ensure()
     (paths.staging / "junk").write_text("x", encoding="utf-8")
     paths.chain.write_text("", encoding="utf-8")
+    paths.walked.write_text("", encoding="utf-8")
     assert commands.clock(runtime, []) == 0
     stamp = json.loads(paths.clock.read_text(encoding="utf-8"))
     assert stamp == {"start_epoch": 1700000000, "hour_utc": 22, "weekday": 1}
     assert not (paths.staging / "junk").exists() and not paths.chain.exists()
+    assert not paths.walked.exists()
 
 
 def test_clock_requires_epoch(runtime_factory, tmp_path):
@@ -48,51 +50,28 @@ def test_state_fresh_starts_run_with_budget_override(
     fresh.close()
 
 
+def test_state_records_the_toolbox_reconcile_decision(
+    state_context, plain_crypt, monkeypatch
+):
+    cfg, paths, state, _, runtime = state_context
+    state.close()
+    paths.state_db.unlink()
+    commands.clock(runtime, [])
+    paths.reconcile.write_text("", encoding="utf-8")
+    monkeypatch.setattr(commands, "Store", lambda runtime, paths: FakeStore())
+    monkeypatch.setattr(commands, "load_config", lambda _: cfg)
+    assert commands.state(runtime, []) == 0
+    fresh = State(paths.state_db, cfg.mirror.id)
+    assert fresh.current_run()["reconcile"] == 1
+    fresh.close()
+
+
 def runtime_factory_override(runtime, **changes):
     from dataclasses import replace
 
     return replace(runtime, **changes)
 
 
-def test_is_reconcile_run_is_first_run_of_the_weekday(state_context):
-    cfg, _, state, _, runtime = state_context  # reconcile.weekday 0
-    monday = 1700438400  # 2023-11-20 00:00:00 UTC, a Monday
-    assert (
-        commands.is_reconcile_run(
-            cfg, runtime, state, start_epoch=monday + 3600, weekday=0
-        )
-        is True
-    )
-    state.start_run(
-        start_epoch=monday + 3600,
-        hour_utc=1,
-        weekday=0,
-        budget_minutes=1,
-        host="t",
-        reconcile=True,
-    )
-    # a chained or queued run later the same day does not walk Proton again
-    assert (
-        commands.is_reconcile_run(
-            cfg, runtime, state, start_epoch=monday + 7200, weekday=0
-        )
-        is False
-    )
-    assert (
-        commands.is_reconcile_run(
-            cfg, runtime, state, start_epoch=monday + 90000, weekday=1
-        )
-        is False
-    )
-    forced = runtime_factory_override(runtime, reconcile=True)
-    assert (
-        commands.is_reconcile_run(
-            cfg, forced, state, start_epoch=monday + 7200, weekday=0
-        )
-        is True
-    )
-
-
 def test_status_prints_counts_only(state_context, capsys, monkeypatch):
     cfg, _paths, state, _, runtime = state_context
     monkeypatch.setattr(commands, "load_config", lambda _: cfg)
diff --git a/tests/test_config.py b/tests/test_config.py
index 578604c..1e25c53 100644
--- a/tests/test_config.py
+++ b/tests/test_config.py
@@ -31,7 +31,6 @@ def test_defaults_and_derived_bytes(tmp_path):
     assert cfg.budget.ceiling_gb == 4000
     assert cfg.proton.destination == "/my-files/Dropbox"
     assert cfg.proton.walk_workers == 8
-    assert cfg.reconcile.weekday == 0
 
 
 def test_unknown_key_rejected(tmp_path):
@@ -56,8 +55,6 @@ def test_numeric_floors(tmp_path):
         load_config(_write(tmp_path, GOOD + "\n[budget]\nbatch_gb = 0\n"))
     with pytest.raises(ConfigError, match="listing_floor_ratio"):
         load_config(_write(tmp_path, GOOD + "\n[budget]\nlisting_floor_ratio = 1.5\n"))
-    with pytest.raises(ConfigError, match="weekday"):
-        load_config(_write(tmp_path, GOOD + "\n[reconcile]\nweekday = 7\n"))
     with pytest.raises(ConfigError, match="walk_workers"):
         load_config(_write(tmp_path, GOOD + "\nwalk_workers = 0\n"))
     with pytest.raises(ConfigError, match="walk_workers"):
diff --git a/tests/test_env.py b/tests/test_env.py
index 0663eb0..d53fe61 100644
--- a/tests/test_env.py
+++ b/tests/test_env.py
@@ -24,7 +24,6 @@ def test_defaults_and_secrets():
     assert runtime.config_path == Path("config/mirror.toml")
     assert runtime.run_epoch is None
     assert runtime.budget_override is None
-    assert runtime.reconcile is False
     assert set(runtime.secrets()) == {
         "AGE-SECRET-KEY-1TEST",
         "s",
@@ -52,14 +51,12 @@ def test_overrides_and_host():
         **BASE,
         "MIRROR_RUN_EPOCH": "1700000000",
         "RUN_BUDGET_MIN": "30",
-        "RECONCILE": "true",
         "GITHUB_RUN_ID": "42",
         "MIRROR_WORK_DIR": "/tmp/w",
     }
     runtime = Runtime.from_environ(env)
     assert runtime.run_epoch == 1700000000
     assert runtime.budget_override == 30
-    assert runtime.reconcile is True
     assert runtime.host == "github:42"
     assert runtime.work_dir == Path("/tmp/w")
 
diff --git a/tests/test_reconcile.py b/tests/test_reconcile.py
index 58b008c..f0dd7d8 100644
--- a/tests/test_reconcile.py
+++ b/tests/test_reconcile.py
@@ -164,6 +164,7 @@ def test_reconcile_drops_missing_missized_and_sha1_mismatched(
         ).fetchone()[0]
         == 1
     )
+    assert ctx.paths.walked.exists()
     fields = _figures_event(ctx.state)
     assert fields["complete"] == 1
     assert fields["snapshot_id"] == snapshot_id
@@ -258,6 +259,7 @@ def _refuse_trash(self, paths, phase):
     assert result.status == "PASS"
     assert result.outputs == {"partial": 1}
     assert pushed == ["1-reconcile"]
+    assert not ctx.paths.walked.exists()
     left = {
         r["path_lower"]
         for r in ctx.state.connection.execute("SELECT * FROM mirror_objects")