acumatica-cli 0.12.0__tar.gz → 0.13.0__tar.gz

{acumatica_cli-0.12.0 → acumatica_cli-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: acumatica-cli
-Version: 0.12.0
+Version: 0.13.0
 Summary: Acumatica ERP Config-as-Code: tenant provisioning, baseline config, and reference data
 Author: Konstantin Borovik
 Author-email: Konstantin Borovik <kb@lab5.ca>
@@ -89,6 +89,8 @@ acu [--tenant NAME] [--url URL] [--ssh USER@HOST] [--api-version V]
 ├── apply [--dry-run] [FILES...]      push YAML via REST (idempotent PUT upserts)
 ├── diff  [FILES...]                  drift check vs the live tenant (exit 2 on drift)
 ├── run   [--dry-run] [FILES...]      execute transaction scenario YAML (exit 1 on any miss)
+├── snapshot [--out DIR] [--diff] [--assert-unchanged] [--dry-run] [FILES...]
+│                                     capture derived state into state/ (not seed)
 ├── extract [--out DIR] [--only NAME]... [--force] [--dry-run]
 │                                     dump live tenant state as seed YAML (inverse of apply)
 ├── schema [--out DIR]                dump the endpoint's OpenAPI schema (swagger.json)
@@ -103,6 +105,7 @@ acu [--tenant NAME] [--url URL] [--ssh USER@HOST] [--api-version V]
 `apply` and `diff` without FILES prefer `config/<name>/` when any seed child exists under `config/`; otherwise root `bootstrap/`, `baseline/`, `setup/`, then `master/` when present.
 A path like `config/` expands nested seed dirs in that fixed order.
 `run` without FILES defaults to `scenario/`.
+`snapshot` without FILES defaults to `config/snapshot/`; writes go to `state/` (`--out`).
 `acu --completion` emits a completion script for bash, zsh, or fish — source it from your shell profile.
 Run `acu <command> --help` for details on any command.
 
@@ -119,6 +122,8 @@ Your configuration lives in its own git repo.
 | `setup/` / `config/setup/` | one-time actions: financial year, master calendar, open periods |
 | `config/master/` | distribution masters (prefs, warehouse, items, parties); flavor only |
 | `scenario/` | lifecycle txns for `acu run`: once capital, then buy, build stub, sell |
+| `config/snapshot/` | observer views for `acu snapshot` (`inquire:` / `entity:` / `gi:`; not SEED_DIRS) |
+| `state/` | committed derived-state observations (evidence, not seed; money/qty fixed-point) |
 | `target.yaml` | committed verified matrix: `erp` + `default_api` (what, not where) |
 | `.env` | where to apply and who signs in, every key an `ACU_*` variable |
 
@@ -131,6 +136,10 @@ Scenario YAML is different — it describes transactions that flow forward.
 `acu run` executes each step in order (`put`, `action`, `wait`, `get`), captures server-assigned document numbers into `${var}` references for later steps, and checks `expect:` assertions as deltas against a pre-run snapshot, so additive scenarios re-run safely on a warm tenant.
 `once: true` scenarios declare a `present` inquire-absolute gate; when the probe already holds, the CLI prints `skip <path> (once: already present)` and runs neither steps nor expects (Owner Capital does not restack).
 
+`acu snapshot` is the third observation path: it captures live derived state (balances) into `state/` for git review. It is not `extract` (config seed) and not `diff` (desired vs actual config). Packaged golden is trial-balance via contract `inquire:` (`EndingBalance` fixed-point); inventory-summary is not golden this pass. `gi:` stays optional when a GI is V12-verified and **Expose via OData** is on (`params` fail-closed vs `$metadata`). After a cold `acu run scenario/ && acu snapshot`, warm `acu run scenario/10-seed-capital.yaml && acu snapshot --assert-unchanged` is the once-class gate (full scenario re-run is additive and moves cash observations on the TB).
+
+**Migration (path hard-cut):** bare defaults are `config/snapshot/` (views) and `state/` (observations). Root `snapshot/` and `snapshots/` are no longer defaulted — move files or pass explicit path args.
+
 ### Seed `endpoint:` symbols
 
 Dual-served entities (on both Bootstrap and Default) need an explicit `endpoint:` line.

{acumatica_cli-0.12.0 → acumatica_cli-0.13.0}/README.md

@@ -71,6 +71,8 @@ acu [--tenant NAME] [--url URL] [--ssh USER@HOST] [--api-version V]
 ├── apply [--dry-run] [FILES...]      push YAML via REST (idempotent PUT upserts)
 ├── diff  [FILES...]                  drift check vs the live tenant (exit 2 on drift)
 ├── run   [--dry-run] [FILES...]      execute transaction scenario YAML (exit 1 on any miss)
+├── snapshot [--out DIR] [--diff] [--assert-unchanged] [--dry-run] [FILES...]
+│                                     capture derived state into state/ (not seed)
 ├── extract [--out DIR] [--only NAME]... [--force] [--dry-run]
 │                                     dump live tenant state as seed YAML (inverse of apply)
 ├── schema [--out DIR]                dump the endpoint's OpenAPI schema (swagger.json)
@@ -85,6 +87,7 @@ acu [--tenant NAME] [--url URL] [--ssh USER@HOST] [--api-version V]
 `apply` and `diff` without FILES prefer `config/<name>/` when any seed child exists under `config/`; otherwise root `bootstrap/`, `baseline/`, `setup/`, then `master/` when present.
 A path like `config/` expands nested seed dirs in that fixed order.
 `run` without FILES defaults to `scenario/`.
+`snapshot` without FILES defaults to `config/snapshot/`; writes go to `state/` (`--out`).
 `acu --completion` emits a completion script for bash, zsh, or fish — source it from your shell profile.
 Run `acu <command> --help` for details on any command.
 
@@ -101,6 +104,8 @@ Your configuration lives in its own git repo.
 | `setup/` / `config/setup/` | one-time actions: financial year, master calendar, open periods |
 | `config/master/` | distribution masters (prefs, warehouse, items, parties); flavor only |
 | `scenario/` | lifecycle txns for `acu run`: once capital, then buy, build stub, sell |
+| `config/snapshot/` | observer views for `acu snapshot` (`inquire:` / `entity:` / `gi:`; not SEED_DIRS) |
+| `state/` | committed derived-state observations (evidence, not seed; money/qty fixed-point) |
 | `target.yaml` | committed verified matrix: `erp` + `default_api` (what, not where) |
 | `.env` | where to apply and who signs in, every key an `ACU_*` variable |
 
@@ -113,6 +118,10 @@ Scenario YAML is different — it describes transactions that flow forward.
 `acu run` executes each step in order (`put`, `action`, `wait`, `get`), captures server-assigned document numbers into `${var}` references for later steps, and checks `expect:` assertions as deltas against a pre-run snapshot, so additive scenarios re-run safely on a warm tenant.
 `once: true` scenarios declare a `present` inquire-absolute gate; when the probe already holds, the CLI prints `skip <path> (once: already present)` and runs neither steps nor expects (Owner Capital does not restack).
 
+`acu snapshot` is the third observation path: it captures live derived state (balances) into `state/` for git review. It is not `extract` (config seed) and not `diff` (desired vs actual config). Packaged golden is trial-balance via contract `inquire:` (`EndingBalance` fixed-point); inventory-summary is not golden this pass. `gi:` stays optional when a GI is V12-verified and **Expose via OData** is on (`params` fail-closed vs `$metadata`). After a cold `acu run scenario/ && acu snapshot`, warm `acu run scenario/10-seed-capital.yaml && acu snapshot --assert-unchanged` is the once-class gate (full scenario re-run is additive and moves cash observations on the TB).
+
+**Migration (path hard-cut):** bare defaults are `config/snapshot/` (views) and `state/` (observations). Root `snapshot/` and `snapshots/` are no longer defaulted — move files or pass explicit path args.
+
 ### Seed `endpoint:` symbols
 
 Dual-served entities (on both Bootstrap and Default) need an explicit `endpoint:` line.

{acumatica_cli-0.12.0 → acumatica_cli-0.13.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "acumatica-cli"
-version = "0.12.0"
+version = "0.13.0"
 description = "Acumatica ERP Config-as-Code: tenant provisioning, baseline config, and reference data"
 authors = [{ name = "Konstantin Borovik", email = "kb@lab5.ca" }]
 license = "PolyForm-Noncommercial-1.0.0"

{acumatica_cli-0.12.0 → acumatica_cli-0.13.0}/src/acumatica_cli/cli.py

@@ -12,7 +12,7 @@ import click
 import httpx
 from click.shell_completion import get_completion_class
 
-from . import bootstrap, extract, firstlogin, output, run, seed
+from . import bootstrap, extract, firstlogin, output, run, seed, snapshot
 from .client import AcumaticaClient
 from .config import (
     INIT_FLAVORS,
@@ -537,37 +537,73 @@ def config_check(ctx: click.Context, strict: bool) -> None:
     # both live probes run through the exact objects live commands use, so
     # a pass here proves the real code path, not a parallel one
     inst = _resolve_instance(ctx)
-    failed = _probe_target(root, inst, strict=strict)
+    failed, claimed_erp = _probe_target(root, inst, strict=strict)
+    if not _probe_rest(inst, claimed_erp):
+        failed = True
+    if not _probe_ssh(inst):
+        failed = True
+    if failed:
+        raise SystemExit(1)
+
+
+def _probe_rest(inst: Instance, claimed_erp: str | None) -> bool:
+    """REST login + endpoints + optional ERP build; True = all passed.
+
+    Entering the client is the probe: login + landed-tenant verify (V5);
+    context manager guarantees logout (V6). One GET /entity feeds endpoints
+    (T74/T90) and optional ERP build (T92).
+    """
     try:
-        # entering the client is the whole probe: login + landed-tenant
-        # verify (V5), and the context manager guarantees logout (V6);
-        # endpoints probe (T74) reuses the same session when login succeeds
         with AcumaticaClient(inst) as client:
             output.data(f"ok rest ({inst.base_url}, tenant {inst.tenant})")
-            if not _probe_endpoints(client, inst):
-                failed = True
+            return _probe_entity_root(client, inst, claimed_erp)
     except (RuntimeError, httpx.HTTPError) as exc:
         output.data(f"fail rest: {exc}")
-        failed = True
+        return False
+
+
+def _probe_entity_root(
+    client: AcumaticaClient, inst: Instance, claimed_erp: str | None
+) -> bool:
+    """Endpoints (+ ERP when claimed); True = all passed."""
+    ok = True
+    try:
+        endpoints, live_build = client.entity_root()
+    except (RuntimeError, httpx.HTTPError) as exc:
+        output.data(f"fail endpoints: {exc}")
+        endpoints, live_build = [], None
+        ok = False
+    else:
+        if not _probe_endpoints(endpoints, inst):
+            ok = False
+    if claimed_erp is not None and not _probe_erp(claimed_erp, live_build):
+        ok = False
+    return ok
+
+
+def _probe_ssh(inst: Instance) -> bool:
+    """SSH ping or skip when unset; True = pass/skip, False = fail."""
     if not inst.ssh:
         # V3/I.cmd: ACU_SSH optional — hosted data-plane path skips, never fails
         output.data("skip ssh (ACU_SSH not set)")
-    else:
-        try:
-            TenantManager(inst).ping()
-            output.data(f"ok ssh ({inst.ssh})")
-        except RuntimeError as exc:
-            output.data(f"fail ssh: {exc}")
-            failed = True
-    if failed:
-        raise SystemExit(1)
+        return True
+    try:
+        TenantManager(inst).ping()
+        output.data(f"ok ssh ({inst.ssh})")
+        return True
+    except RuntimeError as exc:
+        output.data(f"fail ssh: {exc}")
+        return False
 
 
-def _probe_target(root: Path | None, inst: Instance, *, strict: bool) -> bool:
-    """Emit the local target probe line; return True when it failed (V27).
+def _probe_target(
+    root: Path | None, inst: Instance, *, strict: bool
+) -> tuple[bool, str | None]:
+    """Emit local target probe; return ``(failed, claimed_erp?)`` (V27).
 
     Invalid target hard-exits (any loader). Missing under data root warns
-    unless --strict. No data root → skip. Match → ok (erp claimed-only).
+    unless --strict. No data root → skip. Match → ok + claimed ``erp`` for
+    the live ERP probe after REST (T92).
     """
     try:
         target = load_target(root)
@@ -576,7 +612,7 @@ def _probe_target(root: Path | None, inst: Instance, *, strict: bool) -> bool:
         raise SystemExit(1) from exc
     if root is None:
         output.data("skip target (no data root)")
-        return False
+        return False, None
     if target is None:
         msg = (
             f"target: no target.yaml under {root} - dataset verified matrix "
@@ -584,35 +620,27 @@ def _probe_target(root: Path | None, inst: Instance, *, strict: bool) -> bool:
             "to require it"
         )
         output.data(f"{'fail' if strict else 'warn'} {msg}")
-        return strict
+        return strict, None
     if target.default_api != inst.api_version:
         output.data(
             f"fail target: dataset default_api={target.default_api} vs "
             f"configured {inst.api_version}"
         )
-        return True
+        return True, None
     output.data(
         f"ok target (default_api={target.default_api} matches configured; "
         f"erp={target.erp} claimed)"
     )
-    # T76: no stable HTTP ERP-build discovery (V12) — keep erp claimed-only;
-    # skip rather than invent SSH/sqlcmd (control-plane exclusion, V1)
-    output.data(f"skip erp (live probe not available; claimed {target.erp})")
-    return False
+    return False, target.erp
 
 
-def _probe_endpoints(client: AcumaticaClient, inst: Instance) -> bool:
+def _probe_endpoints(endpoints: list[tuple[str, str]], inst: Instance) -> bool:
     """Emit endpoints probe; return True on pass, False on fail (V12/V27).
 
     Exact match: a Default entry whose version half equals
-    ``Instance.api_version``. Fail-closed when GET /entity is unparseable.
+    ``Instance.api_version``. Caller already fail-closed on unparseable GET.
     """
     want = f"Default/{inst.api_version}"
-    try:
-        endpoints = client.list_endpoints()
-    except (RuntimeError, httpx.HTTPError) as exc:
-        output.data(f"fail endpoints: {exc}")
-        return False
     defaults = [v for name, v in endpoints if name == "Default"]
     if inst.api_version in defaults:
         output.data(f"ok endpoints ({want} present)")
@@ -625,6 +653,34 @@ def _probe_endpoints(client: AcumaticaClient, inst: Instance) -> bool:
     return False
 
 
+def _major_minor(version: str) -> str:
+    """First two dotted segments (T76/T92 major.minor match)."""
+    parts = version.split(".")
+    if len(parts) >= 2:
+        return f"{parts[0]}.{parts[1]}"
+    return version
+
+
+def _probe_erp(claimed: str, live: str | None) -> bool:
+    """Emit ERP probe; return True on pass/skip, False on fail (T92).
+
+    Live id comes from 26.x ``GET /entity`` wrapper
+    ``version.acumaticaBuildVersion``. Bare array → skip (no HTTP surface).
+    Compare major.minor only — patch builds may drift within a claimed line.
+    """
+    if live is None:
+        output.data(f"skip erp (live probe not available; claimed {claimed})")
+        return True
+    if _major_minor(live) == _major_minor(claimed):
+        output.data(f"ok erp ({live} matches claimed {claimed})")
+        return True
+    output.data(
+        f"fail erp: live {live} vs claimed {claimed} "
+        f"(major.minor {_major_minor(live)} vs {_major_minor(claimed)})"
+    )
+    return False
+
+
 SEED_DIRS = ("bootstrap", "baseline", "setup", "master")
 
 
@@ -890,3 +946,79 @@ def _exit_on_drift(inst: Instance, drifts: list[str], files: int) -> None:
             output.data(f"  {line}")
         raise SystemExit(2)
     output.success(f"no drift on {inst.tenant} ({inst.base_url}, {files} file(s))")
+
+
+@cli.command("snapshot")
+@click.argument(
+    "files", nargs=-1, required=False, type=click.Path(exists=True, path_type=Path)
+)
+@click.option(
+    "--out",
+    "out_dir",
+    type=click.Path(file_okay=False, path_type=Path),
+    default=None,
+    help="Observation output directory (default: state/)",
+)
+@click.option(
+    "--diff",
+    "do_diff",
+    is_flag=True,
+    help="Compare live vs disk; write nothing (exit 0 either way)",
+)
+@click.option(
+    "--assert-unchanged",
+    is_flag=True,
+    help="Like --diff, but exit 2 when state moved (idempotence gate)",
+)
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    help="Resolve views and validate sources without HTTP",
+)
+@pass_instance
+def snapshot_cmd(
+    inst: Instance,
+    files: tuple[Path, ...],
+    out_dir: Path | None,
+    do_diff: bool,
+    assert_unchanged: bool,
+    dry_run: bool,
+) -> None:
+    """Capture live derived state into committed observation files.
+
+    FILES are snapshot view YAML files or directories. Omitted, they default
+    to the data repo's config/snapshot/ directory (hard-cut; no root
+    snapshot/ fallback). Default write target is state/ (--out; no
+    snapshots/ fallback). Bare capture writes observations (change is
+    fine). --diff compares live to disk without writing.
+    --assert-unchanged is the warm-run idempotence gate (exit 2 when
+    moved). Never writes seed trees or endpoint: symbols (V32). Exit 0
+    ok, 1 op fail, 2 only under --assert-unchanged when state moved.
+    """
+    assert_target_compatible(inst)
+    if not files:
+        default = data_root() / "config" / "snapshot"
+        if not default.is_dir():
+            raise SystemExit(f"{default}: snapshot directory does not exist")
+        files = (Path(os.path.relpath(default)),)
+    paths = snapshot.expand_view_files(files)
+    views = [snapshot.load_view(path) for path in paths]
+    dest = out_dir if out_dir is not None else Path("state")
+    if dry_run:
+        code = snapshot.run_views(None, views, out_dir=dest, mode="dry")
+    else:
+        mode = "assert" if assert_unchanged else "diff" if do_diff else "write"
+        with AcumaticaClient(inst) as client:
+            code = snapshot.run_views(client, views, out_dir=dest, mode=mode)
+    if code:
+        raise SystemExit(code)
+    if dry_run:
+        return
+    if assert_unchanged:
+        output.success(f"{len(views)} snapshot(s) unchanged on {inst.tenant}")
+    elif do_diff:
+        output.success(f"{len(views)} snapshot(s) compared on {inst.tenant}")
+    else:
+        output.success(
+            f"{len(views)} snapshot(s) written under {dest} on {inst.tenant}"
+        )

{acumatica_cli-0.12.0 → acumatica_cli-0.13.0}/src/acumatica_cli/client.py

@@ -65,10 +65,22 @@ def unwrap(entity: dict[str, Any]) -> dict[str, Any]:
 def parse_entity_list(response: httpx.Response) -> list[tuple[str, str]]:
     """Parse ``GET /entity`` into ``[(name, version), ...]`` (fail-closed).
 
-    Vendor contract shape (Acumatica help + docs/rest-api.md): a JSON array
-    of objects with ``name`` and ``version`` strings. Unparseable body →
-    RuntimeError with status, content-type, and a short raw hint so a
-    shape change is re-verified (V12) rather than silently skipped.
+    Dual shape (V31 / gh #20): top-level JSON array (legacy) or object with
+    an ``endpoints`` array (26.x wrapper). Each row needs string ``name``
+    and ``version``. Unparseable body → RuntimeError with status,
+    content-type, and a short raw hint so a shape change is re-verified
+    (V12) rather than silently skipped.
+    """
+    return parse_entity_response(response)[0]
+
+
+def parse_entity_response(
+    response: httpx.Response,
+) -> tuple[list[tuple[str, str]], str | None]:
+    """Parse ``GET /entity`` → ``(endpoints, acumatica_build_version?)``.
+
+    Endpoints dual-shape per V31. Build id is ``version.acumaticaBuildVersion``
+    on the 26.x wrapper only; bare array → ``None`` (T92).
     """
     try:
         body = response.json()
@@ -80,15 +92,17 @@ def parse_entity_list(response: httpx.Response) -> list[tuple[str, str]]:
             f"content-type {response.headers.get('content-type', '?')}; "
             f"first 200 chars: {hint})"
         ) from exc
-    if not isinstance(body, list) or not body:
+    rows = _entity_list_rows(body)
+    if rows is None:
         hint = str(body)[:200]
         raise RuntimeError(
             "GET /entity response not parseable as endpoint list "
-            f"(status {response.status_code}; expected non-empty JSON array; "
+            f"(status {response.status_code}; expected non-empty JSON array "
+            "or object with non-empty 'endpoints' array; "
             f"first 200 chars: {hint})"
         )
     out: list[tuple[str, str]] = []
-    for item in body:
+    for item in rows:
         if not isinstance(item, dict):
             raise RuntimeError(
                 "GET /entity response not parseable as endpoint list "
@@ -102,7 +116,31 @@ def parse_entity_list(response: httpx.Response) -> list[tuple[str, str]]:
                 f"(row missing string name/version: {item!r})"
             )
         out.append((name, version))
-    return out
+    return out, _entity_build_version(body)
+
+
+def _entity_list_rows(body: Any) -> list[Any] | None:
+    """Return endpoint row list from array or 26.x wrapper; else None."""
+    if isinstance(body, list) and body:
+        return body
+    if isinstance(body, dict):
+        endpoints = body.get("endpoints")
+        if isinstance(endpoints, list) and endpoints:
+            return endpoints
+    return None
+
+
+def _entity_build_version(body: Any) -> str | None:
+    """``version.acumaticaBuildVersion`` from 26.x wrapper; else None."""
+    if not isinstance(body, dict):
+        return None
+    version = body.get("version")
+    if not isinstance(version, dict):
+        return None
+    build = version.get("acumaticaBuildVersion")
+    if isinstance(build, str) and build:
+        return build
+    return None
 
 
 # The list GET's optimized-export failure (B9): the contract API's list GET
@@ -245,8 +283,16 @@ class AcumaticaClient:
 
         Fail-closed on unparseable body — see ``parse_entity_list``.
         """
+        return self.entity_root()[0]
+
+    def entity_root(self) -> tuple[list[tuple[str, str]], str | None]:
+        """Authenticated ``GET /entity`` → endpoints + optional ERP build id.
+
+        Build id is present only on the 26.x wrapper
+        (``version.acumaticaBuildVersion``). Bare array → ``None`` (T92).
+        """
         r = self._checked(self._http.get("/entity"))
-        return parse_entity_list(r)
+        return parse_entity_response(r)
 
     @staticmethod
     def _checked(r: httpx.Response) -> httpx.Response:
@@ -492,3 +538,27 @@ class AcumaticaClient:
         return self._checked(
             self._http.post("/CustomizationApi/publishEnd", json={})
         ).json()
+
+    # -- OData Generic Inquiry (snapshot gi: source; V33) --
+
+    def _odata_gi_root(self) -> str:
+        """24R2+ OData GI service root ``/t/<tenant>/api/odata/gi`` (V33)."""
+        tenant = quote(self.instance.tenant, safe="")
+        return f"/t/{tenant}/api/odata/gi"
+
+    def odata_gi_metadata(self, name: str) -> str:
+        """GET OData GI service ``$metadata`` XML (V33 param validation).
+
+        ``name`` is reserved for future per-GI metadata URLs; the 24R2
+        service exposes one EDMX document at the service root.
+        """
+        del name  # service-level metadata; per-GI filter is validate_gi_params
+        r = self._checked(self._http.get(f"{self._odata_gi_root()}/$metadata"))
+        return r.text
+
+    def odata_gi(self, name: str, params: dict[str, str] | None = None) -> Any:
+        """GET OData GI rows as JSON (requires Expose via OData on the GI)."""
+        gi = quote(name, safe="")
+        return self._checked(
+            self._http.get(f"{self._odata_gi_root()}/{gi}", params=params)
+        ).json()

{acumatica_cli-0.12.0 → acumatica_cli-0.13.0}/src/acumatica_cli/config.py

@@ -58,6 +58,11 @@ INIT_TEMPLATES = (
     ("finance/setup/10-financial-year.yaml", "setup/10-financial-year.yaml"),
     ("finance/setup/20-master-calendar.yaml", "setup/20-master-calendar.yaml"),
     ("finance/setup/30-open-periods.yaml", "setup/30-open-periods.yaml"),
+    # V28/V32: observer views under config/snapshot/ (not SEED_DIRS; lone config/ ok)
+    (
+        "finance/snapshot/10-trial-balance.yaml",
+        "config/snapshot/10-trial-balance.yaml",
+    ),
 )
 
 # Opt-in `--flavor distribution` overlays + extras (V28/V29/T87). Resource
@@ -168,6 +173,10 @@ DISTRIBUTION_TEMPLATES = (
     ),
     ("distribution/scenario/30-build.yaml", "scenario/30-build.yaml"),
     ("distribution/scenario/40-sell.yaml", "scenario/40-sell.yaml"),
+    (
+        "distribution/snapshot/10-trial-balance.yaml",
+        "config/snapshot/10-trial-balance.yaml",
+    ),
     ("distribution/README.md", "README.md"),
 )
 
@@ -237,10 +246,13 @@ class Instance(BaseSettings):
 def templates_for(flavor: str | None) -> tuple[tuple[str, str], ...]:
     """Resolve (resource, dest) pairs for ``config init`` (V28/T87).
 
-    Absent flavor → finance-minimal ``INIT_TEMPLATES`` at root. ``distribution``
-    keeps root meta (``.env``/``.gitignore``/``target.yaml``), rehomes finance
-    seed under ``config/``, then overlays ``DISTRIBUTION_TEMPLATES`` (config/
-    seeds + lifecycle ``scenario/`` + README). Never dual root+config trees.
+    Absent flavor → finance-minimal ``INIT_TEMPLATES`` at root (+ observer
+    ``config/snapshot/``). ``distribution`` keeps root meta
+    (``.env``/``.gitignore``/``target.yaml``), rehomes finance seed under
+    ``config/``, then overlays ``DISTRIBUTION_TEMPLATES`` (config/ seeds +
+    lifecycle ``scenario/`` + ``config/snapshot/`` + README). Never dual
+    root+config seed trees. Paths already under ``config/`` (snapshot
+    views) pass through unchanged.
     """
     if flavor is None:
         return INIT_TEMPLATES
@@ -256,11 +268,14 @@ def templates_for(flavor: str | None) -> tuple[tuple[str, str], ...]:
             by_dest[dest] = res
             order.append(dest)
             continue
-        target = (
-            f"config/{dest}"
-            if any(dest.startswith(p) for p in _SEED_PREFIXES)
-            else dest
-        )
+        if dest.startswith("config/"):
+            target = dest
+        else:
+            target = (
+                f"config/{dest}"
+                if any(dest.startswith(p) for p in _SEED_PREFIXES)
+                else dest
+            )
         if target not in by_dest:
             order.append(target)
         by_dest[target] = res