riskrails 4.1.0 → 4.3.0

package/skills/ai-task/rr_state/memory_cmd.py

@@ -1,4 +1,4 @@
-"""memory_cmd: the `memory` and `recall` commands over the memory_store and memory_sync modules -- the actions, the human's route, the risk record.
+"""memory_cmd: the `memory` and `recall` commands over the memory_store module and the owner modules memory_io, memory_config, memory_verify, memory_hook, memory_risks, memory_cleanup, memory_migrate, memory_export and memory_status -- the actions, the human's route, the risk record.
 
 shell: memory_modules, memory_config, memory_human, memory_confirm, cmd_recall, cmd_memory, memory_status, memory_enable, memory_disable, memory_export, memory_verify, memory_show, memory_search, risk_scope, memory_risk, memory_risks, memory_migrate, memory_rebuild, memory_cleanup, memory_restore, memory_pack, memory_redact
 core: MEMORY_ACTIONS
@@ -9,6 +9,7 @@ import json
 import os
 import shlex
 import sys
+import types
 
 from rr_state import fs, journal, task
 from rr_state import dialog as rr_dialog
@@ -22,19 +23,31 @@ except ImportError:                       # an old install that shipped state.py
 
 
 def memory_modules():
-    """memory_sync and memory_store, imported only by the commands that use them."""
+    """The owner modules of the memory commands as one namespace (mem.io, mem.config, mem.verify, mem.hook,
+    mem.risks, mem.cleanup, mem.migrate, mem.export, mem.status -- each name is read on its owner at call time)
+    and memory_store, imported only by the commands that use them."""
     try:
         import memory_store               # pylint: disable=import-outside-toplevel
-        import memory_sync                # pylint: disable=import-outside-toplevel
+        import memory_cleanup as cleanup  # pylint: disable=import-outside-toplevel
+        import memory_config as config  # pylint: disable=import-outside-toplevel
+        import memory_export as export  # pylint: disable=import-outside-toplevel
+        import memory_hook as hook  # pylint: disable=import-outside-toplevel
+        import memory_io as io  # pylint: disable=import-outside-toplevel
+        import memory_migrate as migrate  # pylint: disable=import-outside-toplevel
+        import memory_risks as risks  # pylint: disable=import-outside-toplevel
+        import memory_status as status  # pylint: disable=import-outside-toplevel
+        import memory_verify as verify  # pylint: disable=import-outside-toplevel
     except ImportError as exc:
         fs.die("the memory modules are not installed beside state.py (%s)" % exc, 2)
-    return memory_sync, memory_store
+    mem = types.SimpleNamespace(cleanup=cleanup, config=config, export=export, hook=hook, io=io, migrate=migrate,
+                                risks=risks, status=status, verify=verify)
+    return mem, memory_store
 
 
-def memory_config(sync, root):
+def memory_config(mem, root):
     try:
-        return sync.load_config(root)
-    except sync.MemoryError_ as exc:
+        return mem.config.load_config(root)
+    except mem.io.MemoryError_ as exc:
         fs.die(str(exc), exc.code)
     return None
 
@@ -62,8 +75,8 @@ def memory_confirm(cfg, name, what):
 def cmd_recall(args, root, rt=rr_runtime.Runtime()):
     """R10: the open risks, residual findings, decisions, scope changes and task
     one-liners that touch these files, within the budget. Read-only."""
-    sync, store = memory_modules()
-    cfg = memory_config(sync, root)
+    mem, store = memory_modules()
+    cfg = memory_config(mem, root)
     files = fs._split_files(args.files)
     if not files:
         fs.die("recall needs --files \"a,b,dir/**\"", 2)
@@ -82,45 +95,49 @@ def cmd_recall(args, root, rt=rr_runtime.Runtime()):
 
 
 def cmd_memory(args, root, rt=rr_runtime.Runtime()):
-    sync, store = memory_modules()
+    mem, store = memory_modules()
     action = args.memory_action
     try:
-        MEMORY_ACTIONS[action](args, root, sync, store, rt=rt)
-    except sync.MemoryError_ as exc:
+        MEMORY_ACTIONS[action](args, root, mem, store, rt=rt)
+    except mem.io.MemoryError_ as exc:
         fs.die(str(exc), exc.code)
 
 
-def memory_status(args, root, sync, _store, rt=rr_runtime.Runtime()):
-    lines = sync.status_lines(root)
+def memory_status(args, root, mem, _store, rt=rr_runtime.Runtime()):
+    lines = mem.status.status_lines(root)
     if args.json:
         print(json.dumps(dict(line.split(": ", 1) for line in lines), ensure_ascii=False, sort_keys=True))
         return
     print("\n".join(lines))
 
 
-def memory_enable(args, root, sync, _store, rt=rr_runtime.Runtime()):
+def memory_enable(args, root, mem, _store, rt=rr_runtime.Runtime()):
     if memory_human(root, "enable", allow_dialog=True, rt=rt) == "dialog":
         pick = rr_dialog.pick_data(rr_dialog.DIALOG_PICK[0])
         print("memory: via dialog (consent %s, decision %s)" % (pick["consent"], pick["decision"]))
-    hook = sync.enable(root, args.author, args.period, args.index)
-    print("memory: packages mode on (%s); every teammate's next close exports" % sync.POLICY_REL)
-    print("pre-push: %s" % hook)
+    hook = mem.hook.enable(root, args.author, args.period, args.index, args.share)
+    print("memory: packages mode on (%s); every teammate's next close exports" % mem.io.POLICY_REL)
+    if hook == "local":
+        print("record: local — .ai/memory/ and .ai/reports/ are git-ignored; 'state.py memory enable --share git' "
+              "in your own terminal shares them through git and checks pushes")
+    else:
+        print("pre-push: %s" % hook)
     if hook in ("foreign", "hookspath"):
         print("not written — %s. Add these lines to your own pre-push hook:\n%s" % (
-            "core.hooksPath is set" if hook == "hookspath" else "a pre-push hook exists", sync.snippet_text()))
-    print("\n".join(sync.status_lines(root)))
+            "core.hooksPath is set" if hook == "hookspath" else "a pre-push hook exists", mem.hook.snippet_text()))
+    print("\n".join(mem.status.status_lines(root)))
 
 
-def memory_disable(_args, root, sync, _store, rt=rr_runtime.Runtime()):
+def memory_disable(_args, root, mem, _store, rt=rr_runtime.Runtime()):
     memory_human(root, "disable", rt=rt)
-    print("memory: files mode; packages and local data kept; pre-push: %s" % sync.disable(root))
+    print("memory: files mode; packages and local data kept; pre-push: %s" % mem.hook.disable(root))
 
 
-def memory_export(args, root, sync, _store, rt=rr_runtime.Runtime()):
-    cfg = memory_config(sync, root)
+def memory_export(args, root, mem, _store, rt=rr_runtime.Runtime()):
+    cfg = memory_config(mem, root)
     ids = "pending" if args.pending or not args.ids else [task.valid_task_id(t, "ID") for t in args.ids]
-    result = sync.export(root, ids, cfg)
-    for line in sync.record_lines(result):
+    result = mem.export.export(root, ids, cfg)
+    for line in mem.export.record_lines(result):
         print(line)
     print("exported: +%d entries%s" % (result.added, "" if result.added else " — nothing pending"))
     for task_id, why in result.failures:
@@ -129,36 +146,39 @@ def memory_export(args, root, sync, _store, rt=rr_runtime.Runtime()):
         sys.exit(1)
 
 
-def memory_verify(args, root, sync, _store, rt=rr_runtime.Runtime()):
+def memory_verify(args, root, mem, _store, rt=rr_runtime.Runtime()):
     stats = None
     if args.range:
         if ".." not in args.range:
             fs.die("--range takes OLD..NEW", 2)
         old, new = args.range.split("..", 1)
-        findings, stats = sync.validate_range(root, sync.rev(root, old), sync.rev(root, new) or new, local=False)
+        findings, stats = mem.verify.validate_range(root, mem.verify.rev(root, old), mem.verify.rev(root, new) or new, local=False)
         findings = findings or []
     elif args.fresh_clone:
-        findings = sync.verify_fresh_clone(root)
+        if not mem.io.shared(root):
+            fs.die("the record is local (.ai/memory/ is git-ignored): a fresh clone has none — "
+                   "'state.py memory enable --share git' shares it", 2)
+        findings = mem.verify.verify_fresh_clone(root)
     else:
-        findings = sync.verify(root, "all", [task.valid_task_id(t, "ID") for t in args.ids] or None)
+        findings = mem.verify.verify(root, "all", [task.valid_task_id(t, "ID") for t in args.ids] or None)
     failing = [f for f in findings if not f.check.endswith("-warn")]
     if args.json:
         print(json.dumps({"findings": [f._asdict() for f in findings], "ok": not failing, "stats": stats},
                          ensure_ascii=False, sort_keys=True))
     else:
         for f in findings:
-            print(sync.format_finding(f))
+            print(mem.verify.format_finding(f))
         print("memory verify: %s" % ("ok" if not failing else "%d finding(s)" % len(failing)))
     if failing:
         sys.exit(1)
 
 
-def memory_show(args, root, sync, _store, rt=rr_runtime.Runtime()):
-    print("\n".join(sync.show(root, task.valid_task_id(args.id, "ID"), "json" if args.json else "md", args.entry)))
+def memory_show(args, root, mem, _store, rt=rr_runtime.Runtime()):
+    print("\n".join(mem.status.show(root, task.valid_task_id(args.id, "ID"), "json" if args.json else "md", args.entry)))
 
 
-def memory_search(args, root, sync, store, rt=rr_runtime.Runtime()):
-    cfg = memory_config(sync, root)
+def memory_search(args, root, mem, store, rt=rr_runtime.Runtime()):
+    cfg = memory_config(mem, root)
     filters = {"kind": args.kind, "by": args.by, "task": args.task, "since": args.since, "until": args.until,
                "files": fs._split_files(args.file) or None}
     history = store.open_history(root, cfg)
@@ -187,8 +207,8 @@ def risk_scope(state):
             6)
 
 
-def memory_risk(args, root, sync, store, rt=rr_runtime.Runtime()):
-    cfg = memory_config(sync, root)
+def memory_risk(args, root, mem, store, rt=rr_runtime.Runtime()):
+    cfg = memory_config(mem, root)
     state = task.in_flight(root, rt=rt)
     if args.risk_action == "add":
         where = fs._split_files(args.where)
@@ -199,17 +219,17 @@ def memory_risk(args, root, sync, store, rt=rr_runtime.Runtime()):
         if not cfg.packages:
             risk_scope(state)
             found = "%s, by %s" % (fs.now()[:10], state["task_id"] if state else "no task")
-            rkey = sync.risk_add_files(root, args.title, where, args.label, args.what, args.likely, args.fix,
+            rkey = mem.risks.risk_add_files(root, args.title, where, args.label, args.what, args.likely, args.fix,
                                        args.status, found)
             print("risk: %s added to .ai/project/known-risks.md" % rkey)
             return
-        data = sync.risk_data(args.title, where, args.label, args.what, args.likely, args.fix, args.status)
+        data = mem.risks.risk_data(args.title, where, args.label, args.what, args.likely, args.fix, args.status)
     else:
         if args.status not in ("fixed", "accepted", "ticketed"):
             fs.die("--status takes fixed, accepted or ticketed", 2)
         if not cfg.packages:
             risk_scope(state)
-            sync.risk_close_files(root, args.rkey, args.status, args.why)
+            mem.risks.risk_close_files(root, args.rkey, args.status, args.why)
             print("risk: %s is %s" % (args.rkey, args.status))
             return
         history = store.FileHistory(root, cfg)
@@ -217,7 +237,7 @@ def memory_risk(args, root, sync, store, rt=rr_runtime.Runtime()):
         if not found:
             fs.die("no risk %s ('state.py memory risks --status all')" % args.rkey, 1)
         last = found[0]
-        data = sync.risk_data(last["title"], last.get("where"), last.get("label"), last.get("what"),
+        data = mem.risks.risk_data(last["title"], last.get("where"), last.get("label"), last.get("what"),
                               last.get("likelihood"), last.get("fix"), args.status, args.why, last["rid"])
     if state:
         state = task.load(root, rt=rt)
@@ -225,12 +245,12 @@ def memory_risk(args, root, sync, store, rt=rr_runtime.Runtime()):
         task.save(root, state)
         print("risk: %s recorded in %s's journal (exported at close)" % (data["rkey"], state["task_id"]))
         return
-    entry = sync.standalone_risk(root, cfg, data, rt.name)
+    entry = mem.risks.standalone_risk(root, cfg, data, rt.name)
     print("risk: %s recorded (%s)" % (data["rkey"], entry["rid"]))
 
 
-def memory_risks(args, root, sync, store, rt=rr_runtime.Runtime()):
-    cfg = memory_config(sync, root)
+def memory_risks(args, root, mem, store, rt=rr_runtime.Runtime()):
+    cfg = memory_config(mem, root)
     risks = store.open_history(root, cfg).risks(args.status)
     if args.json:
         for e in risks:
@@ -253,57 +273,57 @@ def memory_risks(args, root, sync, store, rt=rr_runtime.Runtime()):
                                           e.get("title"), e.get("rkey")))
 
 
-def memory_migrate(args, root, sync, _store, rt=rr_runtime.Runtime()):
-    cfg = memory_config(sync, root)
+def memory_migrate(args, root, mem, _store, rt=rr_runtime.Runtime()):
+    cfg = memory_config(mem, root)
     if args.move_logs:
         memory_human(root, "migrate --move-logs", rt=rt)
         memory_confirm(cfg, args.confirm_delete, "migrate --move-logs")
-        moved, command = sync.move_logs(root)
+        moved, command = mem.migrate.move_logs(root)
         print("moved %d committed log(s) into .ai/state/logs/<id>/legacy/; now, as its own commit (C3):\n  %s"
               % (len(moved), command))
         return
     if args.apply:
-        print("\n".join(sync.migrate_apply(root, risks=args.risks)))
+        print("\n".join(mem.migrate.migrate_apply(root, risks=args.risks)))
         return
-    report = sync.migrate_report(root)
+    report = mem.migrate.migrate_report(root)
     print("report: %s (%d lines) — read it, then 'state.py memory migrate --apply'"
-          % (os.path.join(sync.LOCAL_REL, "migration-report.md"), report.count("\n")))
+          % (os.path.join(mem.io.LOCAL_REL, "migration-report.md"), report.count("\n")))
 
 
-def memory_rebuild(_args, root, sync, store, rt=rr_runtime.Runtime()):
-    cfg = memory_config(sync, root)
+def memory_rebuild(_args, root, mem, store, rt=rr_runtime.Runtime()):
+    cfg = memory_config(mem, root)
     print("index: rebuilt from %d sources (%s)" % (store.SqliteHistory(root, cfg).rebuild(), store.INDEX_REL))
 
 
-def memory_cleanup(args, root, sync, _store, rt=rr_runtime.Runtime()):
-    cfg = memory_config(sync, root)
+def memory_cleanup(args, root, mem, _store, rt=rr_runtime.Runtime()):
+    cfg = memory_config(mem, root)
     memory_human(root, "cleanup", rt=rt)
     memory_confirm(cfg, args.confirm_delete, "cleanup")
     if not args.all and not args.ids:
         fs.die("memory cleanup takes IDs or --all", 2)
-    print("\n".join(sync.cleanup(root, "all" if args.all else [task.valid_task_id(t, "ID") for t in args.ids])))
+    print("\n".join(mem.cleanup.cleanup(root, "all" if args.all else [task.valid_task_id(t, "ID") for t in args.ids])))
 
 
-def memory_restore(args, root, sync, _store, rt=rr_runtime.Runtime()):
+def memory_restore(args, root, mem, _store, rt=rr_runtime.Runtime()):
     if not args.all and not args.ids:
         fs.die("memory restore takes IDs or --all", 2)
-    print("\n".join(sync.restore(root, "all" if args.all else [task.valid_task_id(t, "ID") for t in args.ids])))
+    print("\n".join(mem.cleanup.restore(root, "all" if args.all else [task.valid_task_id(t, "ID") for t in args.ids])))
 
 
-def memory_pack(args, root, sync, _store, rt=rr_runtime.Runtime()):
-    cfg = memory_config(sync, root)
+def memory_pack(args, root, mem, _store, rt=rr_runtime.Runtime()):
+    cfg = memory_config(mem, root)
     memory_human(root, "pack", rt=rt)
     memory_confirm(cfg, args.confirm_delete, "pack")
-    target, removed, count = sync.pack(root, args.period)
-    print("pack: %s (%d records; %d batch(es) removed)" % (os.path.join(sync.MEMORY_REL, target), count,
+    target, removed, count = mem.cleanup.pack(root, args.period)
+    print("pack: %s (%d records; %d batch(es) removed)" % (os.path.join(mem.io.MEMORY_REL, target), count,
                                                           len(removed)))
 
 
-def memory_redact(args, root, sync, _store, rt=rr_runtime.Runtime()):
+def memory_redact(args, root, mem, _store, rt=rr_runtime.Runtime()):
     via = memory_human(root, "redact", rt=rt)
-    rid, name = sync.redact(root, args.rid, args.field, args.why, by="%s via %s" % (os.environ.get("USER") or
+    rid, name = mem.cleanup.redact(root, args.rid, args.field, args.why, by="%s via %s" % (os.environ.get("USER") or
                                                                                    "unknown", via))
-    print("redacted: %s in %s (new rid %s)" % (args.field, os.path.join(sync.MEMORY_REL, name), rid))
+    print("redacted: %s in %s (new rid %s)" % (args.field, os.path.join(mem.io.MEMORY_REL, name), rid))
 
 
 MEMORY_ACTIONS = {"status": memory_status, "enable": memory_enable, "disable": memory_disable,

package/skills/ai-task/rr_state/questions_cmd.py

@@ -280,10 +280,11 @@ def close_gate_from_file(root, state, question, by, rt=rr_runtime.Runtime()):
         state.update(fresh)
         seen, why = (True, "") if unattended else dialog.human_turn(root, state)
         if not seen:
-            fs.die("APPROVAL_REFUSED — %s. Fill the answer, tell the session, and sync again, or run "
-                "in your own terminal:\n  python3 %s --root %s approve --by %s"
-                % (why, shlex.quote(fs.ENTRY), shlex.quote(root),
-                   shlex.quote(by)), 5)
+            cmd = "python3 %s --root %s approve --by %s" % (shlex.quote(fs.ENTRY), shlex.quote(root), shlex.quote(by))
+            asked = dialog.human_refusal("'state.py approve'", cmd, why, dialog.open_approval_id(root, rt=rt))
+            fs.die(asked + " Or fill the [Answer]: line, tell the session, and sync again." if asked else
+                   "APPROVAL_REFUSED — %s. Fill the answer, tell the session, and sync again, or run "
+                   "in your own terminal:\n  %s" % (why, cmd), 5)
         approved = question["choice"] == "A"
         session = fs.read_session(root)
         task.claim_runtime(root, state, rt=rt)

package/skills/ai-task/rr_state/report.py

@@ -1,14 +1,16 @@
 """report: the text the state is rendered to — the two close facts, the status lines, the schema line, task.md and its writer.
 
-core: md_cell
-shell: two_facts, status_lines, schema_line, task_md_lines, write_task_md
+core: md_cell, waiting_line
+shell: two_facts, pending_questions, waiting_decisions, waiting, status_lines, schema_line, task_md_lines, write_task_md
 """
 import contextlib
+import json
 import os
 import re
 import sys
 
 from rr_state import fs, journal, locks, questions, task
+from rr_state import ledger as rr_ledger
 from rr_state import policy as rr_policy   # status_lines names a local `policy`, as state.py does
 
 # weight.py and sensors.py sit beside state.py; the entry puts that directory on sys.path.
@@ -73,20 +75,81 @@ def two_facts(root, state, tree):
         b = (True, "%d changed files, all in the task's files" % len(diff))
     return {"a": a, "b": b, "diff": diff or [], "outside": outside, "documents": documents}
 
+def pending_questions(root, state):
+    """The ids the status shows as pending: the cache, and for schema 7 `## Questions`
+    as the file has it (the cache lags a hand-filled [Answer]:, as guard_pending reads it)
+    plus an open gate's id."""
+    pending = ((state or {}).get("questions") or {}).get("pending") or []
+    if task.is_v7(state):
+        with contextlib.suppress(OSError, ValueError, KeyError):
+            _, asked = questions.parse_questions(fs.questions_path(root, state, None))
+            gate_id = task.open_gate(state)
+            pending = [q["id"] for q in asked if (q["kind"] != "G" and questions.is_pending(q)) or q["id"] == gate_id]
+    return pending
+
+
+def waiting_decisions(root):
+    """The open decisions that still wait — dialog.prune_decisions' rule without its
+    writes: not settled, and not every command pick of the latest dialog call used.
+    An unreadable decision.json waits for nobody here; the decision commands say why."""
+    try:
+        with open(fs.decision_path(root), encoding="utf-8") as fh:
+            opened = json.load(fh)["open"]
+    except (OSError, ValueError, KeyError, TypeError, RecursionError):
+        return []
+    ledger = rr_ledger.read_ledger(root)
+    settled = {e.get("decision") for e in ledger if e["type"] == "settle"}
+    used = {e.get("id") for e in ledger if e["type"] == "use"}
+    rounds = rr_ledger.latest_rounds(ledger)
+    out = []
+    for decision in opened:
+        commands = {o.get("n") for o in decision.get("options") or [] if o.get("kind") == "command"}
+        picks = [e for e in rounds.get(decision.get("id"), []) if e.get("option") in commands]
+        if decision.get("id") not in settled and not (picks and all(p.get("id") in used for p in picks)):
+            out.append(decision)
+    return out
+
+
+def waiting(root, state, pending):
+    """R12: who the task waits on and for what — decisions, then the gate, then questions."""
+    decisions = waiting_decisions(root)
+    gate = task.open_gate(state) if task.is_v7(state) else None
+    asked = [q for q in pending if q != gate]
+    on = "you" if decisions or gate or asked else "agent" if (state or {}).get("task_id") else "nobody"
+    return {"on": on, "decisions": decisions, "gate": gate, "questions": asked}
+
+
+def waiting_line(root, state, wait):
+    """Line 1 of the status, or None with no task in flight and nothing open. When
+    several wait, one line joins them in this order: decisions, the gate, questions."""
+    if wait["on"] == "nobody":
+        return None
+    if wait["on"] == "agent":
+        return "waiting on the agent: %s — %s" % (state.get("stage") or state.get("current_stage") or "?",
+                                                   fs.one_line(state.get("next_action"), 140) or "?")
+    parts = []
+    if wait["decisions"]:
+        parts.append("%s — the dialog ('state.py decision show' sends it again)" % ", ".join(
+            "%s %s" % (d.get("id"), fs.one_line(d.get("header"), 40)) for d in wait["decisions"][:4]))
+    if wait["gate"]:
+        parts.append("gate %s — approve in the dialog ('state.py close' offers it) or in your own terminal"
+                     % wait["gate"])
+    if wait["questions"]:
+        parts.append("%s — answer in the dialog or the chat, or fill [Answer]: in %s" % (
+            ", ".join(map(str, wait["questions"][:4])),
+            os.path.relpath(fs.questions_path(root, state, None), root)))
+    return "waiting on you: " + "; ".join(parts)
+
+
 def status_lines(root, state):
     """≤ 20 lines; read-only (the facts are measured, nothing is written)."""
-    lines = ["root: %s" % root]
+    pending = pending_questions(root, state)
+    head = waiting_line(root, state, waiting(root, state, pending))
+    lines = ([head] if head else []) + ["root: %s" % root]
     if not state or not state.get("task_id"):
         return lines + ["task: none — no task in flight", schema_line(root)]
     events, _ = journal.read_journal(root, state["task_id"])
     last = events[-1] if events else {}
-    pending = (state.get("questions") or {}).get("pending") or []
-    if task.is_v7(state):
-        # The cache lags a hand-filled [Answer]:; the file is the truth, as guard_pending reads it.
-        with contextlib.suppress(OSError, ValueError, KeyError):
-            _, asked = questions.parse_questions(fs.questions_path(root, state, None))
-            gate_id = task.open_gate(state)
-            pending = [q["id"] for q in asked if (q["kind"] != "G" and questions.is_pending(q)) or q["id"] == gate_id]
     lines.append("task: %s — %s" % (state["task_id"], fs.one_line(state.get("goal"), 140)))
     if not task.is_v7(state):
         lines += ["tier: %s · workflow %s · stage %s" % (state.get("risk_tier") or "?", state.get("workflow"),

package/skills/ai-task/rr_state/report_cmd.py

@@ -225,6 +225,8 @@ def cmd_status(args, root, rt=rr_runtime.Runtime()):
                                                                             "operations")}
             out["facts"] = {"a": list(facts["a"]), "b": list(facts["b"]), "tree": tree}
             out["questions_pending"] = len((state.get("questions") or {}).get("pending") or [])
+        wait = report.waiting(root, state, report.pending_questions(root, state))
+        out["waiting"] = dict(wait, decisions=[d.get("id") for d in wait["decisions"]])
         print(json.dumps(out, indent=2, ensure_ascii=False))
         return
     print("\n".join(report.status_lines(root, state)))

package/skills/ai-task/rr_state/review.py

@@ -84,20 +84,24 @@ def cmd_review(args, root, rt=rr_runtime.Runtime()):
     if review["passes"] >= rounds:
         if not args.by:
             report = ["--report", os.path.abspath(args.report)] if args.report and os.path.isfile(args.report) else []
-            dialog.offer_decision(root, state, "human_set", "Review",
-                           "%s\nREVIEW_BUDGET: %d review passes; weight.json allows %d%s. The next verdict is yours."
-                           % (dialog.task_facts(root, state), review["passes"], rounds,
-                              " (%s)" % budget_name if rr_policy.batch_on(state) else ""),
-                           [{"kind": "choice", "effect": "keep", "label": "Keep it open — no verdict now"}] +
-                           [{"kind": "command",
-                             "label": rr_labels.state_label(root, ["review", "--verdict", verdict, "--tier", args.tier] +
-                                                     report + ["--by", rr_labels.human_name(root)])}
-                            for verdict in ("pass", "pass_with_findings", "blockers_open")], "review", rt=rt)
-            fs.die("REVIEW_BUDGET — %d review passes; weight.json allows %d (%s). The next "
-                "verdict is the human's, in their own terminal:\n  python3 %s --root %s review --verdict "
-                "<verdict> --tier %s --by \"<name>\"" % (review["passes"], rounds, budget_name,
-                                                         shlex.quote(fs.ENTRY),
-                                                         shlex.quote(root), args.tier), 6)
+            decision = dialog.offer_decision(
+                root, state, "human_set", "Review",
+                "%s\n%d review passes so far; this task allows %d%s. The next verdict is yours."
+                % (dialog.task_facts(root, state), review["passes"], rounds,
+                   " (%s)" % budget_name if rr_policy.batch_on(state) else ""),
+                [{"kind": "choice", "effect": "keep", "label": "Keep it open — no verdict now"}] +
+                [{"kind": "command",
+                  "label": rr_labels.state_label(root, ["review", "--verdict", verdict, "--tier", args.tier] +
+                                                 report + ["--by", rr_labels.human_name(root)])}
+                 for verdict in ("pass", "pass_with_findings", "blockers_open")], "review", rt=rt)
+            cmd = "python3 %s --root %s review --verdict <verdict> --tier %s --by \"<name>\"" % (
+                shlex.quote(fs.ENTRY), shlex.quote(root), args.tier)
+            asked = dialog.human_refusal("the next review verdict", cmd, "the review budget is spent: %d passes, %d allowed"
+                                         % (review["passes"], rounds), decision and decision["id"])
+            fs.die(("REVIEW_BUDGET — %d review passes; weight.json allows %d (%s).\n%s"
+                    % (review["passes"], rounds, budget_name, asked)) if asked else
+                   "REVIEW_BUDGET — %d review passes; weight.json allows %d (%s). The next verdict is the human's, "
+                   "in their own terminal:\n  %s" % (review["passes"], rounds, budget_name, cmd), 6)
         via, why = dialog.human_route(root, allow_dialog=True, rt=rt)
         if via is None:
             fs.die("APPROVAL_REFUSED — a verdict past the review budget is the human's, from their own "

package/skills/ai-task/rr_state/start.py

@@ -159,15 +159,18 @@ def cmd_start(args, root, rt=rr_runtime.Runtime()):
         if rr_policy.MODES.index(args.mode) < rr_policy.MODES.index(mode):
             via, why = dialog.human_route(root, allow_dialog=True, rt=rt)
             if via is None:
-                dialog.offer_decision(root, None, "human_set", "Mode",
-                               "%s — W %s, the weight says %s.\nLower the mode from %s to %s (by %s)?"
-                               % (fs.one_line(args.goal, 300), result.w, mode, mode, args.mode, args.by),
-                               [{"kind": "choice", "effect": "keep", "label": "Keep mode %s" % mode},
-                                {"kind": "command", "label": labels.state_label(root, sys.argv[1:])}], "start --mode", rt=rt)
-                fs.die("APPROVAL_REFUSED — lowering the mode from %s to %s is a human's decision. Run it in "
-                    "your own terminal:\n  python3 %s --root %s start … --mode %s --by %s\nRefused because %s."
-                    % (mode, args.mode, shlex.quote(fs.ENTRY), shlex.quote(root),
-                       args.mode, shlex.quote(args.by), why), 5)
+                decision = dialog.offer_decision(
+                    root, None, "human_set", "Mode",
+                    "%s\nThe task's weight says mode %s. Lower it to %s (by %s)? A lower mode means lighter checks "
+                    "and a lighter review." % (fs.one_line(args.goal, 300), mode, args.mode, args.by),
+                    [{"kind": "choice", "effect": "keep", "label": "Keep mode %s" % mode},
+                     {"kind": "command", "label": labels.state_label(root, sys.argv[1:])}], "start --mode", rt=rt)
+                cmd = "python3 %s --root %s start … --mode %s --by %s" % (
+                    shlex.quote(fs.ENTRY), shlex.quote(root), args.mode, shlex.quote(args.by))
+                what = "lowering the mode from %s to %s" % (mode, args.mode)
+                fs.die(dialog.human_refusal(what, cmd, why, decision and decision["id"])
+                       or "APPROVAL_REFUSED — %s is a human's decision. Run it in your own terminal:\n  %s\n"
+                       "Refused because %s." % (what, cmd, why), 5)
         override = {"from": mode, "to": args.mode, "by": args.by, "why": args.why, "ts": fs.now()}
         mode = args.mode
     if args.slug is not None:

package/skills/ai-task/rr_state/steps.py

@@ -6,8 +6,9 @@ shell: cmd_step_done_v7, cmd_steps, cmd_batch
 # (uniform cli dispatch: every cmd_* takes rt last, whether it uses it or not)
 import json
 import shlex
+import sys
 
-from rr_state import dialog, fs, handoff, journal, report, task
+from rr_state import dialog, fs, handoff, journal, labels, report, task
 from rr_state import policy as rr_policy   # cmd_batch binds a local `policy`
 from rr_state import runtime as rr_runtime
 
@@ -103,11 +104,18 @@ def cmd_batch(args, root, rt=rr_runtime.Runtime()):
         return
     via = None
     if want:
-        via, why = dialog.human_route(root, rt=rt)
+        via, why = dialog.human_route(root, allow_dialog=True, rt=rt)
         if via is None:
-            fs.die("APPROVAL_REFUSED — turning the batch loop on during a task lowers the rigor, so it is the "
-                "human's. In their own terminal:\n  python3 %s --root %s batch on --by \"<name>\"\nRefused "
-                "because %s." % (shlex.quote(fs.ENTRY), shlex.quote(root), why), 5)
+            decision = dialog.offer_decision(
+                root, state, "human_set", "Batch",
+                "%s\nTurn the batch loop on for this task? It lowers the rigor for the rest of the task: the batch "
+                "budgets replace the standard ones." % dialog.task_facts(root, state),
+                [{"kind": "choice", "effect": "keep", "label": "Keep the standard loop"},
+                 {"kind": "command", "label": labels.state_label(root, sys.argv[1:])}], "batch on", rt=rt)
+            cmd = "python3 %s --root %s batch on --by \"<name>\"" % (shlex.quote(fs.ENTRY), shlex.quote(root))
+            fs.die(dialog.human_refusal("turning the batch loop on during a task", cmd, why, decision and decision["id"])
+                   or "APPROVAL_REFUSED — turning the batch loop on during a task lowers the rigor, so it is the "
+                   "human's. In their own terminal:\n  %s\nRefused because %s." % (cmd, why), 5)
     elif not (args.why or "").strip():
         fs.die("batch off needs --why \"<why the standard loop from here>\"")
     policy = rr_policy.weight_policy(root)
@@ -118,8 +126,9 @@ def cmd_batch(args, root, rt=rr_runtime.Runtime()):
         # At the gate (stage ship) the next action is the human's and stays so.
         state["next_action"] = rr_policy.review_next_action(state)
     journal.emit(root, state, "batch_set", "%s by %s%s" % (args.action, args.by, " via %s" % via if via else ""),
-         {"on": want, "by": args.by, "why": args.why or None, "via": via,
-          "review_passes": state["review"]["passes"], "suite_runs": state["verify"]["suite_runs"]},
+         dict({"on": want, "by": args.by, "why": args.why or None, "via": via,
+               "review_passes": state["review"]["passes"], "suite_runs": state["verify"]["suite_runs"]},
+              **dialog.pick_data(dialog.DIALOG_PICK[0])),
          actor="human" if via == "terminal" else "agent", rt=rt)
     handoff.set_resume_point(state, rt=rt)
     handoff.write_handoff(root, state, "batch", rt=rt)

package/skills/ai-task/rr_state/verify.py

@@ -171,18 +171,23 @@ def cmd_verify(args, root, rt=rr_runtime.Runtime()):
     max_runs, budget_name = rr_policy.budget(policy, state, "max_suite_runs")
     if scope in ("suite", "all") and state["verify"]["suite_runs"] >= max_runs:
         if not args.by:
-            dialog.offer_decision(root, state, "human_set", "Budget",
-                           "%s\nSUITE_BUDGET: %d suite runs; weight.json allows %d%s. Run it once more?"
-                           % (dialog.task_facts(root, state), state["verify"]["suite_runs"], max_runs,
-                              " (%s)" % budget_name if rr_policy.batch_on(state) else ""),
-                           [{"kind": "choice", "effect": "keep", "label": "Keep the budget — stop here"},
-                            {"kind": "command",
-                             "label": labels.state_label(root, sys.argv[1:] + ["--by", labels.human_name(root)])}], "verify", rt=rt)
-            fs.die("SUITE_BUDGET — %d suite runs; weight.json allows %d (%s). Running it "
-                "again is not the next move: the human decides. In their own terminal:\n  python3 %s "
-                "--root %s verify --scope %s --by \"<name>\""
-                % (state["verify"]["suite_runs"], max_runs, budget_name, shlex.quote(fs.ENTRY),
-                   shlex.quote(root), scope), 6)
+            runs = state["verify"]["suite_runs"]
+            decision = dialog.offer_decision(
+                root, state, "human_set", "Budget",
+                "%s\nThe test suite has run %d times; this task allows %d%s. Run it once more?"
+                % (dialog.task_facts(root, state), runs, max_runs,
+                   " (%s)" % budget_name if rr_policy.batch_on(state) else ""),
+                [{"kind": "choice", "effect": "keep", "label": "Keep the budget — stop here"},
+                 {"kind": "command",
+                  "label": labels.state_label(root, sys.argv[1:] + ["--by", labels.human_name(root)])}], "verify", rt=rt)
+            cmd = "python3 %s --root %s verify --scope %s --by \"<name>\"" % (
+                shlex.quote(fs.ENTRY), shlex.quote(root), scope)
+            asked = dialog.human_refusal("a run past the suite budget", cmd, "the budget is spent: %d runs, %d allowed"
+                                         % (runs, max_runs), decision and decision["id"])
+            fs.die(("SUITE_BUDGET — %d suite runs; weight.json allows %d (%s).\n%s" % (runs, max_runs, budget_name, asked))
+                   if asked else
+                   "SUITE_BUDGET — %d suite runs; weight.json allows %d (%s). Running it again is not the next "
+                   "move: the human decides. In their own terminal:\n  %s" % (runs, max_runs, budget_name, cmd), 6)
         via, why = dialog.human_route(root, allow_dialog=True, rt=rt)
         if via is None:
             fs.die("APPROVAL_REFUSED — a run past the suite budget is the human's, from their own terminal."