@hanzlaa/rcode 3.6.16 → 4.0.0

package/rihal/workflows/explore.md

@@ -1,171 +0,0 @@
-<purpose>
-Socratic ideation workflow. Guides the developer through exploring an idea via probing questions,
-offers mid-conversation research when useful, then routes crystallized outputs to Rihal artifacts.
-</purpose>
-
-
-## Step 0 — Usage check
-
-If `$ARGUMENTS` is empty or contains only `--help` or `-h`:
-
-```
-/rihal-explore <argument-here>
-```
-
-**Examples:**
-```
-/rihal-explore example 1
-/rihal-explore example 2
-```
-
-STOP — do not proceed.
-
-<required_reading>
-Read all files referenced by the invoking prompt's execution_context before starting.
-
-@.rihal/references/questioning.md
-@.rihal/references/domain-probes.md
-</required_reading>
-
-<available_agent_types>
-Valid Rihal subagent types (use exact names — do not fall back to 'general-purpose'):
-- rihal-phase-researcher — Researches specific questions and returns concise findings
-</available_agent_types>
-
-<process>
-
-## Step 1: Open the conversation
-
-If a topic was provided, acknowledge it and begin exploring:
-```
-## Explore: {topic}
-
-Let's think through this together. I'll ask questions to help clarify the idea
-before we commit to any artifacts.
-```
-
-If no topic, ask:
-```
-## Explore
-
-What's on your mind? This could be a feature idea, an architectural question,
-a problem you're trying to solve, or something you're not sure about yet.
-```
-
-## Step 2: Socratic conversation (2-5 exchanges)
-
-Guide the conversation using principles from `questioning.md` and `domain-probes.md`:
-
-- Ask **one question at a time** (never a list of questions)
-- Questions should probe: constraints, tradeoffs, users, scope, dependencies, risks
-- Use domain-specific probes contextually when the topic touches a known domain
-- Listen for signals: "or" / "versus" / "tradeoff" indicate competing priorities worth exploring
-- Reflect back what you hear to confirm understanding before moving forward
-
-**Conversation should feel natural, not formulaic.** Avoid rigid sequences. Follow the developer's energy — if they're excited about one aspect, go deeper there.
-
-## Step 3: Mid-conversation research offer (after 2-3 exchanges)
-
-If the conversation surfaces factual questions, technology comparisons, or unknowns that research could resolve, offer:
-
-```
-This touches on [specific question]. Want me to do a quick research pass before we continue?
-This would take ~30 seconds and might surface useful context.
-
-[Yes, research this] / [No, let's keep exploring]
-```
-
-If yes, spawn a research agent:
-```
-Task(
-  prompt="Quick research: {specific_question}. Return 3-5 key findings, no more than 200 words.",
-  subagent_type="rihal-phase-researcher"
-)
-```
-
-Share findings and continue the conversation.
-
-If the topic doesn't warrant research, skip this step entirely. **Don't force it.**
-
-## Step 4: Crystallize outputs (after 3-6 exchanges)
-
-When the conversation reaches natural conclusions or the developer signals readiness, propose outputs. Analyze the conversation to identify what was discussed and suggest **up to 4 outputs** from:
-
-| Type | Destination | When to suggest |
-|------|-------------|-----------------|
-| Note | `.planning/notes/{slug}.md` | Observations, context, decisions worth remembering |
-| Todo | `.planning/todos/pending/{slug}.md` | Concrete actionable tasks identified |
-| Seed | `.planning/seeds/{slug}.md` | Forward-looking ideas with trigger conditions |
-| Research question | `.planning/research/questions.md` (append) | Open questions that need deeper investigation |
-| Requirement | `REQUIREMENTS.md` (append) | Clear requirements that emerged from discussion |
-| New phase | `ROADMAP.md` (append) | Scope large enough to warrant its own phase |
-
-Present suggestions:
-```
-Based on our conversation, I'd suggest capturing:
-
-1. **Note:** "Authentication strategy decisions" — your reasoning about JWT vs sessions
-2. **Todo:** "Evaluate Passport.js vs custom middleware" — the comparison you want to do
-3. **Seed:** "OAuth2 provider support" — trigger: when user management phase starts
-
-Create these? You can select specific ones or modify them.
-
-[Create all] / [Let me pick] / [Skip — just exploring]
-```
-
-**Never write artifacts without explicit user selection.**
-
-## Step 5: Write selected outputs
-
-For each selected output, write the file:
-
-- **Notes:** Create `.planning/notes/{slug}.md` with frontmatter (title, date, context)
-- **Todos:** Create `.planning/todos/pending/{slug}.md` with frontmatter (title, date, priority)
-- **Seeds:** Create `.planning/seeds/{slug}.md` with frontmatter (title, trigger_condition, planted_date)
-- **Research questions:** Append to `.planning/research/questions.md`
-- **Requirements:** Append to `.planning/REQUIREMENTS.md` with next available REQ ID
-- **Phases:** Use existing `/rihal-add-phase` command via SlashCommand
-
-Commit if `commit_docs` is enabled:
-```bash
-node "$PROJECT_ROOT/.rihal/bin/rihal-tools.cjs" commit "docs: capture exploration — {topic_slug}" --files {file_list}
-```
-
-## Step 6: Close
-
-```
-## Exploration Complete
-
-**Topic:** {topic}
-**Outputs:** {count} artifact(s) created
-{list of created files}
-
-Continue exploring with `/rihal-explore` or start working with `/rihal-next`.
-```
-
-</process>
-
-<success_criteria>
-- [ ] Socratic conversation follows questioning.md principles
-- [ ] Questions asked one at a time, not in batches
-- [ ] Research offered contextually (not forced)
-- [ ] Up to 4 outputs proposed from conversation
-- [ ] User explicitly selects which outputs to create
-- [ ] Files written to correct destinations
-- [ ] Commit respects commit_docs config
-</success_criteria>
-
-## Success Criteria
-
-- [ ] Task completed as requested
-- [ ] Output saved or reported
-- [ ] State updated if necessary
-- [ ] No errors encountered
-
-## On Error
-
-If arguments are invalid, missing files, or subagent fails:
-- Validate inputs match expected format
-- Check that required files exist
-- Retry with clearer arguments or report the specific error to the user
-

package/rihal/workflows/export-to-github.md

@@ -1,174 +0,0 @@
-# Workflow: rihal-export-to-github
-
-<purpose>
-Push Rihal state to GitHub as issues, milestones, and (optionally) a Project v2 board. Thin slash-command wrapper around the existing `rihal-code github-sync` CLI, plus a `--decisions` mode that publishes the project's recent decision log as a single tracking issue.
-
-Use this to externalize a phase into GitHub for stakeholders who live in issues, to seed a milestone before starting work, or to publish decisions for team visibility.
-</purpose>
-
-<output_format>
-Open with banner:
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- RIHAL ► EXPORT TO GITHUB
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
-
-Always default to dry-run. Show a preview, then require `--execute` on a follow-up run to mutate GitHub.
-</output_format>
-
-<required_reading>
-@.rihal/references/output-format.md
-@.rihal/references/command-redirect-format.md
-</required_reading>
-
-<process>
-## Step 0 — Usage check
-
-If `$ARGUMENTS` is empty or contains `--help` / `-h`:
-
-```
-/rihal-export-to-github [target] [flags]
-
-Targets (mutually exclusive):
-  (none)                    Sync all phases → milestones, epics/stories → issues
-  --phase <id>              One phase
-  --sprint <id>             One sprint's stories
-  --epic <id>               One epic + its child stories
-  --story <id>              One story only
-  --decisions [--since ISO] Publish recent decisions as a single tracking issue
-
-Flags (passed through to rihal-code github-sync):
-  --repo owner/name         Target repo (default: auto-detect from gh)
-  --with-labels             Create Rihal label taxonomy
-  --project                 Also create a GitHub Project v2 board
-  --no-update / --no-close / --no-update-body / --no-update-labels
-  --execute                 Actually mutate (default is dry-run)
-  --yes                     Skip confirmation (requires --force-yolo in yolo mode)
-```
-
-STOP — do not proceed.
-
-## Step 1 — Preflight
-
-```bash
-# gh CLI must be installed and authenticated
-command -v gh >/dev/null 2>&1 || { echo "gh CLI not installed. Install: https://cli.github.com/"; exit 0; }
-gh auth status >/dev/null 2>&1 || { echo "gh not authenticated. Run: gh auth login"; exit 0; }
-```
-
-## Step 2 — Branch on target
-
-### Standard targets (phase/sprint/epic/story/default)
-
-Delegate to the CLI:
-
-```bash
-node "$(command -v rihal-code || echo ./cli/index.js)" github-sync $ARGUMENTS
-```
-
-If `rihal-code` is not on PATH, fall back to `node ./cli/index.js github-sync $ARGUMENTS`. The CLI handles:
-
-- Auto-detecting the repo via `gh repo view`
-- Idempotent sync of phases → milestones, stories → issues
-- Dry-run by default (mutations require `--execute`)
-- Guided/yolo confirmation gates per `AGENTS.md`
-
-Pass through all arguments unchanged. Print the CLI output verbatim — do not re-wrap it.
-
-### Decisions target
-
-When `$ARGUMENTS` starts with `--decisions`, follow this branch instead:
-
-```bash
-SINCE=""
-if echo "$ARGUMENTS" | grep -q -- "--since"; then
-  SINCE=$(echo "$ARGUMENTS" | grep -oE -- "--since [^ ]+" | awk '{print $2}')
-fi
-
-# Pull this project's decisions from the cross-project log
-RESULT=$(node .rihal/bin/rihal-tools.cjs state decisions-global --limit 100 ${SINCE:+--since "$SINCE"} --project "$(node .rihal/bin/rihal-tools.cjs state read | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{process.stdout.write(JSON.parse(s).project||"")}catch{}}')" 2>/dev/null)
-```
-
-Render the decisions as a markdown table in the issue body:
-
-```markdown
-# Decision Log — {project_name}
-
-_Generated by `/rihal-export-to-github --decisions` on {ISO date}. Source: `~/.rihal/decisions.jsonl` (this project only)._
-
-| Date | Phase | Plan | Decision |
-|------|-------|------|----------|
-| {YYYY-MM-DD} | {phase} | {plan} | {summary} |
-| ... |
-```
-
-**Dry-run (default):**
-
-Print the rendered markdown to stdout with a header "The following issue would be created:" and STOP. Do not call `gh`.
-
-**With `--execute`:**
-
-```bash
-REPO_FLAG=""
-if echo "$ARGUMENTS" | grep -q -- "--repo"; then
-  REPO_FLAG=$(echo "$ARGUMENTS" | grep -oE -- "--repo [^ ]+")
-fi
-
-TITLE="Decision log — ${PROJECT_NAME} (${ISO_DATE})"
-
-# Confirmation gate — mandatory before mutating GitHub
-echo "About to create issue: ${TITLE} in repo $(gh repo view --json nameWithOwner -q .nameWithOwner)"
-read -p "Proceed? [y/N] " CONFIRM
-[ "$CONFIRM" = "y" ] || { echo "Aborted."; exit 0; }
-
-gh issue create $REPO_FLAG \
-  --title "$TITLE" \
-  --label "rihal,decisions" \
-  --body-file /tmp/rihal-decisions-export.md
-```
-
-On success, echo the issue URL returned by `gh issue create`.
-
-## Step 3 — Report
-
-For standard targets: rely on the CLI's own summary.
-
-For `--decisions`:
-
-```
-✓ Created issue: {url}
-  Contents: {N} decisions{since_suffix}
-```
-
-Where `since_suffix` is `, since {ISO}` if `--since` was passed.
-
-## Step 4 — Record in state
-
-After a successful mutation (either CLI or --decisions), append a decision for traceability:
-
-```bash
-node .rihal/bin/rihal-tools.cjs state add-decision \
-  "Exported ${TARGET_DESCRIPTION} to GitHub: ${ISSUE_OR_SUMMARY_URL}" \
-  2>/dev/null || true
-```
-
-This also mirrors to `~/.rihal/decisions.jsonl` so `/rihal-decisions` surfaces the export.
-</process>
-
-## Success Criteria
-
-- Dry-run is the default for every target — mutations require `--execute`
-- `gh` preflight aborts cleanly if the CLI is missing or unauthenticated
-- Standard targets fully delegate to `rihal-code github-sync` (no duplicated logic)
-- `--decisions` target reads from `~/.rihal/decisions.jsonl` filtered to this project
-- Confirmation gate is shown before `gh issue create` — yolo mode does NOT bypass this for GitHub mutations
-- Successful export is recorded via `state add-decision` for audit trail
-
-## On Error
-
-- `gh auth status` fails → tell the user to run `gh auth login`, exit
-- `gh repo view` fails (no remote) → tell the user to pass `--repo owner/name`, exit
-- `rihal-code` missing from PATH → fall back to `node ./cli/index.js`; if that also fails, instruct the user to `pnpm install` from the repo root
-- Empty decision log under `--decisions` → print "No decisions to export{since_suffix}. Run /rihal-council or complete a sprint to create some." and exit cleanly

package/rihal/workflows/feature-drift.md

@@ -1,243 +0,0 @@
-# Workflow: rihal-feature-drift
-
-<purpose>
-Detect drift between PRD, epics, stories, and code. Report severity-tagged
-findings; optionally fix trivial items in-place via opt-in `--fix` flag.
-
-Closes the gap between feature-documentation layers that no other rihal tool
-spans (`docs-update` covers project docs, `correct-course` covers PRD-vs-code
-only, `memory-audit` reports but doesn't fix). Mirrors the writer+verifier
-loop pattern established by `docs-update`.
-</purpose>
-
-<required_reading>
-@.rihal/references/output-format.md
-</required_reading>
-
-<process>
-
-<step name="parse_args">
-Extract from $ARGUMENTS:
-- `--fix` flag — opt-in auto-fix for trivial items only (severity allowlist enforced in code)
-- `--quick` flag — fast-mode for hooks (Phase 8). Skips deep verifier loop, runs the auditor scan only. Target runtime <2s. **QUICK_MODE always implies report-only — never patches even if `--fix` is also passed.**
-- `--scope <phase|project>` — phase scope reads phase-local docs; project scope reads root docs
-- `--mode <feature|phase-status>` — drift dimension. `feature` (default) compares PRD↔epics↔stories↔code. `phase-status` (Phase 8 / #461) compares ROADMAP claim against shipping reality (SUMMARY.md presence, SPRINT.md presence, git log).
-- Optional positional phase number (only required when scope=phase)
-
-Default scope: project (root `.planning/PRD.md`, `.planning/epics/`, `.planning/stories/`). Default mode: feature.
-
-```bash
-FIX_MODE=false
-QUICK_MODE=false
-MODE="feature"
-
-if [[ "$ARGUMENTS" =~ (^|[[:space:]])--fix($|[[:space:]]) ]]; then
-  FIX_MODE=true
-fi
-if [[ "$ARGUMENTS" =~ (^|[[:space:]])--quick($|[[:space:]]) ]]; then
-  QUICK_MODE=true
-  # Safety: --quick forces report-only regardless of --fix.
-  # Hooks must never auto-modify files.
-  FIX_MODE=false
-fi
-if [[ "$ARGUMENTS" =~ --mode[[:space:]]+(feature|phase-status) ]]; then
-  MODE="${BASH_REMATCH[1]}"
-fi
-if [[ "$ARGUMENTS" =~ --mode=(feature|phase-status) ]]; then
-  MODE="${BASH_REMATCH[1]}"
-fi
-```
-</step>
-
-<step name="load_artifacts">
-Locate and read the layers that exist; track which layers are absent.
-
-For project scope:
-- PRD: `.planning/PRD.md` (or `.planning/REQUIREMENTS.md` as fallback)
-- Epics: `.planning/epics/*.md`
-- Stories: `.planning/stories/*.md`
-- Code surface: `src/`, `lib/`, `packages/`, `app/` (best-effort directory discovery)
-
-For phase scope (phase number passed):
-- PRD: `.planning/phases/{N}-*/PRD.md` (or per-phase REQUIREMENTS.md)
-- Epics: `.planning/phases/{N}-*/epics/*.md`
-- Stories: `.planning/phases/{N}-*/stories/*.md`
-- Code surface: same as project scope, plus any phase-specific `files_modified` from prior SPRINT.md
-
-For each missing artifact, log a warning to stdout and continue. This is
-**fail-open with notice** per Phase 6 D-3: never block scanning when an
-upstream layer is absent — report partial scope clearly.
-
-Track `present_layers[]` (subset of `["prd","epics","stories","code"]`).
-</step>
-
-<step name="scan_drift">
-**If `MODE=feature` (default):**
-
-Spawn `rihal-docs-auditor` with `--mode=feature-drift`. Pass:
-- artifact contents (from previous step)
-- `present_layers[]` so the auditor doesn't claim drift between absent layers
-- code surface paths
-
-Auditor returns structured JSON:
-
-```json
-{
-  "drift": [
-    {
-      "id": "drift-001",
-      "severity": "trivial|minor|major|critical",
-      "layer_a": "prd|epics|stories|code",
-      "layer_b": "prd|epics|stories|code",
-      "claim_a": "<text from layer_a>",
-      "claim_b": "<text from layer_b>",
-      "file": "<path>",
-      "line": <number-or-null>,
-      "fix_hint": "<exact replacement string when severity=trivial; otherwise null>"
-    }
-  ],
-  "layers_skipped": ["..."]
-}
-```
-
-**If `MODE=phase-status` (Phase 8 / #461):**
-
-Spawn `rihal-docs-auditor` with `--mode=phase-status`. Pass:
-- `roadmap_phases[]` — output of `node .rihal/bin/rihal-tools.cjs roadmap list-phases` (post-#464 fix)
-- `phase_dirs[]` — output of `node .rihal/bin/rihal-tools.cjs init phase-op N` for each phase number, OR a direct walk of `.planning/phases/*` that captures: dir name, presence of `*-SUMMARY.md`, `*-SPRINT.md`, `*-PLAN.md`, `*-CONTEXT.md`, `*-RESEARCH.md`, `*-VERIFICATION.md`
-- For each phase, the most recent commit hash that touches files in `${phase_dir}/` (used as a freshness signal)
-
-Auditor returns structured JSON:
-
-```json
-{
-  "drift": [
-    {
-      "id": "phase-status-drift-001",
-      "severity": "trivial|partial|major",
-      "phase_number": "<N>",
-      "claimed_status": "Complete|Active|Planned",
-      "shipping_signals": {
-        "has_summary": true,
-        "has_sprint": true,
-        "last_commit_iso": "<YYYY-MM-DD>",
-        "phase_dir_present": true
-      },
-      "evidence": "<one-line summary of why this is drift>",
-      "fix_hint": "<for trivial: exact ROADMAP edit (e.g., add ✓ marker); for partial/major: null>"
-    }
-  ]
-}
-```
-
-**Severity rules (HARD, enforced in this workflow not delegated):**
-- `trivial` — missing `✓` marker on heading even though Status says Complete; or missing date on Status: Complete line. `fix_hint` carries the exact insertion.
-- `partial` — N of M acceptance items shipped per phase ROADMAP entry; status doesn't reflect partial state. `fix_hint` is null — humans must decide whether to flip status or update acceptance.
-- `major` — entirely-incorrect status. Examples: Status: Complete with NO SUMMARY.md and NO commits on phase scope; Status: Planned but ALL acceptance items shipped (the Phase 4 case from this session). `fix_hint` always null — humans must decide.
-
-Parse the JSON. If parsing fails or the `drift` field is absent, treat the auditor's response as a malfunction and abort with a clear error pointing the user at the agent definition.
-</step>
-
-<step name="severity_classify">
-Hard allowlist for `--fix` mode — enforced in code, not by agent discretion.
-
-Trivial only:
-- typo correction (single-word misspelling, lowercase/uppercase letter case)
-- stale ISO date (e.g., "2024-12-31" when current date is later)
-- broken relative path (e.g., docs reference `./foo.md` but file moved)
-- factually-wrong-and-mechanically-correctable values (e.g., "API returns JSON" when code returns YAML — only when `fix_hint` carries the exact replacement)
-
-Anything else (minor / major / critical) is **report-only** — never patched
-even if `--fix` is set. This is the safety promise of D-2; do not weaken it.
-</step>
-
-<step name="report_or_fix">
-**If `FIX_MODE=false`:**
-
-Determine output path:
-- Inside a phase context: `${phase_dir}/DRIFT.md`
-- Otherwise: `.planning/audits/feature-drift-${ISO-date}.md`
-
-Write the report grouped by severity (critical / major / minor / trivial),
-each section listing the findings with: layer pair, claim mismatch, file:line.
-Print summary: `{N} drift findings — {trivial}/{minor}/{major}/{critical}`.
-
-**Phase ID convention for "proposed phase" / "Phase candidate" columns.**
-If the report includes a column suggesting where a finding should land
-(e.g. for downstream `/rihal-plan-milestone-gaps`), use the project's
-real numeric phase numbering — never invent English-letter labels like
-`P-NEW-AI-1` or `P-FIX-N`. Resolve the next free integer with:
-
-```bash
-HIGHEST=$(node ".rihal/bin/rihal-tools.cjs" phases list --pick "directories[-1]" 2>/dev/null || echo "")
-# Extract leading number; next candidate = N + 1, N + 2, ...
-```
-
-Or for a related cluster of findings, propose decimals under the most
-relevant existing phase (e.g. 14.1, 14.2) — the CLI auto-resolves the
-next free `parent.M` via `phase add --decimal <parent>` (#477 item C).
-
-This convention follows the `feedback-no-leading-zeros` rule from the
-Memory Bank: phase 6 not 06, phase 14.1 not 14-01, never letter-prefixed
-ad-hoc IDs.
-
-**If `FIX_MODE=true`:**
-
-Bounded fix loop, max 3 passes:
-
-```
-pass = 0
-while pass < 3:
-  pass += 1
-  trivial_findings = drift.filter(d => d.severity == "trivial")
-  if trivial_findings is empty: break
-
-  for each trivial finding:
-    spawn rihal-noor (writer) with the fix_hint payload
-    after the writer returns, run:
-      git add <file>
-      git commit -m "fix(drift): <what was stale> → <what's true now>"
-
-  re-run scan_drift (the auditor) to detect any new drift surfaced by the fixes
-```
-
-For findings with severity > trivial: add to the report only; never patch.
-
-After the loop, write the final report (same path as report-only mode), and
-print: `Fixed {N} trivial drifts across {N} commits. Report: {path}`.
-</step>
-
-<step name="commit">
-If `--fix` produced commits, those were already atomic per fix — no further
-work is needed.
-
-The report file itself is committed only when `commit_docs` is true:
-
-```bash
-COMMIT_DOCS=$(node ".rihal/bin/rihal-tools.cjs" config-get commit_docs 2>/dev/null || echo "false")
-if [[ "$COMMIT_DOCS" == "true" ]]; then
-  git add "${REPORT_PATH}"
-  git commit -m "docs(drift): scan ${ISO_DATE}"
-fi
-```
-</step>
-
-</process>
-
-<guardrails>
-- NEVER patch items above trivial severity, even if user passes a `--force` flag (don't even accept --force here)
-- NEVER spawn parallel writer agents — drift fixes must be sequential to avoid conflicting edits to the same file
-- Bounded fix loop: max 3 passes. If trivial findings remain after 3 passes, abort the loop and report them as unresolvable
-- If `layers_skipped` is non-empty, the report MUST clearly state which drift could not be detected (so the absence of findings doesn't read as "no drift exists")
-- The hard severity allowlist (trivial only for --fix) is enforced in this workflow's code path, not delegated to the agent. Do not move the check into the agent.
-- **`--quick` and `--fix` interaction (Phase 8):** when `QUICK_MODE=true`, `FIX_MODE` is forced to false in parse_args. Hooks must never auto-modify files. If a user explicitly invokes `feature-drift --quick --fix`, the workflow runs in report-only and prints a notice that `--fix` was suppressed by `--quick`. Do not weaken this rule.
-- **`--mode=phase-status` (Phase 8 / #461):** detector reads ROADMAP.md `**Status:**` lines and compares against shipping signals (SUMMARY.md, SPRINT.md, git log on phase scope). Severity rules: trivial = missing ✓ marker; partial = N of M acceptance items shipped; major = entirely-incorrect-status (e.g., Complete with no SUMMARY, Planned with all artifacts shipped). `--fix` patches only the trivial tier (✓ marker addition + missing date). NEVER auto-flip Active→Complete or Planned→Complete — those are decisions, not corrections.
-</guardrails>
-
-<success_criteria>
-- [ ] DRIFT.md (or `audits/feature-drift-{ISO}.md`) written with severity-grouped sections
-- [ ] When `--fix` set: only trivial items patched, each as atomic commit with `fix(drift):` message prefix
-- [ ] When layers missing: report clearly states limited scope (`layers_skipped` block prominent)
-- [ ] Bounded loop terminates within 3 passes
-- [ ] Report-only mode (no `--fix`) preserves zero file modifications outside the report itself
-</success_criteria>