@hanzlaa/rcode 3.6.15 → 4.0.0

package/rcode/skills/core/rcode-init/scripts/tests/test_rcode_init.py

@@ -0,0 +1,329 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["pyyaml"]
+# ///
+
+#!/usr/bin/env python3
+"""Unit tests for rcode_init.py"""
+
+import json
+import os
+import shutil
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from rcode_init import (
+    find_project_root,
+    parse_var_specs,
+    resolve_project_root_placeholder,
+    expand_template,
+    apply_result_template,
+    load_module_yaml,
+    find_core_module_yaml,
+    find_target_module_yaml,
+    load_config_file,
+    load_module_config,
+)
+
+
+class TestFindProjectRoot(unittest.TestCase):
+
+    def test_finds_rcode_folder(self):
+        temp_dir = tempfile.mkdtemp()
+        try:
+            (Path(temp_dir) / '_rcode').mkdir()
+            original_cwd = os.getcwd()
+            try:
+                os.chdir(temp_dir)
+                result = find_project_root()
+                self.assertEqual(result.resolve(), Path(temp_dir).resolve())
+            finally:
+                os.chdir(original_cwd)
+        finally:
+            shutil.rmtree(temp_dir)
+
+    def test_llm_provided_with_rcode(self):
+        temp_dir = tempfile.mkdtemp()
+        try:
+            (Path(temp_dir) / '_rcode').mkdir()
+            result = find_project_root(llm_provided=temp_dir)
+            self.assertEqual(result.resolve(), Path(temp_dir).resolve())
+        finally:
+            shutil.rmtree(temp_dir)
+
+    def test_llm_provided_without_rcode_still_returns_dir(self):
+        """First-run case: LLM provides path but _rcode doesn't exist yet."""
+        temp_dir = tempfile.mkdtemp()
+        try:
+            result = find_project_root(llm_provided=temp_dir)
+            self.assertEqual(result.resolve(), Path(temp_dir).resolve())
+        finally:
+            shutil.rmtree(temp_dir)
+
+
+class TestParseVarSpecs(unittest.TestCase):
+
+    def test_vars_with_defaults(self):
+        specs = parse_var_specs('var1:value1,var2:value2')
+        self.assertEqual(len(specs), 2)
+        self.assertEqual(specs[0]['name'], 'var1')
+        self.assertEqual(specs[0]['default'], 'value1')
+
+    def test_vars_without_defaults(self):
+        specs = parse_var_specs('var1,var2')
+        self.assertEqual(len(specs), 2)
+        self.assertIsNone(specs[0]['default'])
+
+    def test_mixed_vars(self):
+        specs = parse_var_specs('required_var,var2:default2')
+        self.assertIsNone(specs[0]['default'])
+        self.assertEqual(specs[1]['default'], 'default2')
+
+    def test_colon_in_default(self):
+        specs = parse_var_specs('path:{project-root}/some/path')
+        self.assertEqual(specs[0]['default'], '{project-root}/some/path')
+
+    def test_empty_string(self):
+        self.assertEqual(parse_var_specs(''), [])
+
+    def test_none(self):
+        self.assertEqual(parse_var_specs(None), [])
+
+
+class TestResolveProjectRootPlaceholder(unittest.TestCase):
+
+    def test_resolve_placeholder(self):
+        result = resolve_project_root_placeholder('{project-root}/output', Path('/test'))
+        self.assertEqual(result, '/test/output')
+
+    def test_no_placeholder(self):
+        result = resolve_project_root_placeholder('/absolute/path', Path('/test'))
+        self.assertEqual(result, '/absolute/path')
+
+    def test_none(self):
+        self.assertIsNone(resolve_project_root_placeholder(None, Path('/test')))
+
+    def test_non_string(self):
+        self.assertEqual(resolve_project_root_placeholder(42, Path('/test')), 42)
+
+
+class TestExpandTemplate(unittest.TestCase):
+
+    def test_basic_expansion(self):
+        result = expand_template('{project-root}/output', {'project-root': '/test'})
+        self.assertEqual(result, '/test/output')
+
+    def test_multiple_placeholders(self):
+        result = expand_template(
+            '{output_folder}/planning',
+            {'output_folder': '_rcode-output', 'project-root': '/test'}
+        )
+        self.assertEqual(result, '_rcode-output/planning')
+
+    def test_none_value(self):
+        self.assertIsNone(expand_template(None, {}))
+
+    def test_non_string(self):
+        self.assertEqual(expand_template(42, {}), 42)
+
+
+class TestApplyResultTemplate(unittest.TestCase):
+
+    def test_with_result_template(self):
+        var_def = {'result': '{project-root}/{value}'}
+        result = apply_result_template(var_def, '_rcode-output', {'project-root': '/test'})
+        self.assertEqual(result, '/test/_rcode-output')
+
+    def test_without_result_template(self):
+        result = apply_result_template({}, 'raw_value', {})
+        self.assertEqual(result, 'raw_value')
+
+    def test_value_only_template(self):
+        var_def = {'result': '{value}'}
+        result = apply_result_template(var_def, 'English', {})
+        self.assertEqual(result, 'English')
+
+
+class TestLoadModuleYaml(unittest.TestCase):
+
+    def setUp(self):
+        self.temp_dir = tempfile.mkdtemp()
+
+    def tearDown(self):
+        shutil.rmtree(self.temp_dir)
+
+    def test_loads_core_module_yaml(self):
+        path = Path(self.temp_dir) / 'module.yaml'
+        path.write_text(
+            'code: core\n'
+            'name: "rcode Core Module"\n'
+            'header: "Core Config"\n'
+            'user_name:\n'
+            '  prompt: "What should agents call you?"\n'
+            '  default: "rcode"\n'
+            '  result: "{value}"\n'
+        )
+        result = load_module_yaml(path)
+        self.assertIsNotNone(result)
+        self.assertEqual(result['meta']['code'], 'core')
+        self.assertEqual(result['meta']['name'], 'rcode Core Module')
+        self.assertIn('user_name', result['variables'])
+        self.assertEqual(result['variables']['user_name']['prompt'], 'What should agents call you?')
+
+    def test_loads_module_with_directories(self):
+        path = Path(self.temp_dir) / 'module.yaml'
+        path.write_text(
+            'code: bmm\n'
+            'name: "rcode Method"\n'
+            'project_name:\n'
+            '  prompt: "Project name?"\n'
+            '  default: "{directory_name}"\n'
+            '  result: "{value}"\n'
+            'directories:\n'
+            '  - "{planning_artifacts}"\n'
+        )
+        result = load_module_yaml(path)
+        self.assertEqual(result['directories'], ['{planning_artifacts}'])
+
+    def test_returns_none_for_missing(self):
+        result = load_module_yaml(Path(self.temp_dir) / 'nonexistent.yaml')
+        self.assertIsNone(result)
+
+    def test_returns_none_for_empty(self):
+        path = Path(self.temp_dir) / 'empty.yaml'
+        path.write_text('')
+        result = load_module_yaml(path)
+        self.assertIsNone(result)
+
+
+class TestFindCoreModuleYaml(unittest.TestCase):
+
+    def test_returns_path_to_resources(self):
+        path = find_core_module_yaml()
+        self.assertTrue(str(path).endswith('resources/core-module.yaml'))
+
+
+class TestFindTargetModuleYaml(unittest.TestCase):
+
+    def setUp(self):
+        self.temp_dir = tempfile.mkdtemp()
+        self.project_root = Path(self.temp_dir)
+
+    def tearDown(self):
+        shutil.rmtree(self.temp_dir)
+
+    def test_finds_in_skill_assets(self):
+        skill_path = self.project_root / 'skills' / 'test-skill'
+        assets = skill_path / 'assets'
+        assets.mkdir(parents=True)
+        (assets / 'module.yaml').write_text('code: test\n')
+
+        result = find_target_module_yaml('test', self.project_root, str(skill_path))
+        self.assertIsNotNone(result)
+        self.assertTrue(str(result).endswith('assets/module.yaml'))
+
+    def test_finds_in_skill_root(self):
+        skill_path = self.project_root / 'skills' / 'test-skill'
+        skill_path.mkdir(parents=True)
+        (skill_path / 'module.yaml').write_text('code: test\n')
+
+        result = find_target_module_yaml('test', self.project_root, str(skill_path))
+        self.assertIsNotNone(result)
+
+    def test_finds_in_rcode_module_dir(self):
+        module_dir = self.project_root / '_rcode' / 'mymod'
+        module_dir.mkdir(parents=True)
+        (module_dir / 'module.yaml').write_text('code: mymod\n')
+
+        result = find_target_module_yaml('mymod', self.project_root)
+        self.assertIsNotNone(result)
+
+    def test_returns_none_when_not_found(self):
+        result = find_target_module_yaml('missing', self.project_root)
+        self.assertIsNone(result)
+
+    def test_skill_path_takes_priority(self):
+        """Skill assets module.yaml takes priority over _rcode/{module}/."""
+        skill_path = self.project_root / 'skills' / 'test-skill'
+        assets = skill_path / 'assets'
+        assets.mkdir(parents=True)
+        (assets / 'module.yaml').write_text('code: test\nname: from-skill\n')
+
+        module_dir = self.project_root / '_rcode' / 'test'
+        module_dir.mkdir(parents=True)
+        (module_dir / 'module.yaml').write_text('code: test\nname: from-rcode\n')
+
+        result = find_target_module_yaml('test', self.project_root, str(skill_path))
+        self.assertTrue('assets' in str(result))
+
+
+class TestLoadConfigFile(unittest.TestCase):
+
+    def setUp(self):
+        self.temp_dir = tempfile.mkdtemp()
+
+    def tearDown(self):
+        shutil.rmtree(self.temp_dir)
+
+    def test_loads_flat_yaml(self):
+        path = Path(self.temp_dir) / 'config.yaml'
+        path.write_text('user_name: Test\ncommunication_language: English\n')
+        result = load_config_file(path)
+        self.assertEqual(result['user_name'], 'Test')
+
+    def test_returns_none_for_missing(self):
+        result = load_config_file(Path(self.temp_dir) / 'missing.yaml')
+        self.assertIsNone(result)
+
+
+class TestLoadModuleConfig(unittest.TestCase):
+
+    def setUp(self):
+        self.temp_dir = tempfile.mkdtemp()
+        self.project_root = Path(self.temp_dir)
+        rcode_core = self.project_root / '_rcode' / 'core'
+        rcode_core.mkdir(parents=True)
+        (rcode_core / 'config.yaml').write_text(
+            'user_name: TestUser\n'
+            'communication_language: English\n'
+            'document_output_language: English\n'
+            'output_folder: "{project-root}/_rcode-output"\n'
+        )
+        rcode_bmb = self.project_root / '_rcode' / 'bmb'
+        rcode_bmb.mkdir(parents=True)
+        (rcode_bmb / 'config.yaml').write_text(
+            'user_name: TestUser\n'
+            'communication_language: English\n'
+            'document_output_language: English\n'
+            'output_folder: "{project-root}/_rcode-output"\n'
+            'rcode_builder_output_folder: "{project-root}/_rcode-output/skills"\n'
+            'rcode_builder_reports: "{project-root}/_rcode-output/reports"\n'
+        )
+
+    def tearDown(self):
+        shutil.rmtree(self.temp_dir)
+
+    def test_load_core(self):
+        result = load_module_config('core', self.project_root)
+        self.assertIsNotNone(result)
+        self.assertEqual(result['user_name'], 'TestUser')
+
+    def test_load_module_includes_core_vars(self):
+        result = load_module_config('bmb', self.project_root)
+        self.assertIsNotNone(result)
+        # Module-specific var
+        self.assertIn('rcode_builder_output_folder', result)
+        # Core vars also present
+        self.assertEqual(result['user_name'], 'TestUser')
+
+    def test_missing_module(self):
+        result = load_module_config('nonexistent', self.project_root)
+        self.assertIsNone(result)
+
+
+if __name__ == '__main__':
+    unittest.main()

package/rcode/skills/core/rcode-memory-audit/SKILL.md

@@ -0,0 +1,107 @@
+---
+name: rcode-memory-audit
+description: >
+  Audit the Memory Bank for stale entries, contradictions, missing sections,
+  and content that should be archived. Produces a report with severity-tagged
+  findings and one-line fix suggestions. Activates when the user says
+  "audit memory bank", "check memory bank", "/rcode-memory-audit",
+  "memory bank ka audit", "find stale entries", "is my memory bank healthy".
+  Optional --fix flag patches trivial items (typos, stale dates, broken paths)
+  atomically; non-trivial findings always report-only.
+  Do NOT use for: bootstrap (use rcode-memory-init), surgical updates
+  (use rcode-memory-update), or distillate regeneration (use rcode-memory-distill).
+triggers:
+  # English
+  - "audit memory bank"
+  - "check memory bank"
+  - "find stale entries"
+  - "is my memory bank healthy"
+  - "auto-fix memory bank"
+  - "memory bank --fix"
+  - "patch trivial memory drift"
+  - "/rcode-memory-audit"
+  - "/rcode-memory-audit"
+  # Roman Urdu / Hindi
+  - "memory bank ka audit"
+  - "memory bank ka --fix"
+  - "memory check karo"
+  - "purani entries dhoondo"
+  # Arabic native
+  - "افحص بنك الذاكرة"
+  - "تدقيق الذاكرة"
+  - "ابحث عن إدخالات قديمة"
+  - "هل بنك الذاكرة سليم"
+  - "أصلح الذاكرة"
+user-invocable: false
+---
+@.rcode/references/karpathy-guidelines.md
+
+
+## Overview
+
+Walks the Memory Bank and reports problems. Stale entries (referencing milestones that ended), contradictions (decisions log says X, stack file says Y), missing sections (template placeholders never filled), and content that should be archived (resolved issues lingering in `known-issues.md`). Read-only — never modifies files. Produces a fix list the user can act on with `rcode-memory-update`.
+
+## Workflow
+
+1. **Walk the Memory Bank.** List every file and section.
+2. **Run six checks** (see Output Format) and collect findings.
+3. **Tag severity** per finding: `critical` (broken reference), `warn` (stale or contradictory), `info` (template placeholder still present).
+4. **Group findings by file**, sorted by severity descending.
+5. **Print report.** No file changes.
+
+## The six checks
+
+1. **Stale milestone** — `milestones/current.md` references a milestone whose target close date has passed by ≥30 days
+2. **Resolved issues lingering** — `incidents/known-issues.md` entry has a "Real fix planned for" milestone that has completed
+3. **Template placeholders unfilled** — files still contain `{{PLACEHOLDER}}` patterns or `_(e.g. ...)_` italicised hints from templates
+4. **Stack vs decisions contradiction** — a decision in `decisions.md` references a stack item that doesn't appear in `stack.md`
+5. **Empty subdirectories** — `change-records/`, `incidents/post-mortems/`, `milestones/archive/` contain only `.gitkeep`
+6. **Distillate freshness** — `distillates/*.distillate.md` `source-digest` does not match current source files
+
+## Output Format
+
+```
+Memory Bank Audit — 2026-04-26
+================================
+
+CRITICAL (1)
+  project/decisions.md
+    └─ Decision "Switch to Postgres 16" references stack.md row that doesn't exist
+       Fix: update project/stack.md Runtime → Database to "Postgres 16.x"
+
+WARN (3)
+  milestones/current.md
+    └─ Milestone target close was 2026-02-01 (84 days ago) but file still says "active"
+       Fix: archive via /rcode-memory-update or move to milestones/archive/
+
+  incidents/known-issues.md
+    └─ Issue "SSO Safari 16 fails" — real fix was planned for M2 (closed)
+       Fix: verify and remove, or move to post-mortems/
+
+  distillates/project.distillate.md
+    └─ Source digest stale — 4 source files modified since last regenerate
+       Fix: /rcode-memory-distill
+
+INFO (2)
+  project/glossary.md
+    └─ Empty — no terms recorded yet
+  people/team.md
+    └─ Coverage table contains 3 unfilled cells
+       Fix: /rcode-memory-update with team coverage info
+```
+
+## Examples
+
+**Healthy bank**
+Output: `✓ Memory Bank is healthy. 0 findings.`
+
+**Stale milestone + unfilled glossary**
+Output: lists 2 findings, severity warn + info, suggests fixes per finding.
+
+**Negative — used to fix problems**
+This skill only reports. Fixes happen via `rcode-memory-update`, manual edits, or `rcode-memory-distill`. Do not invoke this skill expecting auto-fix.
+
+## Memory Bank Hooks
+
+- **Reads:** every file under `.rcode/memory/`
+- **Writes:** nothing — strictly read-only

package/rcode/skills/core/rcode-memory-distill/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: rcode-memory-distill
+description: >
+  Generate or regenerate Memory Bank distillates — token-optimised, lossless
+  compressions of Memory Bank source files for fast LLM context loading.
+  Produces `distillates/project.distillate.md` and `distillates/stack.distillate.md`.
+  Activates when the user says "distill memory bank", "regenerate distillates",
+  "refresh distillates", "/rcode-memory-distill", "compress memory bank",
+  "memory bank ko compress karo". Do NOT use for: bootstrap (use rcode-memory-init),
+  surgical updates (use rcode-memory-update), or finding stale entries (use
+  rcode-memory-audit). For non-Memory-Bank document compression, use the
+  existing rcode-distillator skill.
+triggers:
+  - "distill memory bank"
+  - "regenerate distillates"
+  - "refresh distillates"
+  - "compress memory bank"
+  - "memory bank ko compress karo"
+  - "/rcode-memory-distill"
+user-invocable: false
+---
+@.rcode/references/karpathy-guidelines.md
+
+
+## Overview
+
+Read the Memory Bank source files and produce two LLM-optimised distillates: a full project distillate (`distillates/project.distillate.md`) and a stack-only distillate (`distillates/stack.distillate.md`). Distillates are lossless: every fact, decision, constraint, and relationship from the source files is preserved, but presentation overhead (headings, tables, prose connective tissue) is stripped to minimise token cost. Reuses the same compression principle as the existing `rcode-distillator` skill, scoped to Memory Bank files.
+
+## Workflow
+
+1. **Discover sources.** Walk `.rcode/memory/` and group files by target distillate:
+   - **project distillate:** `project/*.md`, `people/*.md`, `milestones/current.md`, `incidents/known-issues.md`
+   - **stack distillate:** `project/stack.md` only
+2. **Hash sources.** Compute a digest of source file mtimes. If digest matches the existing distillate's `source-digest:` frontmatter, skip regeneration unless `--force` was passed.
+3. **Compress.** For each target, read all source files, extract every fact/decision/constraint/relationship, and produce a dense markdown document. No summary mode — preserve everything.
+4. **Verify losslessness.** For each fact in the source files, confirm it appears (verbatim or in directly-equivalent form) in the distillate. Report any drops as a warning.
+5. **Write output** with frontmatter:
+   ```yaml
+   ---
+   generated: true
+   do-not-edit: true
+   regenerate-with: /rcode-memory-distill
+   source-digest: <hash>
+   generated-at: <ISO datetime>
+   source-files: [list of files included]
+   token-estimate: <approximate>
+   ---
+   ```
+6. **Print summary.** Show source file count, output token estimate, time taken.
+
+## Output Format
+
+```
+✓ Memory Bank distillates regenerated
+
+  distillates/project.distillate.md
+    sources:  9 files
+    tokens:   ~4,800
+    digest:   a1b2c3d4
+
+  distillates/stack.distillate.md
+    sources:  1 file
+    tokens:   ~600
+    digest:   e5f6a7b8
+
+Skip notice: source files unchanged since last run — no rewrite was needed.
+```
+
+## Examples
+
+**Happy path**
+User: `/rcode-memory-distill`
+Skill: reads sources, regenerates both distillates, prints summary. ~10 seconds for a typical project.
+
+**No-op skip**
+User runs distill twice in a row without changing source files. Second run reports "source files unchanged" and exits without rewriting.
+
+**Force refresh**
+User: `/rcode-memory-distill --force`
+Skill: regenerates regardless of digest match. Useful when distillate format itself changes.
+
+**Negative — used on non-memory docs**
+User wants to compress `docs/REFERENCE.md`. Wrong skill — direct them to `rcode-distillator` (which handles arbitrary documents).
+
+## Memory Bank Hooks
+
+- **Reads:** every file under `.rcode/memory/{project,people,milestones,incidents}/`
+- **Writes:** `.rcode/memory/distillates/project.distillate.md`, `.rcode/memory/distillates/stack.distillate.md`
+- **Idempotent:** safe to re-run; skips work when sources are unchanged

package/rcode/skills/core/rcode-memory-init/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: rcode-memory-init
+description: >
+  Bootstrap the rcode Memory Bank for a project. Copies templates from
+  `rcode/templates/memory/` into `.rcode/memory/`, then asks 5 questions to
+  populate the most-used files (stack, current milestone, primary stakeholder).
+  Activates when the user says "init memory bank", "bootstrap memory",
+  "set up memory bank", "/rcode-memory-init", "create memory bank",
+  "memory bank initialise", "memory bank kaise banayen". Do NOT use for:
+  updating an existing Memory Bank (use rcode-memory-update), regenerating
+  distillates (use rcode-memory-distill), or finding stale entries (use
+  rcode-memory-audit).
+triggers:
+  # English
+  - "init memory bank"
+  - "bootstrap memory"
+  - "set up memory bank"
+  - "create memory bank"
+  - "memory bank initialise"
+  - "/rcode-memory-init"
+  - "/rcode-memory-init"
+  # Roman Urdu / Hindi
+  - "memory bank kaise banayen"
+  - "memory bank banao"
+  - "memory bank shuru karo"
+  - "memory init karo"
+  # Arabic native
+  - "هيّئ ذاكرة المشروع"
+  - "أنشئ بنك الذاكرة"
+  - "ابدأ ذاكرة ريحال"
+  - "إعداد بنك الذاكرة"
+user-invocable: false
+---
+@.rcode/references/karpathy-guidelines.md
+
+
+## Overview
+
+Initialise the `.rcode/memory/` directory in the current project. Copies the template scaffold, fills `INDEX.md` with the project name and date, and asks five short questions to seed the most useful files. Skill is idempotent: re-running on an initialised project will not overwrite existing entries — it reports gaps instead.
+
+## Workflow
+
+1. **Check for existing Memory Bank.** If `.rcode/memory/INDEX.md` exists, switch to "report mode": list files, show which sections are still empty, and exit. Do not overwrite.
+2. **Copy templates.** Recursively copy `rcode/templates/memory/` → `.rcode/memory/`, preserving the directory structure.
+3. **Substitute placeholders.** Replace `{{PROJECT_NAME}}` with the directory name (or `package.json` `name` if present), and `{{INIT_DATE}}` with today's ISO date.
+4. **Ask the 5 init questions** (one at a time, accept short answers):
+   1. One-sentence project goal → seeds `milestones/current.md` Goal field
+   2. Primary stack (frontend / backend / database) → seeds `project/stack.md` Runtime table
+   3. Current milestone name → seeds `milestones/current.md` Milestone Name
+   4. Primary external stakeholder (name + role) → seeds `people/stakeholders.md`
+   5. Any known production issue today → seeds `incidents/known-issues.md`
+5. **Print the summary.** Show the file tree, where to add more, and recommend running `/rcode-memory-distill` once `project/stack.md` is fleshed out.
+6. **Update `.rcode/state.json`** to record `memory_bank.initialised_at` so the dashboard shows it as live.
+
+## Output Format
+
+```
+✓ Memory Bank initialised at .rcode/memory/
+
+Files seeded from your answers:
+  • milestones/current.md  — goal + milestone name
+  • project/stack.md       — runtime stack
+  • people/stakeholders.md — 1 contact
+  • incidents/known-issues.md — 1 entry
+
+Files still empty (fill as you go):
+  • project/glossary.md
+  • project/design-system.md   — visual tokens + components (read by ui-phase / frontend-design)
+  • people/team.md
+  • change-records/
+
+Next step: run /rcode-memory-distill to generate fast-load distillates.
+```
+
+## Examples
+
+**Happy path**
+User: `/rcode-memory-init`
+Skill: asks 5 questions, populates files, prints summary, updates state.json. Total time: under two minutes.
+
+**Already initialised**
+User: `/rcode-memory-init` on a project that already has `.rcode/memory/INDEX.md`.
+Skill: refuses to overwrite. Lists files, shows which are still empty, suggests `/rcode-memory-update` for surgical edits.
+
+**Negative — wrong skill**
+User wants to "update the stakeholder list". Do not use this skill. Use `rcode-memory-update`.
+
+## Memory Bank Hooks
+
+- **Reads:** `package.json` (for project name), existing `.rcode/state.json`
+- **Writes:** every file under `.rcode/memory/` (from templates), `.rcode/state.json` (`memory_bank.initialised_at`)