@r1z4x/tezgah 1.5.1 → 1.7.0

package/bin/tezgah-task

@@ -3,35 +3,57 @@
 
   tezgah-task start <NNN|path> --phase P [--allow GLOB ... | --any-path]   activate a plan
   tezgah-task phase P [--any-path]                            change the active task's phase
-  tezgah-task allow GLOB ... | --any-path                     replace the allowlist
+  tezgah-task allow GLOB ... | --any-path --why REASON         replace the allowlist, recording why
   tezgah-task stop                                            deactivate (clear phase)
   tezgah-task status [--json]                                 the active task, then every open plan: progress, what it waits on, what can run at once
   tezgah-task review <NNN|path> <reviewer> approve|changes    record a fresh review's verdict
-  tezgah-task close <NNN|path> done|discarded                 move a plan to .tezgah/plans/done
+  tezgah-task close <NNN|path> done|discarded [--resolved TEXT] move a plan to .tezgah/plans/done, deactivate it, remove merged worktrees
+  tezgah-task tick <NNN|path> <n> [--undo]                   tick (or untick) Acceptance item n, counted from 1
+  tezgah-task note <NNN|path> state|next "<text>"            replace the body of `## State` (the newest one) or `## Next`
+  tezgah-task slice open --id ID [--kind agent|job] [--host H] [--agent A] [--brief TEXT|--brief-file F] [--parent P] [--cwd PATH]
+                                                              record a delegated slice (a re-open counts one more attempt)
+  tezgah-task slice done ID | slice stop ID [--class C]      close a slice record
+  tezgah-task slice reconcile [--prune]                       every open or stopped slice with its resume brief; --prune also removes landed worktrees and branches
+  tezgah-task slice resume ID                                 the native resume path, else a re-dispatch brief; marks the record resumed
+  tezgah-task slice stats [--window DAYS] [--json]            counts per status, failure class and host, and the RSI lever candidates
+  tezgah-task slice board [--parent P]                        the open sibling slices: what each owns, its worktree, branch and last commit
+  tezgah-task slice merge-plan [--base REF]                   the done slice branches in merge order, with their forecast conflicts
 
 The record is the plan file itself: `phase:` activates it, `allowed_paths:` is
 the scope a write has to stay inside, and at most one open plan carries a phase
-because `start` clears the others. That makes the gate's refusal a rule the user
-set in advance, so this CLI is the only writer and the agent never runs its
-first four commands - `stop` and a hand edit are equally valid ways to take the
-requirement away. `phase implementation` (or `verification`) is what lets a write
+because `start` clears the others. The orchestrating session runs every command
+here itself as the work moves - the lifecycle is never handed back to the user -
+and this CLI is the record's only writer: the gate refuses a write to the plan
+file, because the checks below are made here and a retyped frontmatter would
+skip them. `phase implementation` (or `verification`) is what lets a write
 through, so the phase changes when the work reaches that point and not before.
+`tick` and `note` are the record's body writers for the same reason: they write
+an Acceptance box or the State/Next text on any open plan, active or not, keep
+the frontmatter but `updated:`, and commit nothing.
 
 The allowlist is the plan's own: plan-add writes `allowed_paths:` when it
 creates the plan, and `start` without `--allow` keeps it. A writing phase with
 no allowlist is refused unless `--any-path` says so explicitly, and the record
 keeps where its scope came from (`allowed_from:`), which `status` prints.
 
-`review` and `close` are the session's: the verification phase asks for one
-review of the plan's whole diff, `review` records its verdict as
+The verification phase asks for one review of the plan's whole diff: `review`
+records its verdict as
 `review: <reviewer> <verdict> <date>` together with `reviewed_sha:` (the
 project's HEAD it read) and `review_round:`, so the next round reads only
 `git diff <reviewed_sha>..HEAD`, and refuses a third round: the budget is two
 rounds per plan; `close NNN done` refuses a plan whose review is missing or not
-`approve`. `close` refuses the active task - that one is the user's to stop first.
+`approve`, unless both rounds are spent and `--resolved` records the fix the
+session made and the test that proves it. `close` on the active task clears its phase in the same write, then
+removes each linked worktree whose branch has landed in HEAD, `main`, `master`
+or the remote's default branch (an ancestor of it, or a squash whose merge
+would change nothing) and which holds nothing else (no uncommitted or unknown
+ignored file, no `.tezgah` data, a branch someone committed on, no Orca agent
+still at work; Orca down keeps them all); every worktree it keeps is printed
+with the reason.
 
 Two things the plan owes are asked here, at the only moment they can still be
-fixed - the phase move - because the record is the user's and the refusal is
+fixed - the phase move - because this CLI is the record's only writer and the
+refusal is
 this CLI's: a writing phase needs every Acceptance item to name the command
 proving it (or say `unverifiable` and why), since the report CI runs afterwards
 refuses an open plan on any one item that does neither, through the same
@@ -52,6 +74,30 @@ still HEAD and the tree is still dirty, so committing is the whole way out of it
 and the commit clears the refusal by itself; the per-file snapshots
 (bin/tezgah-rollback) are not one state to return to.
 
+`slice` keeps the slice journal (hooks/tezgah_task.py): one record per delegated
+slice under `.tezgah/slices/` of the main checkout, opened by the post-tool path
+on a spawn call or by `slice open`, so a parent crash, an omp `/clear`, a quota
+stop or a model or host switch loses no slice. `reconcile` reads each open omp
+record's child transcript and closes the ones that ended, then prints one
+resume brief per open or stopped slice; `--prune` first runs the same worktree
+removal `close` does, deletes (`git branch -d`) every local branch that has
+landed and is checked out nowhere - never main, master or the current branch -
+and marks done each record whose branch landed with a commit of its own.
+`resume` prints the host's native path first (omp `write agent://<id>` while
+the parent session lives, Claude `SendMessage`), then a brief any host or model
+can re-dispatch: the original brief plus the last commit, the branch and the
+uncommitted files. `stats` flags a `class+host` signature at 3 events, or at 5%
+of a window holding 20 or more slices, and names its lever from a closed set.
+`board` lists the open slices one parent spawned - the session's own, or for a
+subagent its parent's - with the `Owns:` globs of each brief (the lease the
+gate holds siblings to), worktree, branch and last commit. `merge-plan` forecasts
+each done slice branch against `--base` (HEAD) and against the others with `git
+merge-tree`, leaves out a `merge=union` file such as CHANGELOG.md, and orders
+them with a branch touching MANIFEST or the citation baseline last, then fewest
+conflicts first; a branch merge-tree cannot forecast (git before 2.38, no shared
+history) is printed as `not judged` and the exit is 1. `review ... approve`
+is refused while a record whose id or agent is that reviewer is not done.
+
 Exit codes: 0 ok, 1 a refusal or a problem - one `FAIL <what>` line per problem,
 with nothing written - 2 misuse.
 """
@@ -66,6 +112,7 @@ import time
 HERE = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
 sys.path.insert(0, os.path.join(HERE, "hooks"))
 import tezgah_task as tt  # noqa: E402
+from tezgah_paths import say  # noqa: E402
 
 
 def repo_root(path):
@@ -161,11 +208,13 @@ def allow_source(text):
     `--allow`/`allow` (`allowed_from:` names which), or an explicit
     `--any-path`. No list and no `--any-path` is what a writing phase refuses."""
     allow = tt.allowed_paths(text)
-    source = tt.frontmatter(text).get("allowed_from") or ""
+    fields = tt.frontmatter(text)
+    source = fields.get("allowed_from") or ""
+    why = (" (why: %s)" % fields["allowed_why"]) if fields.get("allowed_why") else ""
     if allow:
-        return allow, ("from tezgah-task %s" % source) if source else "from the plan"
+        return allow, (("from tezgah-task %s" % source) + why) if source else "from the plan"
     if source == ANY_PATH:
-        return allow, "any path in the repo (--any-path)"
+        return allow, "any path in the repo (--any-path)" + why
     return allow, "any path in the repo (no allowlist)"
 
 
@@ -285,9 +334,9 @@ def phase_problems(phase, text, path):
     Both are read from the plan this CLI is about to move, through the same
     readers the CI report uses, so the phase the gate then holds a write to is a
     phase the plan can actually be checked in. They live here, at the phase move,
-    and not in the gate: the phase has one writer, this command, and the record
-    is the user's to write - a gate rule would have to re-read the same body on
-    every write to ask a question whose answer changes only here."""
+    and not in the gate: the phase has one writer, this command - a gate rule
+    would have to re-read the same body on every write to ask a question whose
+    answer changes only here."""
     out = []
     if phase in tt.WRITE_PHASES:
         items = tt.acceptance_gap(text)
@@ -320,6 +369,18 @@ def changed_lines(root, base):
     return sum(int(n) for n in re.findall(r"(\d+) (?:insertion|deletion)", stat))
 
 
+# The checks deferred out of the turn to the merge step (AGENTS.md "Checks, by
+# tier"): (the file that marks the repo has it, the command), in run order.
+MERGE_CHECKS = (
+    ("tests/impacted.py", "python3 tests/impacted.py --all"),
+    ("tests/neuter_matrix.py", "TEZGAH_E2E_STRICT=1 python3 tests/neuter_matrix.py"),
+    ("bin/tezgah-docs", "python3 bin/tezgah-docs --citations"),
+    ("bin/tezgah-docs", "python3 bin/tezgah-docs --clarity"),
+    ("skills/plan-add/render_table.py",
+     "python3 skills/plan-add/render_table.py --acceptance --strict"),
+)
+
+
 def verification_steps(text, path):
     """What the verification phase requires before the plan is done: the plan's
     own acceptance commands run once on the final tree, unpiped, and ONE review
@@ -347,8 +408,12 @@ def verification_steps(text, path):
           "no state go out as tool calls in ONE message, one suite run at a time:")
     for item in items or ["(the plan has no Acceptance items)"]:
         print("     - %s" % item)
-    if os.path.isfile(os.path.join(root, "tests", "impacted.py")):
-        print("     the one full run here is `python3 tests/impacted.py --all`")
+    # the deferred tier: never inside a turn, run once here at the merge step
+    deferred = [cmd for rel, cmd in MERGE_CHECKS
+                if os.path.isfile(os.path.join(root, rel))]
+    if deferred:
+        print("     the merge step's one run of the deferred checks: %s"
+              % ", ".join("`%s`" % c for c in deferred))
     if rounds and review_verdict(text) == "approve":
         print("  2. the review approved in round %d at %s: no further round"
               % (rounds, reviewed))
@@ -356,9 +421,11 @@ def verification_steps(text, path):
         return
     if rounds >= REVIEW_ROUNDS:
         print("  2. the %d-round budget is spent: `tezgah-task review` refuses a "
-              "third round. A critical or major finding still confirmed goes to "
-              "the user (block); a minor or suggestion one is recorded fix-later "
-              "under the plan's ## State" % REVIEW_ROUNDS)
+              "third round. Fix a critical or major finding still confirmed "
+              "yourself, prove it with a test and close with `--resolved`; fix a "
+              "minor or suggestion one now, or record it fix-later under the "
+              "plan's ## State only when it waits on a user decision (%s)"
+              % (REVIEW_ROUNDS, say()["decision"]))
         return
     if rounds:
         print("  2. review round 2 (the last): each confirmed critical or major "
@@ -380,8 +447,10 @@ def verification_steps(text, path):
               "security reviewer" % (REVIEW_ROUNDS, base, SMALL_DIFF,
                                      "unknown" if size is None else size))
         print("     only a confirmed critical or major finding is `changes` and "
-              "opens round 2; a minor or suggestion one is recorded fix-later "
-              "under ## State and the verdict is `approve`")
+              "opens round 2; a minor or suggestion one is fixed in the session "
+              "without a new round, or recorded fix-later under ## State only "
+              "when it waits on a user decision (%s), and the verdict is "
+              "`approve`" % say()["decision"])
     print("  3. record its verdict: `tezgah-task review %s <reviewer> approve|changes`"
           " (records the reviewed sha);"
           " `tezgah-task close %s done` refuses without an approve" % (ident, ident))
@@ -406,7 +475,7 @@ def cmd_start(args):
     if not args:
         return misuse("start needs a plan id or path")
     root = repo_root(os.getcwd())
-    path, problem = plan_path(root, args[0])
+    path, problem = open_plan(args[0])
     phase = None
     allow = []
     any_path = False
@@ -443,10 +512,10 @@ def cmd_start(args):
         return problems([problem])
     text = read(path)
     fields = {"phase": phase, "updated": today()}
-    if allow:
-        fields.update(allowed_paths=allow, allowed_from="--allow")
-    elif any_path:
-        fields.update(allowed_paths=[], allowed_from=ANY_PATH)
+    if allow or any_path:
+        fields.update(allowed_paths=allow, allowed_from="--allow" if allow else ANY_PATH)
+        if tt.frontmatter(text).get("allowed_why"):
+            fields["allowed_why"] = ""  # the reason belonged to the scope replaced
     else:
         # the plan's own scope, as plan-add wrote it (or an earlier --allow)
         allow = tt.allowed_paths(text)
@@ -489,6 +558,8 @@ def cmd_phase(args):
     fields = {"phase": phase, "updated": today()}
     if any_path:
         fields.update(allowed_paths=[], allowed_from=ANY_PATH)
+        if tt.frontmatter(text).get("allowed_why"):
+            fields["allowed_why"] = ""
     granted = (any_path or tt.frontmatter(text).get("allowed_from")
                == ANY_PATH)
     bad = (scope_problem(phase, task["allowed_paths"], granted)
@@ -503,6 +574,13 @@ def cmd_phase(args):
 
 
 def cmd_allow(args):
+    # the scope is the session's to widen, so the reason is the price: a widening
+    # nobody can read back later is the unbounded task this record exists to stop
+    why = ""
+    if "--why" in args:
+        i = args.index("--why")
+        why = " ".join((args[i + 1:i + 2] or [""])[0].split())
+        args = args[:i] + args[i + 2:]
     any_path = ANY_PATH in args
     args = [a for a in args if a != ANY_PATH]
     for arg in args:
@@ -510,6 +588,8 @@ def cmd_allow(args):
             return misuse("allow takes globs, not %r" % arg)
     if bool(args) == any_path:
         return misuse("allow takes globs, or --any-path alone to lift the scope")
+    if not why:
+        return misuse("allow takes --why \"<what in the plan reaches these paths>\"")
     task = active_here(repo_root(os.getcwd()))
     if not task:
         return problems(["no active task to widen: start one with "
@@ -519,7 +599,8 @@ def cmd_allow(args):
     # the way back out of a scope that turned out to be too narrow. A flag and
     # not an empty call, so lifting the scope is always said out loud.
     bad = write_fields(task["path"], allowed_paths=args, updated=today(),
-                       allowed_from=ANY_PATH if any_path else "allow")
+                       allowed_from=ANY_PATH if any_path else "allow",
+                       allowed_why=why)
     if bad:
         return problems(bad)
     return show(task["path"])
@@ -538,6 +619,70 @@ def cmd_stop(args):
     return show(task["path"])
 
 
+def open_plan(ref):
+    """(path, problem) for a plan under `.tezgah/plans/open/`: `tick` and `note`
+    write past the gate, so they take no other file (review of plan 083, F4:
+    `note README.md next ...` rewrote any markdown file with a Next section)."""
+    root = repo_root(os.getcwd())
+    path, problem = plan_path(root, ref)
+    if problem:
+        return None, problem
+    if os.path.dirname(os.path.realpath(path)) != os.path.realpath(open_dir(root)):
+        return None, "%s is not an open plan under %s" % (path, open_dir(root))
+    return path, None
+
+
+def cmd_tick(args):
+    """Tick (or `--undo` untick) one Acceptance box: the plan's progress is the
+    session's to record, and the gate refuses a direct write to the record."""
+    undo = "--undo" in args
+    args = [a for a in args if a != "--undo"]
+    if len(args) != 2 or not args[1].isdigit():
+        return misuse("tick takes <NNN|path> <n> [--undo]")
+    path, problem = open_plan(args[0])
+    if problem:
+        return problems([problem])
+    items = tt.acceptance_items(read(path))
+    n = int(args[1])
+    if not 1 <= n <= len(items):
+        return problems(["%s has %d Acceptance items, not an item %d"
+                         % (path, len(items), n)])
+    item = items[n - 1]
+    try:
+        tt.set_box(path, item["line"], not undo)
+    except OSError as exc:
+        return problems(["cannot write %s: %s" % (path, exc)])
+    bad = write_fields(path, updated=today())
+    if bad:
+        return problems(bad)
+    print("- [%s] %s" % (" " if undo else "x", item["text"]))
+    return 0
+
+
+NOTE_SECTIONS = {"state": "State", "next": "Next"}
+
+
+def cmd_note(args):
+    """Replace the plan's `## State` (the newest one) or `## Next` body."""
+    if len(args) != 3 or args[1] not in NOTE_SECTIONS or not args[2].strip():
+        return misuse('note takes <NNN|path> state|next "<text>"')
+    path, problem = open_plan(args[0])
+    if problem:
+        return problems([problem])
+    heading = NOTE_SECTIONS[args[1]]
+    try:
+        found = tt.set_section(path, heading, args[2])
+    except OSError as exc:
+        return problems(["cannot write %s: %s" % (path, exc)])
+    if not found:
+        return problems(["%s has no `## %s` section" % (path, heading)])
+    bad = write_fields(path, updated=today())
+    if bad:
+        return problems(bad)
+    print("%s: ## %s updated" % (path, heading))
+    return 0
+
+
 def review_verdict(text):
     """The verdict of the plan's `review: <reviewer> <verdict> <date>` line, or
     None when it has none or names a verdict this CLI does not write."""
@@ -546,19 +691,64 @@ def review_verdict(text):
 
 
 def budget_spent(path, ident):
-    """The refusal once REVIEW_ROUNDS rounds are recorded: what is left belongs
-    to the user, never to a third round."""
-    return ("%s has spent its %d-round review budget: never a third round. A "
-            "critical or major finding still confirmed goes to the user, who "
-            "decides (block); a minor or suggestion one is recorded fix-later "
-            "under the plan's ## State; `tezgah-task close %s discarded` needs no "
-            "review" % (path, REVIEW_ROUNDS, ident))
+    """The refusal once REVIEW_ROUNDS rounds are recorded: never a third round,
+    and never a hand-off - the session settles what is left itself."""
+    return ("%s has spent its %d-round review budget: never a third round. Fix a "
+            "critical or major finding still confirmed yourself and prove it with "
+            "a test, then `tezgah-task close %s done --resolved \"<the fix and the "
+            "test that proves it>\"`; fix a minor or suggestion one now, or record "
+            "it fix-later under the plan's ## State only when it waits on a "
+            "user decision (%s); `close %s discarded` needs no review"
+            % (path, REVIEW_ROUNDS, ident, say()["decision"], ident))
+
+
+def unfinished_review(root, reviewer, plan="", since=0):
+    """The refusal of an `approve` while a slice journal record whose id or agent
+    is `reviewer` is open, stopped or stale: a review slice that died on a
+    provider limit had its approve recorded anyway, and a NameError it would have
+    caught reached main (plan 078). A stale review is one whose end nobody saw,
+    which reads no more than a stopped one. The omp records are reconciled with
+    their transcripts first (`tt.pending`), so a review that finished reads as
+    done. A record that names the plan active when it opened counts only for
+    that `plan`; one that names none counts when it changed at or after `since`
+    (epoch seconds; the plan's checkpoint commit). A `resumed` record has handed
+    its work to the re-dispatch, whose own record is the one read. A record
+    spawned as `reviewer` under its own id (`Reviewer-<digest6>`,
+    `tt.open_slice`) counts too. Under TEZGAH_SESSION only this session's
+    records and unowned ones count, by id, agent or name alike: another
+    session's review is not this approve's. The refusal names the exact id,
+    which `slice resume` and `slice done` take from any session."""
+    from tezgah_paths import off
+    if off("slices-off"):
+        return []
+    tt.pending(root)
+    session = os.environ.get("TEZGAH_SESSION")
+
+    def named(rec):
+        return reviewer in (rec.get("id"), rec.get("agent"), rec.get("name")) and (
+            not session or rec.get("parent") in (session, "", None))
+
+    def ours(rec):
+        if rec.get("plan"):
+            return rec["plan"] == plan
+        return (_stamp(rec.get("updated")) or 0) >= since
+
+    return ["review slice %s is %s%s: let it finish, or resume it with `tezgah-task "
+            "slice resume %s` and wait for that run; if the review was finished "
+            "another way, record it with `tezgah-task slice done %s` - an approve "
+            "from a review that did not finish reads nothing"
+            % (rec["id"], rec.get("status"),
+               (" (%s)" % rec["failure"]) if rec.get("failure") else "",
+               rec["id"], rec["id"])
+            for rec in tt.slices(root)
+            if rec.get("status") in ("open", "stopped", "stale")
+            and named(rec) and ours(rec)]
 
 
 def cmd_review(args):
     if len(args) != 3 or args[2] not in VERDICTS:
         return misuse("review takes <NNN|path> <reviewer> %s" % "|".join(VERDICTS))
-    path, problem = plan_path(repo_root(os.getcwd()), args[0])
+    path, problem = open_plan(args[0])
     if problem:
         return problems([problem])
     fields = tt.frontmatter(read(path))
@@ -568,6 +758,17 @@ def cmd_review(args):
     # the project's HEAD, never the private `.tezgah` repository's: the next
     # round's delta is `git diff <this>..HEAD` over the project
     root = os.path.realpath(os.path.join(os.path.dirname(path), "..", "..", ".."))
+    if args[2] == "approve":
+        # the plan's checkpoint commit (a sha, or `pending <sha>`) dates the work
+        # this review is about; with none, every record counts
+        mark = (fields.get("checkpoint") or "").split()
+        since = (git_out(root, "log", "-1", "--format=%ct", mark[-1])
+                 if mark and mark[-1] != tt.CHECKPOINT_PENDING else None)
+        ident = fields.get("id") or os.path.basename(path).split("-")[0]
+        bad = unfinished_review(root, args[1], ident,
+                                int(since) if (since or "").isdigit() else 0)
+        if bad:
+            return problems(bad)
     sha = (git_out(root, "rev-parse", "HEAD") or "")[:12]
     record = {"review": "%s %s %s" % (args[1], args[2], today()),
               "review_round": str(int(prior) + 1 if prior.isdigit() else 1),
@@ -583,8 +784,15 @@ def cmd_review(args):
 
 
 def cmd_close(args):
+    resolved = ""
+    if "--resolved" in args:
+        i = args.index("--resolved")
+        resolved = " ".join((args[i + 1:i + 2] or [""])[0].split())
+        args = args[:i] + args[i + 2:]
+        if not resolved:
+            return misuse("--resolved takes the fix and the test that proves it")
     if len(args) != 2 or args[1] not in ("done", "discarded"):
-        return misuse("close takes <NNN|path> done|discarded")
+        return misuse("close takes <NNN|path> done|discarded [--resolved TEXT]")
     root = repo_root(os.getcwd())
     path, problem = plan_path(root, args[0])
     if problem:
@@ -593,18 +801,26 @@ def cmd_close(args):
         return problems(["%s is not under %s" % (path, open_dir(root))])
     text = read(path)
     ident = os.path.basename(path).split("-")[0]
+    # closing the active task deactivates it in the same write: the plan leaves
+    # open/ anyway, and a separate `stop` first was one more step for nobody
+    fields = {"status": args[1], "updated": today()}
     if tt.frontmatter(text).get("phase"):
-        return problems(["%s is the active task: the user stops it first "
-                         "(`tezgah-task stop`)" % path])
+        fields["phase"] = ""
     if args[1] == "done" and review_verdict(text) != "approve":
         prior = tt.frontmatter(text).get("review_round") or ""
-        if prior.isdigit() and int(prior) >= REVIEW_ROUNDS:
+        spent = prior.isdigit() and int(prior) >= REVIEW_ROUNDS
+        if spent and resolved:
+            # the budget is spent and the session fixed what was left: the fix
+            # and its proof go on the record a later reader rejects it from
+            fields["resolved"] = "%s %s" % (resolved, today())
+        elif spent:
             return problems([budget_spent(path, ident)])
-        return problems(["%s records no approving review: a fresh reviewer reads "
-                         "the diff, then `tezgah-task review %s <reviewer> approve`"
-                         % (path, ident)])
+        else:
+            return problems(["%s records no approving review: a fresh reviewer reads "
+                             "the diff, then `tezgah-task review %s <reviewer> approve`"
+                             % (path, ident)])
     target = os.path.join(root, ".tezgah", "plans", "done", os.path.basename(path))
-    bad = write_fields(path, status=args[1], updated=today())
+    bad = write_fields(path, **fields)
     if bad:
         return problems(bad)
     try:
@@ -613,9 +829,128 @@ def cmd_close(args):
     except OSError as exc:
         return problems(["cannot move %s: %s" % (path, exc)])
     print("moved %s -> %s" % (path, target))
+    for line in prune_worktrees(root):
+        print(line)
     return 0
 
 
+# Ignored output a slice regenerates on its own. Any other ignored path - an
+# `.env`, a local database, a dataset - may be the only copy, so it keeps the
+# worktree; a list rather than `--ignored` alone because every checkout that ran
+# a test holds a cache.
+REGENERABLE = frozenset(("__pycache__", ".pytest_cache", ".ruff_cache",
+                         ".mypy_cache", "node_modules", ".venv", "venv",
+                         ".DS_Store"))
+
+
+def _landed(root, branch, base):
+    """True when `branch`'s work is in `base`: an ancestor of it, or - for a
+    squash or rebase merge, which leaves no ancestry - a branch whose merge into
+    `base` would change nothing. `merge-tree --write-tree` needs git 2.38; an
+    older git answers None, which reads as not landed and keeps the worktree."""
+    if git_out(root, "merge-base", "--is-ancestor", branch, base) is not None:
+        return True
+    # a branch whose commits cancel out (X then revert X) merges to base's tree
+    # too, while its commits are in base nowhere: it needs a net change to count
+    fork = git_out(root, "merge-base", base, branch)
+    if not fork or git_out(root, "diff", "--quiet", fork, branch) is not None:
+        return False
+    merged = (git_out(root, "merge-tree", "--write-tree", base, branch) or "").split("\n")[0]
+    return bool(merged) and merged == git_out(root, "rev-parse", base + "^{tree}")
+
+
+def _keeps(root, path, branch, bases, agents):
+    """Why the linked worktree `path` must stay, or None when its work is all in
+    `bases` and it holds nothing else. Every question git cannot answer keeps it."""
+    if not branch:
+        return "detached HEAD"
+    # -unormal: a `status.showUntrackedFiles=no` config would hide both lists
+    if git_out(path, "status", "--porcelain", "-unormal") != "":
+        return "uncommitted changes"
+    for line in (git_out(path, "status", "--porcelain", "-unormal", "--ignored") or "").splitlines():
+        rel = line[3:].strip('"').rstrip("/")
+        if rel != ".tezgah" and not REGENERABLE & set(rel.split("/")):
+            return "ignored file %s may be the only copy" % rel
+    ws = os.path.join(path, ".tezgah")
+    if os.path.isdir(ws):
+        if set(os.listdir(ws)) - {".git"}:
+            return "its .tezgah holds data"
+        if os.path.isdir(os.path.join(ws, ".git")) and git_out(ws, "rev-parse", "-q", "--verify", "HEAD"):
+            return "its .tezgah has commits"
+    if not any(_landed(root, branch, b) for b in bases):
+        return "%s is not merged into %s" % (branch, " or ".join(bases))
+    log = git_out(root, "reflog", "show", "--format=%gs", "refs/heads/" + branch) or ""
+    if not any(entry.startswith(("commit:", "commit (amend):", "commit (initial):"))
+               for entry in log.splitlines()):
+        # a branch nobody committed on is a slice that has not started - even
+        # one fast-forwarded to main, or one that only cherry-picked or merged
+        # main in - not one whose work landed
+        return "%s has no commit of its own yet" % branch
+    busy = [a.get("state") for a in agents if a.get("state") != "done"]
+    if busy:
+        return "an agent there is %s" % busy[0]
+    return None
+
+
+def landing_bases(root):
+    """The refs a branch's work counts as landed in, those that exist: HEAD,
+    main, master, and the remote's default branch too - a PR merged on the host
+    lands there first."""
+    return [b for b in ("HEAD", "main", "master", "origin/HEAD", "origin/main",
+                        "origin/master")
+            if git_out(root, "rev-parse", "-q", "--verify", b)]
+
+
+def prune_worktrees(root):
+    """Remove every linked worktree of the repository whose branch has landed and
+    which holds nothing else, so a closed plan leaves no checkout behind; one line
+    per linked worktree, removed or kept with the reason. The main checkout and
+    the one `close` runs in always stay. Under Orca the removal is Orca's (its
+    card, terminals and merged branch go with it), else `git worktree remove`
+    and a safe `git branch -d`. When Orca is installed but does not answer, its
+    agents cannot be checked, so every worktree stays."""
+    import tezgah_orca
+    from tezgah_paths import worktrees
+    found = worktrees(root)
+    here = os.path.realpath(root)
+    linked = [p for p in found[1:] if p != here]
+    if not linked:
+        return []
+    ps = tezgah_orca.run(["worktree", "ps", "--limit", "1000"])
+    rows = ps.get("worktrees") if isinstance(ps, dict) else None
+    if not isinstance(rows, list) and tezgah_orca.cli():
+        # down, or an answer in a shape this reader does not know: either way
+        # its agents cannot be checked
+        return ["worktree kept: %s (Orca did not answer, so its agents cannot be "
+                "checked; run close again once `orca worktree ps` answers)" % p
+                for p in linked]
+    orca = {os.path.realpath(r.get("path") or ""): r for r in rows or []
+            if isinstance(r, dict)}
+    bases = landing_bases(root)
+    out = []
+    for path in linked:
+        branch = git_out(path, "symbolic-ref", "-q", "--short", "HEAD")
+        try:
+            why = _keeps(root, path, branch, bases,
+                         orca.get(path, {}).get("agents") or [])
+        except OSError as exc:
+            why = "cannot read it: %s" % exc
+        if why is None:
+            if path in orca:
+                gone = tezgah_orca.run(["worktree", "rm", "--worktree", "path:" + path],
+                                       timeout=60) is not None
+                how = "orca worktree rm --worktree path:%s" % path
+            else:
+                gone = git_out(root, "worktree", "remove", path) is not None
+                how = "git worktree remove %s" % path
+                if gone:
+                    git_out(root, "branch", "-d", branch)
+            why = None if gone else "`%s` failed; run it and report its error" % how
+        out.append("worktree %s: %s (%s)" % ("kept" if why else "removed", path,
+                                             why or branch))
+    return out
+
+
 def cmd_status(args):
     as_json = "--json" in args
     rest = [a for a in args if a != "--json"]
@@ -673,6 +1008,390 @@ def cmd_status(args):
     return 1 if bad else 0
 
 
+# ------------------------------------------------------------------ slice
+
+# The closed lever set a stats candidate is named from (the research line's
+# RSI loop): one file or mechanism per failure class, never prose.
+LEVERS = {"rate_limit": "hooks/tezgah_models.py fallback chain",
+          "quota": "hooks/tezgah_models.py fallback chain",
+          "cut_off": "per-slice deadline", "timeout": "per-slice deadline",
+          "aborted": "wip: commit cadence", "duplicate": "journal background jobs",
+          "error": "none (read the transcript)"}
+STATS_WINDOW = 14
+# A signature is a candidate at this many events, or at this share of the slices
+# in the window once the window holds STATS_SHARE_FLOOR slices: below that, one
+# event is already 5% and every stop would read as a pattern.
+STATS_EVENTS = 3
+STATS_SHARE = 0.05
+STATS_SHARE_FLOOR = 20
+
+
+def parse_options(args, valued, flags=()):
+    """(options, positionals, problem) for `args`: each `valued` option takes the
+    next argument, each flag stands alone, any other `--x` is a problem."""
+    opts, pos, i = {}, [], 0
+    while i < len(args):
+        arg = args[i]
+        if arg in valued:
+            if i + 1 >= len(args):
+                return None, None, "%s needs a value" % arg
+            opts[arg] = args[i + 1]
+            i += 2
+        elif arg in flags:
+            opts[arg] = True
+            i += 1
+        elif arg.startswith("--"):
+            return None, None, "unknown option %r" % arg
+        else:
+            pos.append(arg)
+            i += 1
+    return opts, pos, None
+
+
+def resume_text(root, rec):
+    """The way back into one record's work: the host's native path first (omp
+    `write agent://<id>` while the parent session lives, Claude `SendMessage`),
+    else a re-dispatch brief that runs on any host or model - the original brief
+    plus where the work stands (last commit, branch, uncommitted files)."""
+    sid = rec["id"]
+    lines = [tt.slice_line(rec)]
+    if rec.get("kind") == "job":
+        lines.append("  command: %s" % (rec.get("brief") or "(none recorded)"))
+        return "\n".join(lines)
+    tree = rec.get("worktree") or ""
+    cwd = rec.get("cwd") or ""
+    where = (tree if tree and os.path.isdir(tree) else
+             cwd if cwd and os.path.isdir(cwd) else root)
+    last = git_out(where, "log", "-1", "--format=%h %s") or "(none)"
+    branch = (rec.get("branch") or git_out(where, "symbolic-ref", "-q", "--short", "HEAD")
+              or "(detached HEAD)")
+    # the journal's own directory is not the slice's work, ignored or not
+    dirty = [line[3:] for line in (git_out(where, "status", "--porcelain") or "").splitlines()
+             if not line[3:].startswith(".tezgah")]
+    resume = ("Resume: last commit %s on %s; uncommitted: %s; continue from there, "
+              "do not redo committed steps" % (last, branch, ", ".join(dirty) or "none"))
+    # a Claude record named by a 12-hex brief digest addresses no agent: no
+    # SendMessage line for it, only the re-dispatch
+    named = not re.fullmatch(r"[0-9a-f]{12}", sid)
+    native = {"omp": "`write agent://%s` (while omp session %s still runs)"
+                     % (sid, rec.get("parent") or "?"),
+              "claude": "`SendMessage` to %s" % sid if named else None}.get(rec.get("host"))
+    if native:
+        lines.append("  native: %s with: %s" % (native, resume))
+    provider = (" on another provider (`tezgah-route` names the tier; the same "
+                "account's limit would stop it again)"
+                if rec.get("failure") in ("quota", "rate_limit") else
+                " on any host or model")
+    lines.append("  %sre-dispatch%s with this brief:" % ("else " if native else "", provider))
+    lines.append(rec.get("brief") or "(no brief recorded)")
+    lines.append(resume)
+    return "\n".join(lines)
+
+
+def own_commits(root, rec):
+    """Does the record's branch carry a commit past the base it was opened on?
+    A branch still at its base is a slice that has not started, not one whose
+    work landed."""
+    base, branch = rec.get("base"), rec.get("branch")
+    if not base or not branch:
+        return False
+    count = git_out(root, "rev-list", "--count", "%s..%s" % (base, branch))
+    return bool(count) and count != "0"
+
+
+def prune_branches(root, bases):
+    """`git branch -d` every local branch whose work landed in `bases`, that no
+    worktree has checked out, that tracks no upstream (a long-lived branch such
+    as `develop` tracks one) and that carries a commit of its own (its reflog
+    names one, the guard `_keeps` applies to a worktree: a pre-created branch
+    nobody committed on is a slice not yet started) - never main, master or the
+    current branch. One line per branch it deletes or git refuses."""
+    current = git_out(root, "symbolic-ref", "-q", "--short", "HEAD")
+    held = {line[len("branch refs/heads/"):] for line in
+            (git_out(root, "worktree", "list", "--porcelain") or "").splitlines()
+            if line.startswith("branch refs/heads/")}
+    out = []
+    for row in (git_out(root, "for-each-ref", "--format=%(refname:short)\t%(upstream)",
+                        "refs/heads") or "").splitlines():
+        branch, _tab, upstream = row.partition("\t")
+        if branch in ("main", "master", current) or branch in held or upstream:
+            continue
+        log = git_out(root, "reflog", "show", "--format=%gs", "refs/heads/" + branch) or ""
+        if not any(entry.startswith(("commit:", "commit (amend):", "commit (initial):"))
+                   for entry in log.splitlines()):
+            continue
+        if not any(_landed(root, branch, b) for b in bases):
+            continue
+        done = subprocess.run(["git", "-C", root, "branch", "-d", branch],
+                              capture_output=True, text=True)
+        out.append("branch deleted: %s" % branch if done.returncode == 0 else
+                   "branch kept: %s (`git branch -d %s` refused: %s)"
+                   % (branch, branch, (done.stderr.strip().splitlines() or ["?"])[0]))
+    return out
+
+
+def _stamp(value):
+    """Seconds since the epoch of an ISO-8601 UTC record time, None when bad."""
+    import calendar
+    try:
+        return calendar.timegm(time.strptime(str(value), "%Y-%m-%dT%H:%M:%SZ"))
+    except ValueError:
+        return None
+
+
+def slice_stats(rows, window, now=None):
+    """Counts per status, failure class and host over the records updated in the
+    last `window` days, and the candidate signatures: `class+host`, one event per
+    record (the class it last stopped with) and `duplicate+host` per job record
+    run more than once, at STATS_EVENTS events or STATS_SHARE of the slices."""
+    from collections import Counter
+    cutoff = (time.time() if now is None else now) - window * 86400
+    picked = [r for r in rows if (_stamp(r.get("updated") or r.get("opened")) or 0) >= cutoff]
+    sigs = Counter()
+    for rec in picked:
+        host = rec.get("host") or "?"
+        if rec.get("failure") in LEVERS:
+            sigs[(rec["failure"], host)] += 1
+        if rec.get("kind") == "job" and int(rec.get("attempts") or 1) > 1:
+            sigs[("duplicate", host)] += 1
+    total = len(picked)
+    candidates = [{"signature": "%s+%s" % key, "events": n,
+                   "share": round(n / total, 3), "lever": LEVERS[key[0]]}
+                  for key, n in sorted(sigs.items(), key=lambda kv: (-kv[1], kv[0]))
+                  if n >= STATS_EVENTS
+                  or (total >= STATS_SHARE_FLOOR and n >= STATS_SHARE * total)]
+    return {"window_days": window, "slices": total,
+            "status": dict(Counter(r.get("status") or "?" for r in picked)),
+            "failure": dict(Counter(r["failure"] for r in picked if r.get("failure"))),
+            "host": dict(Counter(r.get("host") or "?" for r in picked)),
+            "candidates": candidates}
+
+
+def _counts(counter):
+    return ", ".join("%s %d" % kv for kv in sorted(counter.items())) or "none"
+
+
+# Files every slice appends to and only the integrator resolves (research
+# orchestrator-flow-audit S6, finding 8): a branch that touches one merges
+# after every branch that does not.
+HOTSPOTS = ("MANIFEST", "docs/citations-baseline.json")
+
+
+def merge_conflicts(root, ours, theirs):
+    """The files `git merge-tree` forecasts in conflict when `theirs` merges
+    into `ours`, minus the ones a `merge=union` attribute merges (CHANGELOG.md
+    here); None when git cannot answer (no such ref, git before 2.38)."""
+    try:
+        out = subprocess.run(["git", "-C", root, "merge-tree", "--write-tree",
+                              "--name-only", "--no-messages", ours, theirs],
+                             capture_output=True, text=True)
+    except OSError:
+        return None
+    if out.returncode not in (0, 1):
+        return None
+    files = sorted(set(out.stdout.split("\n\n")[0].splitlines()[1:]))
+    if not files:
+        return []
+    attrs = git_out(root, "check-attr", "merge", "--", *files) or ""
+    union = {line.rsplit(": merge: ", 1)[0] for line in attrs.splitlines()
+             if line.endswith(": merge: union")}
+    return [f for f in files if f not in union]
+
+
+def merge_plan(root, base):
+    """(lines, unjudged) for the done slices whose branch carries work `base`
+    lacks. The lines are the order to merge them: a branch touching no
+    HOTSPOTS first, then fewest forecast conflicts with `base`, then fewest
+    siblings it overlaps; each names its conflicting files and the siblings it
+    collides with. `unjudged` names each branch `git merge-tree` could not
+    forecast (git before 2.38, no shared history) instead of dropping it."""
+    branches = {}
+    for rec in tt.slices(root):
+        branch = rec.get("branch")
+        if (rec.get("status") == "done" and branch and branch not in branches
+                and own_commits(root, rec) and not _landed(root, branch, base)):
+            branches[branch] = rec
+    rows, unjudged = [], []
+    for branch, rec in branches.items():
+        mine = merge_conflicts(root, base, branch)
+        if mine is None:
+            unjudged.append("not judged: %s (slice %s): `git merge-tree --write-tree` "
+                            "could not forecast it against %s" % (branch, rec["id"], base))
+            continue
+        overlaps = {}
+        for other in branches:
+            files = merge_conflicts(root, other, branch) if other != branch else None
+            if files:
+                overlaps[other] = files
+        touched = (git_out(root, "diff", "--name-only", "%s...%s" % (base, branch))
+                   or "").splitlines()
+        hot = any(f in HOTSPOTS for f in touched)
+        rows.append(((hot, len(mine), len(overlaps), branch), rec, mine, overlaps))
+    rows.sort(key=lambda row: row[0])
+    out = []
+    for n, (key, rec, mine, overlaps) in enumerate(rows, 1):
+        line = "%d. %s (slice %s): %d conflict(s) with %s%s" % (
+            n, rec["branch"], rec["id"], len(mine), base,
+            ": " + ", ".join(mine) if mine else "")
+        for other, files in sorted(overlaps.items()):
+            line += "; overlaps %s on %s" % (other, ", ".join(files))
+        out.append(line + (" (touches a hotspot: the integrator merges it last)"
+                           if key[0] else ""))
+    return out, unjudged
+
+
+def board_parent():
+    """The parent whose slices `slice board` shows: the session in
+    TEZGAH_SESSION, or - read from a subagent - the parent that spawned it
+    (`tezgah_integrity.spawn_of`), so a slice sees its siblings; None, every
+    open slice, outside a session."""
+    session = os.environ.get("TEZGAH_SESSION")
+    if not session:
+        return None
+    try:
+        from tezgah_integrity import spawn_of
+        spawn = spawn_of(session)
+    except Exception:
+        spawn = None
+    return spawn[0] if spawn else session
+
+
+def cmd_slice(args):
+    usage = ("slice takes open|done|stop|reconcile|resume|stats|board|merge-plan "
+             "(open --id ID [--kind agent|job] [--host H] [--agent A] "
+             "[--brief TEXT|--brief-file F] [--parent P] [--cwd PATH]; done ID; stop ID "
+             "[--class C]; reconcile [--prune]; resume ID; stats [--window DAYS] "
+             "[--json]; board [--parent P]; merge-plan [--base REF])")
+    if not args:
+        return misuse(usage)
+    sub, rest = args[0], args[1:]
+    root = repo_root(os.getcwd())
+    if sub == "board":
+        opts, pos, bad = parse_options(rest, ("--parent",))
+        if bad or pos:
+            return misuse(bad or "slice board takes [--parent P] and nothing else")
+        lines = tt.board(root, opts.get("--parent") or board_parent())
+        print("\n".join(lines) if lines else "no open slice")
+        return 0
+    if sub == "merge-plan":
+        opts, pos, bad = parse_options(rest, ("--base",))
+        if bad or pos:
+            return misuse(bad or "slice merge-plan takes [--base REF] and nothing else")
+        base = opts.get("--base", "HEAD")
+        if git_out(root, "rev-parse", "-q", "--verify", base) is None:
+            return problems(["no revision %s in %s" % (base, root)])
+        lines, unjudged = merge_plan(root, base)
+        if lines or not unjudged:
+            print("\n".join(lines) if lines else "no done slice branch to merge into %s" % base)
+        for line in unjudged:
+            print(line)
+        return 1 if unjudged else 0
+    if sub == "open":
+        opts, pos, bad = parse_options(rest, ("--id", "--kind", "--host", "--agent",
+                                              "--brief", "--brief-file", "--parent",
+                                              "--cwd"))
+        if bad or pos:
+            return misuse(bad or "slice open takes options only (%r)" % pos[0])
+        if not opts.get("--id"):
+            return misuse("slice open needs --id ID")
+        if "--brief" in opts and "--brief-file" in opts:
+            return misuse("--brief and --brief-file contradict each other")
+        kind, host = opts.get("--kind", "agent"), opts.get("--host", "")
+        if kind not in tt.SLICE_KINDS:
+            return misuse("--kind is one of %s" % ", ".join(tt.SLICE_KINDS))
+        if host and host not in tt.SLICE_HOSTS:
+            return misuse("--host is one of %s" % ", ".join(tt.SLICE_HOSTS))
+        brief = opts.get("--brief", "")
+        if "--brief-file" in opts:
+            try:
+                brief = read(opts["--brief-file"])
+            except (OSError, UnicodeDecodeError) as exc:
+                return problems(["cannot read %s: %s" % (opts["--brief-file"], exc)])
+        try:
+            rec = tt.open_slice(root, opts["--id"], kind=kind, host=host,
+                                agent=opts.get("--agent", ""), brief=brief,
+                                parent=opts.get("--parent", ""),
+                                cwd=opts.get("--cwd") or os.getcwd())
+        except OSError as exc:
+            return problems(["cannot write the slice record: %s" % exc])
+        print("slice %s open (%s, attempt %d)%s" % (
+            rec["id"], rec["kind"], rec["attempts"],
+            " worktree %s on %s" % (rec["worktree"], rec["branch"] or "?")
+            if rec["worktree"] else ""))
+        return 0
+    if sub in ("done", "stop"):
+        opts, pos, bad = parse_options(rest, ("--class",) if sub == "stop" else ())
+        if bad or len(pos) != 1:
+            return misuse(bad or "slice %s takes one ID%s" % (
+                sub, " [--class C]" if sub == "stop" else ""))
+        failure = opts.get("--class", "")
+        if failure and failure not in tt.FAILURES:
+            return misuse("--class is one of %s" % ", ".join(tt.FAILURES))
+        status = "done" if sub == "done" else "stopped"
+        try:
+            found = tt.find_slice(root, pos[0], os.environ.get("TEZGAH_SESSION"))
+            rec = found and tt.close_slice(root, found["id"], status, failure)
+        except OSError as exc:
+            return problems(["cannot write the slice record: %s" % exc])
+        if not rec:
+            return problems(["no slice record %s under %s" % (pos[0], tt.slice_dir(root))])
+        print("slice %s %s%s" % (rec["id"], status,
+                                 " (%s)" % rec["failure"] if rec.get("failure") else ""))
+        return 0
+    if sub == "reconcile":
+        opts, pos, bad = parse_options(rest, (), ("--prune",))
+        if bad or pos:
+            return misuse(bad or "slice reconcile takes --prune and nothing else")
+        if opts.get("--prune"):
+            bases = landing_bases(root)
+            # read before the prune: a removed worktree takes its branch with it
+            landed = [rec for rec in tt.slices(root)
+                      if rec.get("status") != "done" and own_commits(root, rec)
+                      and any(_landed(root, rec["branch"], b) for b in bases)]
+            for line in prune_worktrees(root) + prune_branches(root, bases):
+                print(line)
+            for rec in landed:
+                tt.close_slice(root, rec["id"], "done")
+                print("slice %s done: %s landed" % (rec["id"], rec["branch"]))
+        rows = tt.pending(root)
+        if not rows:
+            print("no open or stopped slice")
+        for rec in rows:
+            print(resume_text(root, rec))
+        return 0
+    if sub == "resume":
+        if len(rest) != 1:
+            return misuse("slice resume takes one ID")
+        rec = tt.find_slice(root, rest[0], os.environ.get("TEZGAH_SESSION"))
+        if rec is None:
+            return problems(["no slice record %s under %s" % (rest[0], tt.slice_dir(root))])
+        print(resume_text(root, rec))
+        tt.close_slice(root, rec["id"], "resumed")
+        return 0
+    if sub == "stats":
+        opts, pos, bad = parse_options(rest, ("--window",), ("--json",))
+        if bad or pos:
+            return misuse(bad or "slice stats takes [--window DAYS] [--json]")
+        window = opts.get("--window", str(STATS_WINDOW))
+        if not window.isdigit() or int(window) < 1:
+            return misuse("--window takes a whole number of days")
+        stats = slice_stats(tt.slices(root), int(window))
+        if opts.get("--json"):
+            print(json.dumps(stats, indent=2, sort_keys=True))
+            return 0
+        print("slices in the last %d days: %d" % (stats["window_days"], stats["slices"]))
+        for key in ("status", "failure", "host"):
+            print("  %s: %s" % (key, _counts(stats[key])))
+        for row in stats["candidates"]:
+            print("candidate: %s - %d events (%d%% of slices) - lever: %s" % (
+                row["signature"], row["events"], round(row["share"] * 100), row["lever"]))
+        if not stats["candidates"]:
+            print("no signature at %d events or %d%% of the slices"
+                  % (STATS_EVENTS, round(STATS_SHARE * 100)))
+        return 0
+    return misuse(usage)
+
+
 def main(argv):
     if len(argv) < 2:
         print(__doc__, file=sys.stderr)
@@ -692,8 +1411,14 @@ def main(argv):
         return cmd_review(rest)
     if cmd == "close":
         return cmd_close(rest)
+    if cmd == "tick":
+        return cmd_tick(rest)
+    if cmd == "note":
+        return cmd_note(rest)
+    if cmd == "slice":
+        return cmd_slice(rest)
     return misuse("unknown command %r (start, phase, allow, stop, status, review, "
-                  "close)" % cmd)
+                  "close, tick, note, slice)" % cmd)
 
 
 if __name__ == "__main__":