riskrails 3.2.1 → 4.0.1

package/skills/project-update/migrations/0001_schema_version.py

@@ -1,13 +0,0 @@
-"""0001: record the schema version.
-
-A project scaffolded before schema versions existed has .ai/ without .ai/VERSION,
-which is schema 0. This migration has no operations: the .ai/VERSION write that
-closes every migration run is its whole effect.
-"""
-VERSION = 1
-TITLE = "record the schema version in .ai/VERSION"
-MOVES = []
-
-
-def plan(ctx):  # pylint: disable=unused-argument  # no operations; update.py writes .ai/VERSION
-    """Nothing to do."""

package/skills/project-update/migrations/0002_task_journal.py

@@ -1,123 +0,0 @@
-"""0002: the event journal, and the state keys a task in flight needs for it.
-
-Schema 1 recorded a task's history inside the state file and nowhere else. A
-history entry has three fields and no types, so a reader cannot ask it which
-tier a task was raised from, which step a scope change touched, or how an
-approval was given. The journal answers those, one line per change, append-only,
-beside the audit trail it belongs to.
-
-Two operations, both idempotent:
-
-  * the new state keys, added only where they are absent, so a re-run records
-    nothing and a task at any stage keeps working;
-  * a journal backfilled from `history[]`, written once. Every line it produces
-    carries `backfilled: true` and the legacy event name it came from, because a
-    line reconstructed after the fact is not the same evidence as one written at
-    the moment it happened — and the values that were never recorded (the tier a
-    task was raised *from*, who granted an approval and how) stay missing rather
-    than being invented.
-
-A run interrupted between the two leaves .ai/VERSION at 1, and the next --apply
-completes both.
-"""
-import json
-
-VERSION = 2
-TITLE = "add the task journal and the schema-2 state keys"
-MOVES = []
-
-# history[] event name -> the journal type it becomes. Anything not named here
-# keeps its name in data.legacy_event and is recorded as "legacy": a type this
-# file does not know is still a fact that happened.
-LEGACY_TYPES = {
-    "task_started": "task_started",
-    "stage": "stage_started",
-    "risk_classified": "tier_set",
-    "plan_approved": "plan_registered",
-    "step_started": "step_started",
-    "step_completed": "step_done",
-    "remediation": "step_started",
-    "set": "field_set",
-    "risk_added": "field_set",
-    "risks_cleared": "field_set",
-    "modules": "field_set",
-    "human_approval": "gate_approved",
-    "task_closed": "task_closed",
-    "schema_migrated": "schema_migrated",
-}
-STAGES_IN_DETAIL = " -> "
-
-
-def _add_defaults(state):
-    """The schema-2 keys, added only where they are absent."""
-    task_id = state.get("task_id") or ""
-    state.setdefault("owner_runtime", None)
-    state.setdefault("resume_point", None)
-    state.setdefault("questions",
-                     {"file": ".ai/reports/%s/questions.md" % task_id, "pending": []})
-    state.setdefault("handoff",
-                     {"file": ".ai/state/handoff.md", "written_at": None, "reason": None})
-    approval = state.setdefault("human_approval", {})
-    if isinstance(approval, dict):
-        for key, value in (("requested_at", None), ("gate_id", None),
-                           ("requested_session", None), ("rejected_at", None),
-                           ("via", None), ("unattended", False)):
-            approval.setdefault(key, value)
-    return state
-
-
-def _stage_of(detail, current):
-    """The stage a history entry left the task in, read out of its own text."""
-    if STAGES_IN_DETAIL not in detail:
-        return current
-    return detail.split(STAGES_IN_DETAIL)[-1].split(":")[0].strip() or current
-
-
-def _line(entry, stage, task_id):
-    legacy = entry.get("event") or "legacy"
-    detail = entry.get("detail") or ""
-    data = {"backfilled": True, "legacy_event": legacy}
-    if legacy == "stage" and STAGES_IN_DETAIL in detail:
-        data["from"] = detail.split(STAGES_IN_DETAIL)[0].strip()
-        data["to"] = stage
-    elif legacy == "risk_classified":
-        data["tier"] = detail.split(":")[0].strip()
-        data["from"] = None
-    elif legacy in ("step_completed", "step_started", "remediation"):
-        data["step_id"] = detail.split(":")[0].strip()
-        if legacy == "remediation":
-            data["kind"] = "remediation"
-    elif legacy == "human_approval":
-        data["via"] = "legacy"
-    elif legacy in ("set", "risk_added", "risks_cleared", "modules"):
-        data["field"] = detail.split(" = ")[0].strip() if " = " in detail else legacy
-    return {
-        "ts": entry.get("at") or "",
-        "task": task_id,
-        "event": LEGACY_TYPES.get(legacy, "legacy"),
-        "actor": "migration",
-        "runtime": "unknown",
-        "stage": stage,
-        "detail": detail[:500],
-        "data": data,
-    }
-
-
-def _backfill(state):
-    """One line per history entry, in order, with the stage each one left."""
-    task_id = state.get("task_id") or "unknown"
-    stage, out = "", []
-    for entry in state.get("history") or []:
-        if not isinstance(entry, dict):
-            continue
-        stage = _stage_of(entry.get("detail") or "", stage)
-        out.append(json.dumps(_line(entry, stage, task_id), ensure_ascii=False))
-    return ("\n".join(out) + "\n").encode("utf-8") if out else b""
-
-
-def plan(ctx):
-    ctx.patch_state(_add_defaults)
-    state = ctx.state
-    if not state or not state.get("task_id"):
-        return                            # no task in flight: the journal starts empty
-    ctx.create(".ai/reports/%s/events.jsonl" % state["task_id"], _backfill(state))

package/skills/project-update/migrations/0003_context_diet.py

@@ -1,65 +0,0 @@
-"""0003: take the pipeline text out of the root instruction files.
-
-Every root instruction file used to carry a `## SDLC workflow` section that
-repeated, in prose, what the managed block now routes to. Two copies of the same
-rule is one copy too many: the section is loaded into every session, it drifts
-away from the block the moment either one is edited, and it is the part of the
-file a human never wrote.
-
-The section is removed only when the bytes in the project's file are bytes this
-plugin shipped — matched against a version in the template history, never
-against a pattern over the human's own prose. Anything else is a hint:
-
-  * a section that was edited is the human's text now, and only they can merge it;
-  * a managed block that was edited is never written over, here or anywhere else.
-
-The file is the project's, not the plugin's, so `apply` keeps the original under
-`.ai/reports/project-update-<date>/original/` before the rewrite.
-
-Nothing here is a conflict and nothing is a deletion, so this migration never
-holds `.ai/VERSION`: a project whose sections were all edited still reaches the
-current schema, carrying two hints.
-"""
-
-VERSION = 3
-TITLE = "move the pipeline text out of the instruction files (context diet)"
-MOVES = []
-
-HEADING = b"\n## SDLC workflow"
-NEXT_SECTION = b"\n## "
-NOTE = "SDLC workflow section removed (now in the managed block)"
-
-
-def _section(blob):
-    """The `## SDLC workflow` section of one shipped template, or None: from the
-    newline before its heading to the newline before the next heading, so cutting
-    it out of a file leaves the surrounding blank lines as they were."""
-    start = blob.find(HEADING)
-    if start < 0:
-        return None
-    end = blob.find(NEXT_SECTION, start + 1)
-    return blob[start:] if end < 0 else blob[start:end]
-
-
-def _shipped_section(text, shipped):
-    """The one shipped section this file carries verbatim, or None."""
-    for blob in shipped:
-        section = _section(blob)
-        if section and section in text:
-            return section
-    return None
-
-
-def plan(ctx):
-    for path in ctx.instruction_files():
-        text = ctx.read(path)
-        section = _shipped_section(text, ctx.shipped(path))
-        if section:
-            ctx.edit_text(path, lambda t, s=section: t.replace(s, b"", 1), NOTE)
-        elif HEADING in text:
-            ctx.hint("%s: the SDLC workflow section was edited, so it is yours to keep — "
-                     "the managed block below it now says the same thing" % path)
-        if ctx.block_status(path) == "edited":
-            ctx.hint("%s: the managed block was edited here, so the plugin's stub cannot "
-                     "replace it — move your lines below the block and run /rr-setup --update "
-                     "again" % path)

package/skills/project-update/migrations/0004_deterministic_gates.py

@@ -1,57 +0,0 @@
-"""0004: the state keys the deterministic gates measure into.
-
-Schema 3 recorded what a task decided; it recorded nothing about what the task
-actually changed. `state.py step-done` now measures the step's diff between two
-tree objects, re-scores the tier from it, and the review gate reads a sensor
-report — all of which need somewhere to live in the state file.
-
-One operation, and it adds keys only where they are absent, so a re-run records
-nothing and a task at any stage keeps working. Nothing is backfilled and
-nothing is invented: a task that started before this schema has no base tree,
-and there is no honest way to reconstruct one after the fact. Its measurements
-read `unavailable`, which keeps every review its tier asks for — the safe
-reading, and the true one.
-
-The policy side of this change (the diff budget, the path scopes, the sensor
-set in `risk-tiers.json`) arrives through the normal template walk, which
-merges a JSON policy per key and re-hashes a mirror that was in step. A
-migration that rewrote the same file would ask the human to confirm the same
-change twice.
-"""
-
-VERSION = 4
-TITLE = "add the diff, sensor and test-run keys a task in flight needs"
-MOVES = []
-
-
-def _add_defaults(state):
-    """The schema-4 keys, added only where they are absent."""
-    task_id = state.get("task_id") or ""
-    diff = state.setdefault("diff", {})
-    diff.setdefault("base_commit", None)
-    diff.setdefault("base_tree", None)
-    diff.setdefault("task", {"files": 0, "added": 0, "deleted": 0, "lines": 0,
-                             "excluded_lines": 0, "unbudgeted_lines": 0, "tree": None,
-                             "measured_at": None, "status": "not_measured"})
-    diff.setdefault("rescored_tier", None)
-    diff.setdefault("rescore_reasons", [])
-    diff.setdefault("over_budget", False)
-    state.setdefault("sensors", {"file": ".ai/reports/%s/sensors.json" % task_id,
-                                 "tree": None, "verdict": None, "checked_at": None})
-    state.setdefault("tests", {"runs": [], "suite_runs": 0})
-    state.setdefault("risk_tier_lowered", {"by": None, "at": None, "from": None})
-    for step in ((state.get("approved_plan") or {}).get("steps") or []):
-        if not isinstance(step, dict):
-            continue
-        # A step's kind is what the must-bite check reads: a remediation step
-        # proves nothing on its own, and the R-prefix is how they were named
-        # before there was a field to say so.
-        step.setdefault("kind", "remediation"
-                        if str(step.get("step_id", "")).startswith("R") else "implementation")
-        step.setdefault("tree_before", None)
-        step.setdefault("diff", None)
-    return state
-
-
-def plan(ctx):
-    ctx.patch_state(_add_defaults)

package/skills/project-update/migrations/0005_runtimes_and_plans.py

@@ -1,35 +0,0 @@
-"""0005: the state keys a task needs to move between runtimes on purpose.
-
-Schema 4 already recorded which runtime owns a task and where it resumes, but
-a move was only ever noticed after the fact, by the next command that ran
-somewhere else. `state.py handoff --to` now hands a task over deliberately and
-waits for the receiving side to pick it up; a T4+ review can be asked of the
-other side. Both need a place in the state file.
-
-One operation, adding keys only where they are absent, so a re-run records
-nothing and a task at any stage keeps working. `state.py` fills the same
-defaults in memory, so a task in flight works whether or not this has run; the
-migration exists so the project reports itself behind until it has, and so
-`schema_migrated` lands in the journal. Nothing is backfilled: a task that was
-never handed over has nothing pending, and no review was ever asked of anyone.
-"""
-
-VERSION = 5
-TITLE = "add the pending-handoff and cross-vendor-review keys a task in flight needs"
-MOVES = []
-
-
-def _add_defaults(state):
-    """The schema-5 keys, added only where they are absent."""
-    handoff = state.get("handoff")
-    if not isinstance(handoff, dict):
-        handoff = state["handoff"] = {"file": ".ai/state/handoff.md", "written_at": None,
-                                      "reason": None}
-    handoff.setdefault("pending_to", None)
-    handoff.setdefault("pending_since", None)
-    state.setdefault("cross_vendor_review", None)
-    return state
-
-
-def plan(ctx):
-    ctx.patch_state(_add_defaults)

package/skills/project-update/migrations/0006_shared_files.py

@@ -1,154 +0,0 @@
-"""0006: the shared policies, agent contracts, workflows and templates are read
-from the plugin, not from a copy in every project.
-
-Twenty-nine files under `.ai/` were the same in every project that never edited
-them, and each one was merged on every update. They now ship once, in the
-plugin's shared tree, and a project reads them from there; a file at the same
-path under `.ai/` still wins, as an override. The project keeps what is its own:
-`project/`, `rules/`, `state/`, `reports/`, `VERSION`, and the policies
-risk-tiers.json, risk-tiers.md, path-guard.json, testing.md, coding.md,
-safety.md and security.md. Those two stay project-owned, so an instruction file
-that names `.ai/policies/safety.md` keeps pointing at a file that exists.
-
-The router goes first: before any copy is proposed for deletion, `.ai/AGENTS.md`
-says where the shared files now live. `apply` stops at the first item that
-fails, so no deletion lands while the router is unwritten.
-
-  * no router: the shipped one is created;
-  * a router that already names the shared tree: nothing;
-  * a router the plugin shipped, unedited: replaced by the current one;
-  * an edited router: the section is inserted before the heading that follows
-    it in the shipped router, or appended when that heading was renamed. The
-    human's lines are kept as they are.
-
-Then each shared copy the project has:
-
-  * reached through a symlink, or resolving outside the project: a hint, never
-    deleted;
-  * edited: a hint that it is now an override and no longer receives changes;
-  * byte-identical to a version the plugin shipped (CRLF counts): proposed for
-    deletion, once every installed home has the shared file it falls back to.
-
-A deletion waits for --apply --confirm-delete NAME, and `.ai/VERSION` stays
-where it was until it is settled. The original of every deleted file is kept
-under `.ai/reports/project-update-<date>/original/`; git is the rollback.
-"""
-import re
-
-from migrations import SchemaError
-
-VERSION = 6
-TITLE = "read the shared policies, agent contracts, workflows and templates from the plugin"
-MOVES = []
-
-ROUTER = ".ai/AGENTS.md"
-HEADING = b"\n## Shared files"
-NEXT_SECTION = b"\n## "
-HAS_SECTION = re.compile(rb"(?m)^## Shared files[ \t]*\r?$")
-
-# The shared set, literally: the plugin's tree must equal it (tested). A file
-# that projects once held a copy of is added by a new migration, which plans
-# that copy's deletion; one no project ever held needs only its name here.
-SHARED = (
-    ".ai/policies/production.md",
-    ".ai/policies/database.md",
-    ".ai/policies/git.md",
-    ".ai/policies/release.md",
-    ".ai/policies/context-management.md",
-    ".ai/policies/tooling.md",
-    ".ai/policies/model-routing.md",
-    ".ai/policies/review-economy.md",
-    ".ai/agents/context.md",
-    ".ai/agents/discovery.md",
-    ".ai/agents/implementer.md",
-    ".ai/agents/manager.md",
-    ".ai/agents/planner.md",
-    ".ai/agents/release.md",
-    ".ai/agents/reviewer.md",
-    ".ai/agents/risk.md",
-    ".ai/agents/security.md",
-    ".ai/agents/tester.md",
-    ".ai/workflows/feature.md",
-    ".ai/workflows/bugfix.md",
-    ".ai/workflows/hotfix.md",
-    ".ai/workflows/investigation.md",
-    ".ai/workflows/refactoring.md",
-    ".ai/templates/task-context.md",
-    ".ai/templates/impact-report.md",
-    ".ai/templates/review-report.md",
-    ".ai/templates/release-report.md",
-    ".ai/templates/architecture-decision.md",
-    ".ai/templates/implementation-plan.md",
-    # Added after 0006 shipped (redesign 2.3), so declared_shared() knows them.
-    # They were never copied into a project, so a schema < 6 project has
-    # neither and plan() skips both.
-    ".ai/using-riskrails.md",
-    ".ai/workflows.md",
-)
-REASON = "identical to a version the plugin shipped; its shared copy applies"
-
-
-def _section(blob):
-    """The `## Shared files` section of the shipped router and the line that
-    follows it: from the newline before its heading to the newline before the
-    next heading, so inserting it leaves the blank lines as they were."""
-    start = blob.find(HEADING)
-    if start < 0:
-        return None, None
-    end = blob.find(NEXT_SECTION, start + 1)
-    if end < 0:
-        return blob[start:], None
-    anchor_end = blob.find(b"\n", end + 1)
-    return blob[start:end], blob[end:] if anchor_end < 0 else blob[end:anchor_end]
-
-
-def _add_section(text, section, anchor):
-    """The router with the section in it, its own lines untouched."""
-    crlf = b"\r\n" in text
-    if anchor:
-        at = text.find(anchor + (b"\r\n" if crlf else b"\n"))
-        if at < 0 and text.endswith(anchor):
-            at = len(text) - len(anchor)
-        if at >= 0:
-            if crlf:  # inserted after the \r of the line before the anchor
-                section = section.replace(b"\n", b"\r\n")[1:] + b"\r"
-            return text[:at] + section + text[at:]
-    eol = b"\r\n" if crlf else b"\n"
-    return text.rstrip(b"\r\n") + eol + section.rstrip(b"\n").replace(b"\n", eol) + eol
-
-
-def _router(ctx):
-    shipped = ctx.template(ROUTER)
-    text = ctx.read(ROUTER)
-    if text is None:
-        ctx.create(ROUTER, shipped)
-    elif HAS_SECTION.search(text):
-        return
-    elif ctx.is_shipped(ROUTER, text):
-        ctx.edit_text(ROUTER, lambda _t: shipped, "unchanged since it was installed; now names the shared files")
-    else:
-        section, anchor = _section(shipped)
-        if section is None:
-            raise SchemaError("%04d: the shipped router has no Shared files section" % VERSION)
-        ctx.edit_text(ROUTER, lambda t: _add_section(t, section, anchor),
-                      "Shared files section added; your router edits kept")
-
-
-def plan(ctx):
-    _router(ctx)
-    candidates = []
-    for path in SHARED:
-        if not ctx.exists(path):
-            continue
-        why = ctx.unsafe_target(path)
-        if why:
-            ctx.hint("%s: %s, so this update never deletes it — check by hand whether it is "
-                     "still needed" % (path, why))
-        elif not ctx.is_shipped(path, ctx.read(path)):
-            ctx.hint(ctx.override_note(path))
-        else:
-            candidates.append(path)
-    if candidates:
-        ctx.require_shared(candidates)
-    for path in candidates:
-        ctx.delete(path, REASON)