riskrails 3.2.2 → 4.1.0

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

@@ -1,19 +1,27 @@
 """dialog_cmd: the consent and decision commands -- decision open/show/settle/fallback, the pick applied, and the read-only consent view.
 
-core: SETTLE_EFFECT
-shell: cmd_decision, decision_open, decision_settle, apply_choice, cmd_consent
+core: SETTLE_EFFECT, SETUP_VALUES, SETUP_VALUE_MAX, SETUP_SPEC_MAX, setup_option_why, setup_decision_why, setup_spec_why
+shell: cmd_decision, decision_open, read_setup_spec, setup_command_why, check_setup_labels, setup_open, decision_settle, apply_choice, cmd_consent
 """
 # pylint: disable=unused-argument  # uniform cli dispatch: cmd_consent takes rt like every command
 import argparse
 import json
 import os
+import shlex
 import sys
 
 from rr_state import dialog, fs, labels, profile, questions_cmd, task
 from rr_state import ledger as rr_ledger
 from rr_state import runtime as rr_runtime
 
-SETTLE_EFFECT = {"defer": "defer", "keep": "ack", "ack": "ack", "answer": "answered"}
+SETTLE_EFFECT = {"defer": "defer", "keep": "ack", "ack": "ack", "answer": "answered", "set": "set"}
+# What `decision open --kind setup` accepts (R11): the questions /rr-setup asks, each with the words a choice may set
+# (what the skill applies is what the human read: one of these words, or, for verify only, a command shown verbatim
+# in its own label), the longest value, and the most characters of a spec it reads.
+SETUP_VALUES = {"memory": ("off", "keep"), "runtime": ("auto", "claude", "codex", "both"),
+                "survey": ("light", "full", "keep"), "verify": ("", "other", "keep", "edit")}
+SETUP_VALUE_MAX = 200
+SETUP_SPEC_MAX = 262144
 
 
 def cmd_decision(args, root, rt=rr_runtime.Runtime()):
@@ -53,10 +61,16 @@ def cmd_decision(args, root, rt=rr_runtime.Runtime()):
 
 
 def decision_open(args, root, rt=rr_runtime.Runtime()):
-    """The one opener the model may call: commit and push, nothing else."""
+    """The openers the model may call: --kind commit (git commit and git push) and --kind setup (the /rr-setup
+    questions: choices that set a value, and this project's `memory enable`); nothing else."""
+    if args.kind == "setup":
+        setup_open(args, root, rt=rt)
+        return
     if args.kind != "commit":
-        fs.die("decision open takes --kind commit; every other decision is opened by the command that "
-            "needs it (close, ask, the budgets, start --mode)")
+        fs.die("decision open takes --kind commit or --kind setup; every other decision is opened by the "
+            "command that needs it (close, ask, the budgets, start --mode)")
+    if args.spec is not None:
+        fs.die("decision open --kind commit takes --command, not --spec", 2)
     if not args.commands:
         fs.die("decision open --kind commit needs --command \"git commit …\" [--command \"git push <remote> <branch>\"]")
     for command in args.commands:
@@ -83,6 +97,165 @@ def decision_open(args, root, rt=rr_runtime.Runtime()):
     dialog.print_dialog([decision], rt=rt)
 
 
+def read_setup_spec(path):
+    """--spec FILE|- as JSON: a spec that cannot be read, is longer than SETUP_SPEC_MAX characters, is not JSON or
+    nests deeper than the dialog's own cap is a bad spec (exit 2)."""
+    try:
+        if path == "-":
+            text = sys.stdin.read(SETUP_SPEC_MAX + 1)
+        else:
+            with open(path, encoding="utf-8") as fh:
+                text = fh.read(SETUP_SPEC_MAX + 1)
+        if len(text) > SETUP_SPEC_MAX:
+            fs.die("bad spec — more than %d characters" % SETUP_SPEC_MAX, 2)
+        spec = dialog.json_loads_capped(text)
+        # A lone surrogate ("\ud800") parses, yet no file can hold it: refused here, not after a first decision is written.
+        json.dumps(spec, ensure_ascii=False).encode("utf-8")
+        return spec
+    except (OSError, ValueError, RecursionError) as exc:
+        fs.die("bad spec — %s" % exc, 2)
+
+
+def setup_option_why(option, key):
+    """Why one option of the decision `key` is not {kind: choice, label, value[, description]} or {kind: command,
+    label[, description]}, else None. A choice sets one of its key's words (SETUP_VALUES); a verify choice may also
+    set a command, and check_setup_labels (exit 6) makes its label show it, like every rule of the labels."""
+    if not isinstance(option, dict) or option.get("kind") not in ("choice", "command"):
+        return "an option is an object whose kind is choice or command"
+    need = {"kind", "label", "value"} if option["kind"] == "choice" else {"kind", "label"}
+    if not need <= set(option) <= need | {"description"}:
+        return "a %s option holds %s, and a description if it has one" % (option["kind"], ", ".join(sorted(need)))
+    text, value = option.get("description", ""), option.get("value", "")
+    if not isinstance(option["label"], str) or not isinstance(text, str) or len(text) > dialog.QUESTION_MAX:
+        return "a label and a description are text, a description at most %d characters" % dialog.QUESTION_MAX
+    if not isinstance(value, str) or len(value) > SETUP_VALUE_MAX or not value.isprintable():
+        return "a choice value is at most %d printable characters (empty is allowed)" % SETUP_VALUE_MAX
+    if option["kind"] == "choice" and key != "verify" and value not in SETUP_VALUES[key]:
+        return "a %s choice sets one of: %s" % (key, ", ".join(SETUP_VALUES[key]))
+    return None
+
+
+def setup_decision_why(item):
+    """Why one decision of a spec is not {key, header, question, options}, else None."""
+    if not isinstance(item, dict) or set(item) != {"key", "header", "question", "options"}:
+        return "a decision is an object holding exactly key, header, question and options"
+    if not isinstance(item["key"], str) or item["key"] not in SETUP_VALUES:
+        return "a decision key is one of %s" % ", ".join(SETUP_VALUES)
+    if not all(isinstance(item[name], str) and item[name].strip() for name in ("header", "question")):
+        return "a header and a question are text and not empty"
+    if not isinstance(item["options"], list) or not 2 <= len(item["options"]) <= 4:
+        return "a decision has 2 to 4 options"
+    for number, option in enumerate(item["options"], 1):
+        why = setup_option_why(option, item["key"])
+        if why:
+            return "option %d: %s" % (number, why)
+    return None
+
+
+def setup_spec_why(spec):
+    """Why a parsed spec is not {"schema": 1, "decisions": [...]} with 1 to DECISIONS_MAX decisions, each key
+    once, else None (R11)."""
+    if not isinstance(spec, dict) or set(spec) != {"schema", "decisions"}:
+        return "a spec is an object holding exactly schema and decisions"
+    schema, decisions = spec["schema"], spec["decisions"]
+    if not isinstance(schema, int) or isinstance(schema, bool) or schema != 1:
+        return "schema is 1"
+    if not isinstance(decisions, list) or not 1 <= len(decisions) <= dialog.DECISIONS_MAX:
+        return "decisions is a list of 1 to %d decisions" % dialog.DECISIONS_MAX
+    for number, item in enumerate(decisions, 1):
+        why = setup_decision_why(item)
+        if why:
+            return "decision %d: %s" % (number, why)
+    keys = [item["key"] for item in decisions]
+    return None if len(set(keys)) == len(keys) else "a decision key is used once"
+
+
+def setup_command_why(root, label):
+    """Why `label` is not exactly `python3 <this state.py> --root <this project> memory enable [options]`, else
+    None. validate_label alone also passes another --root, a --runtime, interpreter flags, approve and git commit
+    (R11, B1); the paths must be absolute, as the labels state_label writes."""
+    why = labels.validate_label(label)
+    if why:
+        return why
+    words = shlex.split(label)
+    if len(words) >= 6 and words[0] == "python3" and words[2] == "--root" and words[4:6] == ["memory", "enable"] \
+            and os.path.isabs(words[1]) and os.path.realpath(words[1]) == os.path.realpath(fs.ENTRY) \
+            and os.path.isabs(words[3]) and os.path.realpath(words[3]) == os.path.realpath(root):
+        return None
+    return ("a setup command is exactly python3 <this state.py> --root <this project> memory enable "
+            "[--author S] [--period P] [--index none|sqlite]")
+
+
+def check_setup_labels(root, decisions):
+    """Every label of the spec, before anything is written (exit 6): only the memory decision offers a command, and
+    that is setup_command_why's; a choice never reads as a command, because the gate passes a Bash command equal
+    to any pick and dialog_pick runs a pick that is a state.py label; and a verify choice that sets a command
+    shows it, whole, as one `span` of its label, because the skill applies the value and the human reads the
+    label (R11, B1)."""
+    for item in decisions:
+        options = item["options"]
+        if len({option["label"] for option in options}) != len(options):
+            fs.die("CONSENT_LABEL_INVALID — two options of the %s decision carry the same label" % item["key"], 6)
+        for option in options:
+            label = option["label"]
+            if option["kind"] == "command":
+                why = setup_command_why(root, label) if item["key"] == "memory" else \
+                    "only the memory decision offers a command"
+            elif not 0 < len(label) <= labels.LABEL_MAX or not label.isprintable():
+                why = "a choice label is 1 to %d printable characters" % labels.LABEL_MAX
+            elif label.startswith(("python3", "git", "npx")) or labels.label_argv(label) \
+                    or labels.validate_label(label) is None:
+                why = "a choice label never reads as a command"
+            elif item["key"] == "verify" and option["value"] not in SETUP_VALUES["verify"] \
+                    and option["value"] not in label.split("`")[1:-1:2]:
+                why = "a verify command is shown verbatim in its label, inside backticks"
+            else:
+                why = None
+            if why:
+                fs.die("CONSENT_LABEL_INVALID — %s: %s" % (why, label[:120]), 6)
+
+
+def setup_open(args, root, rt=rr_runtime.Runtime()):
+    """decision open --kind setup --spec FILE|-: every check runs for every decision of the spec before the first
+    write, then all are opened in the spec's order, or none (R11). The caller sends the one dialog."""
+    if args.commands or args.spec is None:
+        fs.die("decision open --kind setup takes --spec FILE|- and no --command", 2)
+    spec = read_setup_spec(args.spec)
+    why = setup_spec_why(spec)
+    if why:
+        fs.die("bad spec — %s" % why, 2)
+    decisions = spec["decisions"]
+    check_setup_labels(root, decisions)
+    if not dialog.dialog_on(root, runtime=rt.name):
+        fs.die("the dialog is off here (.ai/policies/dialog.json, the runtime's dialog tool, a session id): "
+            "suggest the commands; the human runs them outside the agent")
+    data = rr_ledger.read_decisions(root)
+    questions = [item["question"].strip()[:dialog.QUESTION_MAX] for item in decisions]   # as open_decision stores them
+    if len(set(questions)) != len(questions):
+        fs.die("DECISION_DUPLICATE — two decisions of the spec carry one question text", 6)
+    twin = next((d for d in data["open"] if d.get("question") in questions), None)
+    if twin:
+        fs.die("DECISION_DUPLICATE — %s is open with this very question; settle it, or 'state.py decision fallback "
+            "--id %s --why …', before opening it again" % (twin.get("id"), twin.get("id")), 6)
+    open_questions = sum(len(dialog.dialog_questions(d)) for d in data["open"])
+    if open_questions + len(decisions) > dialog.DECISIONS_MAX:
+        fs.die("DECISION_LIMIT — %d questions are open and the spec adds %d; one dialog call carries %d"
+            % (open_questions, len(decisions), dialog.DECISIONS_MAX), 6)
+    state = task.load(root, required=False, claim=False, rt=rt)
+    state = state if state and task.is_v7(state) else None
+    opened = []
+    for item in decisions:
+        options = [dict(o, effect="set") if o["kind"] == "choice" else o for o in item["options"]]
+        decision, why = dialog.open_decision(root, state, "setup", item["header"], item["question"], options,
+                                      "decision open --kind setup", rt=rt, setup_key=item["key"])
+        if decision is None:
+            for done in opened:               # a race since the checks above: none of this call stays open
+                dialog.settle_decision(root, done["id"], "withdrawn")
+            fs.die(why, 6)
+        opened.append(decision)
+    dialog.print_dialog(opened, rt=rt)
+
+
 def decision_settle(args, root, decision, rt=rr_runtime.Runtime()):
     """(b) apply what the recorder wrote — a choice pick or a decline; (c) a
     human in a terminal picks an option by number (R36.14)."""
@@ -112,6 +285,8 @@ def decision_settle(args, root, decision, rt=rr_runtime.Runtime()):
         dialog.settle_decision(root, decision["id"], "declined")
         print("%s settled: declined in the dialog (%s); nothing runs"
               % (decision["id"], mine[-1].get("why") or "no answer"))
+        if decision.get("kind") == "setup":
+            print("SETUP_PICK %s=" % decision.get("setup_key"))
         return
     live = [p for p in rr_ledger.live_picks(ledger, (dialog.dialog_on(root, runtime=rt.name) or {}).get("session"))
             if p.get("decision") == decision["id"]]
@@ -132,6 +307,8 @@ def apply_choice(root, decision, option, pick_id, by, via, rt=rr_runtime.Runtime
                    root, rt=rt)
     dialog.settle_decision(root, decision["id"], effect, pick_id)
     print("%s settled: %s (%s)" % (decision["id"], option["label"], effect))
+    if decision.get("kind") == "setup":
+        print("SETUP_PICK %s=%s" % (decision.get("setup_key"), option.get("value", "")))
 
 
 def cmd_consent(args, root, rt=rr_runtime.Runtime()):

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

@@ -1,7 +1,7 @@
 """The store: where the state, the session, the journal and the logs live, and the clock, the root search and the one subprocess runner.
 
 shell: ENTRY, now, now_ms, find_root, find_root_quiet, die, state_path, remove_state, read_session, safe_sensor, find_docs_root, questions_path, read_lines, run_text, read_text, current_tree, ensure_logs
-core: STATE_NAMES, session_path, journal_path, _split_files, SLUG_RE, one_line, handoff_path, decision_path, ledger_path, logs_dir, task_md_path
+core: session_path, journal_path, _split_files, SLUG_RE, one_line, handoff_path, decision_path, ledger_path, logs_dir, task_md_path
 """
 
 import contextlib
@@ -59,22 +59,14 @@ def die(message, code=1):
     sys.exit(code)
 
 
-STATE_NAMES = ("state.json", "current.json")
-
-
 def state_path(root):
-    """The task's state file, read and written where it is: state.json, or
-    current.json when that is the file a task in flight sits in. A new task
-    starts in state.json (R34's contract half, migration 0009 moves an old one);
-    both names stay readable, so a revert of that move still finds the task."""
-    new, legacy = (os.path.join(root, ".ai", "state", name) for name in STATE_NAMES)
-    return legacy if not os.path.exists(new) and os.path.exists(legacy) else new
+    """The task's state file: state.json, the only name read."""
+    return os.path.join(root, ".ai", "state", "state.json")
 
 
 def remove_state(root):
-    for path in (os.path.join(root, ".ai", "state", name) for name in STATE_NAMES):
-        with contextlib.suppress(FileNotFoundError):
-            os.remove(path)
+    with contextlib.suppress(FileNotFoundError):
+        os.remove(os.path.join(root, ".ai", "state", "state.json"))
 
 
 def session_path(root):

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

@@ -43,12 +43,23 @@ def subcommand(argv):
 
 
 def state_label_ok(argv):
-    """approve | reject | profile set | verify --by | review --by | start --mode … --by."""
+    """approve | reject | profile set | verify --by | review --by | start --mode … --by |
+    memory enable [--author S] [--period month|quarter|year] [--index none|sqlite]: each option at most
+    once, as two words, in any order, and no other memory verb. hooks/guard/dialog.py keeps the same
+    rule; tests/test_dialog_contract.py pins the two equal."""
     rest = subcommand(argv)
     if rest[:1] in (["approve"], ["reject"]) or rest[:2] == ["profile", "set"]:
         return True
     if rest[:1] in (["verify"], ["review"]):
         return "--by" in rest
+    if rest[:2] == ["memory", "enable"]:
+        # The pick is the exact command the human read: no `--opt=value`, no abbreviation argparse would
+        # take, no positional, an option once, a value of its own kind (an author never starts with '-').
+        names, values = rest[2::2], rest[3::2]
+        kinds = {"--author": None, "--period": ("month", "quarter", "year"), "--index": ("none", "sqlite")}
+        return (len(names) == len(values) == len(set(names)) and set(names) <= set(kinds)
+                and all((v[:1] not in ("", "-")) if kinds[n] is None else v in kinds[n]
+                        for n, v in zip(names, values)))
     return rest[:1] == ["start"] and "--mode" in rest and "--by" in rest
 
 
@@ -78,7 +89,8 @@ def validate_label(label):
             and state_label_ok(script[1]):
         return None
     return ("a label starts with git commit, git push <remote> <branch>, state.py approve|reject|"
-            "profile set|verify --by|review --by|start --mode --by, or npx riskrails@<v> … --yes")
+            "profile set|verify --by|review --by|start --mode --by|memory enable [--author S] "
+            "[--period P] [--index none|sqlite], or npx riskrails@<v> … --yes")
 
 
 def human_name(root):

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

@@ -39,9 +39,10 @@ def memory_config(sync, root):
     return None
 
 
-def memory_human(root, what, rt=rr_runtime.Runtime()):
-    """R16: enable, disable, cleanup, pack, redact and move-logs take the human's route, as approve does."""
-    via, why = rr_dialog.human_route(root, rt=rt)
+def memory_human(root, what, allow_dialog=False, rt=rr_runtime.Runtime()):
+    """R16: enable, disable, cleanup, pack, redact and move-logs take the human's route, as approve does. Only
+    enable passes allow_dialog: a live pick of this session that is this very command is the human's answer."""
+    via, why = rr_dialog.human_route(root, allow_dialog=allow_dialog, rt=rt)
     if via is None:
         fs.die("APPROVAL_REFUSED — 'memory %s' is the human's, from their own terminal:\n  python3 %s --root %s "
             "%s\nRefused because %s." % (what, shlex.quote(fs.ENTRY), shlex.quote(root),
@@ -98,7 +99,9 @@ def memory_status(args, root, sync, _store, rt=rr_runtime.Runtime()):
 
 
 def memory_enable(args, root, sync, _store, rt=rr_runtime.Runtime()):
-    memory_human(root, "enable", rt=rt)
+    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)

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

@@ -22,10 +22,8 @@ from rr_state import task
 
 
 def profile_file(home):
-    """<home>/riskrails/profile.json, or <home>/claude-agentic/profile.json where
-    the installer has not run since 3.4b (R35, one version)."""
-    path = os.path.join(home, "riskrails", "profile.json")
-    return path if os.path.exists(path) else os.path.join(home, "claude-agentic", "profile.json")
+    """<home>/riskrails/profile.json."""
+    return os.path.join(home, "riskrails", "profile.json")
 
 
 def read_profile(runtime=None, rt=rr_runtime.Runtime()):

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

@@ -241,7 +241,7 @@ def cmd_questions(args, root, rt=rr_runtime.Runtime()):
             # into the file must be in the state and the history too.
             # Only a sync that changed something writes at all — questions.pending
             # is a cache, and guard_pending re-parses the file anyway, so a read
-            # (which /ai-status and the session-start hook both perform) never
+            # (which /rr-status and the session-start hook both perform) never
             # races a command that is mid-write.
             _, questions = rr_questions.parse_questions(path)
             rr_questions.set_pending(root, state, questions, path)

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

@@ -154,11 +154,10 @@ def schema_line(root):
         project = "0"
     here = os.path.dirname(os.path.dirname(fs.ENTRY))
     try:
-        names = os.listdir(os.path.join(here, "project-update", "migrations"))
+        with open(os.path.join(here, "ai-init", "templates", ".ai", "VERSION"), encoding="utf-8") as fh:
+            plugin = fh.read().strip() or "?"
     except OSError:
-        names = []
-    numbers = [int(n[:4]) for n in names if re.match(r"\d{4}_", n)]
-    plugin = str(max(numbers)) if numbers else "?"
+        plugin = "?"
     behind = project.isdigit() and plugin.isdigit() and int(project) < int(plugin)
     return "schema: project %s · plugin %s%s" % (project, plugin, " — behind: run /rr-setup --update" if behind else "")
 

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

@@ -69,7 +69,7 @@ def installed(runtime):
 
 
 # Set by the runtimes in every process they start, the `!` prefix's shell
-# included. Duplicated on purpose from skills/project-update/adopt.py
+# included. Duplicated on purpose from the removed adopt script
 # (AGENT_MARKERS): the two skills are installed independently and neither
 # imports the other.
 AGENT_MARKERS = ("CLAUDECODE", "CODEX_THREAD_ID", "CODEX_SESSION_ID", "CODEX_CI",

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

@@ -39,15 +39,15 @@ def cmd_weight(args, root, rt=rr_runtime.Runtime()):
     except (OSError, ValueError, RecursionError) as exc:
         fs.die("cannot read the weight table: %s" % exc)
     if args.mirror:
-        own = os.path.join(root, ".ai", "policies", "weight.json")
-        if path != own:
-            fs.die("%s has no .ai/policies/weight.json: the mirror is written beside the project's own table"
+        policies = os.path.join(root, ".ai", "policies")
+        if not os.path.isdir(policies):
+            fs.die("%s has no .ai/policies/: the mirror is written beside the project's own table"
                 % root)
-        target = os.path.join(os.path.dirname(own), "weight.md")
+        target = os.path.join(policies, "weight.md")
         tmp = "%s.%d.tmp" % (target, os.getpid())
         try:
             with open(tmp, "w", encoding="utf-8") as fh:
-                fh.write(weight.mirror(own))
+                fh.write(weight.mirror(policy))
             os.replace(tmp, target)
         except OSError as exc:
             with contextlib.suppress(OSError):
@@ -70,9 +70,9 @@ def cmd_weight(args, root, rt=rr_runtime.Runtime()):
     except ValueError as exc:
         fs.die(str(exc))
     except (TypeError, AttributeError) as exc:     # a table whose values have the wrong shape
-        fs.die("%s is malformed: %s" % (path, exc))
+        fs.die("%s is malformed: %s" % (path[-1] if os.path.isfile(path[-1]) else path[0], exc))
     if args.json:
-        out = dict(result.as_dict(), policy=path)
+        out = dict(result.as_dict(), policy=path[0])
         if result.documents_only is not None:
             out["documents_only"] = result.documents_only
         print(json.dumps(out, indent=2, ensure_ascii=False))

package/skills/ai-task/sensors.py

@@ -3,7 +3,7 @@
 
 Why a separate module: state.py owns every write to state.json and has no
 subprocess use at all; this module shells out to git and to the commands written
-in .ai/policies/testing.md, imports nothing from state.py, and never opens
+in .ai/policies/verification.md, imports nothing from state.py, and never opens
 state.json for writing. state.py imports it, not the reverse. Since redesign
 2.6 it measures nothing else: the size budget, the re-score and the static
 sensors (bite, duplicates, traceability, plan sections, lint, typecheck, detect)
@@ -213,11 +213,11 @@ SCOPE_FIELD = {"suite": "verify_command", "step": "step_test_command",
 
 
 def testing_path(root):
-    return os.path.join(root, ".ai", "policies", "testing.md")
+    return os.path.join(root, ".ai", "policies", "verification.md")
 
 
 def read_commands(root):
-    """The project's own commands, as a human wrote them into testing.md.
+    """The project's own commands, as a human wrote them into verification.md.
 
     A line's value is everything after the colon, minus a trailing comment; the
     template ships the fields with an explanatory comment and no value, and that
@@ -253,7 +253,7 @@ def _escaped(text):
 
 def bite_codes(root):
     """The exit codes that count as "the test fails" under --expect fail: the
-    testing.md `bite_codes` list of integers 1-255, 1 when absent or not a clean list
+    verification.md `bite_codes` list of integers 1-255, 1 when absent or not a clean list
     (an empty part, a non-integer, 0, a negative or a value over 255 all fall back)."""
     raw = read_commands(root).get("bite_codes", "")
     try:
@@ -349,8 +349,6 @@ def resolve_trees(root, args):
     from_tree = args.from_tree
     if not from_tree:
         state = os.path.join(root, ".ai", "state", "state.json")
-        if not os.path.isfile(state):
-            state = os.path.join(root, ".ai", "state", "current.json")  # R34: legacy name, one version
         try:
             with open(state, encoding="utf-8") as fh:
                 from_tree = ((json.load(fh) or {}).get("diff") or {}).get("base_tree")
@@ -387,11 +385,12 @@ def cmd_diff(args, root):
 
 
 def tests_config(root):
-    """The runner's caps from weight.json `tests`, the template's numbers otherwise."""
+    """The runner's caps from the weight table's `tests` (the plugin's, the project's
+    weight.project.json over it), {} when the table cannot be read."""
     try:
-        with open(os.path.join(root, ".ai", "policies", "weight.json"), encoding="utf-8") as fh:
-            config = (json.load(fh) or {}).get("tests") or {}
-    except (OSError, ValueError, AttributeError):
+        import weight  # pylint: disable=import-outside-toplevel  # sits beside this file; only cmd_run needs it
+        config = weight.load_policy(root)[0].get("tests") or {}
+    except (ImportError, OSError, ValueError, AttributeError):
         config = {}
     return config if isinstance(config, dict) else {}
 
@@ -400,7 +399,7 @@ def cmd_run(args, root):
     config = tests_config(root)
     command = command_for(root, args.scope)
     if not command:
-        print("%-13s UNAVAIL  %s is not written down in .ai/policies/testing.md"
+        print("%-13s UNAVAIL  %s is not written down in .ai/policies/verification.md"
               % (args.scope, SCOPE_FIELD.get(args.scope, args.scope)))
         return UNKNOWNCODE
     files = [f.strip() for f in (args.files or "").split(",") if f.strip()]

package/skills/ai-task/state.py

@@ -1,16 +1,16 @@
 #!/usr/bin/env python3
-"""Task state for /ai-task — the small, machine-readable record of one task.
+"""Task state for /rr-build — the small, machine-readable record of one task.
 
 Why a file and not the conversation: a conversation is expensive to re-read and
 impossible for a hook to consult. This file is what ai-scope-guard enforces
-against, what /ai-status reports, and what lets a task survive a /clear or a
+against, what /rr-status reports, and what lets a task survive a /clear or a
 crash. It holds facts, never transcripts.
 
 Everything is stdlib. Writes are atomic (temp file + os.replace), so a hook that
 reads the file while a stage is being recorded never sees half a document.
 
 Every state change is also appended to .ai/reports/<task-id>/events.jsonl, the
-append-only journal /ai-status and /usage-report read at zero model cost. The
+append-only journal /rr-status and /rr-status --cost read at zero model cost. The
 journal is best effort by contract: a line that cannot be written never fails
 the command that emitted it, and nothing here depends on it being lossless.
 history[] keeps its exact shape and its original event names beside it.
@@ -57,8 +57,7 @@ redesign 2.6) answers status, handoff and questions, and close --abandon drops
 it; every other command refuses it.
 """
 
-# pylint: disable=unused-import,wrong-import-position
-import json
+# pylint: disable=wrong-import-position
 import os
 import sys
 
@@ -68,26 +67,7 @@ try:
 except ImportError:
     sys.exit("rr_state/ is missing beside state.py: re-run `npx riskrails`")
 fs.ENTRY = os.path.abspath(__file__)    # R6a: the one path the package prints and compares
-
-# The names the suites reach as state_mod.<name> (R6) and json_loads_capped, which
-# tests/test_dialog_contract.py:176,189 reach as module.json_loads_capped over (dialog, state_mod);
-# json and os are imported above for the same reason: the suites patch state_mod.json.dump and state_mod.os.
 from rr_state.cli import main
-from rr_state.fs import current_tree, read_session, session_path, state_path
-from rr_state.runtime import AGENT_MARKERS
-from rr_state.journal import append_journal, journal_line, read_journal
-from rr_state.task import TASK_ID_RE, abandon_old, load, next_task_id, sealed_task_ids, valid_task_id
-from rr_state.policy import NEVER_DOCUMENTS, is_document, mode_for, rescore_weight
-from rr_state.locks import LOCK_STALE
-from rr_state.questions import parse_questions
-from rr_state.questions_cmd import close_gate_from_file, sync_answers
-from rr_state.ledger import LEDGER_LINE_MAX, LEDGER_TYPES, live_picks, read_ledger
-from rr_state.dialog import DIALOG_TOOL, JSON_DEPTH_MAX, QUESTION_MAX, SESSION_ENV, json_loads_capped
-from rr_state.dialog import dialog_on, dialog_payload, dialog_policy, dialog_tool_verified, task_facts
-from rr_state.labels import LABEL_MAX, validate_label
-from rr_state.gate import confirm_names
-from rr_state.profile import jwt_plan_type, read_json_object, read_profile, read_quota
-from rr_state.close import archive_v7
 
 if __name__ == "__main__":
     main()

package/skills/ai-task/weight.py

@@ -1,4 +1,4 @@
-"""Weight — six axes, 0 to 2 each, from .ai/policies/weight.json.
+"""Weight — six axes, 0 to 2 each, from the plugin's weight table with .ai/policies/weight.project.json laid over it.
 
 Pure computation: it reads the declared files, the tree listing and `git grep`,
 and writes nothing. A measured value is a floor: the session may raise an axis
@@ -39,15 +39,10 @@ class Weight:
 
 
 def load_policy(root):
-    """(policy, path): the project's table, else the one this plugin ships.
-    A broken table raises ValueError, never a silent default."""
-    own = os.path.join(root, ".ai", "policies", "weight.json")
-    path = own if os.path.isfile(own) else SHIPPED
-    with open(path, encoding="utf-8") as fh:
-        policy = json.load(fh)
-    if not isinstance(policy, dict) or not all(isinstance(policy.get(k), dict) for k in ("axes", "modes")):
-        raise ValueError("%s has no axes or modes table" % path)
-    return policy, path
+    """(policy, [shipped, project]): the shipped table with the project's weight.project.json laid over it."""
+    import weight_overlay  # pylint: disable=import-outside-toplevel  # beside this file; update.py loads this file by path
+    own = os.path.join(root, ".ai", "policies", "weight.project.json")
+    return weight_overlay.load(SHIPPED, own), [SHIPPED, own]
 
 
 @functools.lru_cache(maxsize=None)
@@ -268,14 +263,19 @@ def render(result, long=False):
     return "\n".join(lines)
 
 
-def mirror(path):
-    """weight.md for the JSON at `path`, carrying its sha256."""
-    with open(path, "rb") as fh:
-        raw = fh.read()
-    policy = json.loads(raw.decode("utf-8"))
+def mirror(source):
+    """weight.md for `source`: a policy dict (the effective table, sha256 of its canonical JSON) or
+    the path of one JSON file (sha256 of its bytes)."""
+    if isinstance(source, dict):
+        policy, origin = source, "the plugin's weight table plus weight.project.json"
+        raw = json.dumps(source, sort_keys=True, ensure_ascii=False).encode("utf-8")
+    else:
+        with open(source, "rb") as fh:
+            raw = fh.read()
+        policy, origin = json.loads(raw.decode("utf-8")), "weight.json"
     out = ["# Weight table", "",
-           "<!-- generated by `state.py weight --mirror` from weight.json; edit the JSON and regenerate."
-           " sha256: %s -->" % hashlib.sha256(raw).hexdigest(), "",
+           "<!-- generated by `state.py weight --mirror` from %s; edit the JSON and regenerate."
+           " sha256: %s -->" % (origin, hashlib.sha256(raw).hexdigest()), "",
            "Six axes, 0–2 each; W is their sum. Why each rule is what it is: the plugin's `docs/weight.md`.", "",
            "| Axis | Measured by | Table |", "|---|---|---|"]
     for axis in AXES:

package/skills/ai-task/weight_overlay.py

@@ -0,0 +1,38 @@
+"""The weight table a project sees: the plugin's shipped table with the project's
+weight.project.json laid over it (R9). weight.py's `load_policy` calls `load`.
+
+Objects merge recursively, any other value (a list too) replaces. A file that is not
+a JSON object, or a result without the axes and modes tables, raises ValueError
+naming the file; nothing falls back to a default.
+"""
+import json
+import os
+
+
+def _table(path):
+    """One JSON object from `path`; ValueError naming the file when it is not one."""
+    try:
+        with open(path, encoding="utf-8") as fh:
+            table = json.load(fh)
+        if isinstance(table, dict):
+            return table
+        raise ValueError("not a JSON object")
+    except ValueError as exc:
+        raise ValueError("%s: %s" % (path, exc)) from exc
+
+
+def _overlay(base, top):
+    """`top` laid over `base`: dicts merge, any other value (a list too) replaces."""
+    for key, value in top.items():
+        base[key] = _overlay(base[key], value) if isinstance(value, dict) and isinstance(base.get(key), dict) else value
+    return base
+
+
+def load(shipped, own):
+    """The table at `shipped`, with `own` laid over it when that file exists."""
+    policy = _table(shipped)
+    if os.path.isfile(own):
+        _overlay(policy, _table(own))
+    if not all(isinstance(policy.get(k), dict) for k in ("axes", "modes")):
+        raise ValueError("%s has no axes or modes table" % own)
+    return policy