Every register write goes through its lane's own checkout <W>-lanes/<lane>/, where lane-start and lane-end read the lane's row; a LANES_REPO naming W refuses; locks name their holder's container; refresh-workspace fast-forwards W (Amendment 23)

lane-end

@@ -523,11 +523,18 @@ lanes_workspace_why() {
 # — so `$SCRIPT_DIR` answers both without a second rule. `$OPENREPOTOOLS_BIN_DIR`
 # and `$PATH` are the fallbacks for a command copied somewhere on its own.
 LANES_WS_ROOT=""
+# AMENDMENT 23 (act 2, slice 1a). With neither variable set, every write of a
+# lane goes through that lane's own register checkout, and the register this
+# command READS follows it there once the lane's name is known
+# (`lane_register_follow`, below). A caller's `LANES_REPO` without `LANES_FILE`
+# is the checkout the helper now writes in, so its own register is the one read.
+LANES_REG_DEFAULT=0
+[ -n "${LANES_FILE:-}" ] || [ -n "${LANES_REPO:-}" ] || LANES_REG_DEFAULT=1
 if [ -z "${LANES_FILE:-}" ] || [ -z "${LANES_REPO:-}" ]; then
   LANES_WS_ROOT="$(lanes_workspace_root || :)"
 fi
 : "${LANES_REPO:=$LANES_WS_ROOT}"
-LANES_FILE="${LANES_FILE:-${LANES_WS_ROOT:+$LANES_WS_ROOT/lanes/LANES.md}}"
+LANES_FILE="${LANES_FILE:-${LANES_REPO:+$LANES_REPO/lanes/LANES.md}}"
 
 lanes_edit_default() {
   local d
@@ -940,6 +947,52 @@ if [ "$cl_rc" = 0 ] && [ -n "$cl_out" ] && [ "$cl_out" != "$LANE" ]; then
   LANE="$cl_out"
 fi
 
+# AMENDMENT 23 S1, S2 — THE REGISTER THIS COMMAND READS IS THE ONE ITS WRITES GO
+# THROUGH. Under `LANES_ROUTE_WRITES=1` (opt-in until slice 1b, the review of
+# #282's MUST 2) and the default resolution, every write of this lane goes
+# through its own checkout, `<W>-lanes/<lane>/`, and W, the readers' copy, moves
+# only by `lanes-edit.sh refresh-workspace`. So W's working tree does not carry the
+# lane's own rows once they are written: a lane started through its checkout
+# read as a lane with no row, and a second start refused to add a duplicate
+# that W could not see. The row this command counts and acts on is therefore
+# read from that checkout. The helper makes the checkout here if it is not
+# there yet, exactly as this command's first write would; a dry run makes
+# nothing and reads W where there is no checkout. ONLY THE READ MOVES: the
+# handoff this command publishes is still W's until Amendment 23's later slices.
+# A helper that predates the verb writes W itself, so W is what is read. A
+# checkout that could not be made (2) or whose creation lock is held (4) is
+# SAID, and W is read (SHOULD 2): Amendment 8(d) — a launch is never refused for
+# a register act it can do without, and the writes after it say their own.
+lane_register_follow() {
+  [ "${LANES_ROUTE_WRITES:-}" = 1 ] || return 0
+  [ "$LANES_REG_DEFAULT" = 1 ] && [ -n "${LANE:-}" ] || return 0
+  case "$prog" in lane-end) lrf_none="Nothing was written." ;; *) lrf_none="Nothing was launched, renamed or written." ;; esac
+  lrf_args=(lane-checkout "$LANE")
+  [ "${dry_run:-0}" = 1 ] || lrf_args+=(--create)
+  lrf_errf="$(mktemp "${TMPDIR:-/tmp}/${prog}-register.XXXXXX" 2>/dev/null || printf '')"
+  lrf_out=""; lrf_rc=0
+  lrf_out="$("$LANES_EDIT" "${lrf_args[@]}" 2>"${lrf_errf:-/dev/null}")" || lrf_rc=$?
+  lrf_err=""
+  if [ -n "$lrf_errf" ]; then lrf_err="$(cat -- "$lrf_errf" 2>/dev/null || :)"; rm -f -- "$lrf_errf"; fi
+  case "$lrf_rc" in
+    0)
+      [ -z "$lrf_err" ] || printf '%s\n' "$lrf_err" >&2
+      [ -f "$lrf_out/lanes/LANES.md" ] ||
+        die "lane $LANE's register checkout $lrf_out carries no lanes/LANES.md, so the lane's row cannot be read (Amendment 23 S1). $lrf_none" 1
+      LANES_FILE="$lrf_out/lanes/LANES.md" ;;
+    8) : ;;                        # a dry run, and no checkout yet: W is what there is
+    2 | 4)
+      case "$lrf_err" in *"unknown subcommand 'lane-checkout'"*) return 0 ;; esac
+      [ -z "$lrf_err" ] || printf '%s\n' "$lrf_err" >&2
+      note "lane $LANE's own register checkout could not be made (\`$LANES_EDIT lane-checkout $LANE --create\` exited $lrf_rc, above), so this command reads W's register, which may not show what this lane's earlier writes put there (Amendment 23 S1, 8(d)). Each write below says for itself whether it went through." ;;
+    *)
+      [ -z "$lrf_err" ] || printf '%s\n' "$lrf_err" >&2
+      die "lane $LANE's own register checkout could not be read (\`$LANES_EDIT lane-checkout $LANE\` exited $lrf_rc, above), so the row this command acts on cannot be read where its writes go (Amendment 23 S1). $lrf_none" 1 ;;
+  esac
+  return 0
+}
+lane_register_follow
+
 # THE SEAM (ruling 2026-10-04): A MANAGED-OWNED LANE IS NOT THIS COMMAND'S.
 # `lanes-edit.sh managed-projection` answers 0 with the owner where the lane's
 # register row carries the managed ledger's marker, 8 for a legacy lane, and 1

lane-start

@@ -605,11 +605,18 @@ lanes_workspace_why() {
 # — so `$SCRIPT_DIR` answers both without a second rule. `$OPENREPOTOOLS_BIN_DIR`
 # and `$PATH` are the fallbacks for a command copied somewhere on its own.
 LANES_WS_ROOT=""
+# AMENDMENT 23 (act 2, slice 1a). With neither variable set, every write of a
+# lane goes through that lane's own register checkout, and the register this
+# command READS follows it there once the lane's name is known
+# (`lane_register_follow`, below). A caller's `LANES_REPO` without `LANES_FILE`
+# is the checkout the helper now writes in, so its own register is the one read.
+LANES_REG_DEFAULT=0
+[ -n "${LANES_FILE:-}" ] || [ -n "${LANES_REPO:-}" ] || LANES_REG_DEFAULT=1
 if [ -z "${LANES_FILE:-}" ] || [ -z "${LANES_REPO:-}" ]; then
   LANES_WS_ROOT="$(lanes_workspace_root || :)"
 fi
 : "${LANES_REPO:=$LANES_WS_ROOT}"
-LANES_FILE="${LANES_FILE:-${LANES_WS_ROOT:+$LANES_WS_ROOT/lanes/LANES.md}}"
+LANES_FILE="${LANES_FILE:-${LANES_REPO:+$LANES_REPO/lanes/LANES.md}}"
 
 lanes_edit_default() {
   local d
@@ -1157,6 +1164,52 @@ esac
 repo="${repo:-$LANE}"          # the verbatim form has no <repo> of its own
 estate="${estate:-$repo}"
 
+# AMENDMENT 23 S1, S2 — THE REGISTER THIS COMMAND READS IS THE ONE ITS WRITES GO
+# THROUGH. Under `LANES_ROUTE_WRITES=1` (opt-in until slice 1b, the review of
+# #282's MUST 2) and the default resolution, every write of this lane goes
+# through its own checkout, `<W>-lanes/<lane>/`, and W, the readers' copy, moves
+# only by `lanes-edit.sh refresh-workspace`. So W's working tree does not carry the
+# lane's own rows once they are written: a lane started through its checkout
+# read as a lane with no row, and a second start refused to add a duplicate
+# that W could not see. The row this command counts and acts on is therefore
+# read from that checkout. The helper makes the checkout here if it is not
+# there yet, exactly as this command's first write would; a dry run makes
+# nothing and reads W where there is no checkout. ONLY THE READ MOVES: the
+# handoff this command publishes is still W's until Amendment 23's later slices.
+# A helper that predates the verb writes W itself, so W is what is read. A
+# checkout that could not be made (2) or whose creation lock is held (4) is
+# SAID, and W is read (SHOULD 2): Amendment 8(d) — a launch is never refused for
+# a register act it can do without, and the writes after it say their own.
+lane_register_follow() {
+  [ "${LANES_ROUTE_WRITES:-}" = 1 ] || return 0
+  [ "$LANES_REG_DEFAULT" = 1 ] && [ -n "${LANE:-}" ] || return 0
+  case "$prog" in lane-end) lrf_none="Nothing was written." ;; *) lrf_none="Nothing was launched, renamed or written." ;; esac
+  lrf_args=(lane-checkout "$LANE")
+  [ "${dry_run:-0}" = 1 ] || lrf_args+=(--create)
+  lrf_errf="$(mktemp "${TMPDIR:-/tmp}/${prog}-register.XXXXXX" 2>/dev/null || printf '')"
+  lrf_out=""; lrf_rc=0
+  lrf_out="$("$LANES_EDIT" "${lrf_args[@]}" 2>"${lrf_errf:-/dev/null}")" || lrf_rc=$?
+  lrf_err=""
+  if [ -n "$lrf_errf" ]; then lrf_err="$(cat -- "$lrf_errf" 2>/dev/null || :)"; rm -f -- "$lrf_errf"; fi
+  case "$lrf_rc" in
+    0)
+      [ -z "$lrf_err" ] || printf '%s\n' "$lrf_err" >&2
+      [ -f "$lrf_out/lanes/LANES.md" ] ||
+        die "lane $LANE's register checkout $lrf_out carries no lanes/LANES.md, so the lane's row cannot be read (Amendment 23 S1). $lrf_none" 1
+      LANES_FILE="$lrf_out/lanes/LANES.md" ;;
+    8) : ;;                        # a dry run, and no checkout yet: W is what there is
+    2 | 4)
+      case "$lrf_err" in *"unknown subcommand 'lane-checkout'"*) return 0 ;; esac
+      [ -z "$lrf_err" ] || printf '%s\n' "$lrf_err" >&2
+      note "lane $LANE's own register checkout could not be made (\`$LANES_EDIT lane-checkout $LANE --create\` exited $lrf_rc, above), so this command reads W's register, which may not show what this lane's earlier writes put there (Amendment 23 S1, 8(d)). Each write below says for itself whether it went through." ;;
+    *)
+      [ -z "$lrf_err" ] || printf '%s\n' "$lrf_err" >&2
+      die "lane $LANE's own register checkout could not be read (\`$LANES_EDIT lane-checkout $LANE\` exited $lrf_rc, above), so the row this command acts on cannot be read where its writes go (Amendment 23 S1). $lrf_none" 1 ;;
+  esac
+  return 0
+}
+lane_register_follow
+
 # ----------------------------------------- 1b. THE LANE'S DIRECTORY
 #
 # AMENDMENT 11 CLAUSE (c). A lane's checkout is known to every process that is
@@ -4255,7 +4308,13 @@ hs_git_net() {
 # `lanes-edit.sh` write goes out of it. Promising a carry that will not happen
 # is worse than printing the command, so the note says which it is.
 hs_carry_note() {
-  if [ -n "${LANES_REPO:-}" ] && [ "$hs_repo" = "$LANES_REPO" ]; then
+  # UNDER `LANES_ROUTE_WRITES=1` NO WRITE GOES OUT OF W (Amendment 23 S2; the
+  # review of #282, SHOULD 6): with the default resolution each one goes through
+  # its lane's own checkout, so none will ever push a commit made here.
+  if [ "${LANES_ROUTE_WRITES:-}" = 1 ] && [ "$LANES_REG_DEFAULT" = 1 ] &&
+     [ -n "${LANES_REPO:-}" ] && [ "$hs_repo" = "$LANES_REPO" ]; then
+    note "  (this handoff is in W ($hs_repo), and under LANES_ROUTE_WRITES=1 every lanes-edit.sh write goes through its lane's own checkout instead, so none will push this commit: the command above is the whole of the recovery.)"
+  elif [ -n "${LANES_REPO:-}" ] && [ "$hs_repo" = "$LANES_REPO" ]; then
     note "  (this handoff is in the register's own checkout, so the next lanes-edit.sh write out of it pushes the branch and carries this commit with it.)"
   else
     note "  (this handoff is NOT in the register's checkout ($hs_repo), so no lanes-edit.sh write will ever push it: the command above is the whole of the recovery.)"

lane-worktrees

@@ -5519,7 +5519,24 @@ class Report:
 
     def _foreign(self, clones: list, canonical: list) -> None:
         rows = []
+        # AMENDMENT 23 S1 - A LANE'S REGISTER CHECKOUT IS NOT A STRAY CLONE (the
+        # review of opensoft/openRepoTools#282, SHOULD 5). `<W>-lanes/<lane>/` is
+        # a clone of the register's origin beside W, made on purpose and holding
+        # that lane's writes; listing it here told a person to dispose of it.
+        wroot = self.helper.workspace_root() if self.helper.path else ""
+        lanes_home = real(wroot) + "-lanes" if wroot else ""
+        # AND A W THAT IS ITSELF A LANE CHECKOUT (the re-review of #282, SHOULD
+        # 5): Eagle's lane windows resolve W to their own `<X>-lanes/<lane>/`,
+        # and lane-start runs this report from there. Its lanes home is then its
+        # parent, as lanes-edit.sh's `lanes_home_check` reads a `*-lanes` one.
+        home = os.path.dirname(real(wroot)) if wroot else ""
+        if len(os.path.basename(home)) > len("-lanes") and home.endswith("-lanes"):
+            lanes_home = home
+        registers = []
         for c in clones:
+            if lanes_home and os.path.dirname(real(c)) == lanes_home:
+                registers.append(c)
+                continue
             container = _under_container(c, self.root)
             why = ""
             if container:
@@ -5541,6 +5558,24 @@ class Report:
                          ("LOAD-BEARING: " + _lean_text(lean)) if lean else ""])
         self.add("FOREIGN repositories", rows, "none: every clone is the estate's own checkout",
                  "A lane creates worktrees, never clones. Each is a person's to dispose of.")
+        if registers:
+            self._register_checkouts(registers)
+
+    def _register_checkouts(self, registers: list) -> None:
+        """Amendment 23 S1: each lane's own checkout of the register, reported
+        with what it holds that origin lacks, and never offered for disposal."""
+        rows = []
+        for c in registers:
+            last = git_out(c, "log", "-1", "--date=short", "--format=%cd") or "?"
+            ahead = git_out(c, "rev-list", "--count", "origin/main..HEAD")
+            held = ("its HEAD could not be compared with origin/main" if ahead is None else
+                    f"{ahead} commit(s) origin/main lacks" if ahead != "0" else "")
+            rows.append([c, f"lane {os.path.basename(c)}", human_size(dir_size(c)), last, held])
+        self.add("Register checkouts (Amendment 23 S1)", rows, "none",
+                 "Each is one lane's own checkout of the register, where its writes go, and "
+                 "not a stray clone: lane-end's sweep retires one (Amendment 23 S6), and a "
+                 "person moves one aside only once `git -C <path> cherry -v origin/main` "
+                 "shows nothing.")
 
     def _closed_lanes(self) -> dict:
         """{lane: why} for every lane whose snapshot is CLOSED or whose log's