riskrails 4.2.0 → 4.3.0

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."

package/skills/project-update/history/blobs/dac90781793b8a1c8e5f3e0307665b6394d922140c3831c5508d019f79e1ed0a

@@ -0,0 +1,41 @@
+# Coding policy
+
+<!-- /ai-init fills the project-specific half of this file from the repository.
+     The rules above the line are general and apply everywhere. -->
+
+## General
+
+- Follow the conventions already in the file you are editing, even when they are
+  not the conventions you would choose. Consistency inside a file beats
+  correctness in the abstract.
+- One logical change per step. If you find yourself writing "and also", stop.
+- No new abstraction until there are three call sites that need it.
+- Extend through the framework's own extension points before writing a new
+  mechanism: decorators, event subscribers, form extensions, template overrides,
+  compiler passes, configuration.
+- Never modify `vendor/` or `node_modules/`. A needed change to a third-party
+  package becomes a decorator, an event listener, or a patch that is applied on
+  install and reviewable in git.
+- Dead code is deleted only in a task that is about deleting it, with evidence
+  that it is dead.
+- A function does one thing and its name says which. When the name needs
+  "and", split it.
+- Inputs come in as parameters and the result goes out as the return value;
+  files, the network and the clock stay at the edge, in the caller.
+- An error message says what failed, what was expected, what was found, and
+  the way out.
+
+In existing code the file's conventions win; the last three lines hold for the
+functions you add.
+
+## Comments
+
+Write the comment that explains *why*, and only when the reason is not visible in
+the code. Do not narrate what the next line does. Do not leave commented-out
+code; git remembers it.
+
+## Project specifics
+
+<!-- KNOWN FACT entries only: the linters that actually run, the static-analysis
+     level actually configured, the naming and layering the code actually uses.
+     Cite the config file for each. -->

package/skills/project-update/history/index.json

@@ -40,7 +40,8 @@
  "ai-init/.ai/agents/implementer.md": [
   "7e5c824bb71fe5353ec8a67827145b8fbc22ecd902ade1ad3005fafeed4ffb71",
   "94da08ac6945d5614cc7918d450aab94f3aa8a929a1c8f9fa9a0a9ac51176287",
-  "1fe2f3d3bfe2d1b671aa759b89ac1d88ae73eefed2208a485c9e972fa7b079e6"
+  "1fe2f3d3bfe2d1b671aa759b89ac1d88ae73eefed2208a485c9e972fa7b079e6",
+  "71364f3e392fe460b5b32cfec8de047a0aae8f88f144d110f90a329163677d42"
  ],
  "ai-init/.ai/agents/manager.md": [
   "0aeb04b04262683cac6513545683486a73dc473b447bba43b5aaab18403957a6",
@@ -67,7 +68,8 @@
   "e71abd1823fbbe6e635b141f04a301c3d24c2cdd56c7a5c2b25c7ea1898be54f",
   "be34ab013c39ace1e1ec902b9bcfe9653ba6aaeddb9df63fde2d2aa17bfb2263",
   "6956a4c991262b5733645f29d7067c091c1126721623b07275b4f276560ec28e",
-  "707e67834ec3295705c4e391b794d8600a3fbc3c02dda16db50035f84e6b47c9"
+  "707e67834ec3295705c4e391b794d8600a3fbc3c02dda16db50035f84e6b47c9",
+  "499e51e1a393f776aa425aeb2be575f0a58eb483d83bc9f1c7da94ff38c3fb0e"
  ],
  "ai-init/.ai/agents/risk.md": [
   "d7146a591898984115124c83174a2c93cc080ad594f132f3d89c8b41b006c805",
@@ -83,7 +85,8 @@
   "7f713c6ecd00bc2379deda511d8bda786341dbe5f5187f3b899302d904fed6bc"
  ],
  "ai-init/.ai/policies/coding.md": [
-  "3dd55bf5f9d9471c68af3353166da11593a11e639f7557397ce46787291fa629"
+  "3dd55bf5f9d9471c68af3353166da11593a11e639f7557397ce46787291fa629",
+  "dac90781793b8a1c8e5f3e0307665b6394d922140c3831c5508d019f79e1ed0a"
  ],
  "ai-init/.ai/policies/context-management.md": [
   "230df2220e9c73c563c3c926d26f5c6dbe249df26a56fa43b7b321cdee2d5783",

package/skills/rr-build/SKILL.md

@@ -157,10 +157,13 @@ The batch is `[{"question": "…", "options": [{"key": "A", "text": "…"}, …]
 `"A: text"` becomes `{"key": "A", "text": "text"}`.
 
 Option keys are single letters, A first, at least two; `--recommend` marks the
-one you would pick. Then **stop** and show the questions: while one is pending,
+one you would pick. If `ask` printed `DIALOG_PENDING`, send that dialog. With no
+decision pending (a free question-tool call is denied while one is), put the
+question through the question tool and record the pick with
+`$STATE answer Q1=B --via picker`. Otherwise **stop** and show the questions: while one is pending,
 `step-done` and `close` exit 4. The human answers in the conversation — record
 it with `$STATE answer Q1=B Q2=X:"free text"` or `--prose "1B 2A"` — or fills the
-`[Answer]:` line in `.ai/reports/<task-id>/task.md` §Questions, which is then the
+`[Answer]:` line in `.ai/reports/<task-id>/task.md` §Questions; that file stays the
 record. Never edit that file, and never answer on the human's behalf.
 
 ## 6. Hand over by mode

package/skills/rr-ship/SKILL.md

@@ -51,8 +51,8 @@ approve in your own terminal, then run close again:
   python3 /home/…/skills/ai-task/state.py --root /path/to/project approve --by "<name>"
 ```
 
-Show the human the summary (§3), the open findings, the rollback, and that
-command **verbatim** — paths absolute and quoted, because they paste it into
+Show the human the summary (§3), the review's `READ FIRST` lines, the open
+findings, the rollback, and that command **verbatim** — paths absolute and quoted, because they paste it into
 their own shell, where `$AI_HOME` is not set. Then **stop**.
 
 - **You approve only through the dialog.** With `.ai/policies/dialog.json`

package/skills/rr-spec/SKILL.md

@@ -39,6 +39,12 @@ $STATE ask --topic <slug> "<one line>" --option "A: <text>" --option "B: <text>"
 $STATE answer --topic <slug> Q1=B              # or --prose "1B", or Q1=X:"free text"
 ```
 
+If `ask` printed `DIALOG_PENDING`, send that dialog. With no decision pending (a
+free question-tool call is denied while one is), put the question through the
+question tool and relay the pick with `$STATE answer --topic <slug> Q1=B --via
+picker`; the questions file stays the record, and the human may still answer in
+the chat or fill `[Answer]:`.
+
 If `superpowers:brainstorming` is available, let it drive the conversation; the
 questions and answers still go through `ask` and `answer`. Otherwise:
 

package/skills/rr-status/SKILL.md

@@ -16,6 +16,8 @@ done
 python3 -I "$AI_HOME/skills/rr-status/status.py" --root "$PWD"
 ```
 
+With a task in flight or a decision open, the first line says who it waits on (`waiting on you` or `waiting on the agent`).
+
 After the output, at most one line, and only when a line asks for it:
 
 - `root:` is an ancestor of this repository, or `$HOME`: that `.ai/` arms the

package/skills/rr-status/status.py

@@ -174,9 +174,11 @@ def main(argv=None):
         return 1
     lines, task_id = None, None
     state = read_json(state_file(root))
-    if state.get("schema") == 7:
-        # A schema-7 task is state.py's to describe; this file's own read stays for
-        # an older task, and for an install whose state.py cannot answer.
+    decisions = read_json(os.path.join(root, ".ai", "state", "decision.json")).get("open")
+    if state.get("schema") == 7 or (not state.get("task_id") and decisions):
+        # A schema-7 task, or an open decision with no task, is state.py's to describe
+        # (its first line says who waits); this file's own read stays for an older
+        # task, and for an install whose state.py cannot answer.
         done = subprocess.run([sys.executable, "-I", os.path.join(SKILLS, "ai-task", "state.py"),
                                "--root", root, "status"], capture_output=True, text=True, check=False)
         if done.returncode == 0 and done.stdout.strip():