@r1z4x/tezgah 1.11.0 → 1.13.0

package/hooks/tezgah_paths.py

@@ -100,10 +100,51 @@ HOST_DIRS = {
     "opencode": os.path.join(XDG_CONFIG, "opencode"),
     "dsh": os.environ.get("DSH_HOME") or os.path.join(HOME, ".dsh"),
     "omp": os.path.join(HOME, ".omp"),
+    # qwen 0.21.13 reads a relocated home from QWEN_HOME (`getGlobalQwenDir`
+    # in its bundle), the same pattern as CODEX_HOME
+    "qwen": os.environ.get("QWEN_HOME") or os.path.join(HOME, ".qwen"),
+    # Factory Droid documents no relocated home: hooks.json, AGENTS.md and skills
+    # live under ~/.factory (docs.factory.com harness/hooks, agents-md, skills)
+    "droid": os.path.join(HOME, ".factory"),
+    # Command Code resolves ~/.commandcode from HOME alone (docs/settings,
+    # "Environment variables"): settings.json, AGENTS.md and skills live there
+    "commandcode": os.path.join(HOME, ".commandcode"),
+    # Copilot CLI reads a relocated home from COPILOT_HOME, which replaces the
+    # whole ~/.copilot path (docs.github.com cli-config-dir-reference)
+    "copilot": os.environ.get("COPILOT_HOME") or os.path.join(HOME, ".copilot"),
+    # Gemini CLI puts `.gemini` inside GEMINI_CLI_HOME, else the home dir
+    # (geminicli configuration "Environment variables"); a GEMINI_CLI_* name
+    # survives the sanitizer, so the hook sees it too. Antigravity shares
+    # ~/.gemini, so a machine with only Antigravity reads as Gemini-installed.
+    "gemini": os.path.join(os.environ.get("GEMINI_CLI_HOME") or HOME, ".gemini"),
+    # Antigravity CLI's own app dir (settings.json, skills); its hooks live in
+    # ~/.gemini/config/hooks.json and its rules in ~/.gemini/GEMINI.md, one level
+    # up. No relocated home is documented (antigravity.google/docs/settings)
+    "antigravity": os.path.join(HOME, ".gemini", "antigravity-cli"),
+    # Goose's config dir on macOS and Linux (docs guides/config-files): its
+    # global `.goosehints` lives here. Its hooks and skills come from a plugin
+    # under ~/.agents/plugins (guides/context-engineering/plugins), outside it.
+    # GOOSE_PATH_ROOT is a test/dev override whose effect on the hints file is
+    # undocumented, so it is not followed
+    "goose": os.path.join(HOME, ".config", "goose"),
+    # Amp's user dir: settings.json and AGENTS.md are HOME-literal in its docs
+    # (ampcode.com/docs cli/settings, customize/agents-md); skills under it too
+    "amp": os.path.join(HOME, ".config", "amp"),
 }
-# a host can be installed with no config dir yet (a CLI on PATH is enough)
+# tezgah's own Goose plugin, wholly tezgah's: plugin.json, hooks/hooks.json and
+# skill links (goose docs guides/context-engineering/plugins "Plugin Locations")
+GOOSE_PLUGIN = os.path.join(HOME, ".agents", "plugins", "tezgah")
+# tezgah's Amp system plugin, one file: Amp follows XDG_CONFIG_HOME for its
+# plugin dir alone (ampcode.com/docs customize/plugins "Plugin Locations")
+AMP_PLUGIN = os.path.join(XDG_CONFIG, "amp", "plugins", "tezgah.ts")
+# a host can be installed with no config dir yet (a CLI on PATH is enough).
+# Command Code's short alias `cmd` is Windows' own shell there, so only its
+# full name counts (docs/quickstart)
 HOST_BINS = {"cursor": ("cursor-agent", "cursor"), "opencode": ("opencode",),
-             "dsh": ("dsh",), "omp": ("omp",)}
+             "dsh": ("dsh",), "omp": ("omp",), "qwen": ("qwen",), "droid": ("droid",),
+             "commandcode": ("command-code",), "copilot": ("copilot",),
+             "gemini": ("gemini",), "antigravity": ("agy",), "goose": ("goose",),
+             "amp": ("amp",)}
 
 
 def host_installed(name):

package/hooks/tezgah_policy.py

@@ -78,7 +78,11 @@ The reader has to act on the answer, and the friction between "got it" and
    line - never also narrate the plan as prose.
 4. End with the approval questions the Ask policy leaves (the executive mode's
    "Ask policy"), or with nothing when none is left. A step you can take
-   yourself is taken, never handed over.
+   yourself is taken, never handed over: "run `pytest -q` and tell me what it
+   says" is a step you run. In the host's plan mode nothing can run, and there
+   the plan is the deliverable: the approval question is the one question that
+   turn asks, every step waits for it, and nothing is reported as done or
+   tested, because nothing ran.
 5. Suppress tangents: finish the issue in hand, then raise the second as its own
    question. A question the reader raised mid-work is not a tangent - answer it
    and fold the result in.
@@ -123,7 +127,8 @@ intuitive". Such a request is NEVER built from a guess. Before any code:
 3. Ask at most three blocking questions, the ones that change the outcome and
    that no default may take. Every other question goes in the approval batch
    with a recommended default, and the work proceeds on the defaults in the
-   same turn (the executive mode's "Ask policy").
+   same turn (the executive mode's "Ask policy"); a class-F item waits for the
+   answer.
 4. Verify design, behavior and quality claims against an external source, never
    from memory alone: `{CONSULT_BIN} --online "<question>"` for a fast second
    opinion, or the OpenResearch CLI (`{ORX_BIN}`) when it is a real
@@ -286,7 +291,12 @@ after round two what is left is fixed by the session and closed with
 A round spawns its reviewers in ONE message, one per dimension (correctness
 and contract, security, tests and performance) or file group; a diff under 300
 changed lines gets one reviewer. Per-task work gets tests, not a reviewer, and
-`{TASK_BIN} review` refuses a third round.
+`{TASK_BIN} review` refuses a third round. No fresh subagent, no review verdict:
+on a host or mode that cannot start a fresh reviewer, say so and ask the owner;
+never record a verdict from your own read. The author contests a confirmed
+finding only by citing evidence the reviewer could read (file:line); knowledge
+outside the files goes to the owner as a question, and the author never lowers
+a severity.
 
 **The process is yours: never hand a step back.** The orchestrator runs the
 plan lifecycle itself - `{TASK_BIN} start`, every `phase` move, `review`,
@@ -314,13 +324,13 @@ whether the user already decided it (named it this session, or granted it).
 | C. Reversible choice the evidence settles | a fix's scope inside the ask, naming, a palette when tokens exist | decide from evidence; real taste goes in the batch with a default, taken this turn |
 | D. Intent fork | two readings of the ask with different deliverables | batch with a default; do the shared part first and proceed on the default |
 | E. Outward on the user's own remote | push, PR, tag, release, publishing the user's own package | act on a grant written in chat ({GRANT_EXAMPLES}); else ask once per session, never again after a grant |
-| F. Never on a default | force push or history rewrite on a shared ref; deleting data the session did not make; production deploy, stop or migration; a credential, account or identity change; sending to a third party; a spend over `spend_cap`; building a plan this turn wrote from a research, analysis, review or plan ask | do all other work first, ask, and wait: silence is no consent, and only an answer that names the action and its target clears it |
+| F. Never on a default | force push or history rewrite on a shared ref; deleting data the session did not make; production deploy, stop or migration; a credential, account or identity change; sending to a third party; a spend over `spend_cap`; building a plan this turn wrote from a research, analysis, review or plan ask; choosing a variant or option a research, analysis or review recommends; a way around a tezgah refusal (another folder, a hidden dir, a hatch the owner did not grant); deciding about another session's work (its line, plan or branch) | do all other work first, ask, and wait: silence is no consent, and only an answer that names the action and its target clears it |
 | G. {ACCESS} | a credential or grant no tool supplies | take every route that needs none first, then ask once, naming what it unlocks |
 
 A grant is read from the user's prompt and recorded for the session; "artık
 bana sor", "ask me again" or a later "don't push" lifts it. The batch is one
 block in the reply language: one "{APPROVAL_HEADING}" heading, one line saying
-the work proceeds on the defaults when no answer comes, then numbered items -
+the work proceeds on the defaults when no answer comes (a class-F item waits for its answer), then numbered items -
 the question in bold, one line of context, "{RECOMMENDED}:" the default, and
 the other option. Class-F items come first, marked as waiting; the defaulted
 items follow, with no count cap, because they do not block. An ask tool (omp
@@ -415,7 +425,10 @@ Routing: `{ROUTE_BIN} "<brief>"` names the worker - tezgah-cheap, -standard or
 never the host's generic task agent (overrides for stored data, credentials,
 security first; then a Jev judgement; the static phase table with no key). A report missing an output field, or an
 `ESCALATE:`, gets one narrower re-brief of the same role naming that field or judgement; only a second miss is
-restarted on tezgah-frontier with the original brief, never continued; the main thread never switches model (the cache is per model). A
+restarted on tezgah-frontier with the original brief, never continued; the main thread never switches model (the cache is per model).
+A subagent's question only the owner can answer (a class-F item, `ESCALATE: owner`) is relayed to
+the user in the approval batch: the orchestrator never answers it for the user
+and never escalates it to a stronger model. A
 code-discovery brief names codegraph's tools (`codegraph callers`, `callees`,
 `impact`, `node`, `files`, `codegraph_explore`) and says "answer from
 the graph, grep only for literal text"; never a grep-only explorer (observed).
@@ -839,7 +852,10 @@ bounded action per step, and while it is in flight its position is restated in
 one line - the todo list is that source, never re-narrate the plan. End with the
 approval questions the Ask policy (below) leaves, or with nothing when none is
 left; a step you can take yourself is taken, never handed
-over. Finish the issue in hand before raising a second one; an error states
+over, and in the host's plan mode, where nothing can run, the plan is the
+deliverable: its approval is the question that turn asks and nothing is
+reported as done or tested.
+Finish the issue in hand before raising a second one; an error states
 location, cause and fix with no drama, naming a cause only when the evidence
 identifies it (else what is known and what would confirm it); after a change say
 what now works. A list shows at most five items, ranked, the rest kept in
@@ -904,15 +920,17 @@ lines: item - blocker - evidence - what unblocks it. No blockers: no heading.
 Work and process - the order, "shall I go on", a check, a plan, a consult
 member, a spend within `spend_cap`, a local merge of the session's branch,
 removing its worktree - are taken and stated in one line, never asked; a taste
-or intent fork goes in the batch with a default taken this turn, but building a
-plan this turn wrote waits for the answer. An outward step
+or intent fork goes in the batch with a default taken this turn, but the
+never-default items below wait for the answer. An outward step
 on the user's own remote (push, PR, release, their package) runs on a grant
 ({GRANT_EXAMPLES}), else is asked once. Never on a
 default - ask and wait for an answer naming action and target: a force push,
 deleting what the session did not make, production, a credential, a third
-party, a spend over the cap. The batch: one "{APPROVAL_HEADING}" heading, waiting
+party, a spend over the cap, building a plan this turn wrote, picking a
+recommended variant, a way around a tezgah refusal, another session's work. The batch: one "{APPROVAL_HEADING}" heading, waiting
 items first, each numbered item with "{RECOMMENDED}:" its default; an ask tool
-sets a recommended option.
+sets a recommended option. No fresh subagent, no review verdict: say so and
+ask. Contest a finding only with a file:line; never lower a severity.
 **Say what a number was measured on.** A figure produced by a fixture - a temp
 HOME, a generated repository, a stand-in, a hand-written sample - is evidence
 about the code path, never a property of the running system, and it is reported
@@ -1117,7 +1135,9 @@ edit one file - and say which. The todo list is the step queue: dispatch every
 ready step at once and mark each one blocked on its slice, never `wait` while
 a step is ready, and once every open step is blocked on a running slice,
 `wait` or end the turn. A subagent does its own slice and
-never fans out again. Off: `orchestrate-off`.
+never fans out again; its question only the owner can answer (a never-default
+item) goes to the user in the approval batch, never answered by the
+orchestrator or escalated to a stronger model. Off: `orchestrate-off`.
 
 **Kill switches:** each one removes its own rule from this text, not just the
 status mark. `~/.config/tezgah/`: `exec-mode.off`, `orchestrate-off`,
@@ -1187,7 +1207,9 @@ irreversible calls; done/tested claims need observed
 evidence -> the gate denies a neutered check (`--no-verify`, `|| true`, a new
 test skip) and the Stop hook on Claude/Codex/Cursor/omp blocks an unverified
 "done"; never end on a question you can decide - ask only in one batch, each
-with a recommended default; leftover work is done now, not listed - only a {DECISION}/{ACCESS}/{IRREVERSIBLE}/{ENV}
+with a recommended default; a research/analysis/review recommendation, a way around a
+tezgah refusal and another session's work wait for the owner's answer;
+leftover work is done now, not listed - only a {DECISION}/{ACCESS}/{IRREVERSIBLE}/{ENV}
 blocker with its evidence goes under "{BLOCKERS_HEADING}"; no
 AI/model attribution in any persisted or published artifact. Full
 detail: the tezgah-contract skill.{PONY_LEVEL} Kill switches under ~/.config/tezgah/.

package/hooks/tezgah_replay.py

@@ -469,6 +469,9 @@ def build_corpus(cutoff, since=None):
                     "live_rule": rule_of(detail) if kind == "deny"
                     else detail.split(":", 1)[1].strip() if kind == "claim"
                     and detail.startswith("blocked:") else None,
+                    # the host's permission mode, written on the row of a
+                    # read-only turn only (plan 142): the verdict depended on it
+                    "mode": row.get("mode"),
                     "tool": row.get("tool"), "join": None}
             if kind == "claim":
                 replies = [{"ts": ts, "text": text, "cwd": where} for ts, text, where in
@@ -586,8 +589,11 @@ def _replay_one(it, prefix, tg, seen, live_events):
 
             ti.events = events
             try:
-                cls, _reason = ti._stop_block(it["text"], it["sid"], rows=turn,
-                                              cwd=it["cwd"])
+                # a plan-mode turn is judged as one (plan 142): the mode rides
+                # the claim row this item came from
+                cls, _reason = ti._stop_block(
+                    it["text"], it["sid"], rows=turn, cwd=it["cwd"],
+                    read_only=ti.read_only_turn(it.get("mode")))
             finally:
                 ti.events = live_events
             out.update(replay="block" if cls else "allow", rule=cls,

package/hooks/tezgah_research.py

@@ -143,7 +143,7 @@ SOURCE_CLASSES = ("formal", "grey", "agent-report")
 # that owes no variants), 6 the selection warnings (`_check_selection`: the
 # held-out set, repeats per arm, the noise band), 7 the exploratory method (an
 # arena locked before the first idea, the idea/stage/tournament rows and their
-# rules, `_check_exploratory`). A `rules` above `EVIDENCE_RULES` is
+# rules, `_check_exploratory`). A `rules` above `RULES` is
 # a line a later tezgah wrote, and every reader and writer here refuses it by name
 # (`newer_rules`) rather than judging it by rules it does not know.
 STANDARDS_RULES = 2
@@ -152,10 +152,13 @@ SCOPE_RULES = 5
 HOLDOUT_RULES = 6
 EXPLORE_RULES = 7
 # Rules 8 (plan 127): evidence captured by the tool and claims narrowed rather
-# than lines refused. `init` writes it since the plan's last wave moved `RULES`
-# here.
+# than lines refused.
 EVIDENCE_RULES = 8
-RULES = EVIDENCE_RULES
+# Rules 9 (plan 136): a decision.md writes the line's own pick as `recommended:`;
+# `chosen:` is the owner's, recorded by `choose` with an `owner:` line carrying
+# the owner's words. `init` writes 9.
+OWNER_CHOICE_RULES = 9
+RULES = OWNER_CHOICE_RULES
 # How a rules-5 line answers its question. `qualitative` is a source or
 # reference review and owes no metric; `measured` runs experiments and locks
 # one. The question picks it, not the tooling: a qualitative ask answered with a
@@ -362,6 +365,27 @@ def slugs(repo):
     return sorted(seen)
 
 
+def stray_dirs(repo):
+    """[(path, error)] for the hidden dirs under research/, its open/ or its done/:
+    `slugs` skips them, so a line written into one (a `.staging` beside a refusal)
+    is invisible to every check. `status` and the no-slug `check` report each."""
+    out = []
+    for folder in layout_roots(repo):
+        try:
+            names = sorted(os.listdir(folder))
+        except OSError:
+            continue
+        for name in names:
+            path = os.path.join(folder, name)
+            if name.startswith(".") and os.path.isdir(path):
+                rel = os.path.relpath(path, repo)
+                out.append((rel, "%s is not a research line: a line lives under "
+                                 "research/open or research/done; import it with "
+                                 "`tezgah-research init` then move its files, or "
+                                 "delete it" % rel))
+    return out
+
+
 def line_dir(repo, slug):
     """The one resolver: the first layout root that holds the line, else the
     `open/` path a new line is created at."""
@@ -971,6 +995,13 @@ def _check_state(base, errors, warnings, strict):
     _check_derived_phase(base, state.get("phase"), state.get("direction"), warnings)
 
 
+def _verdict_error(sid, verdict):
+    """The error a verdict outside `VERDICTS` gets; `broken_open_lines` builds the
+    same text for a `pending` one, so an in-flight line is told from a broken one."""
+    return "success criterion %s: verdict %r is not one of %s" % (
+        sid, verdict, ", ".join(VERDICTS))
+
+
 def _check_success(state, errors, warnings, strict):
     """The ask contract, on a line that states an ask (rules 3 onward).
 
@@ -1002,8 +1033,7 @@ def _check_success(state, errors, warnings, strict):
         if not sid or not criterion:
             errors.append("a success criterion carries no id or no text")
         if verdict and verdict not in VERDICTS:
-            errors.append("success criterion %s: verdict %r is not one of %s"
-                          % (sid, verdict, ", ".join(VERDICTS)))
+            errors.append(_verdict_error(sid, verdict))
         if verdict in VERDICTS and not evidence:
             errors.append("success criterion %s: a verdict with no evidence "
                           "pointer is an opinion" % sid)
@@ -2828,16 +2858,16 @@ def _state(base):
 def newer_rules(state):
     """The refusal for a line a later tezgah wrote, or None.
 
-    A `rules` above `EVIDENCE_RULES` names rules this code does not implement.
+    A `rules` above `RULES` names rules this code does not implement.
     Reading the line by the rules it does know would pass what the later set
     refuses, and a writer would append rows judged by the older set. So the line
     is refused by name, before any rule reads it."""
     found = _rules(state)
-    if found <= EVIDENCE_RULES:
+    if found <= RULES:
         return None
     return ("state.json rules %d is newer than the rules this tezgah implements (%d): "
             "a later tezgah wrote this line, so it is refused rather than read as if "
-            "current - upgrade tezgah to read or write it" % (found, EVIDENCE_RULES))
+            "current - upgrade tezgah to read or write it" % (found, RULES))
 
 
 def _concluding(base, state):
@@ -3244,6 +3274,34 @@ def _mentions(token, text):
     return re.search(r"(?<![\w.-])%s(?![\w.-])" % re.escape(token), text) is not None
 
 
+# A decision.md's pick: `chosen:` is the owner's, `recommended:` the line's own
+# (rules 9); every reader takes `chosen:` when present, else `recommended:`.
+PICK = r"(?im)^\W*%s\W*:\s*`?([\w.-]+)"
+# The `owner:` line `choose` writes: a date and the owner's words, quoted.
+OWNER_WORDS = re.compile(r'(?im)^\W*owner\W*:[^\n]*"[^"\n]*\S[^"\n]*"')
+
+
+def decision_pick(body):
+    """(variant, "chosen" or "recommended") for a decision.md body, else (None, None)."""
+    for field in ("chosen", "recommended"):
+        found = re.search(PICK % field, body)
+        if found:
+            return found.group(1), field
+    return None, None
+
+
+def line_pick(body):
+    """The line's own pick, which the line's rules judge (rejected variants,
+    dominance, post-hoc): `recommended:`, else a `chosen:` with no owner's words.
+    An owner's `chosen:` is the owner's call, so a dominated or post-hoc owner
+    choice is never the line's error."""
+    found = re.search(PICK % "recommended", body)
+    if found:
+        return found.group(1)
+    found = re.search(PICK % "chosen", body)
+    return found.group(1) if found and not OWNER_WORDS.search(body) else None
+
+
 def _check_decision(repo, base, name, ddir, need, errors, warnings, strict, git,
                     concluding):
     label = "decisions/%s" % name
@@ -3327,13 +3385,19 @@ def _check_decision(repo, base, name, ddir, need, errors, warnings, strict, git,
               "says what ruled it out" % label)
         return
     body = _note_text(os.path.join(ddir, "decision.md"))
-    found = re.search(r"(?im)^\W*chosen\W*:\s*`?([\w.-]+)", body)
-    chosen = found.group(1) if found else None
+    chosen, field = decision_pick(body)
     if chosen not in produced:
         errors.append("%s: decision.md chosen %r is not a produced variant"
                       % (label, chosen))
+    if field == "chosen" and _rules(_state(base)) >= OWNER_CHOICE_RULES \
+            and not OWNER_WORDS.search(body):
+        errors.append("%s: decision.md chosen %s names no owner choice: the line "
+                      "writes recommended:, and the owner's pick is recorded with "
+                      "tezgah-research choose" % (label, chosen))
+    pick = line_pick(body)
+    owned = chosen if field == "chosen" and OWNER_WORDS.search(body) else None
     for vid in produced:
-        if vid == chosen:
+        if vid in (pick, owned):
             continue
         lines = [line for line in body.splitlines() if _mentions(vid, line)]
         if not any(_mentions(cid, line) for line in lines for cid in criteria):
@@ -3342,12 +3406,12 @@ def _check_decision(repo, base, name, ddir, need, errors, warnings, strict, git,
     if not re.search(r"(?im)^\W*flip\W*:", body):
         errors.append("%s: decision.md names no `flip:` condition - the result that "
                       "would reverse the choice" % label)
-    if chosen in produced:
-        better = dominated_by(chosen, produced, criteria, cells)
+    if pick in produced:
+        better = dominated_by(pick, produced, criteria, cells)
         if better:
             errors.append("%s: the chosen variant %s is dominated by %s, which is at "
                           "least as good on every criterion and better on one"
-                          % (label, chosen, better))
+                          % (label, pick, better))
 
 
 def _deliverable_path(state):
@@ -4534,12 +4598,12 @@ def _core_rules8(repo, slug, base, state, errors, warnings, strict, git, steps,
     if git:
         for name, ddir in _decision_dirs(base):
             body = _note_text(os.path.join(ddir, "decision.md"))
-            found = re.search(r"(?im)^\W*chosen\W*:\s*`?([\w.-]+)", body)
-            if found and found.group(1) in _post_hoc(repo, ddir) \
+            picked = line_pick(body)
+            if picked and picked in _post_hoc(repo, ddir) \
                     and "post-hoc" not in body and "post_hoc" not in body:
                 errors.append("decisions/%s: decision.md chooses %s, a variant first "
                               "committed after the first comparison cell, without saying "
-                              "post-hoc" % (name, found.group(1)))
+                              "post-hoc" % (name, picked))
         related = {(str(r.get("line")), str(r.get("claim")))
                    for r in _row_objects(os.path.join(base, "related.jsonl"))
                    if r.get("relation") in ("builds-on", "dismissed")}
@@ -4734,8 +4798,11 @@ def check(repo, slug=None, git=True, strict=False, all_lines=True, code=None, fl
     With `all_lines=False` and no slug, a line under `done/` is read by its order
     seal alone (`done_seal`), not re-checked, and appears only when that read
     fails: the default no-slug `check` and the session note report the open
-    lines, and `check --all-lines` re-runs the closed ones (ADR 015)."""
-    out = {}
+    lines, and `check --all-lines` re-runs the closed ones (ADR 015). With no
+    slug, each hidden dir under research/ (`stray_dirs`) is a row of its own,
+    keyed by its path."""
+    out = {} if slug else {path: {"errors": [error], "warnings": []}
+                           for path, error in stray_dirs(repo)}
     for name in ([slug] if slug else slugs(repo)):
         if not slug and not all_lines and sealed(repo, name):
             errors = done_seal(repo, name)[0]
@@ -5044,14 +5111,14 @@ def import_line(repo, source, slug=None, allow_open=None, date=""):
     unfinished = open_lines(repo) if arriving else []
     if (unfinished or len(arriving) > 1) and allow_open is None:
         return [], ("%s would open beside unfinished line(s) %s; say why with "
-                    "--allow-open \"<reason>\"" % (
+                    "--allow-open \"<reason>\"; %s" % (
                         ", ".join(arriving),
                         "; ".join("%s (%s)" % (n, "; ".join(r)) for n, r in unfinished)
-                        or ", ".join(arriving)))
+                        or ", ".join(arriving), OWNER_ASK))
     broken = broken_open_lines(repo) if unfinished else []
     if broken:
         return [], ("--allow-open does not open a line beside an open line check "
-                    "refuses: %s" % ", ".join(n for n, _e in broken))
+                    "refuses: %s; %s" % (", ".join(n for n, _e in broken), OWNER_ASK))
     if fresh:
         done = tp.ws_git(repo, "commit", "-q", "--allow-empty", "-m",
                          "research: workspace root")
@@ -5179,10 +5246,16 @@ def _variants_owed(base, state):
 def broken_open_lines(repo):
     """[(slug, errors)] for the open lines `check` refuses: what `init
     --allow-open` will not open a new line beside, because a hatch past broken
-    lines is how they stayed broken."""
+    lines is how they stayed broken. A criterion whose verdict is still
+    `pending` is a line in flight, not a broken one, so that error alone does
+    not block: another session may be running the line."""
     out = []
     for slug, _reasons in open_lines(repo):
         errors, _ = check_line(repo, slug)
+        pending = {_verdict_error(sid, verdict) for sid, _c, verdict, _e
+                   in success_rows(line_state(repo, slug).get("success"))
+                   if verdict == "pending"}
+        errors = [e for e in errors if e not in pending]
         if errors:
             out.append((slug, errors))
     return out
@@ -5295,6 +5368,75 @@ def conclude_line(repo, slug, date=""):
     return ([problem] if problem else []), state
 
 
+# The line every refusal over open lines carries (`init`, `import`): deciding
+# about another session's work (its line, plan or branch) is the owner's.
+OWNER_ASK = ("a line another session is running is not this session's to fix or "
+             "close: stop and ask the owner (a decision only the owner makes), never "
+             "a way around a tezgah refusal (another folder, a hidden dir)")
+
+
+def choose_line(repo, slug, decision, variant, ack, date=""):
+    """The problem that stopped the owner's choice being written, or None.
+
+    A line recommends; the owner chooses (rules 9). `chosen: <variant>` and
+    `owner: <date> "<words>"` replace any earlier pair in the decision's
+    decision.md; the line's own pick stays as written, and a pick a rules-8 line
+    wrote as `chosen:` is renamed `recommended:`. log.md gets one line. A done
+    line takes it too: its order seal hashes the experiments alone, so the
+    decision note stays writable."""
+    words = " ".join(str(ack or "").replace('"', "'").split())
+    if not words:
+        return ("choose needs --ack \"<the owner's words>\": choosing a variant or "
+                "option a research, analysis or review recommends is the owner's call")
+    base = line_dir(repo, slug)
+    newer = newer_rules(_state(base))
+    if newer:
+        return newer
+    ddir = dict(_decision_dirs(base)).get(decision)
+    path = os.path.join(ddir or "", "decision.md")
+    if not ddir or not os.path.isfile(path):
+        return "decisions/%s has no decision.md in %s" % (decision, slug)
+    _criteria, variants, _problems = load_decision(ddir)
+    produced = sorted(v for v, row in variants.items() if row.get("status") == "produced")
+    if variant not in produced:
+        return "variant %s is not produced in decisions/%s (produced: %s)" % (
+            variant, decision, ", ".join(produced) or "none")
+    body = _note_text(path)
+    replace = OWNER_WORDS.search(body) or re.search(PICK % "recommended", body)
+    kept = []
+    for line in body.splitlines():
+        if re.match(r"(?i)\W*owner\W*:", line):
+            continue
+        if re.match(r"(?i)\W*chosen\W*:", line):
+            if replace:
+                continue
+            # the line wrote its own pick as `chosen:` (rules 8): it stays the
+            # line's pick, for the line's rules to judge
+            line = re.sub(r"(?i)chosen", "recommended", line, count=1)
+        kept.append(line)
+    try:
+        with open(path, "w", encoding="utf-8") as fh:
+            fh.write("\n".join(kept + ["chosen: %s" % variant,
+                                       'owner: %s "%s"' % (date, words)]) + "\n")
+        with open(os.path.join(base, "log.md"), "a", encoding="utf-8") as fh:
+            fh.write('- %s owner chose %s in decisions/%s: "%s"\n'
+                     % (date, variant, decision, words))
+    except OSError as exc:
+        return str(exc)
+    return None
+
+
+def owner_waits(repo, slug):
+    """[(decision, variant)] for each decision.md that recommends a variant and
+    records no owner choice: what `conclude` tells the session to report."""
+    out = []
+    for name, ddir in _decision_dirs(line_dir(repo, slug)):
+        picked, field = decision_pick(_note_text(os.path.join(ddir, "decision.md")))
+        if field == "recommended":
+            out.append((name, picked))
+    return out
+
+
 def open_lines(repo):
     """[(slug, [reason, ...])] for every line that is not finished, for `init`.
 
@@ -5353,6 +5495,7 @@ def summary(repo):
         if fixtures:
             note += ", %d fixture-scoped claim(s): %s" % (len(fixtures), ", ".join(fixtures))
         out.append("%s: %s" % (slug, note))
+    out.extend("FAIL %s" % error for _path, error in stray_dirs(repo))
     unfinished = open_note(repo)
     if unfinished:
         out.append(unfinished)