riskrails 4.0.1 → 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/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/project-update/history/blobs/8ec171f0fbdf38cc6996d496f01491fd1f21f04a435a118ad979b127a8be06f1

@@ -0,0 +1,85 @@
+# Safety policy
+
+This is the file every agent reads first. It is short on purpose. It binds every
+agent in every runtime — Claude Code and Codex alike.
+
+## The one rule
+
+**Production behaviour is the source of truth until proven otherwise.** Code that
+looks wrong, dead, or badly written may be load-bearing. The repository's history
+is evidence; your intuition about how the code "should" look is not.
+
+## What an agent must never do
+
+- Change application code that the current task did not ask about.
+- Rename, move, reorganise or "clean up" anything as a side effect.
+- Remove code because it looks unused. Find the callers first; if there are none,
+  say so in the report and leave the code alone.
+- Combine a refactoring with a feature change in the same step.
+- Modify database schemas, dependencies or framework versions outside a task that
+  is explicitly about that.
+- Weaken a test, a linter rule or a static-analysis level to make a check pass.
+- Commit, push, merge or deploy on its own initiative.
+- Read production secrets or customer data into the model context.
+
+If you find a problem outside the current task: **write it down, do not fix it.**
+Unrelated findings are recorded with `state.py memory risk add` (in files mode it
+writes `.ai/project/known-risks.md`) or go into the report's "observations"
+section, and the human decides whether they become their own task.
+
+The compact record is the human's to switch: `state.py memory enable`, `disable`,
+`cleanup`, `pack`, `redact` and `migrate --move-logs` take the human route, as
+`approve` does. `enable` may also run as the command the human picked in the
+`/rr-setup` dialog; the rest have no dialog route. `.ai/memory/` and
+`.ai/local/memory/` are written by `state.py` alone — an agent never edits them
+(`state.py memory --help`; the plugin's `docs/local-memory.md`).
+
+## Scope
+
+Every implementation step names the files it may touch. Editing anything else is
+refused by `ai-scope-guard` and must be answered with `SCOPE_CHANGE_REQUIRED`:
+stop, say which file you need and why, and let the plan be amended. A step whose
+scope keeps growing is a step that was planned wrong.
+
+`ai-git-guard`, `ai-path-guard` and `ai-scope-guard` all run in both runtimes. A
+multi-file edit in one call — Codex's `apply_patch` — is checked path by path, so
+a single out-of-scope or protected file rejects the whole patch. What a guard
+refuses is not a hint: do not reword the command to get past it.
+
+A guard is a backstop, not the policy. Some checks exist in only one runtime —
+Codex has no hookable read tool, so the large-read cap is Claude-only there — and
+an agent that behaves correctly only because a hook is watching is not behaving
+correctly. The rules above hold whether or not a hook enforces them.
+
+**The guards' threat model.** The guards defend against an agent's mistakes — a
+careless `rm`, a write to a frozen policy during a task, a commit with a
+secret — not against an agent that constructs a command to exhaust them. A
+command built to time the guard out is visible in the transcript and in the
+journal, and the human gate in full and full_irreversible mode is the boundary
+for anything that matters.
+Approval rests on a guard plus a ledger: a command the agent constructs to pass
+for the human's pick is outside the threat model, and `state.py consent audit`
+detects it afterwards.
+
+## Evidence labels
+
+Anything an agent writes into `.ai/project/` carries one of four labels:
+
+- **KNOWN FACT** — read from the code, a config file, a migration or a test.
+  Cite `file:line`.
+- **INFERENCE** — a conclusion drawn from facts. Say what it is drawn from.
+- **UNKNOWN** — something that matters and could not be determined. Say what
+  would answer it.
+- **RISK** — something that looks dangerous. Say what could go wrong.
+
+Never present an inference as a fact. When documentation and code disagree,
+record both under "Documented behaviour" and "Observed behaviour", with the
+evidence for each, and let the human decide which is the bug.
+
+## When in doubt
+
+Stop and ask. An agent that pauses costs a message; an agent that guesses on a
+payment path costs an incident.
+
+Doubt on reversibility or domain is a blocker; other doubt is written to
+`task.md` and the work continues.

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

@@ -171,7 +171,8 @@
   "ae9a22907ba9acbb7e80fac1ba4e3d1ff09e5f1df5c4456afb9099d7090fcaa6",
   "fae3064e648cdc55be4aeb1177525b302a5e34ebd752e4a904f47dc0f4557b96",
   "e9adb7a9905eb719ac78ab96671f055da53e5001810f5ad6d6c94306b0323fe7",
-  "ae5ce131d6bae401199ff32d8c3dc4d8aec188010a9111624ac64506e2116ff4"
+  "ae5ce131d6bae401199ff32d8c3dc4d8aec188010a9111624ac64506e2116ff4",
+  "8ec171f0fbdf38cc6996d496f01491fd1f21f04a435a118ad979b127a8be06f1"
  ],
  "ai-init/.ai/policies/security.md": [
   "cc808d5b940109f1703abfb3ca0334a3fcfd34267feefb2323627d0decc8b89a",

package/skills/rr-setup/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: rr-setup
-description: Set up and maintain the .ai/ layer of an existing production codebase. With no flag, scaffold docs/sdlc/, the runtime directory and .ai/, survey the code into .ai/project/ (light or full), write the Verification commands, the weight table's project entries and the constitution — read-only towards application code. --update regenerates a project's files from the installed plugin (a copy that is a shipped version is replaced, an edited one waits for the human, the project's own files are kept); run it right after installing a new riskrails; --audit scores the repository against the twelve plays and writes docs/ai-sdlc-adoption-plan.md. Use on "/rr-setup", "set up this project", "analyse this project for AI work", "update the rules", "обнови правилата", "audit our AI setup", or when /rr-status says the project is behind.
-argument-hint: [--survey light|full] | --update [--apply] | --audit [context]
+description: Set up and maintain the .ai/ layer of an existing production codebase. With no flag, scaffold docs/sdlc/, the runtime directory and .ai/, ask the open options (memory, runtimes, survey depth, verify command) in one dialog, survey the code into .ai/project/ (light or full), write the Verification commands, the weight table's project entries and the constitution — read-only towards application code. --options asks them all again; --update regenerates a project's files from the installed plugin (a copy that is a shipped version is replaced, an edited one waits for the human, the project's own files are kept); run it right after installing a new riskrails; --audit scores the repository against the twelve plays and writes docs/ai-sdlc-adoption-plan.md. Use on "/rr-setup", "set up this project", "analyse this project for AI work", "update the rules", "обнови правилата", "audit our AI setup", or when /rr-status says the project is behind.
+argument-hint: [--survey light|full] | --options | --update [--apply] | --audit [context]
 ---
 
 # /rr-setup $ARGUMENTS
@@ -17,29 +17,74 @@ UPDATE="python3 $AI_HOME/skills/project-update/update.py $PWD"
 SETUP="python3 $AI_HOME/skills/rr-setup/setup.py"
 ```
 
-`--update` and `--audit` go to their sections below; anything else
+`--options`, `--update` and `--audit` go to their sections below; anything else
 is **Setup**. In every mode: no application code changes — not a rename, not a
 formatting fix. Problems you find are written down, never fixed. Never read
 `.env`, secrets, dumps or production logs. Do not commit; suggest the `git add`.
 
 ## Setup
 
+0. **Options.** Project memory, the runtimes, the survey depth and `verify_command`
+   are asked once, in one dialog, before any work; the picks feed steps 1, 3 and 5.
+
+   ```bash
+   "$AI_HOME/skills/ai-init/scaffold-ai.sh" "$PWD" --runtime none   # 0a
+   $SETUP options --open    # 0b; --options adds --all, a given --survey adds --skip survey
+   ```
+
+   **0a** makes `.ai/` (so `.ai/policies/dialog.json`) and its `.gitignore` lines, with no
+   instruction file and no runtime directory; only this script takes `none`
+   (`project-scaffold.sh` refuses it). If its output does **not** list
+   `.ai/project/overview.md`, the project was set up before.
+
+   **0b** prints one of three first lines:
+   - `OPTIONS_DIALOG D<n> …`, then state.py's `DIALOG_PENDING` line and a JSON: send that
+     JSON exactly as printed with the dialog tool the line names (AskUserQuestion; Codex:
+     request_user_input).
+   - `OPTIONS_FALLBACK <why>`: nothing was opened. Ask the numbered questions after it in
+     chat as printed, the answers being the picks; show its `memory is the human's` line
+     as printed and never run it.
+   - `OPTIONS_NONE`: nothing to ask.
+
+   Exit 6 (no first line, the reason on stderr): `DECISION_LIMIT` or `DECISION_DUPLICATE`
+   means a decision is already open — settle every one first (`$STATE decision show` and
+   send it, or `$STATE decision fallback --id <Dn> --why "<why>"`), then run 0b once more.
+   Any other refusal, or a second one: ask the questions of steps 1, 3 and 5 in prose and,
+   in a git work tree, give the human for their own terminal, with `$AI_HOME` and `$PWD`
+   substituted: `python3 "<home>/skills/ai-task/state.py" --root "<project>" memory enable
+   --period quarter [--index sqlite]`.
+
+   **0c** — the human answers. After a dialog, a memory command they picked is run first,
+   at once, verbatim and alone; it prints `memory: via dialog (consent C<n>, decision D<n>)`
+   and its pick settles its decision. Then `$STATE decision settle --id <Dn>` for each other
+   decision: it prints `D<n> settled: <label> (set)` and `SETUP_PICK <key>=<value>`, after
+   a decline `SETUP_PICK <key>=`. Apply each pick where its step needs it:
+   - `runtime=<v>` → step 1's two scaffolds with `--runtime <v>`;
+   - `verify=<cmd>` → `$SETUP verify --set "<cmd>"` after step 2; `keep` and `edit` → nothing;
+   - `survey=light` or `full` → step 3's depth; `keep` → no new survey;
+   - `memory=off` or `keep` → nothing: a picked command already ran.
+
+   An empty value (`verify=` is "Not now"; any key after a decline) or `other` → the step
+   as it was without the dialog: step 1 passes `auto`, step 3 surveys `light`, step 5 asks
+   in chat.
 1. **Scaffold.** Both scripts are idempotent, never overwrite, and print what
-   they created; note it. They take `--runtime auto|claude|codex|both` (`auto`
-   follows `CLAUDE.md`/`.claude/` and `AGENTS.md`/`.codex/`); pass `both` when
-   the repository is worked on from both runtimes.
+   they created; note it, 0a's too. They take `--runtime auto|claude|codex|both`
+   (`auto` follows `CLAUDE.md`/`.claude/` and `AGENTS.md`/`.codex/`); pass the
+   `runtime` pick, else `auto` — `both` when the repository is worked on from
+   both runtimes.
 
    ```bash
-   "$AI_HOME/hooks/project-scaffold.sh" "$PWD"       # docs/sdlc/, the runtime dir, .gitignore
-   "$AI_HOME/skills/ai-init/scaffold-ai.sh" "$PWD"   # .ai/
+   "$AI_HOME/hooks/project-scaffold.sh" "$PWD" --runtime <pick>      # docs/sdlc/, the runtime dir, .gitignore
+   "$AI_HOME/skills/ai-init/scaffold-ai.sh" "$PWD" --runtime <pick>  # the instruction file; .ai/ is 0a's
    ```
 
-   If `.ai/project/overview.md` was **not** created, the project was set up
+   If 0a did **not** create `.ai/project/overview.md`, the project was set up
    before: run **--update** below, then ask whether the survey should be
    refreshed; a refresh never overwrites a `.ai/project/` file a human edited
-   without saying so first. If only an instruction file was created (no `.ai/`
-   wanted), fill its Commands / Conventions / Architecture from the manifests —
-   one line per command, five sentences of architecture — and stop.
+   without saying so first. If 0a and this step together created only an
+   instruction file (no `.ai/` wanted), fill its Commands / Conventions /
+   Architecture from the manifests — one line per command, five sentences of
+   architecture — and stop.
 2. **Stack.** `$SETUP survey` first: the project's own toolbox
    (`.claude/{skills,commands,rules,agents,hooks}`, `.codex/*`, `bin/*.sh`,
    Makefile targets) with each item's purpose, the guards a project hook
@@ -51,13 +96,15 @@ formatting fix. Problems you find are written down, never fixed. Never read
    (`phpunit.xml*`, `phpstan.neon*`, `playwright.config.*` …). For Symfony or
    Sylius also: bundles, entities, state machines, Messenger, event
    subscribers, payment, shipping, tax, promotions, ERP or fiscal integrations.
-3. **Survey.** `--survey light` is the default, for a developer who knows the
-   project: ask for a ten-minute brain dump (entry points, modules that matter,
-   integrations, unwritten business rules, areas nobody dares touch), confirm
+   Then write the `verify=<cmd>` pick, if any (0c).
+3. **Survey.** The depth is the `survey` pick or `--survey light|full`. `light`,
+   the default, is for a developer who knows the project: ask for a ten-minute
+   brain dump (entry points, modules that matter, integrations,
+   unwritten business rules, areas nobody dares touch), confirm
    each claim with `grep -n`, then fan out exactly **two** `ai-discovery` agents
    in one message: (1) legacy, risks and code that looks unused; (2) tests,
    CI/CD, data and configuration — how secrets are supplied, never their
-   values. `--survey full`, for a codebase new to you: one `Explore` for the
+   values. `full`, for a codebase new to you: one `Explore` for the
    inventory, then six `ai-discovery` agents in one message — entry points;
    domain modules; integrations and their failure handling; business rules and
    legacy; tests and CI/CD; data and configuration. Hand each the slice of the
@@ -68,14 +115,15 @@ formatting fix. Problems you find are written down, never fixed. Never read
    write `Documented behaviour / Observed behaviour / Evidence / Risk` and do
    not resolve it.
 5. **Policies.** Fill the project sections of `.ai/policies/coding.md` and
-   `testing.md` only if step 1 created them. The **Verification** block of
+   `testing.md` only if 0a created them. The **Verification** block of
    `testing.md` is the feedback loop every task runs:
    - `verify_command` — the fast suite to the end, the e2e group **excluded**;
    - `step_test_command` — the same runner on given paths (`{files}`);
    - `e2e_command` — the end-to-end suite, or `none` when there is none;
    - two or three lines of what healthy output looks like.
 
-   `verify_command` comes from the human: show the one `$SETUP survey`
+   `verify_command` comes from the human: the `verify=<cmd>` pick is their yes,
+   written at the end of step 2; without one, show the one `$SETUP survey`
    proposed, ask, and only after a yes in chat write it with
    `$SETUP verify --set "<command>"` (exit 3: one is already set — the human
    edits it). `$SETUP check` then exits 0; `VERIFY_COMMAND_MISSING` (exit 1)
@@ -109,7 +157,7 @@ formatting fix. Problems you find are written down, never fixed. Never read
    casually, the weight-table entries you chose, recommended next improvements —
    recommendations only, none implemented. When the survey found a toolbox,
    name each toolbox item the project keeps using; they stay where they are.
-9. **Report.** Files created (a tree from the scaffold output), surprising
+9. **Report.** Files created (a tree from the scaffold output, 0a's too), surprising
    findings, the modes and what puts a change in each, the safety restrictions
    in force (hooks versus policy), the tooling the workflows reuse, assumptions,
    unresolved questions and who can answer them, the survey's superpowers
@@ -118,6 +166,14 @@ formatting fix. Problems you find are written down, never fixed. Never read
    `/rr-plan <it>`. Claim nothing was validated that was not run. Suggest
    `git add .ai .gitignore docs/sdlc` plus the instruction files created.
 
+## --options
+
+Reopens every option on a set-up project: 0a, then `$SETUP options --open --all`, then
+send, settle and apply as in step 0 — a `survey` pick runs steps 3–4 at that depth, as a
+refresh (step 1), and a `verify` command is written at once. Say what changed and stop;
+no other step reruns. A project 0a just scaffolded (it listed
+`.ai/project/overview.md`) continues as the plain **Setup**.
+
 ## --update
 
 The script regenerates; you show it, confirm what is owed, and merge what it

package/skills/rr-setup/scaffold_ai.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """Idempotent .ai/ scaffold for RiskRails.
-  scaffold_ai.py [project-dir] [--runtime auto|claude|codex|both]   (default: $PWD, auto)
+  scaffold_ai.py [project-dir] [--runtime auto|claude|codex|both|none]   (default: $PWD, auto)
 skills/ai-init/scaffold-ai.sh execs it; the templates stay in skills/ai-init/.
 
 Never overwrites an existing file. Run it as often as you like: it creates what
@@ -14,6 +14,10 @@ that points at it differs — CLAUDE.md for Claude Code, AGENTS.md for Codex.
 A port of the shell script it replaced, kept to its bytes: the same files and
 modes, the same listing in the same order, the same messages and exit codes
 (tests/test_scaffold_differential.py runs the frozen shell beside it).
+
+One value is new, and the shell refuses it: `--runtime none` (or AI_RUNTIMES=none) scaffolds .ai/ and its
+.gitignore lines and no instruction file, so /rr-setup can open .ai/ before the project's runtimes are chosen.
+Like `both` and `auto` it is a whole value: inside a list it is an unknown runtime, as in the shell.
 """
 import errno
 import json
@@ -143,7 +147,9 @@ def logical_cd(root):
 
 
 def runtimes(runtime, root):
-    """The runtimes in scope: what the project declares (auto), or the list given."""
+    """The runtimes in scope: what the project declares (auto), the list given, or none at all."""
+    if runtime == "none":
+        return set()
     if runtime == "both":
         runtime = "claude,codex"
     if runtime == "auto":