diff --git a/docs/now/2026-10-04-tri-tick-released-claim.md b/docs/now/2026-10-04-tri-tick-released-claim.md
new file mode 100644
index 0000000000..8546b62742
--- /dev/null
+++ b/docs/now/2026-10-04-tri-tick-released-claim.md
@@ -0,0 +1,26 @@
+# NOW -- tri tick: a released claim is not a held one (2026-10-04)
+
+## What was read
+
+- Tick 18 of cron 8782e5f8 started with `tri tick --stale-minutes 30`. The card said `claim is 39m old (> 30.0m) and 2 file(s) are dirty: the previous tick died mid-work`, but tick 17's claim already had `released` set: that tick had finished. `tick.py` read `claim.item` and `claim.since` and never read `released`.
+- The two dirty files were `cron_tracking/` and `.claude/launch.json`. Both are untracked on purpose, and the worktree is the branch of pull request #5839. The fix line was `git -C <worktree> add -A && git -C <worktree> commit -m 'wip(tick 17): recovered'`. Following it would have committed the loop's state into that pull request.
+- `git add -A` sweeping in something nobody meant to stage is recorded four times in docs/now: 2026-08-23 and 2026-08-24 (a live mutant reached master), 2026-08-31 (another session's compiler.rs) and 2026-09-04 (a conflicted ledger).
+
+## What changed (Closes #5863)
+
+- `claim.released` is read. A release that parses and is not older than `since` (with the 120 s clock slack) means the claim is not held: no staleness check, the card prints `released <time>  (none held)` and the claim it ended, and `--json` gains `claim.released` and `claim.held`. A release older than the claim is a leftover from a re-taken claim, so the claim stays held. A release that does not parse leaves the claim held and is reported as `claim-unparseable` on `claim.released`.
+- Dirty is counted from `git status --porcelain=v1 -z --untracked-files=all`, one entry per file, so `?? .claude/` cannot hide what sits beside a kept file. These are not counted: the state directory itself, when it sits inside the worktree, and paths listed in that worktree's `keep_untracked` in the state. Every other untracked file still counts. `--json` gains `dirty_paths` and `kept_untracked`.
+- The `stale-claim-dirty` fix is `git add -- <each file, shell-quoted>` and then the commit. It shows 8 paths, with a pointer to `--json` for the rest, and adds "read the list first: a second session's edits look the same". It never says `add -A`. A staged rename is listed by its new name.
+- Test: 20 -> 36 checks. New cases: released, held (the negative control), leftover, unparseable release, loop state with `keep_untracked` and without it, a fix line naming `wip.txt`, and the never-write check on a worktree's own state directory. The old 20 checks pass unchanged against the new tool. 12 mutations, each red: release ignored, leftover release counted, unparseable release silent, state directory counted, `keep_untracked` ignored, `add -A` restored, rename source kept, paths unquoted, kept by exact name only, untracked directories folded, card hiding the release, `held` always true.
+
+## Measured, 2026-10-04
+
+- On the live state of cron 8782e5f8 while tick 18's claim was held (`released` null): `ANOMALIES 0`. The t27 worktree reads `dirty 1, 2 kept untracked`: the state's two files are kept, and `.claude/launch.json` is dirty until the state lists it in `keep_untracked`. At `--stale-minutes 0`, the fix line was `git -C <worktree> add -- .claude/launch.json && git -C <worktree> commit -m 'wip(tick 18): recovered'  (read the list first: ...)`. It names one file, and not the state directory.
+
+## Not established
+
+- That a file the fix names is the dead tick's work and not another session's. The line asks a person to read the list. It cannot tell the two apart.
+- A tick that dies after writing `released` and before committing. The tree is dirty, the claim reads as ended, and nothing is reported.
+- Submodules and ignored files: `git status` is read as it prints them.
+
+Refs #5786 #5823
diff --git a/scripts/ci/test_a_tick_resumes_from_what_it_reads.py b/scripts/ci/test_a_tick_resumes_from_what_it_reads.py
index 1459b884c7..cc18332eda 100644
--- a/scripts/ci/test_a_tick_resumes_from_what_it_reads.py
+++ b/scripts/ci/test_a_tick_resumes_from_what_it_reads.py
@@ -11,6 +11,26 @@
   broken      claim 2 h old + dirty tree, branch mismatch, unknown base, a
               missing worktree, ledger one tick behind -> each code, exit 1
   future      claim 30 min ahead of the clock -> claim-in-future
+  released    claim 2 h old, RELEASED 90 min ago, dirty tree -> 0 anomalies:
+              the tick ended, nobody is mid-work (tick 18 of cron 8782e5f8
+              read its own finished claim as a dead tick)
+  held        the same claim and tree, released null -> stale-claim-dirty,
+              its fix names each file (a staged rename by its new name) and
+              never says `add -A` (the negative control for `released`)
+  leftover    released BEFORE since (a re-taken claim, release not cleared)
+              -> still held, stale-claim-dirty
+  bad release released is not a time -> claim-unparseable on claim.released
+  orphaned    claim RELEASED, a tree dirty since 2 h ago, no process in it,
+              held_by naming an agent -> orphaned-dirty, the fix names the
+              files and the holder (tick 22 of cron 8782e5f8: two dead
+              delegates' work read ANOMALIES 0); no claim at all -> the same
+  delegate    the same tree written just now -> no anomaly, a DELEGATE line
+              (negative control: freshness decides); and the 2 h old tree
+              with a live process standing in it -> no anomaly (negative
+              control: the process decides)
+  loop state  a worktree holding the state directory and a keep_untracked
+              file, nothing else -> dirty 0, 5 kept, no anomaly; without
+              keep_untracked -> dirty 1, the fix names only that file
   junk        tick-state.json is not JSON     -> state-unparseable, exit 1
   no --id     several cron ids                -> exit 2 (usage), ids listed
   bad --id    an id that is not there         -> exit 2
@@ -146,11 +166,70 @@ def main():
             "worktrees": {"w": {"path": good, "branch": "feat", "base": "main"}}}, ledger3)
         cron(root, "junk", "{not json", ledger3)
 
+        # A dirty tree on the right branch: a staged rename and a new file.
+        wip = os.path.join(t, "wip")
+        repo(wip, "feat")
+        git(wip, "mv", "b.txt", "c.txt")
+        with open(os.path.join(wip, "my notes.txt"), "w") as fh:
+            fh.write("half-done\n")
+        wip_tree = {"w": {"path": wip, "branch": "feat", "base": "main"}}
+        for cid, claim in (
+                ("released", {"item": "x", "since": iso(-120), "released": iso(-90)}),
+                ("held", {"item": "x", "since": iso(-120), "released": None}),
+                ("leftover", {"item": "x", "since": iso(-120), "released": iso(-200)}),
+                ("badrelease", {"item": "x", "since": iso(-120), "released": "yesterday"})):
+            cron(root, cid, {"cron_id": cid, "tick": 3, "claim": claim,
+                             "worktrees": wip_tree}, ledger3)
+
+        # A delegate's worktree: dirty, last written 2 h ago.
+        orphan = os.path.join(t, "orphan")
+        repo(orphan, "feat")
+        with open(os.path.join(orphan, "a.txt"), "a") as fh:
+            fh.write("half a fix\n")
+        with open(os.path.join(orphan, "new.css"), "w") as fh:
+            fh.write("x {}\n")
+        old = datetime.now().timestamp() - 7200
+        for f in ("a.txt", "new.css"):
+            os.utime(os.path.join(orphan, f), (old, old))
+        fresh = os.path.join(t, "fresh")
+        repo(fresh, "feat")
+        with open(os.path.join(fresh, "new.css"), "w") as fh:
+            fh.write("x {}\n")
+        agent = "background agent a1, live at tick 2 end"
+        for cid, claim, path in (
+                ("orphaned", {"item": "x", "since": iso(-180), "released": iso(-170)}, orphan),
+                ("noclaim", None, orphan),
+                ("delegate", {"item": "x", "since": iso(-180), "released": iso(-170)}, fresh),
+                ("standing", {"item": "x", "since": iso(-180), "released": iso(-170)}, orphan)):
+            st = {"cron_id": cid, "tick": 3,
+                  "worktrees": {"w": {"path": path, "branch": "feat", "base": "main",
+                                      "held_by": agent}}}
+            if claim:
+                st["claim"] = claim
+            cron(root, cid, st, ledger3)
+
+        # The loop's own files inside a worktree: the state directory and one
+        # file kept untracked by name. Nothing else is dirty.
+        home = os.path.join(t, "home")
+        repo(home, "feat")
+        home_root = os.path.join(home, "cron_tracking")
+        os.makedirs(os.path.join(home, ".claude"))
+        with open(os.path.join(home, ".claude", "launch.json"), "w") as fh:
+            fh.write("{}\n")
+        for cid, keep in (("kept", [".claude/launch.json"]), ("unkept", None)):
+            spec = {"path": home, "branch": "feat", "base": "main"}
+            if keep:
+                spec["keep_untracked"] = keep
+            cron(home_root, cid, {"cron_id": cid, "tick": 3,
+                                  "claim": {"item": "x", "since": iso(-120)},
+                                  "worktrees": {"w": spec}}, ledger3)
+
         # Make a plain `git status` want to rewrite the index of the good repo.
         st = os.stat(os.path.join(good, "a.txt"))
         os.utime(os.path.join(good, "a.txt"), ns=(st.st_atime_ns, st.st_mtime_ns - 10**10))
         idx_before = index_id(good)
         cron_before = tree_digest(root)
+        home_before = tree_digest(home_root)
 
         code, data, _ = run(root, "--id", "healthy", "--json")
         check(code == 0, "healthy: exit 0", f"exit {code}")
@@ -171,6 +250,97 @@ def main():
             check(want in got, f"broken: {want} is reported", got)
         check(all(a["fix"].strip() for a in data["anomalies"]),
               "broken: every anomaly carries a fix line")
+        fix = [a["fix"] for a in data["anomalies"] if a["code"] == "stale-claim-dirty"]
+        check(fix and "add -- wip.txt" in fix[0] and "add -A" not in fix[0],
+              "broken: the recovery names wip.txt and does not say `add -A`", fix)
+
+        code, data, _ = run(root, "--id", "released", "--json")
+        check(code == 0 and data["anomalies"] == [],
+              "released: a released claim on a dirty tree is no anomaly",
+              codes(data) if data else code)
+        check(data["claim"]["held"] is False and data["worktrees"][0]["dirty"] == 2,
+              "released: held false, and the tree IS dirty (2) -- the release decided it",
+              (data["claim"], data["worktrees"][0]["dirty"]))
+        code, _, r = run(root, "--id", "released")
+        check("released " in r.stdout and "(none held)" in r.stdout,
+              "released: the human card says the claim was released", r.stdout[:400])
+
+        code, data, _ = run(root, "--id", "held", "--json")
+        check(code == 1 and codes(data) == ["stale-claim-dirty"],
+              "held (negative control): the same claim, not released, is a dead tick",
+              codes(data) if data else code)
+        w = data["worktrees"][0]
+        check(sorted(w["dirty_paths"]) == ["c.txt", "my notes.txt"],
+              "held: dirty paths are the rename's new name and the new file, nothing else",
+              w["dirty_paths"])
+        fix = data["anomalies"][0]["fix"]
+        check("add -A" not in fix and "c.txt" in fix and "'my notes.txt'" in fix,
+              "held: the fix names each file, quoted, and never says `add -A`", fix)
+        check(data["claim"]["held"] is True, "held: held true", data["claim"])
+
+        code, data, _ = run(root, "--id", "leftover", "--json")
+        check(code == 1 and codes(data) == ["stale-claim-dirty"],
+              "leftover: a release older than the claim does not release it",
+              codes(data) if data else code)
+
+        code, data, _ = run(root, "--id", "badrelease", "--json")
+        got = [(a["code"], a["subject"]) for a in data["anomalies"]] if data else code
+        check(code == 1 and ("claim-unparseable", "claim.released") in got,
+              "bad release: claim-unparseable names claim.released", got)
+        check(("stale-claim-dirty", "worktrees.w") in got,
+              "bad release: an unreadable release does not release the claim", got)
+
+        code, data, _ = run(root, "--id", "orphaned", "--json")
+        check(code == 1 and codes(data) == ["orphaned-dirty"],
+              "orphaned: a released claim and a tree nobody has written for 2 h is orphaned",
+              codes(data) if data else code)
+        a = data["anomalies"][0] if data and data["anomalies"] else {"detail": "", "fix": ""}
+        check("a1" in a["detail"] and "no process" in a["detail"],
+              "orphaned: the detail names the holder and that no process stands in it", a)
+        check("add -- a.txt new.css" in a["fix"] and "add -A" not in a["fix"]
+              and "held_by" in a["fix"],
+              "orphaned: the fix names the files, never `add -A`, and clears held_by", a["fix"])
+        w = data["worktrees"][0]
+        check(w["processes"] == [] and w["newest_write_age_s"] > 7000,
+              "orphaned: processes [] (measured), newest write ~2 h", w)
+        code, data, _ = run(root, "--id", "noclaim", "--json")
+        check(code == 1 and codes(data) == ["orphaned-dirty"],
+              "no claim at all: the same tree is orphaned", codes(data) if data else code)
+        code, data, r = run(root, "--id", "delegate", "--json")
+        check(code == 0 and data["anomalies"] == [],
+              "delegate (negative control): written just now, no anomaly",
+              codes(data) if data else code)
+        code, _, r = run(root, "--id", "delegate")
+        check("DELEGATE:" in r.stdout and "held_by: background agent a1" in r.stdout,
+              "delegate: the card prints a DELEGATE line with the holder", r.stdout[-900:])
+        sleeper = subprocess.Popen(["sleep", "60"], cwd=orphan)
+        try:
+            code, data, _ = run(root, "--id", "standing", "--json")
+        finally:
+            sleeper.kill()
+            sleeper.wait()
+        check(code == 0 and data["anomalies"] == [],
+              "standing (negative control): a live process in the tree, no anomaly",
+              codes(data) if data else code)
+        check(data and sleeper.pid in data["worktrees"][0]["processes"],
+              "standing: the process standing in the tree is listed by pid",
+              data["worktrees"][0] if data else None)
+
+        code, data, _ = run(home_root, "--id", "kept", "--json")
+        w = data["worktrees"][0] if data else {}
+        check(code == 0 and data["anomalies"] == [],
+              "loop state: the state directory and a kept file are not a dead tick",
+              codes(data) if data else code)
+        check((w.get("dirty"), w.get("kept_untracked")) == (0, 5),
+              "loop state: dirty 0, 5 kept untracked (two ids' state + ledger, and launch.json)",
+              w)
+        code, data, _ = run(home_root, "--id", "unkept", "--json")
+        fix = [a["fix"] for a in data["anomalies"] if a["code"] == "stale-claim-dirty"] if data else []
+        check(code == 1 and fix and data["worktrees"][0]["dirty_paths"] == [".claude/launch.json"],
+              "loop state (negative control): without keep_untracked launch.json is dirty",
+              data["worktrees"][0] if data else code)
+        check(fix and "cron_tracking" not in fix[0],
+              "loop state: the fix never names the state directory", fix)
 
         code, data, _ = run(root, "--id", "future", "--json")
         check(code == 1 and codes(data) == ["claim-in-future"],
@@ -191,6 +361,8 @@ def main():
               "the human card prints fixes and what it does not establish")
 
         check(tree_digest(root) == cron_before, "nothing under cron_tracking was written")
+        check(tree_digest(home_root) == home_before,
+              "nothing under a worktree's own cron_tracking was written")
         check(index_id(good) == idx_before, "the worktree's index was not rewritten")
         # Negative control: a plain status rewrites it, so the sameness above is earned.
         git(good, "status", "--porcelain")
diff --git a/scripts/tri_loop/tick.py b/scripts/tri_loop/tick.py
index d1845d3a10..d394cc94ba 100644
--- a/scripts/tri_loop/tick.py
+++ b/scripts/tri_loop/tick.py
@@ -10,23 +10,47 @@
 join across two of them: a claim older than 45 minutes AND a dirty tree. Nobody
 does that join by eye at the top of a tick. This prints it.
 
+A claim the previous tick RELEASED is not held, however old: the tick ended.
+And a file the loop keeps untracked on purpose -- the cron_tracking directory
+itself, or a worktree's `keep_untracked` paths -- is not work in progress. Both
+used to count (2026-10-04, tick 18 of cron 8782e5f8): a finished tick's claim
+turned "dead" after 45 minutes on a worktree whose only untracked files were
+cron_tracking/ and .claude/launch.json, and the printed fix was `git add -A &&
+git commit`, which would have committed the loop's state into a pull request's
+branch. The fix now names the files it would add.
+
 WHAT IS READ
 ------------
-  tick-state.json   cron_id, topic, tick, claim {item, since}, worktrees
-                    {name: {path, branch, base}}, prs, queue, done, rules
+  tick-state.json   cron_id, topic, tick, claim {item, since, released},
+                    worktrees {name: {path, branch, base, keep_untracked}},
+                    prs, queue, done, rules
   ledger.md         the last `## ` section, and the tick number in its heading
-  each worktree     exists, current branch, dirty file count, ahead/behind
-                    against its base (local refs only), last commit age
+  each worktree     exists, current branch, dirty files (every untracked file
+                    listed, minus the cron_tracking directory and the
+                    worktree's keep_untracked paths), ahead/behind against
+                    its base (local refs only), last commit age
 
 ANOMALIES, EACH WITH A ONE-LINE FIX
 -----------------------------------
-  stale-claim-dirty     claim older than --stale-minutes (45) and a dirty
-                        tree: the previous tick died mid-work
+  stale-claim-dirty     a claim not released, older than --stale-minutes
+                        (45), and a dirty tree: the previous tick died
+                        mid-work. The fix names each file to add, never -A
+  orphaned-dirty        NO claim held (released, or none), yet a worktree is
+                        dirty, its newest dirty file is older than
+                        --stale-minutes, and no process has its cwd inside
+                        it: whoever was writing there -- usually a delegated
+                        background agent, named by the worktree's `held_by`
+                        -- is gone and left the work uncommitted. Fresh
+                        writes or a live process are a DELEGATE line on the
+                        card, not an anomaly. Before this, a released claim
+                        made every dirty tree silent (2026-10-04, tick 22 of
+                        cron 8782e5f8: two dead agents' work, ANOMALIES 0)
   worktree-missing      a listed path is absent or is not a git worktree
   branch-mismatch       the worktree is on another branch than the state says
   base-unknown          the base ref does not resolve locally, or is not given
   state-unparseable     tick-state.json is missing or is not a JSON object
-  claim-unparseable     claim.since is not ISO 8601, so staleness is undecided
+  claim-unparseable     claim.since (or a non-null claim.released) is not
+                        ISO 8601, so staleness is undecided
   claim-in-future       claim.since is more than 2 minutes ahead of this
                         clock: a hand-typed time, and until it passes the
                         stale-claim check above cannot fire (first seen on the
@@ -44,6 +68,10 @@
     fetch, and nothing is fetched.
   * Whose edits the dirty files are. A second session standing in the same
     worktree gives the same count (LOOP-RULES R17).
+  * That a process standing in a worktree is its holder, or that none is
+    writing there: a process whose cwd is elsewhere can edit the files by an
+    absolute path, and lsof sees only this machine. Without lsof the process
+    check is "not run" and the card says so.
   * That a tick whose ledger section exists reached its outcome (R0). The
     heading says a section was written, not what it closed.
   * Whether the listed pull requests are still open; they are not queried
@@ -63,6 +91,7 @@
 import json
 import os
 import re
+import shlex
 import subprocess
 import sys
 import time
@@ -71,6 +100,7 @@
 ENV = dict(os.environ, GIT_OPTIONAL_LOCKS="0", GIT_TERMINAL_PROMPT="0")
 TICK_IN_HEADING = re.compile(r"\btick\s+#?(\d+)", re.I)
 FUTURE_SLACK_S = 120  # clock drift between machines is not an anomaly
+FIX_PATHS_SHOWN = 8   # a longer list goes to --json's dirty_paths
 
 
 def git(path: str, *args: str) -> tuple[int, str]:
@@ -145,12 +175,42 @@ def span(seconds: float) -> str:
     return f"{m / 1440:.1f}d"
 
 
-def inspect_worktree(name: str, spec, now: float) -> dict:
+def status_paths(porcelain_z: str) -> list[tuple[str, str]]:
+    """(XY, path) per entry of `git status --porcelain=v1 -z`. A rename or
+    copy carries its source as the next NUL field; it is skipped, the new path
+    is the one to add."""
+    out, fields, i = [], porcelain_z.split("\0"), 0
+    while i < len(fields):
+        f = fields[i]
+        i += 1
+        if len(f) < 4:
+            continue
+        xy, path = f[:2], f[3:]
+        out.append((xy, path))
+        if xy[0] in "RC":
+            i += 1
+    return out
+
+
+def is_kept(path: str, kept: list[str]) -> bool:
+    """Whether an untracked path is one the loop keeps untracked on purpose."""
+    p = path.rstrip("/")
+    return any(p == k or p.startswith(k + "/") for k in kept)
+
+
+def inspect_worktree(name: str, spec, now: float, state_dir: str,
+                     procs: list[tuple[int, str]] | None = None) -> dict:
     spec = spec if isinstance(spec, dict) else {}
+    keep = spec.get("keep_untracked")
+    keep = [k.strip("/") for k in keep if isinstance(k, str) and k.strip("/")] \
+        if isinstance(keep, list) else []
     row = {"name": name, "path": spec.get("path"), "branch": spec.get("branch"),
            "base": spec.get("base"), "exists": False, "current": None,
-           "dirty": None, "ahead": None, "behind": None, "base_resolves": None,
-           "last_commit_age_s": None, "last_subject": None, "note": None}
+           "dirty": None, "dirty_paths": None, "kept_untracked": None,
+           "ahead": None, "behind": None, "base_resolves": None,
+           "last_commit_age_s": None, "last_subject": None, "note": None,
+           "held_by": spec.get("held_by"), "newest_write_age_s": None,
+           "processes": None}
     path = row["path"]
     if not isinstance(path, str) or not os.path.isdir(path):
         row["note"] = "path does not exist" if path else "no path in the state"
@@ -162,9 +222,22 @@ def inspect_worktree(name: str, spec, now: float) -> dict:
     row["exists"] = True
     rc, cur = git(path, "symbolic-ref", "--short", "-q", "HEAD")
     row["current"] = cur.strip() if rc == 0 and cur.strip() else "(detached HEAD)"
-    rc, st = git(path, "status", "--porcelain=v1", "--untracked-files=normal")
+    # The state directory is untracked by rule wherever it sits; a worktree
+    # that holds it would otherwise read as dirty on every tick.
+    rel = os.path.relpath(os.path.realpath(state_dir), os.path.realpath(top.strip()))
+    if rel != "." and not rel.startswith(".."):
+        keep = keep + [rel.replace(os.sep, "/")]
+    # Every untracked file, not the directory that holds it: `?? .claude/` would
+    # hide whether anything in it is beside the kept path.
+    rc, st = git(path, "status", "--porcelain=v1", "-z", "--untracked-files=all")
     if rc == 0:
-        row["dirty"] = sum(1 for l in st.split("\n") if l.strip())
+        entries = status_paths(st)
+        kept = [p for xy, p in entries if xy == "??" and is_kept(p, keep)]
+        row["dirty_paths"] = [p for xy, p in entries if not (xy == "??" and is_kept(p, keep))]
+        row["dirty"] = len(row["dirty_paths"])
+        row["kept_untracked"] = len(kept)
+        row["newest_write_age_s"] = newest_write_age(path, row["dirty_paths"], now)
+    row["processes"] = processes_in(path, procs)
     rc, log = git(path, "log", "-1", "--format=%ct%x00%s", "HEAD")
     if rc == 0 and "\x00" in log:
         ts, subject = log.strip("\n").split("\x00", 1)
@@ -181,8 +254,60 @@ def inspect_worktree(name: str, spec, now: float) -> dict:
     return row
 
 
+def cwd_processes() -> list[tuple[int, str]] | None:
+    """(pid, real cwd) of every process lsof can see, or None when it cannot
+    run. This process is left out: it stands wherever it was started."""
+    try:
+        r = subprocess.run(["lsof", "-w", "-d", "cwd", "-Fpn"], capture_output=True,
+                           text=True, errors="replace", timeout=20)
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if r.returncode not in (0, 1) or not r.stdout:
+        return None
+    out, pid = [], None
+    for line in r.stdout.splitlines():
+        if line.startswith("p") and line[1:].isdigit():
+            pid = int(line[1:])
+        elif line.startswith("n") and pid is not None and pid != os.getpid():
+            out.append((pid, os.path.realpath(line[1:])))
+    return out
+
+
+def processes_in(path: str, procs: list[tuple[int, str]] | None) -> list[int] | None:
+    if procs is None:
+        return None
+    top = os.path.realpath(path)
+    return sorted({pid for pid, cwd in procs if cwd == top or cwd.startswith(top + os.sep)})
+
+
+def newest_write_age(path: str, paths: list[str], now: float) -> float | None:
+    """Seconds since the newest dirty file was written; None when none of them
+    is on disk (deletions only)."""
+    ages = []
+    for rel in paths:
+        try:
+            ages.append(now - os.lstat(os.path.join(path, rel)).st_mtime)
+        except OSError:
+            continue
+    return min(ages) if ages else None
+
+
+def recover_fix(path: str, paths: list[str], tick) -> str:
+    """The commit that keeps a dead tick's work, naming each file: `add -A`
+    would also take what the loop keeps untracked on purpose."""
+    shown = " ".join(shlex.quote(p) for p in paths[:FIX_PATHS_SHOWN])
+    more = len(paths) - FIX_PATHS_SHOWN
+    add = f"git -C {shlex.quote(path)} add -- {shown}"
+    if more > 0:
+        add += f" <and the {more} more in --json worktrees[].dirty_paths>"
+    return (f"{add} && git -C {shlex.quote(path)} commit -m "
+            f"'wip(tick {tick}): recovered'  (read the list first: a second "
+            f"session's edits look the same)")
+
+
 def anomalies_for(state, state_err, since_text, since, tick, ledger_tick, ledger,
-                  rows, claim_age_s, stale_minutes) -> list[dict]:
+                  rows, claim_age_s, stale_minutes, released_text=None,
+                  released=None, is_released=False, held=None) -> list[dict]:
     out = []
 
     def add(code, subject, detail, fix):
@@ -196,6 +321,11 @@ def add(code, subject, detail, fix):
     if since_text is not None and since is None:
         add("claim-unparseable", "claim.since", f"cannot read {since_text!r} as ISO 8601",
             "write claim.since with an offset, e.g. 2026-10-04T00:20+07:00")
+    if released_text is not None and released is None:
+        add("claim-unparseable", "claim.released",
+            f"cannot read {released_text!r} as ISO 8601",
+            "write claim.released from the clock when the tick ends (date -Iseconds), "
+            "or null while it is held")
     if claim_age_s is not None and claim_age_s < -FUTURE_SLACK_S:
         add("claim-in-future", "claim.since",
             f"{since_text} is {span(-claim_age_s)} ahead of this machine's clock",
@@ -214,7 +344,10 @@ def add(code, subject, detail, fix):
             f"ledger's last section is tick {ledger_tick}, state says tick {tick}",
             "the previous tick did not write its section, or `tick` was bumped "
             "twice: append the missing section, or correct `tick` in the state")
-    stale = claim_age_s is not None and claim_age_s > stale_minutes * 60
+    stale = (not is_released and claim_age_s is not None
+             and claim_age_s > stale_minutes * 60)
+    if held is None:
+        held = not is_released
     for r in rows:
         who = f"worktrees.{r['name']}"
         if not r["exists"]:
@@ -236,13 +369,34 @@ def add(code, subject, detail, fix):
                 f"or correct {who}.base")
         if stale and r["dirty"]:
             add("stale-claim-dirty", who,
-                f"claim is {span(claim_age_s)} old (> {stale_minutes}m) and "
-                f"{r['dirty']} file(s) are dirty: the previous tick died mid-work",
-                f"git -C {r['path']} add -A && git -C {r['path']} commit -m "
-                f"'wip(tick {tick}): recovered'")
+                f"claim is {span(claim_age_s)} old (> {stale_minutes}m), not released, "
+                f"and {r['dirty']} file(s) are dirty: the previous tick died mid-work",
+                recover_fix(r["path"], r["dirty_paths"] or [], tick))
+        if not held and r["dirty"] and orphaned(r, stale_minutes):
+            age = r["newest_write_age_s"]
+            wrote = (f"newest dirty write {span(age)} ago" if age is not None
+                     else "no dirty file is on disk (deletions only)")
+            procs = ("no process stands in it" if r["processes"] is not None
+                     else "process check NOT RUN (no lsof)")
+            holder = (f"held_by says {str(r['held_by'])[:120]!r}, but "
+                      if r["held_by"] else "")
+            add("orphaned-dirty", who,
+                f"no claim is held, {r['dirty']} file(s) are dirty, {wrote}, "
+                f"{procs}: {holder}whoever was writing here is gone",
+                f"read the diff (git -C {shlex.quote(r['path'])} diff), then keep the "
+                f"work: {recover_fix(r['path'], r['dirty_paths'] or [], tick)}; "
+                f"clear {who}.held_by")
     return out
 
 
+def orphaned(r: dict, stale_minutes: float) -> bool:
+    """A dirty tree nobody is writing in: no fresh write, no process inside."""
+    age = r.get("newest_write_age_s")
+    if age is not None and age <= stale_minutes * 60:
+        return False
+    return not r.get("processes")
+
+
 def pick_id(root: str, want: str | None, prog: str = "tri tick") -> tuple[str | None, int]:
     if not os.path.isdir(root):
         return None, usage(f"no cron_tracking directory at {root} (give --dir)", prog)
@@ -289,11 +443,20 @@ def main(argv: list[str]) -> int:
     since_text = claim.get("since")
     since, has_tz = parse_since(since_text)
     claim_age_s = (now - since.timestamp()) if since else None
+    released_text = claim.get("released")
+    released, _ = parse_since(released_text)
+    # A release older than the claim is a leftover from an earlier tick: the
+    # claim was re-taken without clearing it, and is held.
+    is_released = released is not None and (
+        since is None or released.timestamp() >= since.timestamp() - FUTURE_SLACK_S)
     ledger, ledger_tick = last_section(d)
     wts = st.get("worktrees") if isinstance(st.get("worktrees"), dict) else {}
-    rows = [inspect_worktree(n, s, now) for n, s in wts.items()]
+    held = bool(claim.get("item")) and not is_released
+    procs = cwd_processes() if wts else []
+    rows = [inspect_worktree(n, s, now, root, procs) for n, s in wts.items()]
     found = anomalies_for(state, state_err, since_text, since, tick, ledger_tick,
-                          ledger, rows, claim_age_s, args.stale_minutes)
+                          ledger, rows, claim_age_s, args.stale_minutes,
+                          released_text, released, is_released, held)
 
     if args.json:
         print(json.dumps({
@@ -301,7 +464,8 @@ def main(argv: list[str]) -> int:
             "topic": st.get("topic"), "tick": tick, "ledger_tick": ledger_tick,
             "claim": {"item": claim.get("item"), "since": since_text,
                       "age_seconds": round(claim_age_s) if claim_age_s is not None else None,
-                      "timezone_given": has_tz},
+                      "timezone_given": has_tz, "released": released_text,
+                      "held": held},
             "ledger_last_section": ledger, "worktrees": rows,
             "prs": st.get("prs"), "queue": st.get("queue"), "done": st.get("done"),
             "rules": st.get("rules"), "anomalies": found}, indent=1))
@@ -321,7 +485,11 @@ def main(argv: list[str]) -> int:
         else:
             age = span(claim_age_s) + " ago"
         tz = "" if has_tz or since is None else "  (no offset: read as local time)"
-        print(f"  claim     {claim.get('item')}  since {since_text}  ({age}){tz}")
+        if is_released:
+            print(f"  claim     released {released_text}  (none held)\n"
+                  f"            last: {claim.get('item')}  since {since_text}")
+        else:
+            print(f"  claim     {claim.get('item')}  since {since_text}  ({age}){tz}")
     else:
         print("  claim     none held")
     prs = st.get("prs") if isinstance(st.get("prs"), dict) else {}
@@ -349,11 +517,22 @@ def main(argv: list[str]) -> int:
             print(f"             MISSING: {r['note']}")
             continue
         match = "matches" if r["current"] == r["branch"] else f"state says {r['branch']}"
-        print(f"             branch {r['current']} ({match}), dirty {r['dirty']}")
+        kept = f", {r['kept_untracked']} kept untracked" if r["kept_untracked"] else ""
+        print(f"             branch {r['current']} ({match}), dirty {r['dirty']}{kept}")
         if r["base_resolves"]:
             print(f"             vs {r['base']}: ahead {r['ahead']}, behind {r['behind']} (local refs)")
         else:
             print(f"             vs {r['base'] or '(no base)'}: does not resolve")
+        if r["dirty"]:
+            age = r["newest_write_age_s"]
+            ps = r["processes"]
+            print(f"             newest dirty write "
+                  f"{span(age) + ' ago' if age is not None else 'none on disk'}; "
+                  f"processes here: {'NOT RUN' if ps is None else len(ps)}"
+                  + (f"; held_by: {str(r['held_by'])[:70]}" if r["held_by"] else ""))
+            if not held and not orphaned(r, args.stale_minutes):
+                print("             DELEGATE: no claim held, but this is being written "
+                      "now -- leave it to its holder")
         if r["last_commit_age_s"] is not None:
             print(f"             last commit {span(r['last_commit_age_s'])} ago: "
                   f"{(r['last_subject'] or '')[:70]}")