fix(lpb-config): render runtime config from templates after reset/update/merge

The config repo ships templates (settings.json.template,
lpb-memory-config.json.template); the rendered runtime files are
gitignored and only start.sh's first-boot block renders them — gated by
~/.pi/.initialized, which survives 'lpb-config reset'. Consequences:

- 'reset' wiped the rendered config and the re-clone only restored
  templates — Pi then ran with no settings.json (no extensions/packages)
  and no memory config, unrecoverable via lpb-config.
- 'update'/'merge' refreshed templates but left rendered pins frozen at
  the old stack version, with no warning.

lpb-config now renders itself:
- 'render [--force]' command: non-forcing creates missing files and warns
  on stale pins / new template packages; forcing merges (user keys and
  user-added packages preserved; template pins win in settings.json,
  local keys win in the memory config)
- auto-render after reset (force), update and merge (non-forcing)
- version substitution mirrors start.sh (LPB_VERSION env first, then the
  devstack VERSION file)
- clone_or_init survives a stale .git with an existing origin
  (remote set-url fallback)
- reset verifies the wipe and warns when entries survive rmtree
- align notes that its pin edits are local (gitignored) state
- status marks the remote HEAD as last-fetch

Tests: 9 new cases in test_localpibox_config.py (20/20 passing;
test_lpb.py 52/52 + all 13 localpibox suites green).

Author: lpb-docs

.pi/skills/localpibox-repo-workflow/SKILL.md

@@ -179,10 +179,20 @@ push. `bump` (without `--push`) warns about this.
 
 ```bash
 lpb-config status | update | reset [--force] | merge   # config repo
+lpb-config render [--force]                             # regen runtime config from templates
 lpb-config align                                        # pins → latest GitHub tags
 lpb-config memory show | setup                          # lpb-memory config
 ```
 
+`render` recreates the gitignored runtime files (`settings.json`,
+`lpb-memory-config.json`) from the repo's templates. lpb-config auto-renders
+after `reset` (force) / `update` / `merge` (non-forcing): without it the
+rendered config was unrecoverable after `reset` (start.sh only renders on
+first boot, gated by `~/.pi/.initialized`). Non-forcing render never
+overwrites — it creates missing files and warns on stale pins; `--force`
+merges (user keys/packages preserved, template pins win in settings.json,
+local keys win in the memory config).
+
 **`lpb-devstack`** — DevOps workspace tool (container + host):
 
 ```bash
@@ -207,11 +217,14 @@ Both tools are thin CLIs over the shared `scripts/localpibox/stack/` library
 
 1. Config repo ships `settings.json.template` with `__LPB_VERSION__` placeholders
 2. First boot: `start.sh` generates `settings.json` (replaces placeholders)
-3. No model/provider preconfigured — user runs `/login lemonade`
-4. Pin sync: `lpb-devstack workspace sync --extensions`
+3. `lpb-config render` regenerates it on demand (auto after reset/update/
+   merge) — this is the recovery path when the rendered file is lost or
+   its pins are stale after a stack version move
+4. No model/provider preconfigured — user runs `/login lemonade`
+5. Pin sync: `lpb-devstack workspace sync --extensions`
    (main pipeline reads the stable version from devstack `origin/main`)
-5. `lpb-devstack validate` checks pins match the current stack version
-6. Persistent on the host volume — survives container rebuilds
+6. `lpb-devstack validate` checks pins match the current stack version
+7. Persistent on the host volume — survives container rebuilds
 
 Pins look like: `git:github.com/lpb-stack/pi-subagents@0.0.57-lpb-dev`
 

scripts/test_localpibox_config.py

@@ -7,6 +7,8 @@
 from testharness import run_lpbx_suite, _quiet_console, log_mod, _load_script, SUPPORT_DIR
 
 import io
+import json
+import os
 import subprocess
 
 lc = _load_script('lpb_config', SUPPORT_DIR / 'lpb-config')
@@ -146,6 +148,256 @@ def test_lpb_config_merge_uptodate(tmpdir):
     assert lc.cmd_merge(tmpdir / "nope", str(remote), "main", _quiet_console()) == 1
 
 
+# ─── Template rendering (render / auto-render after reset/update/merge) ──
+
+
+def _make_templates(dir_):
+    (dir_ / "settings.json.template").write_text(json.dumps({
+        "packages": ["git:github.com/lpb-stack/demo@__LPB_VERSION__", "npm:somepkg"],
+        "theme": "dark",
+    }))
+    (dir_ / "lpb-memory-config.json.template").write_text(json.dumps({
+        "reviewTransport": "subprocess",
+        "memoryCharLimit": 3000,
+    }))
+
+
+def _push_templates(work):
+    _make_templates(work)
+    # Mirror the real config repo: rendered runtime files are gitignored,
+    # otherwise they'd trip lpb-config's local-change guard.
+    (work / ".gitignore").write_text("settings.json\nlpb-memory-config.json\n")
+    subprocess.run(["git", "-C", str(work), "add", "."], check=True)
+    subprocess.run(["git", "-C", str(work), "commit", "-qm", "templates"], check=True)
+    subprocess.run(["git", "-C", str(work), "push", "-q", "origin", "main"], check=True)
+
+
+def _with_lpb_version(value: str):
+    """Set LPB_VERSION for the duration of a test; returns restore closure."""
+    old = os.environ.get("LPB_VERSION")
+    os.environ["LPB_VERSION"] = value
+
+    def _restore():
+        if old is None:
+            os.environ.pop("LPB_VERSION", None)
+        else:
+            os.environ["LPB_VERSION"] = old
+    return _restore
+
+
+def _capture_console():
+    out, err = io.StringIO(), io.StringIO()
+    cons = log_mod.Console(color=False, out=out, err=err)
+    return cons, lambda: out.getvalue() + err.getvalue()
+
+
+def test_render_creates_from_template(tmpdir):
+    agent = tmpdir / "agent"
+    agent.mkdir()
+    _make_templates(agent)
+    restore = _with_lpb_version("0.9.9-lpb")
+    try:
+        cons, text = _capture_console()
+        assert lc.cmd_render(agent, cons) == 0
+    finally:
+        restore()
+    text = text()
+    raw = (agent / "settings.json").read_text()
+    settings = json.loads(raw)
+    assert settings["packages"][0] == "git:github.com/lpb-stack/demo@0.9.9-lpb"
+    assert "__LPB_VERSION__" not in raw
+    mem = json.loads((agent / "lpb-memory-config.json").read_text())
+    assert mem["reviewTransport"] == "subprocess"
+    assert "Generated" in text
+
+
+def test_render_no_env_uses_version_file_fallback(tmpdir):
+    """With LPB_VERSION unset, falls back to the devstack VERSION file."""
+    agent = tmpdir / "agent"
+    agent.mkdir()
+    _make_templates(agent)
+    old = os.environ.pop("LPB_VERSION", None)
+    try:
+        cons, text = _capture_console()
+        assert lc.cmd_render(agent, cons) == 0
+    finally:
+        if old is not None:
+            os.environ["LPB_VERSION"] = old
+    raw = (agent / "settings.json").read_text()
+    # Must be a real version (no placeholder left, no empty pin)
+    assert "__LPB_VERSION__" not in raw
+    assert "demo@" in raw
+
+
+def test_render_nonforce_never_overwrites(tmpdir):
+    agent = tmpdir / "agent"
+    agent.mkdir()
+    _make_templates(agent)
+    customized = {
+        "packages": ["git:github.com/lpb-stack/demo@0.1.0-lpb", "npm:user-pkg"],
+        "theme": "light",
+        "defaultProvider": "lemonade",
+    }
+    (agent / "settings.json").write_text(json.dumps(customized))
+    restore = _with_lpb_version("0.2.0-lpb")
+    try:
+        cons, text = _capture_console()
+        assert lc.cmd_render(agent, cons) == 0
+    finally:
+        restore()
+    # untouched file, but stale pins reported
+    text = text()
+    assert json.loads((agent / "settings.json").read_text()) == customized
+    assert "stale" in text and "0.1.0-lpb -> 0.2.0-lpb" in text
+
+
+def test_render_force_repins_and_keeps_user_keys(tmpdir):
+    agent = tmpdir / "agent"
+    agent.mkdir()
+    _make_templates(agent)
+    customized = {
+        "packages": ["git:github.com/lpb-stack/demo@0.1.0-lpb", "npm:user-pkg"],
+        "theme": "light",
+        "defaultProvider": "lemonade",
+    }
+    (agent / "settings.json").write_text(json.dumps(customized))
+    restore = _with_lpb_version("0.2.0-lpb")
+    try:
+        cons, text = _capture_console()
+        assert lc.cmd_render(agent, cons, force=True) == 0
+    finally:
+        restore()
+    s = json.loads((agent / "settings.json").read_text())
+    assert s["packages"][0] == "git:github.com/lpb-stack/demo@0.2.0-lpb"  # re-pinned
+    assert "npm:user-pkg" in s["packages"]        # user package preserved
+    assert s["defaultProvider"] == "lemonade"     # user key preserved
+    assert s["theme"] == "dark"                   # template key wins
+
+
+def test_render_force_memory_local_wins(tmpdir):
+    agent = tmpdir / "agent"
+    agent.mkdir()
+    _make_templates(agent)
+    (agent / "lpb-memory-config.json").write_text(json.dumps({
+        "reviewTransport": "direct",
+        "llmModelOverride": "qwen-x",
+    }))
+    restore = _with_lpb_version("0.2.0-lpb")
+    try:
+        cons, text = _capture_console()
+        assert lc.cmd_render(agent, cons, force=True) == 0
+    finally:
+        restore()
+    m = json.loads((agent / "lpb-memory-config.json").read_text())
+    assert m["reviewTransport"] == "direct"       # local (wizard) wins
+    assert m["llmModelOverride"] == "qwen-x"      # wizard key kept
+    assert m["memoryCharLimit"] == 3000           # template fills gaps
+
+
+def test_reset_renders_runtime_config(tmpdir):
+    remote = _setup_git_remote(tmpdir)
+    _push_templates(tmpdir / "work")
+    agent = tmpdir / "agent"
+    restore = _with_lpb_version("0.5.5-lpb")
+    try:
+        lc.cmd_update(agent, str(remote), "main", _quiet_console())
+        (agent / "junk").write_text("x")
+        cons, text = _capture_console()
+        assert lc.cmd_reset(agent, str(remote), "main", cons, force=True) == 0
+    finally:
+        restore()
+    assert not (agent / "junk").exists()
+    s = json.loads((agent / "settings.json").read_text())
+    assert s["packages"][0] == "git:github.com/lpb-stack/demo@0.5.5-lpb"
+    assert (agent / "lpb-memory-config.json").is_file()
+    assert "regenerated from templates" in text()
+
+
+def test_update_restores_missing_rendered(tmpdir):
+    remote = _setup_git_remote(tmpdir)
+    _push_templates(tmpdir / "work")
+    agent = tmpdir / "agent"
+    restore = _with_lpb_version("0.6.6-lpb")
+    try:
+        lc.cmd_update(agent, str(remote), "main", _quiet_console())
+        assert (agent / "settings.json").is_file()
+        (agent / "settings.json").unlink()
+        _push_commit(tmpdir / "work", "bump", "three")
+        cons, text = _capture_console()
+        assert lc.cmd_update(agent, str(remote), "main", cons) == 0
+    finally:
+        restore()
+    raw = (agent / "settings.json").read_text()
+    assert "0.6.6-lpb" in raw
+    assert "Generated settings.json" in text()
+
+
+def test_update_warns_stale_pins_without_clobbering(tmpdir):
+    """Stack version moves (new image), rendered file keeps old pins:
+    update must warn, not silently overwrite."""
+    remote = _setup_git_remote(tmpdir)
+    _push_templates(tmpdir / "work")
+    agent = tmpdir / "agent"
+    restore = _with_lpb_version("0.1.0-lpb")
+    try:
+        lc.cmd_update(agent, str(remote), "main", _quiet_console())
+    finally:
+        restore()
+    restore2 = _with_lpb_version("0.2.0-lpb")
+    try:
+        _push_commit(tmpdir / "work", "x", "four")
+        cons, text = _capture_console()
+        assert lc.cmd_update(agent, str(remote), "main", cons) == 0
+    finally:
+        restore2()
+    assert "stale" in text()
+    s = json.loads((agent / "settings.json").read_text())
+    assert s["packages"][0].endswith("@0.1.0-lpb")  # untouched
+
+
+def test_clone_or_init_survives_stale_remote(tmpdir):
+    """Partial wipe: leftover .git already has an origin — repoint, don't abort."""
+    remote = _setup_git_remote(tmpdir)
+    agent = tmpdir / "agent"
+    agent.mkdir()
+    subprocess.run(["git", "-C", str(agent), "init", "-q"], check=True)
+    subprocess.run(["git", "-C", str(agent), "remote", "add", "origin",
+                    "/old/nonexistent.git"], check=True)
+    (agent / "preexisting").write_text("keep me")
+    cons, text = _capture_console()
+    assert lc.clone_or_init(agent, str(remote), "main", cons) is True
+    assert (agent / "f").read_text() == "one"
+    r = subprocess.run(
+        ["git", "-C", str(agent), "remote", "get-url", "origin"],
+        capture_output=True, text=True, check=False)
+    assert r.returncode == 0 and r.stdout.strip() == str(remote)
+    assert (agent / "preexisting").exists()
+
+
+def test_reset_warns_on_incomplete_wipe(tmpdir):
+    """rmtree that leaves survivors (files in use) must warn, not claim a clean reset."""
+    remote = _setup_git_remote(tmpdir)
+    agent = tmpdir / "agent"
+    lc.cmd_update(agent, str(remote), "main", _quiet_console())
+    (agent / "busy").write_text("in use")
+    real_rmtree = lc.shutil.rmtree
+    lc.shutil.rmtree = lambda *a, **k: None  # simulate failure
+    try:
+        cons, text = _capture_console()
+        assert lc.cmd_reset(agent, str(remote), "main", cons, force=True) == 0
+    finally:
+        lc.shutil.rmtree = real_rmtree
+    assert "Wipe incomplete" in text() and "busy" in text()
+    assert (agent / "busy").exists()          # untracked survivor preserved
+    assert (agent / "f").read_text() == "one"  # tracked tree still reset
+
+
+def test_render_missing_dir_errors(tmpdir):
+    cons, text = _capture_console()
+    assert lc.cmd_render(tmpdir / "nope", cons) == 1
+    assert "No config area" in text()
+
+
 def main() -> int:
     return run_lpbx_suite("lpb-config tests", globals())