@pukujan/create-modular-monolith 2.2.0 → 2.2.3

package/template/backend/src/shared/utils/consolidatedExport.js

@@ -1,30 +1,174 @@
-import { mkdir, writeFile } from "fs/promises";
+import { mkdir, readFile, writeFile } from "fs/promises";
 import { join } from "path";
+import { formatExchangeTimestamp, normalizeExchangeStamp } from "./formatExchangeTimestamp.js";
 
-/** Consolidated deliverables live directly under file-exchange/exports/. */
+/** Session exports and consolidated snapshots root. */
 export const CONSOLIDATED_EXPORT_DIR = "file-exchange/exports";
 
+/** Folder suffix for consolidated audit bundles (matches file-exchange stamp convention). */
+export const CONSOLIDATED_FOLDER_LABEL = "consolidated";
+
 export const CONSOLIDATED_FILENAMES = {
   models: "consolidated-models.json",
   prompts: "consolidated-prompts.json",
   fileStructure: "consolidated-file-structure.json"
 };
 
+export const CONSOLIDATED_MANIFEST_FILENAME = "manifest.json";
+
+const ENV_STAMP = "CONSOLIDATED_EXPORT_STAMP";
+
+/**
+ * @param {string} [stamp]
+ * @param {string} [label]
+ * @returns {string} e.g. 2026-05-23_15-59-43Z_consolidated
+ */
+export function consolidatedExportFolderName(stamp, label = CONSOLIDATED_FOLDER_LABEL) {
+  return `${normalizeExchangeStamp(stamp)}_${label}`;
+}
+
+/**
+ * Resolve or create a shared UTC stamp for one condense run (condense:all shares via env).
+ * @param {{ create?: boolean }} [options]
+ * @returns {string|null}
+ */
+export function getConsolidatedExportStamp({ create = true } = {}) {
+  const fromEnv = process.env[ENV_STAMP];
+  if (fromEnv) {
+    return normalizeExchangeStamp(fromEnv);
+  }
+  if (!create) {
+    return null;
+  }
+  const stamp = formatExchangeTimestamp();
+  process.env[ENV_STAMP] = stamp;
+  return stamp;
+}
+
+/**
+ * Start a consolidated export session (sets CONSOLIDATED_EXPORT_STAMP).
+ * @param {{ stamp?: string, label?: string }} [options]
+ */
+export function beginConsolidatedExportSession(options = {}) {
+  const stamp = options.stamp
+    ? normalizeExchangeStamp(options.stamp)
+    : getConsolidatedExportStamp({ create: true });
+  process.env[ENV_STAMP] = stamp;
+  const folderName = consolidatedExportFolderName(stamp, options.label ?? CONSOLIDATED_FOLDER_LABEL);
+  return {
+    stamp,
+    label: options.label ?? CONSOLIDATED_FOLDER_LABEL,
+    folderName,
+    exportDir: `${CONSOLIDATED_EXPORT_DIR}/${folderName}`
+  };
+}
+
+/**
+ * @param {string} repoRoot
+ * @param {string} stamp
+ * @param {string} [label]
+ * @returns {string} absolute path to dated export folder
+ */
+export function resolveConsolidatedExportDir(repoRoot, stamp, label = CONSOLIDATED_FOLDER_LABEL) {
+  return join(repoRoot, CONSOLIDATED_EXPORT_DIR, consolidatedExportFolderName(stamp, label));
+}
+
 /**
- * Write a consolidated JSON artifact to file-exchange/exports/.
+ * Write a consolidated JSON artifact to a dated export folder and refresh latest mirrors.
  * @param {string} repoRoot
  * @param {string} filename
  * @param {string} jsonText
- * @returns {Promise<string>} absolute path written
+ * @param {{ stamp?: string, label?: string, writeLatest?: boolean, condensedBy?: string }} [options]
+ * @returns {Promise<{ absolutePath: string, exportPath: string, datedExportDir: string, stamp: string, folderName: string }>}
  */
-export async function writeConsolidatedExport(repoRoot, filename, jsonText) {
-  const dest = join(repoRoot, CONSOLIDATED_EXPORT_DIR, filename);
-  await mkdir(join(repoRoot, CONSOLIDATED_EXPORT_DIR), { recursive: true });
-  await writeFile(dest, jsonText, "utf8");
-  return dest;
+export async function writeConsolidatedExport(repoRoot, filename, jsonText, options = {}) {
+  const stamp = options.stamp ?? getConsolidatedExportStamp({ create: true });
+  const label = options.label ?? CONSOLIDATED_FOLDER_LABEL;
+  const folderName = consolidatedExportFolderName(stamp, label);
+  const datedDir = join(repoRoot, CONSOLIDATED_EXPORT_DIR, folderName);
+  const exportsRoot = join(repoRoot, CONSOLIDATED_EXPORT_DIR);
+
+  await mkdir(datedDir, { recursive: true });
+  await mkdir(exportsRoot, { recursive: true });
+
+  const absolutePath = join(datedDir, filename);
+  await writeFile(absolutePath, jsonText, "utf8");
+
+  if (options.writeLatest !== false) {
+    await writeFile(join(exportsRoot, filename), jsonText, "utf8");
+  }
+
+  if (options.condensedBy) {
+    await appendConsolidatedManifest(repoRoot, stamp, {
+      filename,
+      condensedBy: options.condensedBy,
+      label
+    });
+  }
+
+  return {
+    absolutePath,
+    exportPath: `${CONSOLIDATED_EXPORT_DIR}/${folderName}/${filename}`,
+    datedExportDir: `${CONSOLIDATED_EXPORT_DIR}/${folderName}`,
+    stamp,
+    folderName
+  };
+}
+
+/**
+ * @param {string} repoRoot
+ * @param {string} stamp
+ * @param {{ filename: string, condensedBy?: string, label?: string }} entry
+ */
+export async function appendConsolidatedManifest(repoRoot, stamp, entry) {
+  const label = entry.label ?? CONSOLIDATED_FOLDER_LABEL;
+  const folderName = consolidatedExportFolderName(stamp, label);
+  const manifestPath = join(
+    repoRoot,
+    CONSOLIDATED_EXPORT_DIR,
+    folderName,
+    CONSOLIDATED_MANIFEST_FILENAME
+  );
+  const now = new Date().toISOString();
+
+  let manifest = {
+    stamp: normalizeExchangeStamp(stamp),
+    folder: folderName,
+    label,
+    startedAt: now,
+    updatedAt: now,
+    artifacts: []
+  };
+
+  try {
+    const raw = await readFile(manifestPath, "utf8");
+    manifest = JSON.parse(raw);
+    manifest.updatedAt = now;
+    if (!Array.isArray(manifest.artifacts)) {
+      manifest.artifacts = [];
+    }
+  } catch {
+    /* new manifest */
+  }
+
+  const existing = manifest.artifacts.findIndex((a) => a.filename === entry.filename);
+  const row = {
+    filename: entry.filename,
+    condensedBy: entry.condensedBy ?? null,
+    writtenAt: now
+  };
+  if (existing >= 0) {
+    manifest.artifacts[existing] = row;
+  } else {
+    manifest.artifacts.push(row);
+  }
+
+  await mkdir(join(repoRoot, CONSOLIDATED_EXPORT_DIR, folderName), { recursive: true });
+  await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+  return manifestPath;
 }
 
 /** @deprecated use writeConsolidatedExport */
-export async function mirrorConsolidatedExport(repoRoot, filename, jsonText) {
-  return writeConsolidatedExport(repoRoot, filename, jsonText);
+export async function mirrorConsolidatedExport(repoRoot, filename, jsonText, options = {}) {
+  return writeConsolidatedExport(repoRoot, filename, jsonText, options);
 }

package/template/backend/src/shared/utils/consolidatedExport.test.js

@@ -0,0 +1,50 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm, access } from "fs/promises";
+import { join } from "path";
+import { tmpdir } from "os";
+import {
+  beginConsolidatedExportSession,
+  consolidatedExportFolderName,
+  writeConsolidatedExport,
+  CONSOLIDATED_MANIFEST_FILENAME
+} from "./consolidatedExport.js";
+
+test("writeConsolidatedExport writes dated folder and latest copy", async () => {
+  const repoRoot = await mkdtemp(join(tmpdir(), "consolidated-export-"));
+  delete process.env.CONSOLIDATED_EXPORT_STAMP;
+
+  try {
+    const session = beginConsolidatedExportSession({ stamp: "2026-05-23_15-59-43Z" });
+    assert.equal(session.folderName, "2026-05-23_15-59-43Z_consolidated");
+
+    const written = await writeConsolidatedExport(
+      repoRoot,
+      "consolidated-models.json",
+      '{"meta":{"condensedBy":"test"}}',
+      { stamp: session.stamp, condensedBy: "test" }
+    );
+
+    assert.ok(written.exportPath.includes("2026-05-23_15-59-43Z_consolidated/consolidated-models.json"));
+
+    await access(join(repoRoot, "file-exchange/exports/2026-05-23_15-59-43Z_consolidated/consolidated-models.json"));
+    await access(join(repoRoot, "file-exchange/exports/consolidated-models.json"));
+
+    const manifest = JSON.parse(
+      await readFile(
+        join(
+          repoRoot,
+          "file-exchange/exports",
+          consolidatedExportFolderName(session.stamp),
+          CONSOLIDATED_MANIFEST_FILENAME
+        ),
+        "utf8"
+      )
+    );
+    assert.equal(manifest.stamp, "2026-05-23_15-59-43Z");
+    assert.ok(manifest.artifacts.some((a) => a.filename === "consolidated-models.json"));
+  } finally {
+    await rm(repoRoot, { recursive: true, force: true });
+    delete process.env.CONSOLIDATED_EXPORT_STAMP;
+  }
+});

package/template/docs/README.md

@@ -11,7 +11,6 @@ This folder describes the **modular monolith platform starter** and how **archit
 | [Starter pack](./STARTER_PACK.md) | What ships in the repo, how to run it, and how to add modules |
 | [Architecture guardrails](./architecture/ARCHITECTURE_GUARDRAILS.md) | Module contracts, boundaries, naming, and how enforcement works |
 | [Module internal contract](./architecture/MODULE_INTERNAL_CONTRACT.md) | MVC layers, prompts, evals, tests inside each feature module |
-| [Evals, regression, and CI gates](./architecture/EVAL_AND_CI.md) | `test:ci`, GitHub Actions, optional per-case golden |
 | [Evals, regression, and CI gates](./architecture/EVAL_AND_CI.md) | Golden evals, `test:evals`, GitHub Actions gates |
 | [Publishing the CLI](./PUBLISHING.md) | Release `@pukujan/create-modular-monolith` to npm |
 | [Case Filing AI starter](./case-filing-ai/README.md) | Domain blueprint, module split, pipeline, guardrails, and DB schema |

package/template/docs/architecture/EVAL_AND_CI.md

@@ -1,79 +1,106 @@
 # Evals, regression, and CI gates
 
-Plain-language guide for **domain-agnostic** projects scaffolded from this template.
+Plain-language guide to how this repo checks prompt and pipeline quality automatically.
 
 ---
 
 ## What is a “gate”?
 
-A **gate** is an automatic check that must pass before code is merged.
+A **gate** is an automatic check that must pass before code is merged or published.
 
-| Gate | What it blocks |
-|------|----------------|
+Think of it like airport security: if the check fails, you do not proceed until it is fixed.
+
+| Gate (command) | What it blocks |
+|----------------|----------------|
 | `npm run lint:contracts` | Broken contract paths in `manifest.json` |
-| `npm run lint:repo-artifacts` | Missing platform folders (file-exchange, dev-logs, …) |
-| `npm run lint:architecture` | Module boundary / layer / API doc violations |
-| `npm test` | Unit/integration failures |
-| `npm run test:evals` | Module `evals/runners/*.eval.mjs` failures |
+| `npm run lint:repo-artifacts` | Missing required folders/files (including golden CI slice) |
+| `npm run lint:architecture` | Module boundary/layer/API doc violations |
+| `npm test` | Unit/integration test failures |
+| `npm run test:evals` | Golden regression failures (offline, no API key) |
 
-GitHub Actions runs these on push/PR (see `.github/workflows/ci.yml`). Locally: **`npm run test:ci`**.
+GitHub Actions runs these on every push/PR to `main` (see `.github/workflows/ci.yml`).
 
 ---
 
 ## What is “eval / regression”?
 
-**Eval** = automated check that output meets expectations.
+**Eval** = compare actual AI output to **expected** (golden) JSON.
 
-**Regression** = re-run evals after a change to catch quality going **down**.
+**Regression** = re-run that comparison after you change prompts or code, to see if quality got worse.
 
-### Golden data is per domain case — not universal
+```text
+Fixture output (or live batch output)
+        ↓
+   evalRunner.evalDocument()
+        ↓
+Compare to evals/golden/case_001/doc_NNN.expected.json
+        ↓
+Scores + pass | partial | fail
+```
 
-Every product case is different (different users, documents, rules). You **do not** ship one golden dataset for all future cases.
+This repo uses **golden files** under `evals/golden/case_001/`:
 
-| Pattern | When to use |
-|---------|-------------|
-| **Module example evals** | Shipped in `_reference` — smoke tests, no API keys |
-| **Optional `evals/golden/{caseId}/`** | When **you** curate expected JSON for one fixed regression case |
-| **Live runs only** | New cases with no golden yet — process, review, optionally add golden later |
+| File | Purpose |
+|------|---------|
+| `doc_001.expected.json` | What doc 1 extraction should look like |
+| `after_doc_001.expected.json` | Case snapshot after doc 1 |
+| `negative_guardrails.expected.json` | Rules that must never appear in output |
+| `case_001.golden-dataset.json` | Manifest (checkpoints, version) |
 
-Golden answers the question: *“On **this** known fixture, did we get worse than last time?”*  
-Not: *“We already know the truth for every new case.”*
+A **minimal golden slice** is committed for CI. Full synthetic case data can be ingested via:
 
-When you add a domain module (`npm run new:module`), add `evals/runners/` and optional `evals/golden/` for cases you control.
+```bash
+npm run import:file-exchange -- <bundle>
+npm run ingest:golden-expected
+```
 
 ---
 
-## Trace IDs (observability)
-
-Use `backend/src/shared/utils/traceId.js` in long-running workflows:
+## Running evals locally
 
-```js
-import { createTraceId, docTraceId } from "../shared/utils/traceId.js";
+```bash
+# All module eval runners (offline for case-filing-ai)
+npm run test:evals
 
-const batchTraceId = createTraceId("batch_my-job");
-const traceId = docTraceId(batchTraceId, 1);
+# Case Filing AI only
+npm run test:evals -- case-filing-ai
 ```
 
-Log both IDs in JSONL or structured logs so agents and humans can correlate steps. Plug the same IDs into Langfuse/OpenTelemetry later if needed.
+`golden-regression.eval.mjs` uses test fixtures — **no OpenRouter key required**.
+
+Live batch evals still run when you process uploads; reports land in `data/.../batches/batch-NNN/evals/`.
 
 ---
 
-## CI workflow
+## Trace IDs (observability)
 
-`.github/workflows/ci.yml`:
+Each batch gets `batchTraceId`; each document gets `traceId` in:
 
-1. Install backend + frontend  
-2. `lint:contracts` · `lint:repo-artifacts` · `lint:architecture`  
-3. `npm test` · `npm run test:evals`
+- `processing-log.jsonl` entries
+- Document output JSON
+
+Use these to correlate logs, eval reports, and future external tracing (Langfuse, etc.).
 
 ---
 
-## Adding domain evals
+## Schema validation
 
-```bash
-npm run new:module -- billing --label "Billing"
-# Add backend/src/modules/billing/evals/runners/my-check.eval.mjs
-npm run test:evals -- billing
-```
+Master prompt JSON is validated against:
+
+- `schemas/master-output.v1.schema.json` (v1, compact, v2)
+- `schemas/master-output.v001.schema.json` (v001)
+
+Invalid output triggers a schema-aware retry before failing the document.
+
+---
+
+## CI workflow
+
+`.github/workflows/ci.yml` runs on push/PR:
+
+1. Install backend + frontend deps  
+2. `lint:contracts` · `lint:repo-artifacts` · `lint:architecture`  
+3. `npm test`  
+4. `npm run test:evals`  
 
-See [MODULE_INTERNAL_CONTRACT.md](./MODULE_INTERNAL_CONTRACT.md) for colocated `prompts/` and `evals/`.
+Or locally: `npm run test:ci` (same checks from repo root).

package/template/docs/architecture/REPO_ARTIFACT_LAYOUT.md

@@ -1,25 +1,48 @@
 # Repository artifact layout
 
-Canonical paths for platform artifacts and human↔agent exchange.
+Canonical paths for runtime data, golden fixtures, and human↔agent exchange.
 
 ## Roots
 
-| Root | Writable at runtime | Purpose |
-|------|---------------------|---------|
-| `file-exchange/imports\|exports/` | Yes | Dated human↔agent handoff |
-| `work-log/dev-logs/human\|agent/` | Yes | Pre-push audit pairs |
-| `models/consolidated-*.json` | Yes | Mirror of `file-exchange/exports/consolidated-*.json` |
-| `work-log/handoffs/` | Yes | Session handoffs (markdown) |
-| `data/` | Yes | **Your** domain runtime data (gitignore by default) |
-| `evals/golden/{caseId}/` | Optional | Per-case regression fixtures when you add them |
+| Root | Env override | Writable at runtime |
+|------|----------------|---------------------|
+| `data/case-filing-ai/batches/` | `CASE_FILING_BATCH_DIR` | Yes (pipeline) |
+| `evals/golden/{caseId}/` | `GOLDEN_DATASET_DIR` | No (fixtures) |
+| `data/court-rules/fixtures/` | — | No |
+| `eval-bundles/` | `EVAL_BUNDLE_ROOT_DIR` | Yes (export API) |
+| `case-exports/` | `CASE_EXPORT_ROOT_DIR` | Yes (export API) |
+| `file-exchange/imports\|exports/` | — | Yes (human triage) |
+| `work-log/dev-logs/human\|agent/` | — | Yes (pre-push audit) |
+| `models/consolidated-*.json` | — | Yes (condenser mirror) |
+| `work-log/` | — | Yes (docs only) |
+
+## Batch folder (`batches/batch-NNN/`)
+
+```text
+uploads/
+parsed-documents/doc-NNN/    # v2+ parsed cache
+outputs/doc-NNN.json
+evals/doc_NNN.eval-report.json
+rule/
+case-snapshot.json
+processing-log.jsonl
+```
+
+## Golden (`evals/golden/case_001/`)
+
+```text
+case_001.golden-dataset.json
+doc_NNN.expected.json
+parsed/doc-NNN/              # optional parse golden (v2)
+```
 
 ## File exchange
 
 Imports: `file-exchange/imports/{2026-05-23_15-59-43Z}/`  
-Session exports: `file-exchange/exports/{stamp}/`  
-Consolidated snapshots: `file-exchange/exports/consolidated-*.json`
+Session exports: `file-exchange/exports/{stamp}_{label}/`  
+Consolidated snapshots: `file-exchange/exports/{stamp}_consolidated/` (+ latest `consolidated-*.json` at `exports/` root)
 
-See [file-exchange/README.md](../../file-exchange/README.md).
+See [file-exchange/README.md](../../file-exchange/README.md) and [contracts/fileExchange.contract.md](./contracts/fileExchange.contract.md).
 
 ## Pre-push dev logs
 
@@ -28,6 +51,26 @@ work-log/dev-logs/human/{NNN}_{date}_{time}_dev-log_{slug}.md
 work-log/dev-logs/agent/{NNN}_{date}_{time}_dev-log-agent_{slug}.json
 ```
 
-## Domain modules
+`npm run dev-log:pre-push` — see [contracts/prePushDevLog.contract.md](./contracts/prePushDevLog.contract.md).
+
+## Consolidated exports
+
+`npm run condense:all` → [contracts/consolidatedExports.contract.md](./contracts/consolidatedExports.contract.md).
+
+## Contracts
+
+**Overview (start here):** [CONTRACTS_OVERVIEW.md](./CONTRACTS_OVERVIEW.md)  
+Manifest: [contracts/manifest.json](./contracts/manifest.json) · Changelog: [contracts/changelog.jsonl](./contracts/changelog.jsonl)
+
+| Contract | Doc |
+|----------|-----|
+| File exchange | [fileExchange.contract.md](./contracts/fileExchange.contract.md) |
+| Consolidated exports | [consolidatedExports.contract.md](./contracts/consolidatedExports.contract.md) |
+| Pre-push dev log | [prePushDevLog.contract.md](./contracts/prePushDevLog.contract.md) |
+| API registry | [apiDocumentationRegistry.contract.md](./contracts/apiDocumentationRegistry.contract.md) |
+| Case filing storage | `backend/src/modules/case-filing-ai/contracts/storageLayout.contract.js` |
+| Parsed artifacts | `parsedDocumentArtifacts.contract.js` |
+| Pipeline versions | `pipelineVersions.js` |
+| Rule authority | `court-rules/contracts/ruleAuthority.contract.js` |
 
-When you add features with `npm run new:module`, colocate runtime data under `data/<module>/` and optional `evals/golden/` per [EVAL_AND_CI.md](./EVAL_AND_CI.md).
+Human storage doc: [docs/case-filing-ai/STORAGE.md](../case-filing-ai/STORAGE.md)

package/template/docs/architecture/contracts/consolidatedExports.contract.md

@@ -7,25 +7,28 @@
 
 Regenerable **repo snapshots** for human handoff and agent onboarding — not runtime filing data.
 
-## Primary paths (handoff)
+## Primary paths (audit trail)
+
+Each condense run writes a **dated, timestamped folder** (same stamp convention as imports):
 
 ```text
-file-exchange/exports/
+file-exchange/exports/{2026-05-23_15-59-43Z}_consolidated/
   consolidated-models.json
   consolidated-prompts.json
   consolidated-file-structure.json
+  manifest.json                 ← artifact index for the run
 ```
 
-## Mirror paths (API / git)
+`npm run condense:all` uses one shared stamp for all three files in a single folder.
+
+## Latest pointers (agents / API)
 
 ```text
-models/
-  consolidated-models.json      ← model-condenser API writes here first
-  consolidated-prompts.json
-  consolidated-file-structure.json
+file-exchange/exports/consolidated-*.json   ← overwritten each run (latest)
+models/consolidated-*.json                  ← API mirror (latest)
 ```
 
-Every condense run writes **both** export and mirror.
+Every condense run writes **dated folder + latest copies**.
 
 ## Commands
 
@@ -42,11 +45,12 @@ npm --prefix backend run condense-models   # or POST /api/model-condenser/conden
 |------|--------|
 | `consolidated-models.json` | Model condenser — schema inventory |
 | `consolidated-prompts.json` | All `.prompt.md` / `.prompt.js` + manifests |
-| `consolidated-file-structure.json` | Full file tree (tree ignore rules) |
+| `consolidated-file-structure.json` | ASCII `treeText` only + `stats` (not nested JSON / flat path lists) |
 
 ## File tree ignore (consolidated-file-structure)
 
-Same as pre-push dev log: `node_modules`, `.git`, `dist`, `build`.
+Directory names: `node_modules`, `.git`, `dist`, `build`.  
+Skipped subtrees: `data/case-filing-ai/batches`, `eval-bundles`, `case-exports`.
 
 ## Deprecated
 

package/template/docs/architecture/contracts/manifest.json

@@ -35,5 +35,22 @@
     "registry": "docs/API.md",
     "lintScript": "scripts/check-api-docs.mjs",
     "architectureDoc": "docs/architecture/API_DOCUMENTATION_CONTRACT.md"
+  },
+  "caseFilingStorageLayout": {
+    "version": "v001",
+    "file": "backend/src/modules/case-filing-ai/contracts/storageLayout.contract.js"
+  },
+  "parsedDocumentArtifacts": {
+    "version": "v001",
+    "file": "backend/src/modules/case-filing-ai/contracts/parsedDocumentArtifacts.contract.js"
+  },
+  "pipelineVersions": {
+    "version": "v001",
+    "file": "backend/src/modules/case-filing-ai/contracts/pipelineVersions.js",
+    "promptVersions": "backend/src/modules/case-filing-ai/prompts/promptVersions.js"
+  },
+  "ruleAuthority": {
+    "version": "v001",
+    "file": "backend/src/modules/court-rules/contracts/ruleAuthority.contract.js"
   }
 }

package/template/file-exchange/README.md

@@ -6,35 +6,40 @@ Dated folders for human ↔ agent file handoff. **No sensitive filing text in gi
 
 ```text
 file-exchange/
-  imports/{2026-05-23_15-59-43Z}/          ← inbound bundles
-  exports/{2026-05-23_15-59-43Z_...}/      ← session deliverables (batch runs, curl logs)
-  exports/consolidated-models.json         ← repo snapshots (regenerate with condense:all)
-  exports/consolidated-prompts.json
-  exports/consolidated-file-structure.json
+  imports/{2026-05-23_15-59-43Z}/                    ← inbound bundles
+  exports/{2026-05-23_15-59-43Z_live-batch-run}/      ← session deliverables
+  exports/{2026-05-23_15-59-43Z}_consolidated/        ← repo snapshots (audit trail)
+    consolidated-models.json
+    consolidated-prompts.json
+    consolidated-file-structure.json
+    manifest.json
+  exports/consolidated-*.json                        ← latest copies (regenerate with condense:all)
 ```
 
 **Stamp format:** `YYYY-MM-DD_HH-MM-SSZ` via `formatExchangeTimestamp()` in `backend/src/shared/utils/formatExchangeTimestamp.js`.
 
-## Consolidated exports (in `exports/`)
+## Consolidated exports
 
 ```bash
 npm run condense:all
 ```
 
-| File in `exports/` | Mirror (API) |
-|--------------------|--------------|
-| `consolidated-models.json` | `models/consolidated-models.json` |
-| `consolidated-prompts.json` | `models/consolidated-prompts.json` |
-| `consolidated-file-structure.json` | `models/consolidated-file-structure.json` |
+Writes all three artifacts into **one dated folder** `{stamp}_consolidated/` and refreshes latest copies:
 
-**Open `file-exchange/exports/`** — all three consolidated files sit next to dated batch export folders.
+| Audit (dated folder) | Latest (`exports/` + `models/`) |
+|----------------------|----------------------------------|
+| `{stamp}_consolidated/consolidated-models.json` | `exports/consolidated-models.json`, `models/consolidated-models.json` |
+| `{stamp}_consolidated/consolidated-prompts.json` | same pattern |
+| `{stamp}_consolidated/consolidated-file-structure.json` | same pattern |
+
+Individual runs (`npm run condense-prompts`, etc.) create their own `{stamp}_consolidated/` folder for that artifact (plus `manifest.json`).
 
 ## Workflow
 
 1. Triage loose files into `imports/{stamp}/` (`npm run import:file-exchange -- <path>`).
-2. Process via your domain module APIs using files **under that stamp** only.
-3. Copy batch bundles / reports to `exports/{stamp}/` when done.
-4. Refresh consolidated snapshots: `npm run condense:all`.
+2. Process via case-filing APIs using files **under that stamp** only.
+3. Copy batch bundles / reports to `exports/{stamp}_{label}/` when done.
+4. Refresh consolidated snapshots: `npm run condense:all` → new `exports/{stamp}_consolidated/`.
 
 **Cursor agents:** mandatory — see [AGENTS.md](../AGENTS.md) and `.cursor/rules/file-exchange-inbox.mdc`.
 

package/template/frontend/package.json

@@ -7,7 +7,7 @@
     "dev": "vite",
     "build": "vite build",
     "preview": "vite preview",
-    "test": "node --test 'src/modules/**/tests/**/*.test.js'"
+    "test": "node --test"
   },
   "dependencies": {
     "react": "^18.3.1",

package/template/package.json

@@ -3,6 +3,8 @@
   "private": true,
   "version": "2.0.0",
   "scripts": {
+    "sync:cli-template": "node scripts/sync-cli-template.mjs",
+    "export:architecture-starter": "node scripts/export-architecture-starter.mjs",
     "dev:backend": "npm --prefix backend run dev",
     "dev:frontend": "npm --prefix frontend run dev",
     "lint:boundaries": "npm --prefix backend run lint:boundaries",
@@ -12,12 +14,10 @@
     "lint:repo-artifacts": "node scripts/lint-repo-artifacts.mjs",
     "lint:architecture": "npm --prefix backend run lint:architecture",
     "test": "npm --prefix backend test && npm --prefix frontend test",
-    "test:evals": "npm --prefix backend run test:evals",
-    "test:ci": "npm run lint:contracts && npm run lint:repo-artifacts && npm run lint:architecture && npm test && npm run test:evals",
     "new:module": "node scripts/new-module.mjs",
     "condense-prompts": "node scripts/condense-prompts.mjs",
     "condense-file-structure": "node scripts/condense-file-structure.mjs",
-    "condense:all": "npm run condense-prompts && npm run condense-file-structure && npm --prefix backend run condense-models -- --local",
+    "condense:all": "node scripts/condense-all.mjs",
     "dev-log:pre-push": "node scripts/write-pre-push-dev-log.mjs",
     "dev-log:verify": "node scripts/verify-dev-log.mjs",
     "import:file-exchange": "node scripts/import-to-file-exchange.mjs"