feat: put/hash support --pipe/-p to read JSON from stdin (#83 )

Merge pull request 'fix: CLI put @schema uses putSchema() for recursive validation (#82 )' (#86 ) from fix/82-meta-schema-nested-validation into main
fix: CLI put @schema uses putSchema() for recursive validation (#82 )
2026-06-01 09:50:03 +08:00 · 2026-06-01 01:39:49 +00:00 · 2026-06-01 01:35:40 +00:00 · 2026-06-01 01:26:50 +00:00 · 2026-06-01 01:14:02 +00:00 · 2026-05-31 23:43:51 +00:00
35 changed files with 4695 additions and 649 deletions
@@ -0,0 +1,413 @@
+name: "e2e-check"
+description: "Docker-isolated E2E testing of json-cas CLI. Preparer builds from scratch, tester runs scenarios, reporter files bugs."
+
+roles:
+  preparer:
+    description: "Spins up Docker container, copies repo, installs, builds, runs unit tests"
+    goal: "You set up a clean Docker environment for E2E testing. Your job is to start a container, install deps, build, lint, run unit tests, and initialize a CAS store. Report any setup failures as bugs."
+    capabilities:
+      - docker
+    procedure: |
+      1. Start a detached container:
+         ```bash
+         docker run -d --name json-cas-e2e \
+           -v "<repoPath>:/src:ro" \
+           -w /workspace \
+           oven/bun:latest \
+           sleep 3600
+         ```
+
+      2. Copy repo and install:
+         ```bash
+         docker exec json-cas-e2e bash -c 'cp -r /src/. /workspace/ && cd /workspace && bun install'
+         ```
+         ✅ exit code 0, no missing peer deps
+
+      3. Build:
+         ```bash
+         docker exec json-cas-e2e bash -c 'cd /workspace && bun run build'
+         ```
+         ✅ exit code 0, no type errors
+
+      4. Lint:
+         ```bash
+         docker exec json-cas-e2e bash -c 'cd /workspace && bun run check'
+         ```
+         ✅ exit code 0
+
+      5. Unit tests:
+         ```bash
+         docker exec json-cas-e2e bash -c 'cd /workspace && bun test'
+         ```
+         ✅ all pass (ignore dist/ false positives)
+
+      6. Init CAS store:
+         ```bash
+         docker exec json-cas-e2e bash -c 'mkdir -p /tmp/cas-test && cd /workspace && bun packages/cli-json-cas/src/index.ts --store /tmp/cas-test init && bun packages/cli-json-cas/src/index.ts --store /tmp/cas-test bootstrap'
+         ```
+
+      **Any failure here is a high-severity bug** — it means a clean environment can't build/run the project.
+
+      Set $status=ready if all steps pass. Set $status=setup_failed with failures list if anything breaks.
+
+    output: "Setup result summary."
+    frontmatter:
+      oneOf:
+        - type: object
+          properties:
+            $status: { const: "ready" }
+            containerName: { type: string }
+            storePath: { type: string }
+            repoPath: { type: string }
+          required: [$status, containerName, storePath, repoPath]
+        - type: object
+          properties:
+            $status: { const: "setup_failed" }
+            failures:
+              type: array
+              items:
+                type: object
+                properties:
+                  title: { type: string }
+                  command: { type: string }
+                  expected: { type: string }
+                  actual: { type: string }
+                  severity: { type: string }
+                  phase: { type: string }
+                required: [title, command, expected, actual, severity, phase]
+            repoPath: { type: string }
+          required: [$status, failures, repoPath]
+
+  tester:
+    description: "Runs CLI scenarios against the prepared Docker environment"
+    goal: "You are an exploratory QA agent. The Docker container is already running with the project built and a CAS store initialized. Run CLI test scenarios and report bugs."
+    capabilities:
+      - testing
+      - cli
+    procedure: |
+      The container `{{{containerName}}}` is already running with the project built.
+      Store path: `{{{storePath}}}`.
+
+      Run all commands via:
+      ```bash
+      docker exec {{{containerName}}} bash -c 'cd /workspace && bun packages/cli-json-cas/src/index.ts --store {{{storePath}}} <subcommand>'
+      ```
+
+      Define a shorthand in your notes:
+      `CMD="cd /workspace && bun packages/cli-json-cas/src/index.ts --store {{{storePath}}}"`
+
+      ## Phase 1: CAS Core Operations
+
+      1. **bootstrap** — `$CMD bootstrap`
+         Expected: prints meta-schema hash (13-char Base32)
+
+      2. **schema put** — Create `/tmp/test-schema.json` in container, then `$CMD schema put /tmp/test-schema.json`
+         Schema: `{"type":"object","properties":{"name":{"type":"string"},"age":{"type":"number"}},"required":["name"],"additionalProperties":false}`
+         Expected: prints type hash
+
+      3. **schema get** — `$CMD schema get <type-hash>`
+         Expected: returns the schema JSON
+
+      4. **schema list** — `$CMD schema list`
+         Expected: lists registered schemas
+
+      5. **put** — Create data file, `$CMD put <type-hash> /tmp/test-node.json`
+         Data: `{"name":"Alice","age":30}`
+         Expected: prints node hash
+
+      6. **get** — `$CMD get <node-hash>`
+         Expected: returns node JSON
+
+      7. **has (exists)** — `$CMD has <node-hash>`
+         Expected: true
+
+      8. **has (not exists)** — `$CMD has AAAAAAAAAAAAA`
+         Expected: false
+
+      9. **verify** — `$CMD verify <node-hash>`
+         Expected: ok
+
+      10. **refs** — `$CMD refs <node-hash>`
+          Expected: lists refs (may be empty)
+
+      11. **walk** — `$CMD walk <node-hash>`
+          Expected: shows traversal tree
+
+      12. **hash (dry run)** — `$CMD hash <type-hash> /tmp/test-node.json`
+          Expected: same hash as put
+
+      13. **cat** — `$CMD cat <node-hash>`
+          Expected: full node output
+
+      14. **cat --payload** — `$CMD cat <node-hash> --payload`
+          Expected: payload only (no type wrapper)
+
+      ## Phase 2: Schema Validation
+
+      1. **Invalid node** — `$CMD put <type-hash> /tmp/bad-node.json` where bad-node = `{"name":123}`
+         Expected: validation error, non-zero exit
+
+      2. **schema validate** — `$CMD schema validate <node-hash>`
+         Expected: valid for good node
+
+      3. **Non-existent schema** — `$CMD put AAAAAAAAAAAAA /tmp/test-node.json`
+         Expected: error about missing schema
+
+      ## Phase 3: Variable System
+
+      1. **var set** — `$CMD var set myapp/config <node-hash>`
+         Expected: creates variable
+
+      2. **var get** — `$CMD var get myapp/config --schema <type-hash>`
+         Expected: returns variable
+
+      3. **var list** — `$CMD var list`
+         Expected: shows all variables
+
+      4. **var list prefix** — `$CMD var list myapp/`
+         Expected: filtered results
+
+      5. **var set (update)** — Put a second node, `$CMD var set myapp/config <new-hash>`
+         Expected: upsert succeeds
+
+      6. **var tag** — `$CMD var tag myapp/config --schema <type-hash> env:prod important`
+         Expected: adds tag and label
+
+      7. **var list --tag** — `$CMD var list --tag env:prod`
+         Expected: finds tagged variable
+
+      8. **var list --tag (label)** — `$CMD var list --tag important`
+         Expected: finds labeled variable
+
+      9. **var tag remove** — `$CMD var tag myapp/config --schema <type-hash> :important`
+         Expected: removes label
+
+      10. **var delete** — `$CMD var delete myapp/config`
+          Expected: deletes variable
+
+      11. **var get (deleted)** — `$CMD var get myapp/config --schema <type-hash>`
+          Expected: not found error
+
+      ## Phase 4: Template System
+
+      1. **template set** — Create template file, `$CMD template set <type-hash> /tmp/test.liquid`
+         Template: `Name: {{ payload.name }}, Age: {{ payload.age }}`
+         Expected: success
+
+      2. **template get** — `$CMD template get <type-hash>`
+         Expected: returns template text
+
+      3. **template list** — `$CMD template list`
+         Expected: lists templates
+
+      4. **template delete** — `$CMD template delete <type-hash>`
+         Expected: success
+
+      5. **template get (deleted)** — `$CMD template get <type-hash>`
+         Expected: not found error
+
+      ## Phase 5: Render
+
+      1. Re-register template, then `$CMD render <node-hash>`
+         Expected: rendered output with payload values filled in
+
+      2. **render --resolution** — `$CMD render <node-hash> --resolution 0.5`
+         Expected: different resolution output
+
+      3. **render (bad hash)** — `$CMD render AAAAAAAAAAAAA`
+         Expected: graceful error, non-zero exit
+
+      ## Phase 6: GC
+
+      1. **gc basic** — `$CMD gc`
+         Expected: runs without error
+
+      2. **gc preserves referenced** — Verify `$CMD has <node-hash>` still true
+
+      3. **gc collects orphans** — Put an orphan node (not in any variable), run gc, check it's gone
+
+      ## Phase 7: Edge Cases & Error Handling
+
+      1. `$CMD get AAAAAAAAAAAAA` — non-existent
+      2. `$CMD put <type-hash> /nonexistent/file.json` — missing file
+      3. `$CMD var set "" <hash>` — empty name
+      4. `$CMD var set "bad name!" <hash>` — invalid name chars
+      5. `$CMD schema put /tmp/bad-schema.json` — `{"type":"invalid"}`
+      6. `$CMD` with no subcommand — should show help
+      7. `$CMD --store /nonexistent/path get <hash>` — bad store path
+
+      ## Recording Results
+
+      For each scenario:
+      - ✅ Pass: works as expected
+      - ❌ Fail: unexpected behavior, crash, wrong output
+      - ⚠️ Questionable: works but confusing UX
+
+      Collect all ❌ and ⚠️. For each, record:
+      - Title (concise description)
+      - Command (exact command run)
+      - Expected behavior
+      - Actual behavior (include actual output)
+      - Severity: critical / high / medium / low
+      - Phase: which test phase
+
+      ## CRITICAL: Frontmatter Output Format
+
+      Your response MUST start with YAML frontmatter. The `bugs` field MUST be an array of objects, NOT strings.
+
+      Example of CORRECT frontmatter:
+      ```yaml
+      ---
+      $status: bugs_found
+      containerName: json-cas-e2e
+      repoPath: /path/to/repo
+      bugs:
+        - title: "put does not validate data against schema"
+          command: "json-cas put <hash> bad-data.json"
+          expected: "Validation error, non-zero exit"
+          actual: "Accepted invalid data, exit 0"
+          severity: "high"
+          phase: "Schema Validation"
+      ---
+      ```
+
+      Do NOT write bugs as plain strings like `- some bug description`. Each bug MUST be an object with all 6 fields.
+
+      If all tests pass:
+      ```yaml
+      ---
+      $status: all_passed
+      containerName: json-cas-e2e
+      ---
+      ```
+
+    output: "Summary of all phases with pass/fail counts. Set $status."
+    frontmatter:
+      oneOf:
+        - type: object
+          properties:
+            $status: { const: "bugs_found" }
+            bugs:
+              type: array
+              items:
+                type: object
+                properties:
+                  title: { type: string }
+                  command: { type: string }
+                  expected: { type: string }
+                  actual: { type: string }
+                  severity: { type: string }
+                  phase: { type: string }
+                required: [title, command, expected, actual, severity, phase]
+            containerName: { type: string }
+            repoPath: { type: string }
+          required: [$status, bugs, containerName]
+        - type: object
+          properties:
+            $status: { const: "all_passed" }
+            containerName: { type: string }
+          required: [$status, containerName]
+
+  reporter:
+    description: "Opens Gitea issues for each bug found by the tester"
+    goal: "You are a bug reporter. You create well-formatted Gitea issues for each bug found during E2E testing."
+    capabilities:
+      - issue-management
+    procedure: |
+      1. Parse the bugs array from the tester's output
+      2. Group bugs by severity (critical first)
+      3. For each bug, create a Gitea issue:
+         ```bash
+         tea issues create -r uncaged/json-cas \
+           -t "[E2E] <title>" \
+           -d "## Bug Report (E2E Check)
+
+         **Phase:** <phase>
+         **Severity:** <severity>
+
+         **Command:**
+         \`\`\`
+         <exact command>
+         \`\`\`
+
+         **Expected:** <expected>
+
+         **Actual:** <actual>
+
+         ---
+         _Reported by e2e-check workflow (Docker isolated)_"
+         ```
+
+         ⚠️ If `tea issues create` fails with long body, use Gitea REST API:
+         ```bash
+         eval "$(cfg env)" && GITEA_TOKEN=$(cfg get GITEA_TOKEN)
+         curl -s -X POST "https://git.shazhou.work/api/v1/repos/uncaged/json-cas/issues" \
+           -H "Authorization: token $GITEA_TOKEN" \
+           -H "Content-Type: application/json" \
+           -d '{"title":"[E2E] ...","body":"..."}'
+         ```
+
+      4. Collect created issue numbers
+
+    output: "List created issues. Set $status."
+    frontmatter:
+      oneOf:
+        - type: object
+          properties:
+            $status: { const: "reported" }
+            issues:
+              type: array
+              items: { type: string }
+          required: [$status, issues]
+        - type: object
+          properties:
+            $status: { const: "partial" }
+            created: { type: number }
+            failed: { type: number }
+          required: [$status, created, failed]
+
+  cleanup:
+    description: "Stops and removes the Docker container"
+    goal: "You clean up the Docker environment after testing is complete."
+    capabilities:
+      - docker
+    procedure: |
+      Stop and remove the container:
+      ```bash
+      docker stop {{{containerName}}} && docker rm {{{containerName}}}
+      ```
+
+      Verify it's gone:
+      ```bash
+      docker ps -a --filter name={{{containerName}}} --format '{{.Names}}'
+      ```
+      Expected: empty output.
+
+    output: "Cleanup result."
+    frontmatter:
+      oneOf:
+        - type: object
+          properties:
+            $status: { const: "cleaned" }
+          required: [$status]
+        - type: object
+          properties:
+            $status: { const: "cleanup_failed" }
+            error: { type: string }
+          required: [$status, error]
+
+graph:
+  $START:
+    _: { role: "preparer", prompt: "Set up Docker environment for E2E testing. Repo at {{{repoPath}}}." }
+  preparer:
+    ready: { role: "tester", prompt: "Environment ready. Container: {{{containerName}}}, store: {{{storePath}}}. Run all test scenarios." }
+    setup_failed: { role: "reporter", prompt: "Setup failures found. File these as bugs: {{{failures}}}" }
+  tester:
+    all_passed: { role: "cleanup", prompt: "All tests passed. Clean up container {{{containerName}}}." }
+    bugs_found: { role: "reporter", prompt: "File these bugs as Gitea issues: {{{bugs}}}" }
+  reporter:
+    reported: { role: "cleanup", prompt: "Bugs filed: {{{issues}}}. Clean up container {{{containerName}}}." }
+    partial: { role: "cleanup", prompt: "Filed {{{created}}} issues, {{{failed}}} failed. Clean up container {{{containerName}}}." }
+  cleanup:
+    cleaned: { role: "$END", prompt: "E2E check complete. Environment cleaned up." }
+    cleanup_failed: { role: "$END", prompt: "E2E check complete but cleanup failed: {{{error}}}" }
@@ -51,16 +51,19 @@ roles:
    output: "A findings report with per-issue root cause and suggested procedure fixes. Set $status to clean or findings (with report hash)."
    frontmatter:
      oneOf:
-        - properties:
+        - type: object
+          properties:
            $status: { const: "clean" }
            summary: { type: string }
          required: [$status, summary]
-        - properties:
+        - type: object
+          properties:
            $status: { const: "findings" }
            report: { type: string }
            targetWorkflow: { type: string }
          required: [$status, report, targetWorkflow]
-        - properties:
+        - type: object
+          properties:
            $status: { const: "wrong_project" }
            workflowName: { type: string }
          required: [$status, workflowName]
@@ -93,12 +96,14 @@ roles:
    output: "A change plan stored in CAS. Set $status to ready (with plan hash and repoPath) or no_action (if findings don't warrant changes)."
    frontmatter:
      oneOf:
-        - properties:
+        - type: object
+          properties:
            $status: { const: "ready" }
            plan: { type: string }
            repoPath: { type: string }
          required: [$status, plan, repoPath]
-        - properties:
+        - type: object
+          properties:
            $status: { const: "no_action" }
            reason: { type: string }
          required: [$status, reason]
@@ -128,12 +133,14 @@ roles:
    output: "List all files changed and provide a summary. Set $status to done (with branch/worktree), or failed (with reason)."
    frontmatter:
      oneOf:
-        - properties:
+        - type: object
+          properties:
            $status: { const: "done" }
            branch: { type: string }
            worktree: { type: string }
          required: [$status, branch, worktree]
-        - properties:
+        - type: object
+          properties:
            $status: { const: "failed" }
            reason: { type: string }
          required: [$status, reason]
@@ -157,12 +164,14 @@ roles:
    output: "Explain your decision. Set $status to approved (with branch/worktree) or rejected (with comments)."
    frontmatter:
      oneOf:
-        - properties:
+        - type: object
+          properties:
            $status: { const: "approved" }
            branch: { type: string }
            worktree: { type: string }
          required: [$status, branch, worktree]
-        - properties:
+        - type: object
+          properties:
            $status: { const: "rejected" }
            comments: { type: string }
            worktree: { type: string }
@@ -191,11 +200,13 @@ roles:
    output: "Include PR URL on success or error log on failure. Set $status to committed (with prUrl) or hook_failed (with error)."
    frontmatter:
      oneOf:
-        - properties:
+        - type: object
+          properties:
            $status: { const: "committed" }
            prUrl: { type: string }
          required: [$status, prUrl]
-        - properties:
+        - type: object
+          properties:
            $status: { const: "hook_failed" }
            error: { type: string }
          required: [$status, error]
@@ -26,12 +26,14 @@ roles:
    output: "Output a brief summary of the test spec. Set $status to ready (with plan hash and repoPath) or insufficient_info."
    frontmatter:
      oneOf:
-        - properties:
+        - type: object
+          properties:
            $status: { const: "ready" }
            plan: { type: string }
            repoPath: { type: string }
          required: [$status, plan, repoPath]
-        - properties:
+        - type: object
+          properties:
            $status: { const: "insufficient_info" }
          required: [$status]
  developer:
@@ -67,12 +69,14 @@ roles:
    output: "List all files changed and provide a summary. Set $status to done (with branch/worktree), or failed (with reason)."
    frontmatter:
      oneOf:
-        - properties:
+        - type: object
+          properties:
            $status: { const: "done" }
            branch: { type: string }
            worktree: { type: string }
          required: [$status, branch, worktree]
-        - properties:
+        - type: object
+          properties:
            $status: { const: "failed" }
            reason: { type: string }
          required: [$status, reason]
@@ -105,12 +109,14 @@ roles:
    output: "Explain your decision with specific file/line references. Set $status to approved (with branch/worktree) or rejected (with comments)."
    frontmatter:
      oneOf:
-        - properties:
+        - type: object
+          properties:
            $status: { const: "approved" }
            branch: { type: string }
            worktree: { type: string }
          required: [$status, branch, worktree]
-        - properties:
+        - type: object
+          properties:
            $status: { const: "rejected" }
            comments: { type: string }
            worktree: { type: string }
@@ -133,16 +139,19 @@ roles:
    output: "Report test results per scenario. Set $status to passed (with branch/worktree), fix_code (with report), or fix_spec (with report)."
    frontmatter:
      oneOf:
-        - properties:
+        - type: object
+          properties:
            $status: { const: "passed" }
            branch: { type: string }
            worktree: { type: string }
          required: [$status, branch, worktree]
-        - properties:
+        - type: object
+          properties:
            $status: { const: "fix_code" }
            report: { type: string }
          required: [$status, report]
-        - properties:
+        - type: object
+          properties:
            $status: { const: "fix_spec" }
            report: { type: string }
          required: [$status, report]
@@ -169,11 +178,13 @@ roles:
    output: "Include PR URL on success or error log on failure. Set $status to committed (with prUrl) or hook_failed (with error)."
    frontmatter:
      oneOf:
-        - properties:
+        - type: object
+          properties:
            $status: { const: "committed" }
            prUrl: { type: string }
          required: [$status, prUrl]
-        - properties:
+        - type: object
+          properties:
            $status: { const: "hook_failed" }
            error: { type: string }
          required: [$status, error]
@@ -88,30 +88,60 @@ Or use the CLI (see [CLI Reference](#cli-reference) and [`packages/cli-json-cas/

 ## CLI Reference

-Binary: `json-cas` (from `@uncaged/cli-json-cas`). Default store: `~/.uncaged/json-cas`.
+Binary: `json-cas` (also aliased `ucas`, from `@uncaged/cli-json-cas`). Default store:
+`~/.uncaged/json-cas`. The store is auto-created and bootstrapped on first use — there is
+no `init`/`bootstrap` command, and schemas are ordinary `@schema`-typed nodes (`ucas put
+@schema file.json`), so there is no `schema` subcommand.
+
+### Envelope format
+
+Every JSON-emitting command prints a uniform `{ type, value }` envelope. `type` is the hash
+of the command's `@output/*` result schema and `value` is the command payload. This makes
+output self-describing and pipeable: feed any envelope into `render -p` to render its
+`value` (embedded `cas_ref` hashes are expanded). `render` is the only command that emits
+raw (non-envelope) text.
+
+```jsonc
+// ucas has <hash>
+{ "type": "AYHQD2YA9G667", "value": true }
+```

 ```
 Usage: json-cas [--store <path>] [--json] <command> [args]

-Commands:
-  init                              Create store dir and write bootstrap seed
-  bootstrap                         Write meta-schema seed, print hash
-  schema put <file.json>            Register schema, print type hash
-  schema get <type-hash>            Print schema JSON
-  schema list                       List all schemas (name + hash)
-  schema validate <hash>            Validate node against its schema
-  put <type-hash> <file.json>       Store node, print hash
-  get <hash>                        Print node as JSON
-  has <hash>                        Print true/false
-  verify <hash>                     Verify integrity, print ok/corrupted
-  refs <hash>                       List direct cas_ref edges
-  walk <hash> [--format tree]       Recursive traversal
-  hash <type-hash> <file.json>      Compute hash without storing (dry run)
-  cat <hash> [--payload]            Output node (--payload for payload only)
+Commands (all emit a { type, value } envelope unless noted):
+  put <type-hash> <file.json>       Store node (value = hash)          (@output/put)
+  get <hash>                        Node payload + metadata            (@output/get)
+  has <hash>                        Existence boolean                  (@output/has)
+  verify <hash>                     ok / corrupted / invalid           (@output/verify)
+  refs <hash>                       Direct cas_ref edges               (@output/refs)
+  walk <hash> [--format tree]       Recursive traversal                (@output/walk)
+  hash <type-hash> <file.json>      Compute hash without storing       (@output/hash)
+  render <hash> [options]           Render node as text (raw output)
+  render --pipe/-p [options]        Render a piped envelope (raw output)
+  list --type <hash-or-alias>       Hashes for a type (value = list)   (@output/list)
+  var set|get|delete|tag|list ...   Variable CRUD                      (@output/var-*)
+  template set|get|list|delete ...  Output-template CRUD               (@output/template-*)
+  gc                                Garbage collection                 (@output/gc)

 Flags:
  --store <path>   Store directory (default: ~/.uncaged/json-cas)
  --json           Compact JSON output
+  --pipe, -p       Read a { type, value } envelope from stdin for render
+```
+
+### Pipe examples
+
+```bash
+# Store a node, then render the stored content (the put envelope's hash is
+# a cas_ref, so render -p dereferences and renders it):
+ucas put @schema ./schemas/item.json | ucas render -p
+
+# Render garbage-collection stats:
+ucas gc | ucas render -p
+
+# List every schema, then consume the envelope's value array with jq:
+ucas list --type @schema | jq -r '.value[]'
 ```

 ## Development
@@ -1,5 +1,33 @@
 # @uncaged/cli-json-cas

+## 0.6.0
+
+### Minor Changes
+
+- Unified `{ type, value }` envelope output for all CLI commands (RFC [#67](https://github.com/uncaged/json-cas/issues/67)).
+
+  ### Breaking Changes
+
+  - Removed `init`, `bootstrap`, `cat`, `schema put/get/list/validate` commands
+  - All CLI command outputs now wrapped in `{ type, value }` envelope (except `render`)
+  - `openStore()` is now async and auto-bootstraps
+
+  ### New Features
+
+  - 18 `@output/*` schemas registered at bootstrap
+  - `list --type <hash-or-alias>` command (replaces `schema list`)
+  - `verify` now checks both hash integrity and schema validation
+  - `wrapEnvelope()` helper exported from `@uncaged/json-cas`
+  - `openStore()` in `@uncaged/json-cas-fs` — async, auto mkdir + bootstrap
+  - Default LiquidJS templates for all output schemas
+  - Pipe composition: any command output can be piped to `render -p`
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @uncaged/json-cas@0.6.0
+  - @uncaged/json-cas-fs@0.6.0
+
 ## 0.5.3

 ### Patch Changes
@@ -4,7 +4,9 @@ CLI tool for json-cas stores.

 ## Overview

-`@uncaged/cli-json-cas` provides the `json-cas` command for managing a filesystem-backed store: bootstrap, schema registration, node CRUD, integrity checks, reference listing, and graph walks. It uses `@uncaged/json-cas-fs` for persistence and `@uncaged/json-cas` for core operations.
+`@uncaged/cli-json-cas` provides the `json-cas` command (also aliased `ucas`) for managing a filesystem-backed store: node CRUD, integrity checks, reference listing, graph walks, variables, and output templates. It uses `@uncaged/json-cas-fs` for persistence and `@uncaged/json-cas` for core operations.
+
+The store is **auto-created and bootstrapped** on first use, so there is no `init`/`bootstrap` command. Schemas are ordinary `@schema`-typed nodes — register one with `ucas put @schema file.json` and list them with `ucas list --type @schema`; there is no dedicated `schema` subcommand.

 **Dependencies:** `@uncaged/json-cas`, `@uncaged/json-cas-fs`

@@ -37,48 +39,95 @@ Usage: json-cas [--store <path>] [--json] <command> [args]
 | Flag | Description |
 |------|-------------|
 | `--store <path>` | Store directory (default: `~/.uncaged/json-cas`) |
-| `--json` | Compact JSON output for commands that print JSON |
+| `--var-db <path>` | Variable database path (default: `<store>/variables.db`) |
+| `--json` | Compact (single-line) JSON output |
+
+### Envelope format
+
+Every JSON-emitting command prints a uniform `{ type, value }` envelope. `type` is the hash
+of the command's `@output/*` result schema and `value` is the command payload. The output
+is therefore self-describing and pipeable: feed any envelope into `render -p` to render its
+`value` (embedded `cas_ref` hashes are expanded). `render` is the only command that emits
+raw, non-envelope text.
+
+```jsonc
+// json-cas has <hash>
+{ "type": "AYHQD2YA9G667", "value": true }
+
+// json-cas template set <schema-hash> --inline "Hi {{ payload.name }}"
+{ "type": "9YJZ09DDAYAWR", "value": { "schemaHash": "7XX5H51CVD9H0", "contentHash": "FC8WACA792B6F" } }
+```

 ### Commands

-| Command | Description |
-|---------|-------------|
-| `init` | Create store directory and write bootstrap seed; prints meta hash |
-| `bootstrap` | Write meta-schema seed into existing store; prints hash |
-| `schema put <file.json>` | Register schema from file; prints type hash |
-| `schema get <type-hash>` | Print schema JSON |
-| `schema list` | List all schemas (`hash  name`) |
-| `schema validate <hash>` | Validate node against its schema; prints `valid` / `invalid` |
-| `put <type-hash> <file.json>` | Store node; prints content hash |
-| `get <hash>` | Print full node as JSON |
-| `has <hash>` | Print `true` or `false` |
-| `verify <hash>` | Verify integrity; prints `ok` or `corrupted` |
-| `refs <hash>` | Print direct `cas_ref` targets (one per line) |
-| `walk <hash>` | BFS traversal; one hash per line |
-| `walk <hash> --format tree` | Tree-formatted traversal |
-| `hash <type-hash> <file.json>` | Compute hash without storing |
-| `cat <hash>` | Print node JSON |
-| `cat <hash> --payload` | Print payload only |
+| Command | Envelope `value` | Result schema |
+|---------|------------------|---------------|
+| `put <type-hash> <file.json>` | stored node hash (string) | `@output/put` |
+| `get <hash>` | `{ type, payload, timestamp }` | `@output/get` |
+| `has <hash>` | boolean | `@output/has` |
+| `verify <hash>` | `ok` / `corrupted` / `invalid` | `@output/verify` |
+| `refs <hash>` | hashes (string[]) | `@output/refs` |
+| `walk <hash> [--format tree]` | hashes (string[]) or tree string | `@output/walk` |
+| `hash <type-hash> <file.json>` | computed hash (string) | `@output/hash` |
+| `render <hash> [options]` | raw text (no envelope) | — |
+| `render --pipe/-p [options]` | raw text from piped envelope | — |
+| `list --type <hash-or-alias>` | hashes (string[]) | `@output/list` |
+| `var set <name> <hash> [--tag ...]` | variable object | `@output/var-set` |
+| `var get <name> --schema <hash>` | variable object | `@output/var-get` |
+| `var delete <name> [--schema <hash>]` | variable or variable[] | `@output/var-delete` |
+| `var tag <name> --schema <hash> <ops...>` | variable object | `@output/var-tag` |
+| `var list [prefix] [--schema <hash>] [--tag ...]` | variable[] | `@output/var-list` |
+| `template set <schema-hash> <file> \| --inline <text>` | `{ schemaHash, contentHash }` | `@output/template-set` |
+| `template get <schema-hash>` | template content (string) | `@output/template-get` |
+| `template list` | `{ schemaHash, contentHash }[]` | `@output/template-list` |
+| `template delete <schema-hash>` | `{ deleted: boolean }` | `@output/template-delete` |
+| `gc` | `{ total, reachable, collected, scanned }` | `@output/gc` |

 ### Examples

 ```bash
-# Initialize default store at ~/.uncaged/json-cas
-json-cas init
+# Register a schema (schemas are plain @schema nodes) and store a payload
+json-cas put @schema ./schemas/item.json
+# → { "type": "...", "value": "0123456789ABC" }  (the schema's type hash)

-# Use a custom store path
-json-cas --store ./data/cas bootstrap
-
-# Register a schema and store a payload
-json-cas schema put ./schemas/item.json
-# → prints type hash, e.g. 0123456789ABCD
-
-json-cas put 0123456789ABCD ./payloads/item.json
-# → prints content hash
+json-cas put 0123456789ABC ./payloads/item.json
+# → { "type": "...", "value": "<content-hash>" }

 json-cas get <content-hash> --json
 json-cas verify <content-hash>
 json-cas walk <content-hash> --format tree
+
+# List every registered schema, then extract the hashes with jq
+json-cas list --type @schema | jq -r '.value[]'
+```
+
+### Pipe composition
+
+Because every command shares the `{ type, value }` envelope, output composes directly into
+`render -p`:
+
+```bash
+# put emits a cas_ref hash envelope; render -p dereferences and renders the node
+json-cas put @schema ./schemas/item.json | json-cas render -p
+
+# render gc statistics
+json-cas gc | json-cas render -p
+
+# render every schema referenced by a list result
+json-cas list --type @schema | json-cas render -p
+```
+
+### Templates
+
+`template` commands manage the LiquidJS template bound to a schema (stored as a
+`@ucas/template/text/<schema-hash>` variable). `render <hash>` uses the template registered
+for the node's type, falling back to YAML when none exists.
+
+```bash
+# Bind a template to a schema, then render a node of that type
+json-cas template set 0123456789ABC --inline "Item: {{ payload.name }}"
+json-cas render <content-hash>
+# → Item: Widget
 ```

 ## Internal Structure
@@ -1,6 +1,6 @@
 {
  "name": "@uncaged/cli-json-cas",
-  "version": "0.5.3",
+  "version": "0.6.0",
  "type": "module",
  "bin": {
    "json-cas": "./src/index.ts",
@@ -8,10 +8,10 @@
  },
  "scripts": {
    "test": "bun test",
-    "prepublishOnly": "echo '请用 bun run release 从根目录发版' && exit 1"
+    "prepublishOnly": "bash ../../scripts/check-workspace-deps.sh"
  },
  "dependencies": {
-    "@uncaged/json-cas": "^0.5.3",
-    "@uncaged/json-cas-fs": "^0.5.3"
+    "@uncaged/json-cas": "^0.6.0",
+    "@uncaged/json-cas-fs": "^0.6.0"
  }
 }
@@ -0,0 +1,289 @@
+// Bun Snapshot v1, https://bun.sh/docs/test/snapshots
+
+exports[`Phase 1: CAS Core 1.6 get returns node JSON (snapshot) 1`] = `
+{
+  "type": "2NHHHE9NR0FVT",
+  "value": {
+    "payload": {
+      "age": 30,
+      "name": "Alice",
+    },
+    "type": "3K9ETAPGFPE32",
+  },
+}
+`;
+
+exports[`Phase 1: CAS Core 1.9 verify returns ok for valid node 1`] = `
+{
+  "type": "BZ3TV0PTATA52",
+  "value": "ok",
+}
+`;
+
+exports[`Phase 1: CAS Core 1.10 refs lists direct references (snapshot) 1`] = `
+"{
+  "type": "18HZGJY02WN1K",
+  "value": []
+}"
+`;
+
+exports[`Phase 1: CAS Core 1.11 walk shows traversal tree (snapshot) 1`] = `
+"{
+  "type": "9BVX9SHACFC5J",
+  "value": [
+    "A0QKG4ERMXSFG"
+  ]
+}"
+`;
+
+exports[`Phase 2: Schema Validation 2.3 put against non-existent schema hash fails 1`] = `"Schema not found: AAAAAAAAAAAAA"`;
+
+exports[`Phase 3: Variable System 3.1 var set creates variable 1`] = `
+{
+  "type": "EMX6HW4CECBGK",
+  "value": {
+    "labels": [],
+    "name": "myapp/config",
+    "schema": "3K9ETAPGFPE32",
+    "tags": {},
+    "value": "A0QKG4ERMXSFG",
+  },
+}
+`;
+
+exports[`Phase 3: Variable System 3.2 var get returns variable 1`] = `
+{
+  "type": "F68GWJAT9H6HP",
+  "value": {
+    "labels": [],
+    "name": "myapp/config",
+    "schema": "3K9ETAPGFPE32",
+    "tags": {},
+    "value": "A0QKG4ERMXSFG",
+  },
+}
+`;
+
+exports[`Phase 3: Variable System 3.3 var list shows all variables 1`] = `
+{
+  "type": "A4TV1FVBBNG5M",
+  "value": [
+    {
+      "labels": [],
+      "name": "myapp/config",
+      "schema": "3K9ETAPGFPE32",
+      "tags": {},
+      "value": "A0QKG4ERMXSFG",
+    },
+  ],
+}
+`;
+
+exports[`Phase 3: Variable System 3.4 var list prefix filters by prefix 1`] = `
+{
+  "type": "A4TV1FVBBNG5M",
+  "value": [
+    {
+      "labels": [],
+      "name": "myapp/config",
+      "schema": "3K9ETAPGFPE32",
+      "tags": {},
+      "value": "A0QKG4ERMXSFG",
+    },
+  ],
+}
+`;
+
+exports[`Phase 3: Variable System 3.5 var set upsert updates existing variable 1`] = `
+{
+  "type": "EMX6HW4CECBGK",
+  "value": {
+    "labels": [],
+    "name": "myapp/config",
+    "schema": "3K9ETAPGFPE32",
+    "tags": {},
+    "value": "FNDM9C6P23238",
+  },
+}
+`;
+
+exports[`Phase 3: Variable System 3.6 var tag adds kv tag and label 1`] = `
+{
+  "type": "92JS8RXGKDKC2",
+  "value": {
+    "labels": [
+      "important",
+    ],
+    "name": "myapp/config",
+    "schema": "3K9ETAPGFPE32",
+    "tags": {
+      "env": "prod",
+    },
+    "value": "A0QKG4ERMXSFG",
+  },
+}
+`;
+
+exports[`Phase 3: Variable System 3.7 var list --tag env:prod filters by kv tag 1`] = `
+{
+  "type": "A4TV1FVBBNG5M",
+  "value": [
+    {
+      "labels": [
+        "important",
+      ],
+      "name": "myapp/config",
+      "schema": "3K9ETAPGFPE32",
+      "tags": {
+        "env": "prod",
+      },
+      "value": "A0QKG4ERMXSFG",
+    },
+  ],
+}
+`;
+
+exports[`Phase 3: Variable System 3.8 var list --tag important filters by label 1`] = `
+{
+  "type": "A4TV1FVBBNG5M",
+  "value": [
+    {
+      "labels": [
+        "important",
+      ],
+      "name": "myapp/config",
+      "schema": "3K9ETAPGFPE32",
+      "tags": {
+        "env": "prod",
+      },
+      "value": "A0QKG4ERMXSFG",
+    },
+  ],
+}
+`;
+
+exports[`Phase 3: Variable System 3.9 var tag remove deletes label 1`] = `
+{
+  "type": "92JS8RXGKDKC2",
+  "value": {
+    "labels": [],
+    "name": "myapp/config",
+    "schema": "3K9ETAPGFPE32",
+    "tags": {
+      "env": "prod",
+    },
+    "value": "A0QKG4ERMXSFG",
+  },
+}
+`;
+
+exports[`Phase 3: Variable System 3.10 var delete removes variable 1`] = `
+{
+  "type": "00YH4RTNVWTRB",
+  "value": [
+    {
+      "labels": [],
+      "name": "myapp/config",
+      "schema": "3K9ETAPGFPE32",
+      "tags": {
+        "env": "prod",
+      },
+      "value": "A0QKG4ERMXSFG",
+    },
+  ],
+}
+`;
+
+exports[`Phase 3: Variable System 3.11 var get deleted variable returns not found 1`] = `"Error: Variable not found: name=myapp/config, schema=3K9ETAPGFPE32"`;
+
+exports[`Phase 4: Template System 4.1 template set registers template 1`] = `
+{
+  "type": "DTNQZ90QQHA6D",
+  "value": {
+    "contentHash": "DBBPX5JJ74SWZ",
+    "schemaHash": "3K9ETAPGFPE32",
+  },
+}
+`;
+
+exports[`Phase 4: Template System 4.2 template get returns template text 1`] = `
+{
+  "type": "8KMGVC6TG12TS",
+  "value": "Name: {{ payload.name }}, Age: {{ payload.age }}",
+}
+`;
+
+exports[`Phase 4: Template System 4.3 template list shows registered templates 1`] = `
+{
+  "type": "6RZCT3XX4J8BC",
+  "value": [
+    {
+      "contentHash": "DBBPX5JJ74SWZ",
+      "schemaHash": "3K9ETAPGFPE32",
+    },
+  ],
+}
+`;
+
+exports[`Phase 4: Template System 4.4 template delete removes template 1`] = `
+{
+  "type": "DBHJH385HGVTM",
+  "value": {
+    "deleted": true,
+  },
+}
+`;
+
+exports[`Phase 4: Template System 4.5 template get deleted template returns not found 1`] = `"Error: Template not found for schema: 3K9ETAPGFPE32"`;
+
+exports[`Phase 5: Render 5.1 render fills payload variables 1`] = `"Hello Alice!"`;
+
+exports[`Phase 5: Render 5.2 render --resolution with different value 1`] = `"Hello Alice!"`;
+
+exports[`Phase 7: Edge Cases 7.1 get non-existent hash errors gracefully 1`] = `"Node not found: AAAAAAAAAAAAA"`;
+
+exports[`Phase 7: Edge Cases 7.3 var set empty name errors 1`] = `"Usage: json-cas var set <name> <hash> [--tag <tag>...]"`;
+
+exports[`Phase 7: Edge Cases 7.4 var set name with invalid chars errors 1`] = `"Error: Invalid variable name "invalid name!": Segment "invalid name!" contains invalid characters (only @, a-z, A-Z, 0-9, ., _, - allowed)"`;
+
+exports[`Phase 7: Edge Cases 7.5 no subcommand shows help text 1`] = `
+"Usage: json-cas [--store <path>] [--json] <command> [args]
+
+All JSON commands emit a { type, value } envelope. The type is the hash of the
+command's @output/* schema (shown in parentheses); pipe any envelope into
+\`render -p\` to render its value (cas_ref hashes are expanded).
+
+Commands:
+  put <type-hash> <file.json|--pipe> Store node, print envelope (value=hash)            (@output/put)
+  get <hash>                        Print node as envelope                             (@output/get)
+  has <hash>                        Print envelope (value=boolean)                     (@output/has)
+  verify <hash>                     Verify integrity + schema (value=ok/corrupted/invalid) (@output/verify)
+  refs <hash>                       List direct cas_ref edges                          (@output/refs)
+  walk <hash> [--format tree]       Recursive traversal                                (@output/walk)
+  hash <type-hash> <file.json|--pipe> Compute hash without storing                     (@output/hash)
+  render <hash> [options]           Render node as text with resolution decay (raw output)
+  render --pipe/-p [options]        Render { type, value } from stdin (raw output)
+  list --type <hash-or-alias>       List hashes for a type (value=string[])            (@output/list)
+  var set <name> <hash> [--tag <tag>...] Create/update a variable                      (@output/var-set)
+  var get <name> --schema <hash>    Get a variable by name + schema                    (@output/var-get)
+  var delete <name> [--schema <hash>] Delete variable(s)                               (@output/var-delete)
+  var list [prefix] [--schema <hash>] [--tag <tag>...] List variables                  (@output/var-list)
+  var tag <name> --schema <hash> <operations...> Modify tags/labels                    (@output/var-tag)
+  template set <schema-hash> <file> | --inline <text> Set template for schema          (@output/template-set)
+  template get <schema-hash>        Get template content (value=string)                (@output/template-get)
+  template list                     List all templates                                 (@output/template-list)
+  template delete <schema-hash>     Delete template for schema                         (@output/template-delete)
+  gc                                Run garbage collection                             (@output/gc)
+
+Flags:
+  --store <path>      Store directory (default: ~/.uncaged/json-cas)
+  --var-db <path>     Variable database path (default: <store>/variables.db)
+  --json              Compact JSON output
+  --schema <hash>     Schema hash filter for var get/delete/tag/list
+  --tag <tag>         Tag/label (can be repeated): key:value (tag), name (label), :name (delete)
+  --inline <text>     Inline text content for template set
+  --resolution <n>    Initial resolution for render (default: 1.0)
+  --decay <n>         Decay factor for render (default: 0.5)
+  --epsilon <n>       Cutoff threshold for render (default: 0.01)
+  --pipe, -p          Read from stdin (put/hash: raw JSON payload; render: { type, value } envelope)"
+`;
@@ -0,0 +1,695 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+
+const entrypoint = resolve(import.meta.dir, "index.ts");
+
+let tmpStore: string;
+let varDbPath: string;
+
+// Shared hashes across phases
+let typeHash: string;
+let nodeHash: string;
+
+beforeAll(() => {
+  tmpStore = mkdtempSync(join(tmpdir(), "json-cas-e2e-"));
+  varDbPath = join(tmpStore, "variables.db");
+});
+
+afterAll(() => {
+  rmSync(tmpStore, { recursive: true, force: true });
+});
+
+async function runCli(
+  args: string[],
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  const proc = Bun.spawn(
+    ["bun", entrypoint, "--store", tmpStore, "--var-db", varDbPath, ...args],
+    { stdout: "pipe", stderr: "pipe" },
+  );
+  const exitCode = await proc.exited;
+  const stdout = (await new Response(proc.stdout).text()).trim();
+  const stderr = (await new Response(proc.stderr).text()).trim();
+  return { stdout, stderr, exitCode };
+}
+
+/**
+ * Parse JSON and strip volatile fields (timestamp, created, updated)
+ * so snapshots are stable across runs.
+ */
+function stripVolatile(json: string): unknown {
+  const strip = (v: unknown): unknown => {
+    if (Array.isArray(v)) return v.map(strip);
+    if (v !== null && typeof v === "object") {
+      const out: Record<string, unknown> = {};
+      for (const [k, val] of Object.entries(v as Record<string, unknown>)) {
+        if (k === "timestamp" || k === "created" || k === "updated") continue;
+        out[k] = strip(val);
+      }
+      return out;
+    }
+    return v;
+  };
+  return strip(JSON.parse(json));
+}
+
+/** Extract the `value` field from a { type, value } envelope JSON string. */
+function envValue(json: string): unknown {
+  return (JSON.parse(json) as { value: unknown }).value;
+}
+
+/** Run a CLI command feeding `stdin` to its standard input. */
+async function runCliWithStdin(
+  args: string[],
+  stdin: string,
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  const proc = Bun.spawn(
+    ["bun", entrypoint, "--store", tmpStore, "--var-db", varDbPath, ...args],
+    { stdin: "pipe", stdout: "pipe", stderr: "pipe" },
+  );
+  proc.stdin.write(stdin);
+  proc.stdin.end();
+  const exitCode = await proc.exited;
+  const stdout = (await new Response(proc.stdout).text()).trim();
+  const stderr = (await new Response(proc.stderr).text()).trim();
+  return { stdout, stderr, exitCode };
+}
+
+// ---- Phase 1: CAS Core ----
+
+describe("Phase 1: CAS Core", () => {
+  test("1.1 init + put with @object bootstraps store", async () => {
+    const schemaFile = join(tmpStore, "test-schema.json");
+    writeFileSync(
+      schemaFile,
+      JSON.stringify({
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          age: { type: "number" },
+        },
+        required: ["name"],
+        additionalProperties: false,
+      }),
+    );
+    // Use putSchema via the library to register schema, since CLI schema put is removed
+    const { openStore: openFsStore } = await import("@uncaged/json-cas-fs");
+    const { putSchema } = await import("@uncaged/json-cas");
+    const store = await openFsStore(tmpStore);
+    const hash = await putSchema(
+      store,
+      JSON.parse(readFileSync(schemaFile, "utf-8")),
+    );
+    typeHash = hash;
+    expect(typeHash).toMatch(/^[0-9A-HJKMNP-TV-Z]{13}$/);
+  });
+
+  test("1.5 put returns node hash", async () => {
+    const nodeFile = join(tmpStore, "test-node.json");
+    writeFileSync(nodeFile, JSON.stringify({ name: "Alice", age: 30 }));
+    const { stdout, exitCode } = await runCli(["put", typeHash, nodeFile]);
+    expect(exitCode).toBe(0);
+    expect(envValue(stdout)).toMatch(/^[0-9A-HJKMNP-TV-Z]{13}$/);
+    nodeHash = envValue(stdout) as string;
+  });
+
+  test("1.6 get returns node JSON (snapshot)", async () => {
+    const { stdout, exitCode } = await runCli(["get", nodeHash]);
+    expect(exitCode).toBe(0);
+    expect(stripVolatile(stdout)).toMatchSnapshot();
+  });
+
+  test("1.7 has returns true for existing node", async () => {
+    const { stdout, exitCode } = await runCli(["has", nodeHash]);
+    expect(exitCode).toBe(0);
+    expect(envValue(stdout)).toBe(true);
+  });
+
+  test("1.8 has returns false for non-existing hash", async () => {
+    const { stdout, exitCode } = await runCli(["has", "AAAAAAAAAAAAA"]);
+    expect(exitCode).toBe(0);
+    expect(envValue(stdout)).toBe(false);
+  });
+
+  test("1.9 verify returns ok for valid node", async () => {
+    const { stdout, exitCode } = await runCli(["verify", nodeHash]);
+    expect(exitCode).toBe(0);
+    expect(stripVolatile(stdout)).toMatchSnapshot();
+  });
+
+  test("1.10 refs lists direct references (snapshot)", async () => {
+    const { stdout, exitCode } = await runCli(["refs", nodeHash]);
+    expect(exitCode).toBe(0);
+    expect(stdout).toMatchSnapshot();
+  });
+
+  test("1.11 walk shows traversal tree (snapshot)", async () => {
+    const { stdout, exitCode } = await runCli(["walk", nodeHash]);
+    expect(exitCode).toBe(0);
+    expect(stdout).toMatchSnapshot();
+  });
+
+  test("1.12 hash dry-run returns same hash as put", async () => {
+    const nodeFile = join(tmpStore, "test-node.json");
+    const { stdout, exitCode } = await runCli(["hash", typeHash, nodeFile]);
+    expect(exitCode).toBe(0);
+    expect(envValue(stdout)).toBe(nodeHash);
+  });
+
+  test("1.13 list --type returns nodes of that type", async () => {
+    const { stdout, exitCode } = await runCli(["list", "--type", typeHash]);
+    expect(exitCode).toBe(0);
+    expect(envValue(stdout)).toContain(nodeHash);
+  });
+});
+
+// ---- Phase 2: Schema Validation ----
+
+describe("Phase 2: Schema Validation", () => {
+  test("2.1 put {name:123} against string-schema fails with non-zero exit", async () => {
+    const badFile = join(tmpStore, "bad-node.json");
+    writeFileSync(badFile, JSON.stringify({ name: 123 }));
+    const { stdout, stderr, exitCode } = await runCli([
+      "put",
+      typeHash,
+      badFile,
+    ]);
+    expect(exitCode).not.toBe(0);
+    expect(stdout).toBe("");
+    expect(stderr).toContain("Validation failed");
+    expect(stderr).toContain(typeHash);
+    // Do NOT snapshot stderr — it embeds a machine-specific tmp path
+  });
+
+  test("2.2 verify on valid node returns ok (hash + schema)", async () => {
+    const { stdout, exitCode } = await runCli(["verify", nodeHash]);
+    expect(exitCode).toBe(0);
+    expect(envValue(stdout)).toBe("ok");
+  });
+
+  test("2.3 put against non-existent schema hash fails", async () => {
+    const nodeFile = join(tmpStore, "test-node.json");
+    const { stderr, exitCode } = await runCli([
+      "put",
+      "AAAAAAAAAAAAA",
+      nodeFile,
+    ]);
+    expect(exitCode).not.toBe(0);
+    expect(stderr).toMatchSnapshot();
+  });
+});
+
+// ---- Phase 3: Variable System ----
+
+describe("Phase 3: Variable System", () => {
+  test("3.1 var set creates variable", async () => {
+    const { exitCode, stdout } = await runCli([
+      "var",
+      "set",
+      "myapp/config",
+      nodeHash,
+    ]);
+    expect(exitCode).toBe(0);
+    expect(stripVolatile(stdout)).toMatchSnapshot();
+  });
+
+  test("3.2 var get returns variable", async () => {
+    const { stdout, exitCode } = await runCli([
+      "var",
+      "get",
+      "myapp/config",
+      "--schema",
+      typeHash,
+    ]);
+    expect(exitCode).toBe(0);
+    expect(stripVolatile(stdout)).toMatchSnapshot();
+    expect(stdout).toContain(nodeHash);
+  });
+
+  test("3.3 var list shows all variables", async () => {
+    const { stdout, exitCode } = await runCli(["var", "list"]);
+    expect(exitCode).toBe(0);
+    expect(stripVolatile(stdout)).toMatchSnapshot();
+    expect(stdout).toContain("myapp/config");
+  });
+
+  test("3.4 var list prefix filters by prefix", async () => {
+    const { stdout, exitCode } = await runCli(["var", "list", "myapp/"]);
+    expect(exitCode).toBe(0);
+    expect(stripVolatile(stdout)).toMatchSnapshot();
+    expect(stdout).toContain("myapp/config");
+  });
+
+  test("3.5 var set upsert updates existing variable", async () => {
+    const node2File = join(tmpStore, "node2.json");
+    writeFileSync(node2File, JSON.stringify({ name: "Bob", age: 25 }));
+    const { stdout: node2Out } = await runCli(["put", typeHash, node2File]);
+    const node2Hash = envValue(node2Out) as string;
+    const { exitCode, stdout } = await runCli([
+      "var",
+      "set",
+      "myapp/config",
+      node2Hash,
+    ]);
+    expect(exitCode).toBe(0);
+    expect(stripVolatile(stdout)).toMatchSnapshot();
+    // Restore original value
+    await runCli(["var", "set", "myapp/config", nodeHash]);
+  });
+
+  test("3.6 var tag adds kv tag and label", async () => {
+    const { exitCode, stdout } = await runCli([
+      "var",
+      "tag",
+      "myapp/config",
+      "--schema",
+      typeHash,
+      "env:prod",
+      "important",
+    ]);
+    expect(exitCode).toBe(0);
+    expect(stripVolatile(stdout)).toMatchSnapshot();
+  });
+
+  test("3.7 var list --tag env:prod filters by kv tag", async () => {
+    const { stdout, exitCode } = await runCli([
+      "var",
+      "list",
+      "--tag",
+      "env:prod",
+    ]);
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain("myapp/config");
+    expect(stripVolatile(stdout)).toMatchSnapshot();
+  });
+
+  test("3.8 var list --tag important filters by label", async () => {
+    const { stdout, exitCode } = await runCli([
+      "var",
+      "list",
+      "--tag",
+      "important",
+    ]);
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain("myapp/config");
+    expect(stripVolatile(stdout)).toMatchSnapshot();
+  });
+
+  test("3.9 var tag remove deletes label", async () => {
+    const { exitCode, stdout } = await runCli([
+      "var",
+      "tag",
+      "myapp/config",
+      "--schema",
+      typeHash,
+      ":important",
+    ]);
+    expect(exitCode).toBe(0);
+    expect(stripVolatile(stdout)).toMatchSnapshot();
+    // Verify label is gone
+    const { stdout: listOut } = await runCli([
+      "var",
+      "list",
+      "--tag",
+      "important",
+    ]);
+    expect(listOut).not.toContain("myapp/config");
+  });
+
+  test("3.10 var delete removes variable", async () => {
+    const { exitCode, stdout } = await runCli([
+      "var",
+      "delete",
+      "myapp/config",
+    ]);
+    expect(exitCode).toBe(0);
+    expect(stripVolatile(stdout)).toMatchSnapshot();
+  });
+
+  test("3.11 var get deleted variable returns not found", async () => {
+    const { stderr, exitCode } = await runCli([
+      "var",
+      "get",
+      "myapp/config",
+      "--schema",
+      typeHash,
+    ]);
+    expect(exitCode).not.toBe(0);
+    expect(stderr).toMatchSnapshot();
+  });
+});
+
+// ---- Phase 4: Template System ----
+
+describe("Phase 4: Template System", () => {
+  test("4.1 template set registers template", async () => {
+    const tmplFile = join(tmpStore, "test.liquid");
+    writeFileSync(tmplFile, "Name: {{ payload.name }}, Age: {{ payload.age }}");
+    const { exitCode, stdout } = await runCli([
+      "template",
+      "set",
+      typeHash,
+      tmplFile,
+    ]);
+    expect(exitCode).toBe(0);
+    expect(stripVolatile(stdout)).toMatchSnapshot();
+  });
+
+  test("4.2 template get returns template text", async () => {
+    const { stdout, exitCode } = await runCli(["template", "get", typeHash]);
+    expect(exitCode).toBe(0);
+    expect(envValue(stdout)).toBe(
+      "Name: {{ payload.name }}, Age: {{ payload.age }}",
+    );
+    expect(stripVolatile(stdout)).toMatchSnapshot();
+  });
+
+  test("4.3 template list shows registered templates", async () => {
+    const { stdout, exitCode } = await runCli(["template", "list"]);
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain(typeHash);
+    expect(stripVolatile(stdout)).toMatchSnapshot();
+  });
+
+  test("4.4 template delete removes template", async () => {
+    const { exitCode, stdout } = await runCli(["template", "delete", typeHash]);
+    expect(exitCode).toBe(0);
+    expect(stripVolatile(stdout)).toMatchSnapshot();
+  });
+
+  test("4.5 template get deleted template returns not found", async () => {
+    const { stderr, exitCode } = await runCli(["template", "get", typeHash]);
+    expect(exitCode).not.toBe(0);
+    expect(stderr).toMatchSnapshot();
+  });
+});
+
+// ---- Phase 5: Render ----
+
+describe("Phase 5: Render", () => {
+  beforeAll(async () => {
+    const tmplFile = join(tmpStore, "render-template.liquid");
+    writeFileSync(tmplFile, "Hello {{ payload.name }}!");
+    await runCli(["template", "set", typeHash, tmplFile]);
+  });
+
+  test("5.1 render fills payload variables", async () => {
+    const { stdout, exitCode } = await runCli(["render", nodeHash]);
+    expect(exitCode).toBe(0);
+    expect(stdout).toBe("Hello Alice!");
+    expect(stdout).toMatchSnapshot();
+  });
+
+  test("5.2 render --resolution with different value", async () => {
+    const { stdout, exitCode } = await runCli([
+      "render",
+      nodeHash,
+      "--resolution",
+      "0.5",
+    ]);
+    expect(exitCode).toBe(0);
+    expect(stdout).toMatchSnapshot();
+  });
+
+  test("5.3 render non-existent hash fails with error", async () => {
+    const { stderr, exitCode } = await runCli(["render", "ZZZZZZZZZZZZZ"]);
+    expect(exitCode).not.toBe(0);
+    expect(stderr).toContain("Node not found");
+    expect(stderr).toContain("ZZZZZZZZZZZZZ");
+  });
+});
+
+// ---- Phase 6: GC ----
+
+describe("Phase 6: GC", () => {
+  let gcNodeHash: string;
+
+  beforeAll(async () => {
+    // Create a fresh node for GC tests (independent of shared nodeHash)
+    const gcNodeFile = join(tmpStore, "gc-node.json");
+    writeFileSync(gcNodeFile, JSON.stringify({ name: "GcAlice", age: 30 }));
+    const { stdout } = await runCli(["put", typeHash, gcNodeFile]);
+    gcNodeHash = envValue(stdout) as string;
+    // Set a var referencing this node so it survives GC during Phase 6
+    await runCli(["var", "set", "gc-test/ref", gcNodeHash]);
+  });
+
+  test("6.1 gc runs without error", async () => {
+    const { exitCode, stdout } = await runCli(["gc"]);
+    expect(exitCode).toBe(0);
+    // Assert structural shape only — exact counts depend on phase history
+    const result = envValue(stdout) as Record<string, unknown>;
+    expect(typeof result.total).toBe("number");
+    expect(typeof result.reachable).toBe("number");
+    expect(typeof result.collected).toBe("number");
+    expect(typeof result.scanned).toBe("number");
+    expect(result.total as number).toBeGreaterThanOrEqual(
+      result.reachable as number,
+    );
+  });
+
+  test("6.2 gc preserves node referenced by a var", async () => {
+    const { exitCode } = await runCli(["gc"]);
+    expect(exitCode).toBe(0);
+    const { stdout } = await runCli(["has", gcNodeHash]);
+    expect(envValue(stdout)).toBe(true);
+  });
+
+  test("6.3 gc reclaims orphan node", async () => {
+    const orphanFile = join(tmpStore, "orphan.json");
+    writeFileSync(orphanFile, JSON.stringify({ name: "Orphan", age: 99 }));
+    const { stdout: orphanOut } = await runCli(["put", typeHash, orphanFile]);
+    const orphanHash = envValue(orphanOut) as string;
+
+    const { stdout: beforeGc } = await runCli(["has", orphanHash]);
+    expect(envValue(beforeGc)).toBe(true);
+
+    await runCli(["gc"]);
+    const { stdout: afterGc } = await runCli(["has", orphanHash]);
+    expect(envValue(afterGc)).toBe(false);
+  });
+});
+
+// ---- Phase 7: Edge Cases ----
+
+describe("Phase 7: Edge Cases", () => {
+  test("7.1 get non-existent hash errors gracefully", async () => {
+    const { stderr, exitCode } = await runCli(["get", "AAAAAAAAAAAAA"]);
+    expect(exitCode).not.toBe(0);
+    expect(stderr).toMatchSnapshot();
+  });
+
+  test("7.2 put with non-existent file errors with ENOENT", async () => {
+    const { stderr, exitCode } = await runCli([
+      "put",
+      typeHash,
+      "/nonexistent/file.json",
+    ]);
+    expect(exitCode).not.toBe(0);
+    expect(stderr).toContain("ENOENT");
+  });
+
+  test("7.3 var set empty name errors", async () => {
+    const { stderr, exitCode } = await runCli(["var", "set", "", nodeHash]);
+    expect(exitCode).not.toBe(0);
+    expect(stderr.length).toBeGreaterThan(0);
+    expect(stderr).toMatchSnapshot();
+  });
+
+  test("7.4 var set name with invalid chars errors", async () => {
+    const { stderr, exitCode } = await runCli([
+      "var",
+      "set",
+      "invalid name!",
+      nodeHash,
+    ]);
+    expect(exitCode).not.toBe(0);
+    expect(stderr.length).toBeGreaterThan(0);
+    expect(stderr).toMatchSnapshot();
+  });
+
+  test("7.5 no subcommand shows help text", async () => {
+    const { stdout, stderr, exitCode: _exitCode } = await runCli([]);
+    const combined = stdout + stderr;
+    expect(combined.length).toBeGreaterThan(0);
+    expect(combined).toMatchSnapshot();
+    expect(combined.toLowerCase()).toContain("usage");
+  });
+
+  test("7.6 --store path is a file errors", async () => {
+    const fileAsStore = join(tmpStore, "not-a-directory");
+    writeFileSync(fileAsStore, "test");
+    const proc = Bun.spawn(
+      [
+        "bun",
+        entrypoint,
+        "--store",
+        fileAsStore,
+        "--var-db",
+        varDbPath,
+        "get",
+        "AAAAAAAAAAAAA",
+      ],
+      { stdout: "pipe", stderr: "pipe" },
+    );
+    const exitCode = await proc.exited;
+    const stderr = (await new Response(proc.stderr).text()).trim();
+    expect(exitCode).not.toBe(0);
+    expect(stderr).toContain("not a directory");
+  });
+});
+
+// ---- Phase 8: Pipe Composition ----
+//
+// Every JSON command emits a { type, value } envelope, so its stdout can be
+// fed straight into `render --pipe` (which renders the envelope value) or into
+// any downstream JSON consumer. These tests verify the envelopes compose
+// end-to-end.
+
+describe("Phase 8: Pipe Composition", () => {
+  test("8.1 put | render -p expands the stored hash to its content", async () => {
+    const nodeFile = join(tmpStore, "pipe-node.json");
+    writeFileSync(nodeFile, JSON.stringify({ name: "Bob", age: 42 }));
+
+    const { stdout: putOut, exitCode: putExit } = await runCli([
+      "put",
+      typeHash,
+      nodeFile,
+    ]);
+    expect(putExit).toBe(0);
+
+    // The put envelope value is a cas_ref hash; render -p dereferences it and
+    // renders the stored node's payload.
+    const { stdout, exitCode } = await runCliWithStdin(
+      ["render", "--pipe"],
+      putOut,
+    );
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain("Bob");
+  });
+
+  test("8.2 gc | render -p renders the gc stats", async () => {
+    const { stdout: gcOut, exitCode: gcExit } = await runCli(["gc"]);
+    expect(gcExit).toBe(0);
+
+    const { stdout, exitCode } = await runCliWithStdin(
+      ["render", "--pipe"],
+      gcOut,
+    );
+    expect(exitCode).toBe(0);
+    // gc value is an object { total, reachable, collected, scanned }
+    expect(stdout).toContain("total:");
+  });
+
+  test("8.3 list --type @schema emits a parseable envelope of hashes", async () => {
+    const { stdout, exitCode } = await runCli(["list", "--type", "@schema"]);
+    expect(exitCode).toBe(0);
+
+    // Downstream consumers (jq, etc.) read the `value` array of hashes.
+    const value = envValue(stdout) as string[];
+    expect(Array.isArray(value)).toBe(true);
+    for (const hash of value) {
+      expect(hash).toMatch(/^[0-9A-HJKMNP-TV-Z]{13}$/);
+    }
+  });
+
+  test("8.4 list --type @schema | render -p expands the schema list", async () => {
+    const { stdout: listOut } = await runCli(["list", "--type", "@schema"]);
+    // list result items are cas_ref hashes; render -p dereferences each one
+    // and renders the schema contents.
+    const { stdout, exitCode } = await runCliWithStdin(
+      ["render", "--pipe"],
+      listOut,
+    );
+    expect(exitCode).toBe(0);
+    expect(stdout.length).toBeGreaterThan(0);
+  });
+
+  test("8.5 render <hash> uses a registered template", async () => {
+    // Register a template for the schema, then render a fresh node by hash.
+    const tmplFile = join(tmpStore, "pipe-render.liquid");
+    writeFileSync(tmplFile, "Person: {{ payload.name }} ({{ payload.age }})");
+    const { exitCode: setExit } = await runCli([
+      "template",
+      "set",
+      typeHash,
+      tmplFile,
+    ]);
+    expect(setExit).toBe(0);
+
+    const nodeFile = join(tmpStore, "pipe-render-node.json");
+    writeFileSync(nodeFile, JSON.stringify({ name: "Carol", age: 25 }));
+    const { stdout: putOut } = await runCli(["put", typeHash, nodeFile]);
+    const freshHash = envValue(putOut) as string;
+
+    const { stdout, exitCode } = await runCli(["render", freshHash]);
+    expect(exitCode).toBe(0);
+    expect(stdout).toBe("Person: Carol (25)");
+  });
+});
+
+// ---- Phase 9: Put/Hash Pipe Input ----
+
+describe("Phase 9: Put/Hash Pipe Input", () => {
+  test("9.1 put -p reads JSON from stdin and stores node", async () => {
+    const payload = JSON.stringify({ name: "PipeAlice", age: 99 });
+    const { stdout, exitCode } = await runCliWithStdin(
+      ["put", typeHash, "-p"],
+      payload,
+    );
+    expect(exitCode).toBe(0);
+    const hash = envValue(stdout);
+    expect(hash).toMatch(/^[0-9A-HJKMNP-TV-Z]{13}$/);
+
+    // Verify stored correctly
+    const { stdout: getOut } = await runCli(["get", hash as string]);
+    expect(getOut).toContain("PipeAlice");
+  });
+
+  test("9.2 hash -p reads JSON from stdin and computes hash without storing", async () => {
+    const payload = JSON.stringify({ name: "PipeBob", age: 55 });
+    const { stdout, exitCode } = await runCliWithStdin(
+      ["hash", typeHash, "-p"],
+      payload,
+    );
+    expect(exitCode).toBe(0);
+    const hash = envValue(stdout);
+    expect(hash).toMatch(/^[0-9A-HJKMNP-TV-Z]{13}$/);
+
+    // Should NOT be stored
+    const { exitCode: hasExit, stdout: hasOut } = await runCli([
+      "has",
+      hash as string,
+    ]);
+    expect(hasExit).toBe(0);
+    expect(envValue(hasOut)).toBe(false);
+  });
+
+  test("9.3 put -p with file arg errors", async () => {
+    const { stderr, exitCode } = await runCliWithStdin(
+      ["put", typeHash, "some-file.json", "-p"],
+      "{}",
+    );
+    expect(exitCode).not.toBe(0);
+    expect(stderr).toContain("Cannot use --pipe/-p with a file argument");
+  });
+
+  test("9.4 put -p with empty stdin errors", async () => {
+    const { stderr, exitCode } = await runCliWithStdin(
+      ["put", typeHash, "-p"],
+      "",
+    );
+    expect(exitCode).not.toBe(0);
+    expect(stderr).toContain("No input on stdin");
+  });
+
+  test("9.5 put -p with invalid JSON errors", async () => {
+    const { stderr, exitCode } = await runCliWithStdin(
+      ["put", typeHash, "-p"],
+      "not json",
+    );
+    expect(exitCode).not.toBe(0);
+    expect(stderr).toContain("Invalid JSON on stdin");
+  });
+});
@@ -1,9 +1,9 @@
 #!/usr/bin/env bun

-import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
-import type { Hash, JSONSchema, Store, VariableStore } from "@uncaged/json-cas";
+import type { Hash, Store, VariableStore } from "@uncaged/json-cas";
 import {
  bootstrap,
  CasNodeNotFoundError,
@@ -16,13 +16,15 @@ import {
  putSchema,
  refs,
  renderAsync,
+  renderDirect,
  TagLabelConflictError,
  VariableNotFoundError,
  validate,
  verify,
  walk,
+  wrapEnvelope,
 } from "@uncaged/json-cas";
-import { createFsStore } from "@uncaged/json-cas-fs";
+import { openStore as openFsStore } from "@uncaged/json-cas-fs";

 // ---- Argument parsing ----

@@ -39,6 +41,7 @@ const VALUE_FLAGS = new Set([
  "decay",
  "epsilon",
  "inline",
+  "type",
 ]);

 function parseArgs(argv: string[]): { flags: Flags; positional: string[] } {
@@ -72,6 +75,8 @@ function parseArgs(argv: string[]): { flags: Flags; positional: string[] } {
      } else {
        flags[key] = true;
      }
+    } else if (arg === "-p") {
+      flags.p = true;
    } else {
      positional.push(arg);
    }
@@ -110,13 +115,33 @@ function readJsonFile(file: string): unknown {
  }
 }

-function openStore(): Store {
-  return createFsStore(resolve(storePath));
+async function readStdinJson(): Promise<unknown> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk as Buffer);
+  }
+  const input = Buffer.concat(chunks).toString("utf-8").trim();
+  if (!input) {
+    die("No input on stdin. Pipe JSON content.");
+  }
+  try {
+    return JSON.parse(input);
+  } catch {
+    return die("Invalid JSON on stdin.");
+  }
 }

-function openVarStore(): VariableStore {
-  const store = openStore();
-  mkdirSync(resolve(storePath), { recursive: true });
+/**
+ * Open the filesystem-backed CAS store.
+ * Automatically creates directory and bootstraps if needed.
+ */
+async function openStore(): Promise<Store> {
+  const fullPath = resolve(storePath);
+  return await openFsStore(fullPath);
+}
+
+async function openVarStore(): Promise<VariableStore> {
+  const store = await openStore();
  return createVariableStore(resolve(varDbPath), store);
 }

@@ -127,7 +152,7 @@ function openVarStore(): VariableStore {
 */
 async function resolveTypeHash(typeHashOrAlias: string): Promise<Hash> {
  if (typeHashOrAlias.startsWith("@")) {
-    const store = openStore();
+    const store = await openStore();
    const builtinSchemas = await bootstrap(store);
    const resolvedHash = builtinSchemas[typeHashOrAlias];
    if (!resolvedHash) {
@@ -138,55 +163,6 @@ async function resolveTypeHash(typeHashOrAlias: string): Promise<Hash> {
  return typeHashOrAlias;
 }

-/**
- * Get the Variable schema's CAS hash
- * This is the type hash used in JSON envelopes
- */
-async function getVariableSchemaHash(): Promise<Hash> {
-  const store = openStore();
-
-  // Define the Variable JSON Schema (updated for new model with composite key)
-  const variableSchema: JSONSchema = {
-    title: "Variable",
-    type: "object",
-    properties: {
-      name: { type: "string" },
-      schema: { type: "string" },
-      value: { type: "string" },
-      created: { type: "number" },
-      updated: { type: "number" },
-      tags: { type: "object" },
-      labels: { type: "array", items: { type: "string" } },
-    },
-    required: [
-      "name",
-      "schema",
-      "value",
-      "created",
-      "updated",
-      "tags",
-      "labels",
-    ],
-  };
-
-  // Compute hash or retrieve from store
-  const hash = await putSchema(store, variableSchema);
-  return hash;
-}
-
-/**
- * Wrap Variable output in JSON envelope
- */
-async function wrapVariableEnvelope(
-  variable: unknown,
-): Promise<{ type: Hash; value: unknown }> {
-  const typeHash = await getVariableSchemaHash();
-  return {
-    type: typeHash,
-    value: variable,
-  };
-}
-
 /**
 * Parse tag/label arguments
 * Returns: { tags: Record<string, string>, labels: string[], deleteNames: string[] }
@@ -221,124 +197,103 @@ function parseTagsLabels(args: string[]): {

 // ---- Commands ----

-async function cmdInit(): Promise<void> {
-  const dir = resolve(storePath);
-  mkdirSync(dir, { recursive: true });
-  const store = createFsStore(dir);
-  const builtinSchemas = await bootstrap(store);
-  const metaHash = builtinSchemas["@schema"];
-  console.log(metaHash);
-}
-
-async function cmdBootstrap(): Promise<void> {
-  const store = openStore();
-  const builtinSchemas = await bootstrap(store);
-  const metaHash = builtinSchemas["@schema"];
-  console.log(metaHash);
-}
-
-async function cmdSchemaPut(args: string[]): Promise<void> {
-  const file = args[0];
-  if (!file) die("Usage: json-cas schema put <file.json>");
-  const schema = readJsonFile(file) as JSONSchema;
-  const store = openStore();
-  const hash = await putSchema(store, schema);
-  console.log(hash);
-}
-
-async function cmdSchemaGet(args: string[]): Promise<void> {
-  const hashOrAlias = args[0];
-  if (!hashOrAlias) die("Usage: json-cas schema get <type-hash>");
-  const hash = await resolveTypeHash(hashOrAlias);
-  const store = openStore();
-  const schema = getSchema(store, hash);
-  if (schema === null) die(`Schema not found: ${hashOrAlias}`);
-  out(schema);
-}
-
-async function cmdSchemaList(): Promise<void> {
-  const store = openStore();
-  const builtinSchemas = await bootstrap(store);
-  const metaHash = builtinSchemas["@schema"];
-  if (!metaHash) throw new Error("Meta-schema not found");
-  for (const hash of store.listByType(metaHash)) {
-    if (hash === metaHash) continue;
-    const node = store.get(hash);
-    if (node !== null) {
-      const schema = node.payload as JSONSchema;
-      const name =
-        (schema.title as string | undefined) ??
-        (schema.description as string | undefined) ??
-        "(unnamed)";
-      console.log(`${hash}  ${name}`);
-    }
-  }
-}
-
-async function cmdSchemaValidate(args: string[]): Promise<void> {
-  const hash = args[0];
-  if (!hash) die("Usage: json-cas schema validate <hash>");
-  const store = openStore();
-  const node = store.get(hash);
-  if (node === null) die(`Node not found: ${hash}`);
-  const valid = validate(store, node);
-  console.log(valid ? "valid" : "invalid");
-}
-
 async function cmdPut(args: string[]): Promise<void> {
+  const isPipe = flags.pipe === true || flags.p === true;
  const typeHashOrAlias = args[0];
-  const file = args[1];
-  if (!typeHashOrAlias || !file)
-    die("Usage: json-cas put <type-hash> <file.json>");
+  const file = isPipe ? undefined : args[1];
+  if (!typeHashOrAlias || (!isPipe && !file))
+    die(
+      "Usage: json-cas put <type-hash> <file.json>\n       json-cas put <type-hash> --pipe/-p",
+    );
+  if (isPipe && args[1])
+    die("Cannot use --pipe/-p with a file argument. Use one or the other.");
  const typeHash = await resolveTypeHash(typeHashOrAlias);
-  const payload = readJsonFile(file);
-  const store = openStore();
+  const payload = isPipe ? await readStdinJson() : readJsonFile(file as string);
+  const store = await openStore();
+
+  // Schema nodes: use putSchema() which validates via isValidSchema() (recursive)
+  // instead of ajv against meta-schema (which can't express recursive constraints)
+  const builtinSchemas = await bootstrap(store);
+  const metaHash = builtinSchemas["@schema"];
+  if (typeHash === metaHash) {
+    try {
+      const hash = await putSchema(store, payload as Record<string, unknown>);
+      out(await wrapEnvelope(store, "@output/put", hash));
+    } catch (e) {
+      console.error(
+        `Validation failed: payload in ${file} does not match schema ${typeHash}`,
+      );
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Check if schema exists
+  const schema = getSchema(store, typeHash);
+  if (schema === null) {
+    console.error(`Schema not found: ${typeHash}`);
+    process.exit(1);
+  }
+
+  // Validate payload against schema before storing
+  const tempNode = { type: typeHash, payload, timestamp: Date.now() };
+  if (!validate(store, tempNode)) {
+    console.error(
+      `Validation failed: payload in ${file} does not match schema ${typeHash}`,
+    );
+    process.exit(1);
+  }
+
  const hash = await store.put(typeHash, payload);
-  console.log(hash);
+  out(await wrapEnvelope(store, "@output/put", hash));
 }

 async function cmdGet(args: string[]): Promise<void> {
  const hash = args[0];
  if (!hash) die("Usage: json-cas get <hash>");
-  const store = openStore();
+  const store = await openStore();
  const node = store.get(hash);
  if (node === null) die(`Node not found: ${hash}`);
-  out(node);
+  out(await wrapEnvelope(store, "@output/get", node));
 }

 async function cmdHas(args: string[]): Promise<void> {
  const hash = args[0];
  if (!hash) die("Usage: json-cas has <hash>");
-  const store = openStore();
-  console.log(String(store.has(hash)));
+  const store = await openStore();
+  out(await wrapEnvelope(store, "@output/has", store.has(hash)));
 }

 async function cmdVerify(args: string[]): Promise<void> {
  const hash = args[0];
  if (!hash) die("Usage: json-cas verify <hash>");
-  const store = openStore();
+  const store = await openStore();
  const node = store.get(hash);
  if (node === null) die(`Node not found: ${hash}`);
  const ok = await verify(hash, node);
-  console.log(ok ? "ok" : "corrupted");
+  let status: string;
+  if (!ok) {
+    status = "corrupted";
+  } else {
+    status = validate(store, node) ? "ok" : "invalid";
+  }
+  out(await wrapEnvelope(store, "@output/verify", status));
 }

 async function cmdRefs(args: string[]): Promise<void> {
  const hash = args[0];
  if (!hash) die("Usage: json-cas refs <hash>");
-  const store = openStore();
+  const store = await openStore();
  const node = store.get(hash);
  if (node === null) die(`Node not found: ${hash}`);
  const refHashes = refs(store, node);
-  for (const r of refHashes) {
-    console.log(r);
-  }
+  out(await wrapEnvelope(store, "@output/refs", refHashes));
 }

 async function cmdWalk(args: string[]): Promise<void> {
  const hash = args[0];
  if (!hash) die("Usage: json-cas walk <hash> [--format tree]");
-  const store = openStore();
+  const store = await openStore();
  const format = flags.format;

  if (format === "tree") {
@@ -348,15 +303,16 @@ async function cmdWalk(args: string[]): Promise<void> {
    });

    const printed = new Set<Hash>();
+    const lines: string[] = [];

    function printNode(h: Hash, prefix: string, isLast: boolean): void {
      const connector = prefix === "" ? "" : isLast ? "└── " : "├── ";
      if (printed.has(h)) {
-        console.log(`${prefix}${connector}${h} (seen)`);
+        lines.push(`${prefix}${connector}${h} (seen)`);
        return;
      }
      printed.add(h);
-      console.log(`${prefix}${connector}${h}`);
+      lines.push(`${prefix}${connector}${h}`);

      const kids = childMap.get(h) ?? [];
      const childPrefix =
@@ -367,33 +323,48 @@ async function cmdWalk(args: string[]): Promise<void> {
    }

    printNode(hash, "", true);
+    out(await wrapEnvelope(store, "@output/walk", lines.join("\n")));
  } else {
+    const hashes: Hash[] = [];
    walk(store, hash, (h) => {
-      console.log(h);
+      hashes.push(h);
    });
+    out(await wrapEnvelope(store, "@output/walk", hashes));
  }
 }

 async function cmdHash(args: string[]): Promise<void> {
+  const isPipe = flags.pipe === true || flags.p === true;
  const typeHashOrAlias = args[0];
-  const file = args[1];
-  if (!typeHashOrAlias || !file)
-    die("Usage: json-cas hash <type-hash> <file.json>");
+  const file = isPipe ? undefined : args[1];
+  if (!typeHashOrAlias || (!isPipe && !file))
+    die(
+      "Usage: json-cas hash <type-hash> <file.json>\n       json-cas hash <type-hash> --pipe/-p",
+    );
+  if (isPipe && args[1])
+    die("Cannot use --pipe/-p with a file argument. Use one or the other.");
  const typeHash = await resolveTypeHash(typeHashOrAlias);
-  const payload = readJsonFile(file);
+  const payload = isPipe ? await readStdinJson() : readJsonFile(file as string);
  const hash = await computeHash(typeHash, payload);
-  console.log(hash);
+  const store = await openStore();
+  out(await wrapEnvelope(store, "@output/hash", hash));
 }

 async function cmdRender(args: string[]): Promise<void> {
+  const isPipe = flags.pipe === true || flags.p === true;
  const hash = args[0];
-  if (!hash) {
+
+  if (isPipe && hash) {
+    die("Cannot use --pipe/-p with a hash argument. Use one or the other.");
+  }
+
+  if (!isPipe && !hash) {
    die(
-      "Usage: ucas render <hash> [--resolution <n>] [--decay <n>] [--epsilon <n>]",
+      "Usage: ucas render <hash> [--resolution <n>] [--decay <n>] [--epsilon <n>]\n       ucas render --pipe/-p [--resolution <n>] [--decay <n>] [--epsilon <n>]",
    );
  }

-  const store = openStore();
+  const store = await openStore();

  // Parse numeric options
  const resolution =
@@ -421,16 +392,67 @@ async function cmdRender(args: string[]): Promise<void> {
  }

  try {
-    const varStore = openVarStore();
-    const output = await renderAsync(store, hash, {
-      resolution,
-      decay,
-      epsilon,
-      varStore,
-    });
-    // Output to stdout without JSON wrapping (raw output)
-    process.stdout.write(output);
+    if (isPipe) {
+      // Read { type, value } JSON from stdin
+      const chunks: Buffer[] = [];
+      for await (const chunk of process.stdin) {
+        chunks.push(chunk as Buffer);
+      }
+      const input = Buffer.concat(chunks).toString("utf-8").trim();
+      if (!input) {
+        die("No input on stdin. Pipe a { type, value } JSON envelope.");
+      }
+
+      let envelope: { type: string; value: unknown };
+      try {
+        envelope = JSON.parse(input) as { type: string; value: unknown };
+      } catch {
+        die("Invalid JSON on stdin. Expected { type, value } envelope.");
+        return; // unreachable, for TS
+      }
+
+      if (
+        typeof envelope !== "object" ||
+        envelope === null ||
+        typeof envelope.type !== "string" ||
+        !("value" in envelope)
+      ) {
+        die("Invalid envelope. Expected { type: string, value: unknown }.");
+      }
+
+      // Validate type hash format: 13-char uppercase Crockford Base32
+      if (!/^[0-9A-Z]{13}$/.test(envelope.type)) {
+        die(
+          `Invalid type hash: "${envelope.type}". Expected 13-character uppercase Crockford Base32 string.`,
+        );
+      }
+
+      const output = renderDirect(
+        envelope.type as Hash,
+        envelope.value,
+        store,
+        {
+          resolution,
+          decay,
+          epsilon,
+        },
+      );
+      process.stdout.write(output);
+    } else {
+      const varStore = await openVarStore();
+      const output = await renderAsync(store, hash, {
+        resolution,
+        decay,
+        epsilon,
+        varStore,
+      });
+      // Output to stdout without JSON wrapping (raw output)
+      process.stdout.write(output);
+    }
  } catch (error) {
+    if (error instanceof CasNodeNotFoundError) {
+      die(`Error: Node not found: ${error.hash}`);
+    }
    if (error instanceof Error) {
      die(error.message);
    }
@@ -438,19 +460,6 @@ async function cmdRender(args: string[]): Promise<void> {
  }
 }

-async function cmdCat(args: string[]): Promise<void> {
-  const hash = args[0];
-  if (!hash) die("Usage: json-cas cat <hash>");
-  const store = openStore();
-  const node = store.get(hash);
-  if (node === null) die(`Node not found: ${hash}`);
-  if (flags.payload === true) {
-    out(node.payload);
-  } else {
-    out(node);
-  }
-}
-
 async function cmdVarSet(args: string[]): Promise<void> {
  const name = args[0];
  const value = args[1];
@@ -460,7 +469,8 @@ async function cmdVarSet(args: string[]): Promise<void> {
    die("Usage: json-cas var set <name> <hash> [--tag <tag>...]");
  }

-  const varStore = openVarStore();
+  const store = await openStore();
+  const varStore = createVariableStore(resolve(varDbPath), store);

  try {
    // Parse tags/labels from --tag flags
@@ -487,8 +497,7 @@ async function cmdVarSet(args: string[]): Promise<void> {
        : undefined;

    const variable = varStore.set(name, value, options);
-    const envelope = await wrapVariableEnvelope(variable);
-    out(envelope);
+    out(await wrapEnvelope(store, "@output/var-set", variable));
  } catch (e) {
    if (
      e instanceof InvalidVariableNameError ||
@@ -511,15 +520,15 @@ async function cmdVarGet(args: string[]): Promise<void> {
    die("Usage: json-cas var get <name> --schema <hash>");
  }

-  const varStore = openVarStore();
+  const store = await openStore();
+  const varStore = createVariableStore(resolve(varDbPath), store);

  try {
    const variable = varStore.get(name, schema);
    if (variable === null) {
      die(`Error: Variable not found: name=${name}, schema=${schema}`);
    }
-    const envelope = await wrapVariableEnvelope(variable);
-    out(envelope);
+    out(await wrapEnvelope(store, "@output/var-get", variable));
  } finally {
    varStore.close();
  }
@@ -533,19 +542,18 @@ async function cmdVarDelete(args: string[]): Promise<void> {
    die("Usage: json-cas var delete <name> [--schema <hash>]");
  }

-  const varStore = openVarStore();
+  const store = await openStore();
+  const varStore = createVariableStore(resolve(varDbPath), store);

  try {
    if (schema !== undefined) {
      // Precise deletion: remove specific (name, schema) variant
      const variable = varStore.remove(name, schema);
-      const envelope = await wrapVariableEnvelope(variable);
-      out(envelope);
+      out(await wrapEnvelope(store, "@output/var-delete", variable));
    } else {
      // Batch deletion: remove all variants for this name
      const variables = varStore.remove(name);
-      const envelope = await wrapVariableEnvelope(variables);
-      out(envelope);
+      out(await wrapEnvelope(store, "@output/var-delete", variables));
    }
  } catch (e) {
    if (e instanceof VariableNotFoundError) {
@@ -570,7 +578,8 @@ async function cmdVarTag(args: string[]): Promise<void> {
    die("Usage: json-cas var tag <name> --schema <hash> <operations...>");
  }

-  const varStore = openVarStore();
+  const store = await openStore();
+  const varStore = createVariableStore(resolve(varDbPath), store);

  try {
    const { tags, labels, deleteNames } = parseTagsLabels(tagArgs);
@@ -581,8 +590,7 @@ async function cmdVarTag(args: string[]): Promise<void> {
      delete: deleteNames.length > 0 ? deleteNames : undefined,
    });

-    const envelope = await wrapVariableEnvelope(variable);
-    out(envelope);
+    out(await wrapEnvelope(store, "@output/var-tag", variable));
  } catch (e) {
    if (
      e instanceof VariableNotFoundError ||
@@ -602,7 +610,8 @@ async function cmdVarList(args: string[]): Promise<void> {
  const schema = flags.schema as string | undefined;
  const tagFlags = flags.tag;

-  const varStore = openVarStore();
+  const store = await openStore();
+  const varStore = createVariableStore(resolve(varDbPath), store);

  try {
    // Parse tags/labels from --tag flags
@@ -624,8 +633,7 @@ async function cmdVarList(args: string[]): Promise<void> {
      tags: Object.keys(tags).length > 0 ? tags : undefined,
      labels: labels.length > 0 ? labels : undefined,
    });
-    const envelope = await wrapVariableEnvelope(variables);
-    out(envelope);
+    out(await wrapEnvelope(store, "@output/var-list", variables));
  } catch (e) {
    if (e instanceof InvalidVariableNameError) {
      die(`Error: ${e.message}`);
@@ -644,8 +652,7 @@ async function cmdTemplateSet(args: string[]): Promise<void> {
    die("Usage: json-cas template set <schema-hash> <file> | --inline <text>");
  }

-  const store = openStore();
-  mkdirSync(resolve(storePath), { recursive: true });
+  const store = await openStore();
  const varStore = createVariableStore(resolve(varDbPath), store);

  try {
@@ -695,10 +702,12 @@ async function cmdTemplateSet(args: string[]): Promise<void> {
    const varName = `@ucas/template/text/${schemaHash}`;
    varStore.set(varName, contentHash);

-    out({
-      schemaHash,
-      contentHash,
-    });
+    out(
+      await wrapEnvelope(store, "@output/template-set", {
+        schemaHash,
+        contentHash,
+      }),
+    );
  } catch (e) {
    if (e instanceof CasNodeNotFoundError) {
      die(`Error: ${e.message}`);
@@ -716,8 +725,7 @@ async function cmdTemplateGet(args: string[]): Promise<void> {
    die("Usage: json-cas template get <schema-hash>");
  }

-  const store = openStore();
-  mkdirSync(resolve(storePath), { recursive: true });
+  const store = await openStore();
  const varStore = createVariableStore(resolve(varDbPath), store);

  try {
@@ -735,16 +743,16 @@ async function cmdTemplateGet(args: string[]): Promise<void> {
      die(`Error: Content not found in CAS: ${variable.value}`);
    }

-    // Output raw text (not JSON)
-    process.stdout.write(node.payload as string);
+    out(
+      await wrapEnvelope(store, "@output/template-get", node.payload as string),
+    );
  } finally {
    varStore.close();
  }
 }

 async function cmdTemplateList(_args: string[]): Promise<void> {
-  const store = openStore();
-  mkdirSync(resolve(storePath), { recursive: true });
+  const store = await openStore();
  const varStore = createVariableStore(resolve(varDbPath), store);

  try {
@@ -754,24 +762,12 @@ async function cmdTemplateList(_args: string[]): Promise<void> {
      schema: stringHash,
    });

-    const templates = variables.map((v) => {
-      const schemaHash = v.name.replace("@ucas/template/text/", "");
+    const templates = variables.map((v) => ({
+      schemaHash: v.name.replace("@ucas/template/text/", ""),
+      contentHash: v.value,
+    }));

-      // Get content for preview
-      const node = store.get(v.value);
-      const content = (node?.payload as string | undefined) ?? "";
-
-      // Truncate preview to 80 chars
-      const preview =
-        content.length > 80 ? `${content.slice(0, 77)}...` : content;
-
-      return {
-        schemaHash,
-        preview,
-      };
-    });
-
-    out(templates);
+    out(await wrapEnvelope(store, "@output/template-list", templates));
  } finally {
    varStore.close();
  }
@@ -784,8 +780,7 @@ async function cmdTemplateDelete(args: string[]): Promise<void> {
    die("Usage: json-cas template delete <schema-hash>");
  }

-  const store = openStore();
-  mkdirSync(resolve(storePath), { recursive: true });
+  const store = await openStore();
  const varStore = createVariableStore(resolve(varDbPath), store);

  try {
@@ -793,7 +788,9 @@ async function cmdTemplateDelete(args: string[]): Promise<void> {
    const stringHash = await resolveTypeHash("@string");
    varStore.remove(varName, stringHash);

-    out({ deleted: true });
+    out(
+      await wrapEnvelope(store, "@output/template-delete", { deleted: true }),
+    );
  } catch (e) {
    if (e instanceof VariableNotFoundError) {
      die(`Error: Template not found for schema: ${schemaHash}`);
@@ -805,47 +802,56 @@ async function cmdTemplateDelete(args: string[]): Promise<void> {
 }

 async function cmdGc(_args: string[]): Promise<void> {
-  const store = createFsStore(storePath);
+  const store = await openStore();
  const varStore = createVariableStore(varDbPath, store);

  try {
    const stats = gc(store, varStore);
-    out(stats);
+    out(await wrapEnvelope(store, "@output/gc", stats));
  } finally {
    varStore.close();
  }
 }

+async function cmdList(_args: string[]): Promise<void> {
+  const typeFlag = flags.type;
+  if (typeof typeFlag !== "string")
+    die("Usage: json-cas list --type <hash-or-alias>");
+  const typeHash = await resolveTypeHash(typeFlag);
+  const store = await openStore();
+  const hashes = Array.from(store.listByType(typeHash));
+  out(await wrapEnvelope(store, "@output/list", hashes));
+}
+
 function printUsage(): void {
  console.log(`\
 Usage: json-cas [--store <path>] [--json] <command> [args]

+All JSON commands emit a { type, value } envelope. The type is the hash of the
+command's @output/* schema (shown in parentheses); pipe any envelope into
+\`render -p\` to render its value (cas_ref hashes are expanded).
+
 Commands:
-  init                              Create store dir and write bootstrap seed
-  bootstrap                         Write meta-schema seed, print hash
-  schema put <file.json>            Register schema, print type hash
-  schema get <type-hash>            Print schema JSON
-  schema list                       List all schemas (name + hash)
-  schema validate <hash>            Validate node against its schema
-  put <type-hash> <file.json>       Store node, print hash
-  get <hash>                        Print node as JSON
-  has <hash>                        Print true/false
-  verify <hash>                     Verify integrity, print ok/corrupted
-  refs <hash>                       List direct cas_ref edges
-  walk <hash> [--format tree]       Recursive traversal
-  hash <type-hash> <file.json>      Compute hash without storing (dry run)
-  render <hash> [options]           Render node as YAML with resolution decay
-  cat <hash> [--payload]            Output node (--payload for payload only)
-  var set <name> <hash> [--tag <tag>...] Create/update a variable
-  var get <name> --schema <hash>    Get a variable by name + schema
-  var delete <name> [--schema <hash>] Delete variable(s)
-  var list [prefix] [--schema <hash>] [--tag <tag>...] List variables
-  var tag <name> --schema <hash> <operations...> Modify tags/labels
-  template set <schema-hash> <file> | --inline <text> Set template for schema
-  template get <schema-hash>        Get template content as raw text
-  template list                     List all templates
-  template delete <schema-hash>     Delete template for schema
-  gc                                Run garbage collection
+  put <type-hash> <file.json|--pipe> Store node, print envelope (value=hash)            (@output/put)
+  get <hash>                        Print node as envelope                             (@output/get)
+  has <hash>                        Print envelope (value=boolean)                     (@output/has)
+  verify <hash>                     Verify integrity + schema (value=ok/corrupted/invalid) (@output/verify)
+  refs <hash>                       List direct cas_ref edges                          (@output/refs)
+  walk <hash> [--format tree]       Recursive traversal                                (@output/walk)
+  hash <type-hash> <file.json|--pipe> Compute hash without storing                     (@output/hash)
+  render <hash> [options]           Render node as text with resolution decay (raw output)
+  render --pipe/-p [options]        Render { type, value } from stdin (raw output)
+  list --type <hash-or-alias>       List hashes for a type (value=string[])            (@output/list)
+  var set <name> <hash> [--tag <tag>...] Create/update a variable                      (@output/var-set)
+  var get <name> --schema <hash>    Get a variable by name + schema                    (@output/var-get)
+  var delete <name> [--schema <hash>] Delete variable(s)                               (@output/var-delete)
+  var list [prefix] [--schema <hash>] [--tag <tag>...] List variables                  (@output/var-list)
+  var tag <name> --schema <hash> <operations...> Modify tags/labels                    (@output/var-tag)
+  template set <schema-hash> <file> | --inline <text> Set template for schema          (@output/template-set)
+  template get <schema-hash>        Get template content (value=string)                (@output/template-get)
+  template list                     List all templates                                 (@output/template-list)
+  template delete <schema-hash>     Delete template for schema                         (@output/template-delete)
+  gc                                Run garbage collection                             (@output/gc)

 Flags:
  --store <path>      Store directory (default: ~/.uncaged/json-cas)
@@ -856,7 +862,8 @@ Flags:
  --inline <text>     Inline text content for template set
  --resolution <n>    Initial resolution for render (default: 1.0)
  --decay <n>         Decay factor for render (default: 0.5)
-  --epsilon <n>       Cutoff threshold for render (default: 0.01)`);
+  --epsilon <n>       Cutoff threshold for render (default: 0.01)
+  --pipe, -p          Read from stdin (put/hash: raw JSON payload; render: { type, value } envelope)`);
 }

 // ---- Dispatch ----
@@ -869,35 +876,6 @@ if (!cmd) {
 }

 switch (cmd) {
-  case "init":
-    await cmdInit();
-    break;
-
-  case "bootstrap":
-    await cmdBootstrap();
-    break;
-
-  case "schema": {
-    const [sub, ...subRest] = rest;
-    switch (sub) {
-      case "put":
-        await cmdSchemaPut(subRest);
-        break;
-      case "get":
-        await cmdSchemaGet(subRest);
-        break;
-      case "list":
-        await cmdSchemaList();
-        break;
-      case "validate":
-        await cmdSchemaValidate(subRest);
-        break;
-      default:
-        die(`Unknown schema subcommand: ${sub ?? "(none)"}`);
-    }
-    break;
-  }
-
  case "put":
    await cmdPut(rest);
    break;
@@ -930,8 +908,8 @@ switch (cmd) {
    await cmdRender(rest);
    break;

-  case "cat":
-    await cmdCat(rest);
+  case "list":
+    await cmdList(rest);
    break;

  case "var": {
@@ -103,9 +103,10 @@ describe("template set", () => {
    expect(exitCode).toBe(0);
    expect(stderr).toBe("");

-    const output = JSON.parse(stdout);
-    expect(output).toHaveProperty("contentHash");
-    expect(output.schemaHash).toBe(stringHash);
+    const envelope = JSON.parse(stdout);
+    expect(envelope).toHaveProperty("type");
+    expect(envelope.value).toHaveProperty("contentHash");
+    expect(envelope.value.schemaHash).toBe(stringHash);
  });

  test("set template with --inline flag", async () => {
@@ -122,9 +123,10 @@ describe("template set", () => {

    expect(exitCode).toBe(0);

-    const output = JSON.parse(stdout);
-    expect(output).toHaveProperty("contentHash");
-    expect(output.schemaHash).toBe(stringHash);
+    const envelope = JSON.parse(stdout);
+    expect(envelope).toHaveProperty("type");
+    expect(envelope.value).toHaveProperty("contentHash");
+    expect(envelope.value.schemaHash).toBe(stringHash);
  });

  test("update existing template (idempotent)", async () => {
@@ -148,12 +150,12 @@ describe("template set", () => {

    expect(exitCode).toBe(0);

-    const output = JSON.parse(stdout);
-    expect(output).toHaveProperty("contentHash");
+    const envelope = JSON.parse(stdout);
+    expect(envelope.value).toHaveProperty("contentHash");

    // Verify we can get the new version
    const { stdout: getOut } = await runCli("template", "get", stringHash);
-    expect(getOut).toBe("Version 2");
+    expect(JSON.parse(getOut).value).toBe("Version 2");
  });

  test("error when file not found", async () => {
@@ -223,7 +225,7 @@ describe("template set", () => {

    // Verify content
    const { stdout: getOut } = await runCli("template", "get", stringHash);
-    expect(getOut).toBe(multilineContent);
+    expect(JSON.parse(getOut).value).toBe(multilineContent);
  });

  test("support empty templates", async () => {
@@ -240,8 +242,8 @@ describe("template set", () => {

    expect(exitCode).toBe(0);

-    const output = JSON.parse(stdout);
-    expect(output).toHaveProperty("contentHash");
+    const envelope = JSON.parse(stdout);
+    expect(envelope.value).toHaveProperty("contentHash");
  });

  test("error when neither file nor --inline provided", async () => {
@@ -271,12 +273,12 @@ describe("template set", () => {

    // Verify content preserved
    const { stdout: getOut } = await runCli("template", "get", stringHash);
-    expect(getOut).toBe(specialContent);
+    expect(JSON.parse(getOut).value).toBe(specialContent);
  });
 });

 describe("template get", () => {
-  test("retrieve template as raw text", async () => {
+  test("retrieve template as envelope value", async () => {
    const store = createFsStore(storePath);
    const stringHash = await getStringHash(store);

@@ -291,7 +293,9 @@ describe("template get", () => {

    expect(exitCode).toBe(0);
    expect(stderr).toBe("");
-    expect(stdout).toBe(content);
+    const envelope = JSON.parse(stdout);
+    expect(envelope).toHaveProperty("type");
+    expect(envelope.value).toBe(content);
  });

  test("error when template not found", async () => {
@@ -309,27 +313,26 @@ describe("template get", () => {
    const store = createFsStore(storePath);
    const stringHash = await getStringHash(store);

-    // Note: runCli helper trims stdout, so we test with content that doesn't have leading/trailing whitespace
-    // The actual CLI preserves whitespace correctly
+    // The envelope's value preserves exact whitespace (JSON-escaped),
+    // so trimming the surrounding JSON output is harmless.
    const content = "spaces\n\ttabs\t\nmixed";
    await runCli("template", "set", stringHash, "--inline", content);

    const { stdout } = await runCli("template", "get", stringHash);

-    expect(stdout).toBe(content);
+    expect(JSON.parse(stdout).value).toBe(content);
  });

  test("support multi-line templates", async () => {
    const store = createFsStore(storePath);
    const stringHash = await getStringHash(store);

-    // Note: runCli helper trims stdout, so trailing newline will be removed
    const multiline = "Line 1\nLine 2\nLine 3";
    await runCli("template", "set", stringHash, "--inline", multiline);

    const { stdout } = await runCli("template", "get", stringHash);

-    expect(stdout).toBe(multiline);
+    expect(JSON.parse(stdout).value).toBe(multiline);
  });
 });

@@ -346,34 +349,40 @@ describe("template list", () => {

    expect(exitCode).toBe(0);

-    const output = JSON.parse(stdout);
-    expect(Array.isArray(output)).toBe(true);
-    expect(output.length).toBeGreaterThanOrEqual(1);
+    const envelope = JSON.parse(stdout);
+    expect(envelope).toHaveProperty("type");
+    expect(Array.isArray(envelope.value)).toBe(true);
+    expect(envelope.value.length).toBeGreaterThanOrEqual(1);

    // Check structure
-    const item = output[0];
+    const item = envelope.value[0];
    expect(item).toHaveProperty("schemaHash");
-    expect(item).toHaveProperty("preview");
+    expect(item).toHaveProperty("contentHash");
  });

-  test("preview truncation for long content", async () => {
+  test("entry contentHash matches set result", async () => {
    const store = createFsStore(storePath);
    const stringHash = await getStringHash(store);

-    const longContent = "a".repeat(200);
-    await runCli("template", "set", stringHash, "--inline", longContent);
+    const { stdout: setOut } = await runCli(
+      "template",
+      "set",
+      stringHash,
+      "--inline",
+      "Some template content",
+    );
+    const { contentHash } = JSON.parse(setOut).value;

    const { stdout } = await runCli("template", "list");

-    const output = JSON.parse(stdout) as Array<{
+    const value = JSON.parse(stdout).value as Array<{
      schemaHash: string;
-      preview: string;
+      contentHash: string;
    }>;
-    const item = output.find((i) => i.schemaHash === stringHash);
+    const item = value.find((i) => i.schemaHash === stringHash);
    expect(item).toBeDefined();
    if (item) {
-      expect(item.preview.length).toBeLessThan(longContent.length);
-      expect(item.preview).toContain("...");
+      expect(item.contentHash).toBe(contentHash);
    }
  });

@@ -382,9 +391,9 @@ describe("template list", () => {

    expect(exitCode).toBe(0);

-    const output = JSON.parse(stdout);
-    expect(Array.isArray(output)).toBe(true);
-    expect(output.length).toBe(0);
+    const envelope = JSON.parse(stdout);
+    expect(Array.isArray(envelope.value)).toBe(true);
+    expect(envelope.value.length).toBe(0);
  });

  test("exclude non-template variables", async () => {
@@ -400,14 +409,14 @@ describe("template list", () => {

    const { stdout } = await runCli("template", "list");

-    const output = JSON.parse(stdout);
+    const envelope = JSON.parse(stdout);
    // Should only contain template variables
-    for (const item of output) {
+    for (const item of envelope.value) {
      expect(item.schemaHash).toBeDefined();
    }
  });

-  test("output JSON array format", async () => {
+  test("output JSON envelope with array value", async () => {
    const store = createFsStore(storePath);
    const stringHash = await getStringHash(store);

@@ -418,27 +427,8 @@ describe("template list", () => {
    // Should be valid JSON
    expect(() => JSON.parse(stdout)).not.toThrow();

-    const output = JSON.parse(stdout);
-    expect(Array.isArray(output)).toBe(true);
-  });
-
-  test("preview shows beginning of content", async () => {
-    const store = createFsStore(storePath);
-    const stringHash = await getStringHash(store);
-
-    const content = "Start of template...";
-    await runCli("template", "set", stringHash, "--inline", content);
-
-    const { stdout } = await runCli("template", "list");
-
-    const output = JSON.parse(stdout) as Array<{
-      schemaHash: string;
-      preview: string;
-    }>;
-    const item = output.find((i) => i.schemaHash === stringHash);
-    if (item) {
-      expect(item.preview).toContain("Start");
-    }
+    const envelope = JSON.parse(stdout);
+    expect(Array.isArray(envelope.value)).toBe(true);
  });
 });

@@ -458,9 +448,10 @@ describe("template delete", () => {
    expect(exitCode).toBe(0);
    expect(stderr).toBe("");

-    const output = JSON.parse(stdout);
-    expect(output).toHaveProperty("deleted");
-    expect(output.deleted).toBe(true);
+    const envelope = JSON.parse(stdout);
+    expect(envelope).toHaveProperty("type");
+    expect(envelope.value).toHaveProperty("deleted");
+    expect(envelope.value.deleted).toBe(true);

    // Verify template is gone
    const { exitCode: getExitCode } = await runCli(
@@ -495,13 +486,13 @@ describe("template delete", () => {

    // Verify second still exists
    const { stdout } = await runCli("template", "list");
-    const output = JSON.parse(stdout) as Array<{
+    const value = JSON.parse(stdout).value as Array<{
      schemaHash: string;
-      preview: string;
+      contentHash: string;
    }>;

    // Should not find deleted template
-    const deleted = output.find((i) => i.schemaHash === stringHash);
+    const deleted = value.find((i) => i.schemaHash === stringHash);
    expect(deleted).toBeUndefined();
  });

@@ -519,7 +510,7 @@ describe("template delete", () => {
      "--inline",
      "Content",
    );
-    const { contentHash } = JSON.parse(setOut);
+    const { contentHash } = JSON.parse(setOut).value;

    // Delete the template variable
    await runCli("template", "delete", stringHash);
@@ -577,7 +568,7 @@ describe("template integration", () => {
      stringHash,
    );
    expect(getExit).toBe(0);
-    expect(getOut).toBe(content);
+    expect(JSON.parse(getOut).value).toBe(content);

    // List
    const { stdout: listOut, exitCode: listExit } = await runCli(
@@ -585,7 +576,7 @@ describe("template integration", () => {
      "list",
    );
    expect(listExit).toBe(0);
-    const listData = JSON.parse(listOut);
+    const listData = JSON.parse(listOut).value;
    expect(listData.length).toBeGreaterThan(0);

    // Delete
@@ -626,8 +617,8 @@ describe("template integration", () => {

    // List should show all
    const { stdout } = await runCli("template", "list");
-    const output = JSON.parse(stdout);
-    expect(output.length).toBeGreaterThanOrEqual(1);
+    const value = JSON.parse(stdout).value;
+    expect(value.length).toBeGreaterThanOrEqual(1);
  });
 });

@@ -1,5 +1,32 @@
 # @uncaged/json-cas-fs

+## 0.6.0
+
+### Minor Changes
+
+- Unified `{ type, value }` envelope output for all CLI commands (RFC [#67](https://github.com/uncaged/json-cas/issues/67)).
+
+  ### Breaking Changes
+
+  - Removed `init`, `bootstrap`, `cat`, `schema put/get/list/validate` commands
+  - All CLI command outputs now wrapped in `{ type, value }` envelope (except `render`)
+  - `openStore()` is now async and auto-bootstraps
+
+  ### New Features
+
+  - 18 `@output/*` schemas registered at bootstrap
+  - `list --type <hash-or-alias>` command (replaces `schema list`)
+  - `verify` now checks both hash integrity and schema validation
+  - `wrapEnvelope()` helper exported from `@uncaged/json-cas`
+  - `openStore()` in `@uncaged/json-cas-fs` — async, auto mkdir + bootstrap
+  - Default LiquidJS templates for all output schemas
+  - Pipe composition: any command output can be piped to `render -p`
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @uncaged/json-cas@0.6.0
+
 ## 0.5.3

 ### Patch Changes
@@ -1,6 +1,6 @@
 {
  "name": "@uncaged/json-cas-fs",
-  "version": "0.5.3",
+  "version": "0.6.0",
  "type": "module",
  "main": "./dist/index.js",
  "types": "./dist/index.d.ts",
@@ -16,10 +16,10 @@
  ],
  "scripts": {
    "test": "bun test",
-    "prepublishOnly": "echo '请用 bun run release 从根目录发版' && exit 1"
+    "prepublishOnly": "bash ../../scripts/check-workspace-deps.sh"
  },
  "dependencies": {
-    "@uncaged/json-cas": "^0.5.3",
+    "@uncaged/json-cas": "^0.6.0",
    "cborg": "^4.2.3"
  }
 }
@@ -1 +1 @@
-export { createFsStore } from "./store.js";
+export { createFsStore, openStore } from "./store.js";
@@ -1,5 +1,11 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { existsSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
+import {
+  existsSync,
+  mkdtempSync,
+  readdirSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { CasNode } from "@uncaged/json-cas";
@@ -10,7 +16,7 @@ import {
  verify,
 } from "@uncaged/json-cas";

-import { createFsStore } from "./store.js";
+import { createFsStore, openStore } from "./store.js";

 function makeTmpDir(): string {
  return mkdtempSync(join(tmpdir(), "json-cas-fs-test-"));
@@ -59,7 +65,7 @@ describe("createFsStore – init and bootstrap", () => {
    const h2 = await bootstrap(store);

    expect(h1).toEqual(h2);
-    expect(store.listByType(h1["@schema"] ?? "")).toHaveLength(6);
+    expect(store.listByType(h1["@schema"] ?? "")).toHaveLength(24);
  });
 });

@@ -312,3 +318,114 @@ describe("createFsStore – verify on disk-loaded nodes", () => {
    }
  });
 });
+
+// ──────────────────────────────────────────────────────────────────────────────
+// openStore – async with auto-bootstrap
+// ──────────────────────────────────────────────────────────────────────────────
+describe("openStore – async with auto-bootstrap", () => {
+  let dir: string;
+  beforeEach(() => {
+    dir = makeTmpDir();
+  });
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("openStore returns Promise<Store>", async () => {
+    const store = await openStore(dir);
+    expect(store).toBeDefined();
+    expect(typeof store.put).toBe("function");
+    expect(typeof store.get).toBe("function");
+  });
+
+  test("openStore auto-creates directory when it doesn't exist", async () => {
+    const nested = join(dir, "sub", "nested", "store");
+    expect(existsSync(nested)).toBe(false);
+
+    const store = await openStore(nested);
+    expect(existsSync(nested)).toBe(true);
+
+    // Verify store works
+    const typeHash = await computeSelfHash({ name: "t" });
+    const hash = await store.put(typeHash, { x: 1 });
+    expect(store.has(hash)).toBe(true);
+  });
+
+  test("openStore works when directory already exists", async () => {
+    // Pre-create the directory
+    const store1 = await openStore(dir);
+    const typeHash = await computeSelfHash({ name: "t" });
+    await store1.put(typeHash, { x: 1 });
+
+    // Open again
+    const store2 = await openStore(dir);
+    expect(store2.listByType(typeHash)).toHaveLength(1);
+  });
+
+  test("openStore throws error when path exists but is not a directory", async () => {
+    const filePath = join(dir, "not-a-dir");
+    writeFileSync(filePath, "test");
+
+    await expect(openStore(filePath)).rejects.toThrow();
+  });
+
+  test("openStore auto-bootstraps on first open (empty directory)", async () => {
+    const store = await openStore(dir);
+
+    // Check that bootstrap schemas exist
+    const builtinSchemas = await bootstrap(store);
+    const metaHash = builtinSchemas["@schema"];
+
+    expect(metaHash).toBeDefined();
+    expect(store.has(metaHash as string)).toBe(true);
+
+    // Verify all core schemas exist
+    expect(store.has(builtinSchemas["@string"] as string)).toBe(true);
+    expect(store.has(builtinSchemas["@number"] as string)).toBe(true);
+    expect(store.has(builtinSchemas["@object"] as string)).toBe(true);
+    expect(store.has(builtinSchemas["@array"] as string)).toBe(true);
+    expect(store.has(builtinSchemas["@bool"] as string)).toBe(true);
+    expect(store.has(builtinSchemas["@schema"] as string)).toBe(true);
+  });
+
+  test("openStore bootstrap is idempotent on subsequent opens", async () => {
+    const store1 = await openStore(dir);
+    const schemas1 = await bootstrap(store1);
+    const count1 = store1.listAll().length;
+
+    const store2 = await openStore(dir);
+    const schemas2 = await bootstrap(store2);
+    const count2 = store2.listAll().length;
+
+    // Same schemas, same count
+    expect(schemas1).toEqual(schemas2);
+    expect(count1).toBe(count2);
+  });
+
+  test("openStore works on already-bootstrapped store", async () => {
+    // Bootstrap manually first
+    const store1 = createFsStore(dir);
+    const schemas1 = await bootstrap(store1);
+
+    // Open with openStore
+    const store2 = await openStore(dir);
+    const schemas2 = await bootstrap(store2);
+
+    expect(schemas1).toEqual(schemas2);
+  });
+
+  test("openStore auto-bootstraps old store without bootstrap", async () => {
+    // Create a store with some data but no bootstrap
+    const store1 = createFsStore(dir);
+    const typeHash = await computeSelfHash({ name: "custom" });
+    await store1.put(typeHash, { data: "old" });
+
+    // Open with openStore - should auto-bootstrap
+    const store2 = await openStore(dir);
+    const schemas = await bootstrap(store2);
+
+    expect(store2.has(schemas["@schema"] as string)).toBe(true);
+    // Old data still exists
+    expect(store2.listByType(typeHash)).toHaveLength(1);
+  });
+});
@@ -5,6 +5,7 @@ import {
  readdirSync,
  readFileSync,
  renameSync,
+  statSync,
  unlinkSync,
  writeFileSync,
 } from "node:fs";
@@ -13,6 +14,7 @@ import type { BootstrapCapableStore, CasNode, Hash } from "@uncaged/json-cas";

 import {
  BOOTSTRAP_STORE,
+  bootstrap,
  cborEncode,
  computeHash,
  computeSelfHash,
@@ -219,3 +221,57 @@ export function createFsStore(dir: string): BootstrapCapableStore {

  return store;
 }
+
+/**
+ * Open a filesystem-backed CAS store with automatic directory creation and bootstrap.
+ * This is an async function that:
+ * 1. Creates the directory (with recursive: true) if it doesn't exist
+ * 2. Validates that the path is actually a directory (not a file)
+ * 3. Creates the store
+ * 4. Runs bootstrap (which is idempotent)
+ *
+ * @param dir - The directory path for the store
+ * @returns A Promise resolving to the BootstrapCapableStore
+ * @throws Error if the path exists but is not a directory
+ */
+export async function openStore(dir: string): Promise<BootstrapCapableStore> {
+  // Create directory if it doesn't exist
+  try {
+    mkdirSync(dir, { recursive: true });
+  } catch (error) {
+    if (error instanceof Error && "code" in error) {
+      const nodeError = error as NodeJS.ErrnoException;
+      if (nodeError.code === "EACCES") {
+        throw new Error(`Permission denied: cannot access store at ${dir}`);
+      }
+      if (nodeError.code === "ENOTDIR") {
+        throw new Error(`Path exists but is not a directory: ${dir}`);
+      }
+    }
+    throw error;
+  }
+
+  // Validate that the path is a directory
+  try {
+    const stats = statSync(dir);
+    if (!stats.isDirectory()) {
+      throw new Error(`Path exists but is not a directory: ${dir}`);
+    }
+  } catch (error) {
+    if (error instanceof Error && "code" in error) {
+      const nodeError = error as NodeJS.ErrnoException;
+      if (nodeError.code === "ENOENT") {
+        throw new Error(`Store not found at ${dir}`);
+      }
+    }
+    throw error;
+  }
+
+  // Create the store
+  const store = createFsStore(dir);
+
+  // Bootstrap (idempotent)
+  await bootstrap(store);
+
+  return store;
+}
@@ -1,5 +1,27 @@
 # @uncaged/json-cas

+## 0.6.0
+
+### Minor Changes
+
+- Unified `{ type, value }` envelope output for all CLI commands (RFC [#67](https://github.com/uncaged/json-cas/issues/67)).
+
+  ### Breaking Changes
+
+  - Removed `init`, `bootstrap`, `cat`, `schema put/get/list/validate` commands
+  - All CLI command outputs now wrapped in `{ type, value }` envelope (except `render`)
+  - `openStore()` is now async and auto-bootstraps
+
+  ### New Features
+
+  - 18 `@output/*` schemas registered at bootstrap
+  - `list --type <hash-or-alias>` command (replaces `schema list`)
+  - `verify` now checks both hash integrity and schema validation
+  - `wrapEnvelope()` helper exported from `@uncaged/json-cas`
+  - `openStore()` in `@uncaged/json-cas-fs` — async, auto mkdir + bootstrap
+  - Default LiquidJS templates for all output schemas
+  - Pipe composition: any command output can be piped to `render -p`
+
 ## 0.5.3

 ### Patch Changes
@@ -1,6 +1,6 @@
 {
  "name": "@uncaged/json-cas",
-  "version": "0.5.3",
+  "version": "0.6.0",
  "type": "module",
  "main": "./dist/index.js",
  "types": "./dist/index.d.ts",
@@ -16,7 +16,7 @@
  ],
  "scripts": {
    "test": "bun test",
-    "prepublishOnly": "echo '请用 bun run release 从根目录发版' && exit 1"
+    "prepublishOnly": "bash ../../scripts/check-workspace-deps.sh"
  },
  "dependencies": {
    "ajv": "^8.20.0",
@@ -1,18 +1,40 @@
 import { describe, expect, test } from "bun:test";
 import { bootstrap } from "./bootstrap.js";
+import type { JSONSchema } from "./schema.js";
 import { getSchema } from "./schema.js";
 import { createMemoryStore } from "./store.js";

+const OUTPUT_ALIASES = [
+  "@output/put",
+  "@output/get",
+  "@output/has",
+  "@output/hash",
+  "@output/verify",
+  "@output/refs",
+  "@output/walk",
+  "@output/list",
+  "@output/var-set",
+  "@output/var-get",
+  "@output/var-delete",
+  "@output/var-tag",
+  "@output/var-list",
+  "@output/template-set",
+  "@output/template-get",
+  "@output/template-list",
+  "@output/template-delete",
+  "@output/gc",
+] as const;
+
 // ──────────────────────────────────────────────────────────────────────────────
 // Built-in Schema Registration Tests
 // ──────────────────────────────────────────────────────────────────────────────

 describe("bootstrap - Built-in Schemas", () => {
-  test("should return map of built-in schema aliases to hashes", async () => {
+  test("should return map of 24 built-in schema aliases to hashes", async () => {
    const store = createMemoryStore();
    const builtinSchemas = await bootstrap(store);

-    // Should return object with 6 aliases
+    // Should return object with 6 primitive + 18 output aliases = 24
    expect(builtinSchemas).toHaveProperty("@schema");
    expect(builtinSchemas).toHaveProperty("@string");
    expect(builtinSchemas).toHaveProperty("@number");
@@ -20,6 +42,12 @@ describe("bootstrap - Built-in Schemas", () => {
    expect(builtinSchemas).toHaveProperty("@array");
    expect(builtinSchemas).toHaveProperty("@bool");

+    for (const alias of OUTPUT_ALIASES) {
+      expect(builtinSchemas).toHaveProperty(alias);
+    }
+
+    expect(Object.keys(builtinSchemas)).toHaveLength(24);
+
    // All values should be valid hashes
    for (const [_alias, hash] of Object.entries(builtinSchemas)) {
      expect(typeof hash).toBe("string");
@@ -127,3 +155,164 @@ describe("bootstrap - Built-in Schemas", () => {
    }
  });
 });
+
+// ──────────────────────────────────────────────────────────────────────────────
+// @output/* Schema Registration Tests
+// ──────────────────────────────────────────────────────────────────────────────
+
+describe("bootstrap - @output/* Schemas", () => {
+  test("each @output/* schema has a title", async () => {
+    const store = createMemoryStore();
+    const aliases = await bootstrap(store);
+
+    for (const alias of OUTPUT_ALIASES) {
+      const hash = aliases[alias];
+      if (!hash) throw new Error(`${alias} not found`);
+
+      const schema = getSchema(store, hash) as JSONSchema;
+      expect(schema).not.toBeNull();
+      expect(typeof schema.title).toBe("string");
+      expect((schema.title as string).startsWith("ucas ")).toBe(true);
+    }
+  });
+
+  test("@output/put schema describes a cas_ref string", async () => {
+    const store = createMemoryStore();
+    const aliases = await bootstrap(store);
+    const hash = aliases["@output/put"];
+    if (!hash) throw new Error("@output/put not found");
+
+    const schema = getSchema(store, hash);
+    expect(schema).toEqual({
+      type: "string",
+      format: "cas_ref",
+      title: "ucas put result",
+    });
+  });
+
+  test("@output/get schema describes object with type, payload, timestamp", async () => {
+    const store = createMemoryStore();
+    const aliases = await bootstrap(store);
+    const hash = aliases["@output/get"];
+    if (!hash) throw new Error("@output/get not found");
+
+    const schema = getSchema(store, hash) as JSONSchema;
+    expect(schema.type).toBe("object");
+    expect(schema.title).toBe("ucas get result");
+
+    const props = schema.properties as Record<string, JSONSchema>;
+    expect(props.type).toEqual({ type: "string", format: "cas_ref" });
+    expect(props.payload).toEqual({});
+    expect(props.timestamp).toEqual({ type: "number" });
+  });
+
+  test("@output/has schema describes a boolean", async () => {
+    const store = createMemoryStore();
+    const aliases = await bootstrap(store);
+    const hash = aliases["@output/has"];
+    if (!hash) throw new Error("@output/has not found");
+
+    expect(getSchema(store, hash)).toEqual({
+      type: "boolean",
+      title: "ucas has result",
+    });
+  });
+
+  test("@output/verify schema describes enum of ok|corrupted|invalid", async () => {
+    const store = createMemoryStore();
+    const aliases = await bootstrap(store);
+    const hash = aliases["@output/verify"];
+    if (!hash) throw new Error("@output/verify not found");
+
+    const schema = getSchema(store, hash);
+    expect(schema).toEqual({
+      type: "string",
+      enum: ["ok", "corrupted", "invalid"],
+      title: "ucas verify result",
+    });
+  });
+
+  test("@output/refs schema describes array of cas_ref strings", async () => {
+    const store = createMemoryStore();
+    const aliases = await bootstrap(store);
+    const hash = aliases["@output/refs"];
+    if (!hash) throw new Error("@output/refs not found");
+
+    expect(getSchema(store, hash)).toEqual({
+      type: "array",
+      items: { type: "string", format: "cas_ref" },
+      title: "ucas refs result",
+    });
+  });
+
+  test("@output/gc schema describes object with gc stats fields", async () => {
+    const store = createMemoryStore();
+    const aliases = await bootstrap(store);
+    const hash = aliases["@output/gc"];
+    if (!hash) throw new Error("@output/gc not found");
+
+    const schema = getSchema(store, hash) as JSONSchema;
+    expect(schema.type).toBe("object");
+    expect(schema.title).toBe("ucas gc result");
+
+    const props = schema.properties as Record<string, JSONSchema>;
+    expect(props.total).toEqual({ type: "number" });
+    expect(props.reachable).toEqual({ type: "number" });
+    expect(props.collected).toEqual({ type: "number" });
+    expect(props.scanned).toEqual({ type: "number" });
+  });
+
+  test("@output/var-set schema describes a Variable object", async () => {
+    const store = createMemoryStore();
+    const aliases = await bootstrap(store);
+    const hash = aliases["@output/var-set"];
+    if (!hash) throw new Error("@output/var-set not found");
+
+    const schema = getSchema(store, hash) as JSONSchema;
+    expect(schema.type).toBe("object");
+    expect(schema.title).toBe("ucas var set result");
+
+    const props = schema.properties as Record<string, JSONSchema>;
+    expect(props.name).toEqual({ type: "string" });
+    expect(props.schema).toEqual({ type: "string", format: "cas_ref" });
+    expect(props.value).toEqual({ type: "string", format: "cas_ref" });
+  });
+
+  test("@output/var-list schema describes array of Variable objects", async () => {
+    const store = createMemoryStore();
+    const aliases = await bootstrap(store);
+    const hash = aliases["@output/var-list"];
+    if (!hash) throw new Error("@output/var-list not found");
+
+    const schema = getSchema(store, hash) as JSONSchema;
+    expect(schema.type).toBe("array");
+    expect(schema.title).toBe("ucas var list result");
+
+    const items = schema.items as JSONSchema;
+    expect(items.type).toBe("object");
+    const props = items.properties as Record<string, JSONSchema>;
+    expect(props.name).toEqual({ type: "string" });
+  });
+
+  test("@output/template-delete schema describes object with deleted boolean", async () => {
+    const store = createMemoryStore();
+    const aliases = await bootstrap(store);
+    const hash = aliases["@output/template-delete"];
+    if (!hash) throw new Error("@output/template-delete not found");
+
+    expect(getSchema(store, hash)).toEqual({
+      type: "object",
+      properties: { deleted: { type: "boolean" } },
+      title: "ucas template delete result",
+    });
+  });
+
+  test("all @output/* schemas are distinct hashes", async () => {
+    const store = createMemoryStore();
+    const aliases = await bootstrap(store);
+
+    const outputHashes = OUTPUT_ALIASES.map((alias) => aliases[alias]);
+    const uniqueHashes = new Set(outputHashes);
+    expect(uniqueHashes.size).toBe(OUTPUT_ALIASES.length);
+  });
+});
@@ -60,12 +60,182 @@ const BOOTSTRAP_PAYLOAD = {
    enum: { type: "array" },
    const: {},
    description: { type: "string" },
+    // P1 leaf constraints
+    minimum: { type: "number" },
+    maximum: { type: "number" },
+    exclusiveMinimum: { type: "number" },
+    exclusiveMaximum: { type: "number" },
+    minLength: { type: "number" },
+    maxLength: { type: "number" },
+    pattern: { type: "string" },
+    minItems: { type: "number" },
+    maxItems: { type: "number" },
+    uniqueItems: { type: "boolean" },
  },
 } as const;

+const VARIABLE_PROPERTIES = {
+  name: { type: "string" },
+  schema: { type: "string", format: "cas_ref" },
+  value: { type: "string", format: "cas_ref" },
+  created: { type: "number" },
+  updated: { type: "number" },
+  tags: { type: "object" },
+  labels: { type: "array", items: { type: "string" } },
+} as const;
+
+const OUTPUT_SCHEMAS: ReadonlyArray<
+  readonly [alias: string, schema: Record<string, unknown>]
+> = [
+  [
+    "@output/put",
+    { type: "string", format: "cas_ref", title: "ucas put result" },
+  ],
+  [
+    "@output/get",
+    {
+      type: "object",
+      properties: {
+        type: { type: "string", format: "cas_ref" },
+        payload: {},
+        timestamp: { type: "number" },
+      },
+      title: "ucas get result",
+    },
+  ],
+  ["@output/has", { type: "boolean", title: "ucas has result" }],
+  [
+    "@output/hash",
+    { type: "string", format: "cas_ref", title: "ucas hash result" },
+  ],
+  [
+    "@output/verify",
+    {
+      type: "string",
+      enum: ["ok", "corrupted", "invalid"],
+      title: "ucas verify result",
+    },
+  ],
+  [
+    "@output/refs",
+    {
+      type: "array",
+      items: { type: "string", format: "cas_ref" },
+      title: "ucas refs result",
+    },
+  ],
+  [
+    "@output/walk",
+    {
+      type: "array",
+      items: { type: "string" },
+      title: "ucas walk result",
+    },
+  ],
+  [
+    "@output/list",
+    {
+      type: "array",
+      items: { type: "string", format: "cas_ref" },
+      title: "ucas list result",
+    },
+  ],
+  [
+    "@output/var-set",
+    {
+      type: "object",
+      properties: { ...VARIABLE_PROPERTIES },
+      title: "ucas var set result",
+    },
+  ],
+  [
+    "@output/var-get",
+    {
+      type: "object",
+      properties: { ...VARIABLE_PROPERTIES },
+      title: "ucas var get result",
+    },
+  ],
+  [
+    "@output/var-delete",
+    {
+      type: "object",
+      properties: { ...VARIABLE_PROPERTIES },
+      title: "ucas var delete result",
+    },
+  ],
+  [
+    "@output/var-tag",
+    {
+      type: "object",
+      properties: { ...VARIABLE_PROPERTIES },
+      title: "ucas var tag result",
+    },
+  ],
+  [
+    "@output/var-list",
+    {
+      type: "array",
+      items: { type: "object", properties: { ...VARIABLE_PROPERTIES } },
+      title: "ucas var list result",
+    },
+  ],
+  [
+    "@output/template-set",
+    {
+      type: "object",
+      properties: {
+        schemaHash: { type: "string", format: "cas_ref" },
+        contentHash: { type: "string", format: "cas_ref" },
+      },
+      title: "ucas template set result",
+    },
+  ],
+  [
+    "@output/template-get",
+    { type: "string", title: "ucas template get result" },
+  ],
+  [
+    "@output/template-list",
+    {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          schemaHash: { type: "string", format: "cas_ref" },
+          contentHash: { type: "string", format: "cas_ref" },
+        },
+      },
+      title: "ucas template list result",
+    },
+  ],
+  [
+    "@output/template-delete",
+    {
+      type: "object",
+      properties: { deleted: { type: "boolean" } },
+      title: "ucas template delete result",
+    },
+  ],
+  [
+    "@output/gc",
+    {
+      type: "object",
+      properties: {
+        total: { type: "number" },
+        reachable: { type: "number" },
+        collected: { type: "number" },
+        scanned: { type: "number" },
+      },
+      title: "ucas gc result",
+    },
+  ],
+];
+
 /**
 * Write the meta-schema seed node into the store and register built-in schemas.
- * The returned object contains aliases for the meta-schema and 5 primitive schemas.
+ * The returned object contains aliases for the meta-schema, 5 primitive schemas,
+ * and 18 @output/* schemas (24 total).
 * Idempotent: calling bootstrap multiple times returns the same hashes.
 */
 export async function bootstrap(store: Store): Promise<Record<string, Hash>> {
@@ -83,8 +253,8 @@ export async function bootstrap(store: Store): Promise<Record<string, Hash>> {
  const arrayHash = await store.put(metaHash, { type: "array" });
  const boolHash = await store.put(metaHash, { type: "boolean" });

-  // 3. Return map of aliases to hashes
-  return {
+  // 3. Register @output/* schemas
+  const aliases: Record<string, Hash> = {
    "@schema": metaHash,
    "@string": stringHash,
    "@number": numberHash,
@@ -92,4 +262,10 @@ export async function bootstrap(store: Store): Promise<Record<string, Hash>> {
    "@array": arrayHash,
    "@bool": boolHash,
  };
+
+  for (const [alias, schema] of OUTPUT_SCHEMAS) {
+    aliases[alias] = await store.put(metaHash, schema);
+  }
+
+  return aliases;
 }
@@ -264,7 +264,7 @@ describe("bootstrap", () => {
    );
  });

-  test("returns a map with 6 built-in schema aliases", async () => {
+  test("returns a map with 24 built-in schema aliases", async () => {
    const store = createMemoryStore();
    const builtinSchemas = await bootstrap(store);

@@ -280,6 +280,8 @@ describe("bootstrap", () => {
      expect(hash).toHaveLength(13);
      expect(hash).toMatch(/^[0-9A-HJKMNP-TV-Z]{13}$/);
    }
+
+    expect(Object.keys(builtinSchemas)).toHaveLength(24);
  });

  test("meta-schema node is stored and retrievable", async () => {
@@ -316,7 +318,7 @@ describe("bootstrap", () => {
    const h2 = await bootstrap(store);

    expect(h1).toEqual(h2);
-    // All 6 built-in schemas should be typed by the meta-schema
-    expect(store.listByType(h1["@schema"] ?? "")).toHaveLength(6);
+    // All 24 built-in schemas should be typed by the meta-schema
+    expect(store.listByType(h1["@schema"] ?? "")).toHaveLength(24);
  });
 });
@@ -5,7 +5,13 @@ export { cborEncode } from "./cbor.js";
 export { type GcStats, gc } from "./gc.js";
 export { computeHash, computeSelfHash } from "./hash.js";
 export { renderWithTemplate } from "./liquid-render.js";
-export { type RenderOptions, render, renderAsync } from "./render.js";
+export { registerOutputTemplates } from "./output-templates.js";
+export {
+  type RenderOptions,
+  render,
+  renderAsync,
+  renderDirect,
+} from "./render.js";
 export type { JSONSchema } from "./schema.js";
 export {
  getSchema,
@@ -29,3 +35,4 @@ export {
  VariableStore,
 } from "./variable-store.js";
 export { verify } from "./verify.js";
+export { wrapEnvelope } from "./wrap-envelope.js";
@@ -602,7 +602,7 @@ describe("Suite 4: Render Flow Integration", () => {
    }
  });

-  test("4.4 Empty Template", async () => {
+  test("4.2 Empty Template", async () => {
    const { store, varStore, cleanup } = await createTempVarStore();

    try {
@@ -631,7 +631,7 @@ describe("Suite 4: Render Flow Integration", () => {
    }
  });

-  test("4.5 Template with LiquidJS Syntax Error", async () => {
+  test("4.3 Template with LiquidJS Syntax Error", async () => {
    const { store, varStore, cleanup } = await createTempVarStore();

    try {
@@ -808,8 +808,8 @@ describe("Suite 5: Decay Priority Chain", () => {
  });
 });

-describe("Suite 7: Recursive Rendering Edge Cases", () => {
-  test("7.1 Deep Recursion (10 Levels)", async () => {
+describe("Suite 6: Recursive Rendering Edge Cases", () => {
+  test("6.1 Deep Recursion (10 Levels)", async () => {
    const { store, varStore, cleanup } = await createTempVarStore();

    try {
@@ -856,7 +856,7 @@ describe("Suite 7: Recursive Rendering Edge Cases", () => {
    }
  });

-  test("7.2 Cycle Detection with Templates", async () => {
+  test("6.2 Cycle Detection with Templates", async () => {
    const { store, varStore, cleanup } = await createTempVarStore();

    try {
@@ -893,7 +893,7 @@ describe("Suite 7: Recursive Rendering Edge Cases", () => {
    }
  });

-  test("7.4 Array of cas_ref with Template", async () => {
+  test("6.3 Array of cas_ref with Template", async () => {
    const { store, varStore, cleanup } = await createTempVarStore();

    try {
@@ -949,8 +949,8 @@ describe("Suite 7: Recursive Rendering Edge Cases", () => {
  });
 });

-describe("Suite 8: Error Handling & Edge Cases", () => {
-  test("8.1 Template Missing render Variable", async () => {
+describe("Suite 7: Error Handling & Edge Cases", () => {
+  test("7.1 Template Missing render Variable", async () => {
    const { store, varStore, cleanup } = await createTempVarStore();

    try {
@@ -983,7 +983,7 @@ describe("Suite 8: Error Handling & Edge Cases", () => {
    }
  });

-  test("8.2 Template Invalid Decay Value", async () => {
+  test("7.2 Template Invalid Decay Value", async () => {
    const { store, varStore, cleanup } = await createTempVarStore();

    try {
@@ -1023,7 +1023,7 @@ describe("Suite 8: Error Handling & Edge Cases", () => {
    }
  });

-  test("8.3 Template Negative Decay", async () => {
+  test("7.3 Template Negative Decay", async () => {
    const { store, varStore, cleanup } = await createTempVarStore();

    try {
@@ -1063,7 +1063,7 @@ describe("Suite 8: Error Handling & Edge Cases", () => {
    }
  });

-  test("8.4 Template Decay=0 (Invalid)", async () => {
+  test("7.4 Template Decay=0 (Invalid)", async () => {
    const { store, varStore, cleanup } = await createTempVarStore();

    try {
@@ -1103,7 +1103,7 @@ describe("Suite 8: Error Handling & Edge Cases", () => {
    }
  });

-  test("8.5 Template Decay=1 (Valid Edge)", async () => {
+  test("7.5 Template Decay=1 (Valid Edge)", async () => {
    const { store, varStore, cleanup } = await createTempVarStore();

    try {
@@ -1150,7 +1150,7 @@ describe("Suite 8: Error Handling & Edge Cases", () => {
    }
  });

-  test("8.6 Template with Unicode Content", async () => {
+  test("7.6 Template with Unicode Content", async () => {
    const { store, varStore, cleanup } = await createTempVarStore();

    try {
@@ -1183,8 +1183,8 @@ describe("Suite 8: Error Handling & Edge Cases", () => {
  });
 });

-describe("Suite 10: Performance & Scalability", () => {
-  test("10.1 Wide Fan-out (100 Children)", async () => {
+describe("Suite 8: Performance & Scalability", () => {
+  test("8.1 Wide Fan-out (100 Children)", async () => {
    const { store, varStore, cleanup } = await createTempVarStore();

    try {
@@ -1241,3 +1241,609 @@ describe("Suite 10: Performance & Scalability", () => {
    }
  });
 });
+
+describe("Suite 9: E2E Template Variable Rendering (Issue #52)", () => {
+  test("9.1 Direct Property Access - Should Render Empty", async () => {
+    const { store, varStore, cleanup } = await createTempVarStore();
+
+    try {
+      // Create schema for person object
+      const personSchema = await putSchema(store, {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          age: { type: "number" },
+        },
+      });
+
+      // Create node with data
+      const personHash = await store.put(personSchema, {
+        name: "Alice",
+        age: 30,
+      });
+
+      // Register template using direct property access (incorrect syntax)
+      const templateSchema = await putSchema(store, { type: "string" });
+      const templateHash = await store.put(
+        templateSchema,
+        "Name: {{ name }}, Age: {{ age }}",
+      );
+      varStore.set(`@ucas/template/text/${personSchema}`, templateHash);
+
+      // Render - should produce empty values
+      const output = await renderWithTemplate(store, varStore, personHash, {
+        resolution: 1.0,
+        decay: 0.5,
+        epsilon: 0.01,
+      });
+
+      expect(output).toBe("Name: , Age: ");
+    } finally {
+      varStore.close();
+      await cleanup();
+    }
+  });
+
+  test("9.2 Correct Syntax with payload Prefix", async () => {
+    const { store, varStore, cleanup } = await createTempVarStore();
+
+    try {
+      // Create schema for person object
+      const personSchema = await putSchema(store, {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          age: { type: "number" },
+        },
+      });
+
+      // Create node with data
+      const personHash = await store.put(personSchema, {
+        name: "Alice",
+        age: 30,
+      });
+
+      // Register template using correct payload. prefix
+      const templateSchema = await putSchema(store, { type: "string" });
+      const templateHash = await store.put(
+        templateSchema,
+        "Name: {{ payload.name }}, Age: {{ payload.age }}",
+      );
+      varStore.set(`@ucas/template/text/${personSchema}`, templateHash);
+
+      // Render - should produce correct values
+      const output = await renderWithTemplate(store, varStore, personHash, {
+        resolution: 1.0,
+        decay: 0.5,
+        epsilon: 0.01,
+      });
+
+      expect(output).toBe("Name: Alice, Age: 30");
+    } finally {
+      varStore.close();
+      await cleanup();
+    }
+  });
+
+  test("9.3 CLI Render Command - Template Variable Access", async () => {
+    const { store, varStore, cleanup } = await createTempVarStore();
+
+    try {
+      // Create schema and node
+      const personSchema = await putSchema(store, {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          age: { type: "number" },
+        },
+      });
+
+      const personHash = await store.put(personSchema, {
+        name: "Bob",
+        age: 25,
+      });
+
+      // Register template
+      const templateSchema = await putSchema(store, { type: "string" });
+      const templateHash = await store.put(
+        templateSchema,
+        "User: {{ payload.name }}, Age: {{ payload.age }}",
+      );
+      varStore.set(`@ucas/template/text/${personSchema}`, templateHash);
+
+      // This simulates the CLI flow
+      const output = await renderWithTemplate(store, varStore, personHash, {
+        resolution: 1.0,
+        decay: 0.5,
+        epsilon: 0.01,
+      });
+
+      expect(output).toContain("User: Bob");
+      expect(output).toContain("Age: 25");
+    } finally {
+      varStore.close();
+      await cleanup();
+    }
+  });
+
+  test("9.4 Top-Level Primitive Payload - String", async () => {
+    const { store, varStore, cleanup } = await createTempVarStore();
+
+    try {
+      // Create schema for simple string
+      const stringSchema = await putSchema(store, { type: "string" });
+
+      // Create node with string payload
+      const stringHash = await store.put(stringSchema, "Hello World");
+
+      // Register template
+      const templateSchema = await putSchema(store, { type: "string" });
+      const templateHash = await store.put(
+        templateSchema,
+        "Value is: {{ payload }}",
+      );
+      varStore.set(`@ucas/template/text/${stringSchema}`, templateHash);
+
+      // Render
+      const output = await renderWithTemplate(store, varStore, stringHash, {
+        resolution: 1.0,
+        decay: 0.5,
+        epsilon: 0.01,
+      });
+
+      expect(output).toBe("Value is: Hello World");
+    } finally {
+      varStore.close();
+      await cleanup();
+    }
+  });
+
+  test("9.5 Top-Level Primitive Payload - Number", async () => {
+    const { store, varStore, cleanup } = await createTempVarStore();
+
+    try {
+      // Create schema for number
+      const numberSchema = await putSchema(store, { type: "number" });
+
+      // Create node with number payload
+      const numberHash = await store.put(numberSchema, 42);
+
+      // Register template
+      const templateSchema = await putSchema(store, { type: "string" });
+      const templateHash = await store.put(
+        templateSchema,
+        "The answer is {{ payload }}",
+      );
+      varStore.set(`@ucas/template/text/${numberSchema}`, templateHash);
+
+      // Render
+      const output = await renderWithTemplate(store, varStore, numberHash, {
+        resolution: 1.0,
+        decay: 0.5,
+        epsilon: 0.01,
+      });
+
+      expect(output).toBe("The answer is 42");
+    } finally {
+      varStore.close();
+      await cleanup();
+    }
+  });
+
+  test("9.6 Nested Object Property Access", async () => {
+    const { store, varStore, cleanup } = await createTempVarStore();
+
+    try {
+      // Create schema for nested object
+      const userSchema = await putSchema(store, {
+        type: "object",
+        properties: {
+          user: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              address: {
+                type: "object",
+                properties: {
+                  city: { type: "string" },
+                },
+              },
+            },
+          },
+        },
+      });
+
+      // Create node with nested data
+      const userHash = await store.put(userSchema, {
+        user: {
+          name: "Bob",
+          address: {
+            city: "NYC",
+          },
+        },
+      });
+
+      // Register template with deep property access
+      const templateSchema = await putSchema(store, { type: "string" });
+      const templateHash = await store.put(
+        templateSchema,
+        "User {{ payload.user.name }} lives in {{ payload.user.address.city }}",
+      );
+      varStore.set(`@ucas/template/text/${userSchema}`, templateHash);
+
+      // Render
+      const output = await renderWithTemplate(store, varStore, userHash, {
+        resolution: 1.0,
+        decay: 0.5,
+        epsilon: 0.01,
+      });
+
+      expect(output).toBe("User Bob lives in NYC");
+    } finally {
+      varStore.close();
+      await cleanup();
+    }
+  });
+
+  test("9.7 Array Property Access and Iteration", async () => {
+    const { store, varStore, cleanup } = await createTempVarStore();
+
+    try {
+      // Create schema with array
+      const tagsSchema = await putSchema(store, {
+        type: "object",
+        properties: {
+          tags: {
+            type: "array",
+            items: { type: "string" },
+          },
+        },
+      });
+
+      // Create node with array data
+      const tagsHash = await store.put(tagsSchema, {
+        tags: ["javascript", "typescript", "bun"],
+      });
+
+      // Register template with array iteration
+      const templateSchema = await putSchema(store, { type: "string" });
+      const templateHash = await store.put(
+        templateSchema,
+        "Tags: {% for tag in payload.tags %}{{ tag }}{% unless forloop.last %}, {% endunless %}{% endfor %}",
+      );
+      varStore.set(`@ucas/template/text/${tagsSchema}`, templateHash);
+
+      // Render
+      const output = await renderWithTemplate(store, varStore, tagsHash, {
+        resolution: 1.0,
+        decay: 0.5,
+        epsilon: 0.01,
+      });
+
+      expect(output).toBe("Tags: javascript, typescript, bun");
+    } finally {
+      varStore.close();
+      await cleanup();
+    }
+  });
+
+  test("9.8 Missing Property Access - Graceful Handling", async () => {
+    const { store, varStore, cleanup } = await createTempVarStore();
+
+    try {
+      // Create schema
+      const personSchema = await putSchema(store, {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+        },
+      });
+
+      // Create node without age property
+      const personHash = await store.put(personSchema, {
+        name: "Alice",
+      });
+
+      // Register template that references missing property
+      const templateSchema = await putSchema(store, { type: "string" });
+      const templateHash = await store.put(
+        templateSchema,
+        "Name: {{ payload.name }}, Age: {{ payload.age }}",
+      );
+      varStore.set(`@ucas/template/text/${personSchema}`, templateHash);
+
+      // Render - age should be empty
+      const output = await renderWithTemplate(store, varStore, personHash, {
+        resolution: 1.0,
+        decay: 0.5,
+        epsilon: 0.01,
+      });
+
+      expect(output).toBe("Name: Alice, Age: ");
+    } finally {
+      varStore.close();
+      await cleanup();
+    }
+  });
+
+  test("9.9 Null Property Value Rendering", async () => {
+    const { store, varStore, cleanup } = await createTempVarStore();
+
+    try {
+      // Create schema allowing null
+      const personSchema = await putSchema(store, {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          email: { type: ["string", "null"] },
+        },
+      });
+
+      // Create node with null email
+      const personHash = await store.put(personSchema, {
+        name: "Charlie",
+        email: null,
+      });
+
+      // Register template
+      const templateSchema = await putSchema(store, { type: "string" });
+      const templateHash = await store.put(
+        templateSchema,
+        "Name: {{ payload.name }}, Email: {{ payload.email }}",
+      );
+      varStore.set(`@ucas/template/text/${personSchema}`, templateHash);
+
+      // Render - email should be empty
+      const output = await renderWithTemplate(store, varStore, personHash, {
+        resolution: 1.0,
+        decay: 0.5,
+        epsilon: 0.01,
+      });
+
+      expect(output).toBe("Name: Charlie, Email: ");
+    } finally {
+      varStore.close();
+      await cleanup();
+    }
+  });
+
+  test("9.10 Boolean Property Rendering", async () => {
+    const { store, varStore, cleanup } = await createTempVarStore();
+
+    try {
+      // Create schema with boolean
+      const userSchema = await putSchema(store, {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          active: { type: "boolean" },
+        },
+      });
+
+      // Create node with boolean
+      const userHash = await store.put(userSchema, {
+        name: "Dave",
+        active: true,
+      });
+
+      // Register template with conditional
+      const templateSchema = await putSchema(store, { type: "string" });
+      const templateHash = await store.put(
+        templateSchema,
+        "User {{ payload.name }} is {% if payload.active %}active{% else %}inactive{% endif %}",
+      );
+      varStore.set(`@ucas/template/text/${userSchema}`, templateHash);
+
+      // Render
+      const output = await renderWithTemplate(store, varStore, userHash, {
+        resolution: 1.0,
+        decay: 0.5,
+        epsilon: 0.01,
+      });
+
+      expect(output).toBe("User Dave is active");
+    } finally {
+      varStore.close();
+      await cleanup();
+    }
+  });
+
+  test("9.11 Zero and Empty String Values", async () => {
+    const { store, varStore, cleanup } = await createTempVarStore();
+
+    try {
+      // Create schema
+      const dataSchema = await putSchema(store, {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          count: { type: "number" },
+        },
+      });
+
+      // Create node with empty string and zero
+      const dataHash = await store.put(dataSchema, {
+        name: "",
+        count: 0,
+      });
+
+      // Register template
+      const templateSchema = await putSchema(store, { type: "string" });
+      const templateHash = await store.put(
+        templateSchema,
+        "Name: '{{ payload.name }}', Count: {{ payload.count }}",
+      );
+      varStore.set(`@ucas/template/text/${dataSchema}`, templateHash);
+
+      // Render - zero and empty string should appear
+      const output = await renderWithTemplate(store, varStore, dataHash, {
+        resolution: 1.0,
+        decay: 0.5,
+        epsilon: 0.01,
+      });
+
+      expect(output).toBe("Name: '', Count: 0");
+    } finally {
+      varStore.close();
+      await cleanup();
+    }
+  });
+
+  test("9.12 Special Characters in String Values", async () => {
+    const { store, varStore, cleanup } = await createTempVarStore();
+
+    try {
+      // Create schema
+      const textSchema = await putSchema(store, {
+        type: "object",
+        properties: {
+          text: { type: "string" },
+        },
+      });
+
+      // Create node with special characters
+      const textHash = await store.put(textSchema, {
+        text: 'Hello "World" & <tag>',
+      });
+
+      // Register template
+      const templateSchema = await putSchema(store, { type: "string" });
+      const templateHash = await store.put(
+        templateSchema,
+        "Text: {{ payload.text }}",
+      );
+      varStore.set(`@ucas/template/text/${textSchema}`, templateHash);
+
+      // Render
+      const output = await renderWithTemplate(store, varStore, textHash, {
+        resolution: 1.0,
+        decay: 0.5,
+        epsilon: 0.01,
+      });
+
+      expect(output).toContain('Hello "World" & <tag>');
+    } finally {
+      varStore.close();
+      await cleanup();
+    }
+  });
+});
+
+describe("Suite 10: Context Variable Completeness", () => {
+  test("10.1 Context Propagation in Recursive Renders", async () => {
+    const { store, varStore, cleanup } = await createTempVarStore();
+
+    try {
+      // Create child schema and node
+      const childSchema = await putSchema(store, {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+        },
+      });
+      const childHash = await store.put(childSchema, { name: "child" });
+
+      // Create parent schema and node
+      const parentSchema = await putSchema(store, {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          child: { type: "string", format: "cas_ref" },
+        },
+      });
+      const parentHash = await store.put(parentSchema, {
+        name: "parent",
+        child: childHash,
+      });
+
+      // Register parent template
+      const templateSchema = await putSchema(store, { type: "string" });
+      const parentTemplateHash = await store.put(
+        templateSchema,
+        "Parent: {{ payload.name }}\n{% render payload.child %}",
+      );
+      varStore.set(`@ucas/template/text/${parentSchema}`, parentTemplateHash);
+
+      // Register child template that accesses context variables
+      const childTemplateHash = await store.put(
+        templateSchema,
+        "Child: {{ payload.name }}, Hash: {{ hash }}, Resolution: {{ resolution }}",
+      );
+      varStore.set(`@ucas/template/text/${childSchema}`, childTemplateHash);
+
+      // Render
+      const output = await renderWithTemplate(store, varStore, parentHash, {
+        resolution: 1.0,
+        decay: 0.5,
+        epsilon: 0.01,
+      });
+
+      expect(output).toContain("Parent: parent");
+      expect(output).toContain("Child: child");
+      expect(output).toContain(`Hash: ${childHash}`);
+      expect(output).toContain("Resolution: 0.5");
+    } finally {
+      varStore.close();
+      await cleanup();
+    }
+  });
+
+  test("10.2 Context Isolation Between Parent and Child", async () => {
+    const { store, varStore, cleanup } = await createTempVarStore();
+
+    try {
+      // Create child schema and node
+      const childSchema = await putSchema(store, {
+        type: "object",
+        properties: {
+          custom: { type: "string" },
+        },
+      });
+      const childHash = await store.put(childSchema, {
+        custom: "child_value",
+      });
+
+      // Create parent schema and node
+      const parentSchema = await putSchema(store, {
+        type: "object",
+        properties: {
+          custom: { type: "string" },
+          child: { type: "string", format: "cas_ref" },
+        },
+      });
+      const parentHash = await store.put(parentSchema, {
+        custom: "parent_value",
+        child: childHash,
+      });
+
+      // Register parent template
+      const templateSchema = await putSchema(store, { type: "string" });
+      const parentTemplateHash = await store.put(
+        templateSchema,
+        "Parent custom: {{ payload.custom }}\n{% render payload.child %}",
+      );
+      varStore.set(`@ucas/template/text/${parentSchema}`, parentTemplateHash);
+
+      // Register child template
+      const childTemplateHash = await store.put(
+        templateSchema,
+        "Child custom: {{ payload.custom }}",
+      );
+      varStore.set(`@ucas/template/text/${childSchema}`, childTemplateHash);
+
+      // Render
+      const output = await renderWithTemplate(store, varStore, parentHash, {
+        resolution: 1.0,
+        decay: 0.5,
+        epsilon: 0.01,
+      });
+
+      expect(output).toContain("Parent custom: parent_value");
+      expect(output).toContain("Child custom: child_value");
+      expect(output).not.toContain("Child custom: parent_value");
+    } finally {
+      varStore.close();
+      await cleanup();
+    }
+  });
+});
@@ -1,14 +1,9 @@
 import { type Context, Liquid, type TagToken } from "liquidjs";
+import type { RenderOptions } from "./render.js";
 import { putSchema } from "./schema.js";
 import type { Hash, Store } from "./types.js";
 import type { VariableStore } from "./variable-store.js";

-export type RenderOptions = {
-  resolution?: number; // (0, 1], default 1.0
-  decay?: number; // (0, 1], default 0.5
-  epsilon?: number; // >= 0, default 0.01
-};
-
 const DEFAULT_RESOLUTION = 1.0;
 const DEFAULT_DECAY = 0.5;
 const DEFAULT_EPSILON = 0.01;
@@ -50,7 +45,6 @@ export async function renderWithTemplate(
    varStore,
    hash,
    resolution,
-    decay,
    epsilon,
    visited,
  );
@@ -146,7 +140,6 @@ function createLiquidEngine(
        varStore,
        nodeHash,
        childResolution,
-        globalDecay,
        currentEpsilon,
        visited,
      );
@@ -167,7 +160,6 @@ async function renderNode(
  varStore: VariableStore,
  hash: Hash,
  currentResolution: number,
-  _globalDecay: number,
  epsilon: number,
  visited: Set<Hash>,
 ): Promise<string> {
@@ -0,0 +1,117 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { bootstrap } from "./bootstrap.js";
+import { registerOutputTemplates } from "./output-templates.js";
+import { createMemoryStore } from "./store.js";
+import type { Store } from "./types.js";
+import type { VariableStore } from "./variable-store.js";
+import { createVariableStore } from "./variable-store.js";
+
+const OUTPUT_ALIASES = [
+  "@output/put",
+  "@output/get",
+  "@output/has",
+  "@output/hash",
+  "@output/verify",
+  "@output/refs",
+  "@output/walk",
+  "@output/list",
+  "@output/var-set",
+  "@output/var-get",
+  "@output/var-delete",
+  "@output/var-tag",
+  "@output/var-list",
+  "@output/template-set",
+  "@output/template-get",
+  "@output/template-list",
+  "@output/template-delete",
+  "@output/gc",
+] as const;
+
+describe("registerOutputTemplates", () => {
+  let store: Store;
+  let varStore: VariableStore;
+  let tempDir: string;
+
+  afterEach(async () => {
+    varStore.close();
+    await rm(tempDir, { recursive: true });
+  });
+
+  test("registers a template for every @output/* schema", async () => {
+    tempDir = await mkdtemp(join(tmpdir(), "json-cas-tmpl-"));
+    store = createMemoryStore();
+    await bootstrap(store);
+    varStore = createVariableStore(join(tempDir, "vars.db"), store);
+
+    const registered = await registerOutputTemplates(store, varStore);
+
+    expect(Object.keys(registered)).toHaveLength(18);
+
+    for (const alias of OUTPUT_ALIASES) {
+      expect(registered).toHaveProperty(alias);
+    }
+  });
+
+  test("each template is retrievable via @ucas/template/text/<hash>", async () => {
+    tempDir = await mkdtemp(join(tmpdir(), "json-cas-tmpl-"));
+    store = createMemoryStore();
+    const aliases = await bootstrap(store);
+    varStore = createVariableStore(join(tempDir, "vars.db"), store);
+
+    await registerOutputTemplates(store, varStore);
+
+    const stringHash = aliases["@string"];
+    if (!stringHash) throw new Error("@string not found");
+
+    for (const alias of OUTPUT_ALIASES) {
+      const schemaHash = aliases[alias];
+      if (!schemaHash) throw new Error(`${alias} not found`);
+
+      const varName = `@ucas/template/text/${schemaHash}`;
+      const variable = varStore.get(varName, stringHash);
+      if (variable === null) throw new Error(`Variable ${varName} not found`);
+
+      const templateNode = store.get(variable.value);
+      if (templateNode === null)
+        throw new Error(`Template node ${variable.value} not found`);
+      expect(typeof templateNode.payload).toBe("string");
+    }
+  });
+
+  test("is idempotent — safe to call multiple times", async () => {
+    tempDir = await mkdtemp(join(tmpdir(), "json-cas-tmpl-"));
+    store = createMemoryStore();
+    await bootstrap(store);
+    varStore = createVariableStore(join(tempDir, "vars.db"), store);
+
+    const first = await registerOutputTemplates(store, varStore);
+    const second = await registerOutputTemplates(store, varStore);
+
+    expect(first).toEqual(second);
+  });
+
+  test("@output/put template contains payload reference", async () => {
+    tempDir = await mkdtemp(join(tmpdir(), "json-cas-tmpl-"));
+    store = createMemoryStore();
+    const aliases = await bootstrap(store);
+    varStore = createVariableStore(join(tempDir, "vars.db"), store);
+
+    await registerOutputTemplates(store, varStore);
+
+    const putHash = aliases["@output/put"];
+    if (!putHash) throw new Error("@output/put not found");
+    const stringHash = aliases["@string"];
+    if (!stringHash) throw new Error("@string not found");
+
+    const variable = varStore.get(`@ucas/template/text/${putHash}`, stringHash);
+    if (variable === null)
+      throw new Error("@output/put template variable not found");
+
+    const templateNode = store.get(variable.value);
+    if (templateNode === null) throw new Error("Template node not found");
+    expect(templateNode.payload).toBe("{{ payload }}");
+  });
+});
@@ -0,0 +1,87 @@
+import { bootstrap } from "./bootstrap.js";
+import type { Hash, Store } from "./types.js";
+import type { VariableStore } from "./variable-store.js";
+
+const DEFAULT_TEMPLATES: ReadonlyArray<
+  readonly [alias: string, template: string]
+> = [
+  ["@output/put", "{{ payload }}"],
+  [
+    "@output/get",
+    "type: {{ payload.type }}\ntimestamp: {{ payload.timestamp }}",
+  ],
+  ["@output/has", "{{ payload }}"],
+  ["@output/hash", "{{ payload }}"],
+  ["@output/verify", "{{ payload }}"],
+  ["@output/refs", "{% for ref in payload %}{{ ref }}\n{% endfor %}"],
+  ["@output/walk", "{% for item in payload %}{{ item }}\n{% endfor %}"],
+  ["@output/list", "{% for item in payload %}{{ item }}\n{% endfor %}"],
+  [
+    "@output/var-set",
+    "name: {{ payload.name }}\nschema: {{ payload.schema }}\nvalue: {{ payload.value }}",
+  ],
+  [
+    "@output/var-get",
+    "name: {{ payload.name }}\nschema: {{ payload.schema }}\nvalue: {{ payload.value }}",
+  ],
+  [
+    "@output/var-delete",
+    "name: {{ payload.name }}\nschema: {{ payload.schema }}\nvalue: {{ payload.value }}",
+  ],
+  [
+    "@output/var-tag",
+    "name: {{ payload.name }}\nschema: {{ payload.schema }}\nvalue: {{ payload.value }}",
+  ],
+  [
+    "@output/var-list",
+    "{% for v in payload %}name: {{ v.name }}\nschema: {{ v.schema }}\nvalue: {{ v.value }}\n{% endfor %}",
+  ],
+  [
+    "@output/template-set",
+    "schemaHash: {{ payload.schemaHash }}\ncontentHash: {{ payload.contentHash }}",
+  ],
+  ["@output/template-get", "{{ payload }}"],
+  [
+    "@output/template-list",
+    "{% for t in payload %}schemaHash: {{ t.schemaHash }}\ncontentHash: {{ t.contentHash }}\n{% endfor %}",
+  ],
+  ["@output/template-delete", "deleted: {{ payload.deleted }}"],
+  [
+    "@output/gc",
+    "total: {{ payload.total }}\nreachable: {{ payload.reachable }}\ncollected: {{ payload.collected }}\nscanned: {{ payload.scanned }}",
+  ],
+];
+
+/**
+ * Register default LiquidJS templates for all @output/* schemas.
+ * Each template is stored as a @string CAS node and bound to
+ * the variable `@ucas/template/text/<schema-hash>`.
+ *
+ * Idempotent: safe to call multiple times.
+ */
+export async function registerOutputTemplates(
+  store: Store,
+  varStore: VariableStore,
+): Promise<Record<string, Hash>> {
+  const aliases = await bootstrap(store);
+  const stringHash = aliases["@string"];
+  if (stringHash === undefined) {
+    throw new Error("@string schema not found in bootstrap result");
+  }
+
+  const registered: Record<string, Hash> = {};
+
+  for (const [alias, template] of DEFAULT_TEMPLATES) {
+    const schemaHash = aliases[alias];
+    if (schemaHash === undefined) {
+      throw new Error(`Schema alias not found: ${alias}`);
+    }
+
+    const contentHash = await store.put(stringHash, template);
+    const varName = `@ucas/template/text/${schemaHash}`;
+    varStore.set(varName, contentHash);
+    registered[alias] = contentHash;
+  }
+
+  return registered;
+}
@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
 import { bootstrap } from "./bootstrap.js";
-import { render } from "./render.js";
+import { render, renderAsync, renderDirect } from "./render.js";
 import { putSchema } from "./schema.js";
 import { createMemoryStore } from "./store.js";
 import type { Hash } from "./types.js";
+import { CasNodeNotFoundError } from "./variable-store.js";

 describe("Suite 1: Basic Rendering (No Nesting)", () => {
  test("1.1 Render Simple Primitives", async () => {
@@ -65,13 +66,14 @@ describe("Suite 1: Basic Rendering (No Nesting)", () => {
    expect(output.trim()).toBe(`cas:${hash}`);
  });

-  test("1.5 Render Non-existent Hash", () => {
+  test("1.5 Render Non-existent Hash Throws Error", () => {
    const store = createMemoryStore();
    const fakeHash = "ZZZZZZZZZZZZZ" as Hash;

-    // Non-existent node renders as cas: reference
-    const output = render(store, fakeHash);
-    expect(output.trim()).toBe(`cas:${fakeHash}`);
+    // Non-existent root node should throw
+    expect(() => render(store, fakeHash)).toThrow(CasNodeNotFoundError);
+    expect(() => render(store, fakeHash)).toThrow("CAS node not found");
+    expect(() => render(store, fakeHash)).toThrow(fakeHash);
  });
 });

@@ -793,9 +795,10 @@ describe("Suite 6: Schema Integration", () => {

  test("6.5 Schema-less Node (Bootstrap Node)", async () => {
    const store = createMemoryStore();
-    const metaHash = await bootstrap(store);
+    const types = await bootstrap(store);
+    const schemaHash = types["@schema"];

-    const output = render(store, metaHash);
+    const output = render(store, schemaHash);

    // Should render without recursive expansion
    expect(output).toBeTruthy();
@@ -933,3 +936,217 @@ describe("Suite 8: Performance & Edge Cases", () => {
    expect(output).toContain("🌍");
  });
 });
+
+describe("Suite 9: renderDirect (in-memory rendering)", () => {
+  test("9.1 Render primitive value without store", () => {
+    const fakeTypeHash = "0000000000000" as Hash;
+    const output = renderDirect(fakeTypeHash, "hello world", null, null);
+    expect(output.trim()).toBe("hello world");
+  });
+
+  test("9.2 Render object value without store", () => {
+    const fakeTypeHash = "0000000000000" as Hash;
+    const output = renderDirect(
+      fakeTypeHash,
+      {
+        name: "Alice",
+        age: 30,
+      },
+      null,
+      null,
+    );
+    expect(output).toContain("name: Alice");
+    expect(output).toContain("age: 30");
+  });
+
+  test("9.3 Render array value without store", () => {
+    const fakeTypeHash = "0000000000000" as Hash;
+    const output = renderDirect(fakeTypeHash, ["a", "b", "c"], null, null);
+    expect(output).toContain("-");
+    expect(output).toContain("a");
+    expect(output).toContain("b");
+    expect(output).toContain("c");
+  });
+
+  test("9.4 Render nested object without store", () => {
+    const fakeTypeHash = "0000000000000" as Hash;
+    const output = renderDirect(
+      fakeTypeHash,
+      {
+        user: { name: "Bob", role: "admin" },
+        active: true,
+      },
+      null,
+      null,
+    );
+    expect(output).toContain("name: Bob");
+    expect(output).toContain("role: admin");
+    expect(output).toContain("active: true");
+  });
+
+  test("9.5 Render with store expands cas_ref fields", async () => {
+    const store = createMemoryStore();
+    await bootstrap(store);
+
+    // Create a child node
+    const childSchema = await putSchema(store, {
+      type: "object",
+      properties: { msg: { type: "string" } },
+    });
+    const childHash = await store.put(childSchema, { msg: "inner" });
+
+    // Parent schema with cas_ref
+    const parentSchema = await putSchema(store, {
+      type: "object",
+      properties: {
+        child: { type: "string", format: "cas_ref" },
+      },
+    });
+
+    // Render directly with store — cas_ref should expand
+    const output = renderDirect(
+      parentSchema,
+      { child: childHash },
+      store,
+      null,
+    );
+    expect(output).toContain("msg: inner");
+  });
+
+  test("9.6 Render with resolution/decay options", () => {
+    const fakeTypeHash = "0000000000000" as Hash;
+    const output = renderDirect(fakeTypeHash, { key: "value" }, null, {
+      resolution: 0.5,
+      decay: 0.8,
+    });
+    expect(output).toContain("key: value");
+  });
+
+  test("9.7 Validate parameters", () => {
+    const fakeTypeHash = "0000000000000" as Hash;
+    expect(() =>
+      renderDirect(fakeTypeHash, "x", null, { resolution: 2 }),
+    ).toThrow("resolution must be in [0, 1]");
+    expect(() => renderDirect(fakeTypeHash, "x", null, { decay: 0 })).toThrow(
+      "decay must be in (0, 1]",
+    );
+    expect(() =>
+      renderDirect(fakeTypeHash, "x", null, { epsilon: -1 }),
+    ).toThrow("epsilon must be >= 0");
+  });
+
+  test("9.8 Render null value", () => {
+    const fakeTypeHash = "0000000000000" as Hash;
+    const output = renderDirect(fakeTypeHash, null, null, null);
+    expect(output.trim()).toBe("null");
+  });
+
+  test("9.9 cas_ref without store renders as cas: reference", () => {
+    // Without store, can't identify cas_ref fields — hash strings stay as strings
+    const fakeTypeHash = "0000000000000" as Hash;
+    const someHash = "ABCDEFGH12345" as Hash;
+    const output = renderDirect(fakeTypeHash, { ref: someHash }, null, null);
+    // Without store, it's just a string value
+    expect(output).toContain(`ref: ${someHash}`);
+  });
+
+  test("9.10 store present but schema missing — renders without ref expansion", async () => {
+    const store = createMemoryStore();
+    await bootstrap(store);
+    const unknownType = "ZZZZZZZZZZZZ0" as Hash;
+    const output = renderDirect(unknownType, { key: "val" }, store, null);
+    expect(output).toContain("key: val");
+  });
+});
+
+describe("Suite 10: Missing Root Hash Error Handling (Issue #53)", () => {
+  test("10.1 renderAsync() throws CasNodeNotFoundError for missing root hash", async () => {
+    const store = createMemoryStore();
+    await bootstrap(store);
+    const fakeHash = "AAAAAAAAAAAAA" as Hash;
+
+    await expect(renderAsync(store, fakeHash)).rejects.toThrow(
+      CasNodeNotFoundError,
+    );
+    await expect(renderAsync(store, fakeHash)).rejects.toThrow(
+      "CAS node not found",
+    );
+    await expect(renderAsync(store, fakeHash)).rejects.toThrow(fakeHash);
+  });
+
+  test("10.2 render() throws CasNodeNotFoundError for missing root hash", () => {
+    const store = createMemoryStore();
+    const fakeHash = "ZZZZZZZZZZZZZ" as Hash;
+
+    expect(() => render(store, fakeHash)).toThrow(CasNodeNotFoundError);
+    expect(() => render(store, fakeHash)).toThrow("CAS node not found");
+    expect(() => render(store, fakeHash)).toThrow(fakeHash);
+  });
+
+  test("10.3 renderDirect() does NOT throw for non-existent type hash", () => {
+    const store = createMemoryStore();
+    const fakeTypeHash = "0000000000000" as Hash;
+    const output = renderDirect(fakeTypeHash, { key: "value" }, store, null);
+
+    expect(output).toContain("key: value");
+  });
+
+  test("10.4 Missing nested node renders as cas: reference (no error)", async () => {
+    const store = createMemoryStore();
+    await bootstrap(store);
+
+    const parentSchema = await putSchema(store, {
+      type: "object",
+      properties: {
+        title: { type: "string" },
+        child: { type: "string", format: "cas_ref" },
+      },
+    });
+
+    const fakeChildHash = "ZZZZZZZZZZZZZ" as Hash;
+    const parentHash = await store.put(parentSchema, {
+      title: "root",
+      child: fakeChildHash,
+    });
+
+    const output = render(store, parentHash);
+
+    expect(output).toContain("title: root");
+    expect(output).toContain(`cas:${fakeChildHash}`);
+  });
+
+  test("10.5 Resolution below epsilon renders as cas: reference (no error)", async () => {
+    const store = createMemoryStore();
+    await bootstrap(store);
+
+    const nodeSchema = await putSchema(store, {
+      type: "object",
+      properties: {
+        level: { type: "number" },
+        next: {
+          anyOf: [{ type: "string", format: "cas_ref" }, { type: "null" }],
+        },
+      },
+    });
+
+    // Create 3-level chain
+    let currentHash: Hash | null = null;
+    for (let i = 2; i >= 0; i--) {
+      currentHash = await store.put(nodeSchema, {
+        level: i,
+        next: currentHash,
+      });
+    }
+
+    const output = render(store, currentHash as Hash, {
+      resolution: 1.0,
+      decay: 0.1,
+      epsilon: 0.5,
+    });
+
+    // Level 0 should be expanded (resolution = 1.0 > 0.5)
+    expect(output).toContain("level: 0");
+    // Level 1+ should be cas: references (0.1, 0.01 < 0.5)
+    expect(output).toContain("cas:");
+  });
+});
@@ -1,7 +1,8 @@
 import { renderWithTemplate } from "./liquid-render.js";
-import { putSchema, refs } from "./schema.js";
+import { collectRefs, getSchema, putSchema, refs } from "./schema.js";
 import type { Hash, Store } from "./types.js";
 import type { VariableStore } from "./variable-store.js";
+import { CasNodeNotFoundError } from "./variable-store.js";

 export type RenderOptions = {
  resolution?: number; // (0, 1], default 1.0
@@ -16,6 +17,32 @@ const DEFAULT_EPSILON = 0.01;
 // Small tolerance for floating point comparison
 const FLOAT_TOLERANCE = 1e-10;

+/**
+ * Extract and validate resolution/decay/epsilon from options.
+ */
+function validateAndExtractOptions(
+  options:
+    | Pick<RenderOptions, "resolution" | "decay" | "epsilon">
+    | null
+    | undefined,
+): { resolution: number; decay: number; epsilon: number } {
+  const resolution = options?.resolution ?? DEFAULT_RESOLUTION;
+  const decay = options?.decay ?? DEFAULT_DECAY;
+  const epsilon = options?.epsilon ?? DEFAULT_EPSILON;
+
+  if (resolution < 0 || resolution > 1) {
+    throw new Error("resolution must be in [0, 1]");
+  }
+  if (decay <= 0 || decay > 1) {
+    throw new Error("decay must be in (0, 1]");
+  }
+  if (epsilon < 0) {
+    throw new Error("epsilon must be >= 0");
+  }
+
+  return { resolution, decay, epsilon };
+}
+
 /**
 * Render a CAS node as YAML with resolution-based decay.
 * When resolution ≤ epsilon, nodes are rendered as opaque `cas:<hash>` references.
@@ -27,19 +54,11 @@ export function render(
  hash: Hash,
  options?: RenderOptions,
 ): string {
-  const resolution = options?.resolution ?? DEFAULT_RESOLUTION;
-  const decay = options?.decay ?? DEFAULT_DECAY;
-  const epsilon = options?.epsilon ?? DEFAULT_EPSILON;
+  const { resolution, decay, epsilon } = validateAndExtractOptions(options);

-  // Validate parameters
-  if (resolution < 0 || resolution > 1) {
-    throw new Error("resolution must be in [0, 1]");
-  }
-  if (decay <= 0 || decay > 1) {
-    throw new Error("decay must be in (0, 1]");
-  }
-  if (epsilon < 0) {
-    throw new Error("epsilon must be >= 0");
+  // Check if root node exists
+  if (store.get(hash) === null) {
+    throw new CasNodeNotFoundError(hash);
  }

  const visited = new Set<Hash>();
@@ -56,22 +75,15 @@ export async function renderAsync(
  hash: Hash,
  options?: RenderOptions,
 ): Promise<string> {
-  const resolution = options?.resolution ?? DEFAULT_RESOLUTION;
-  const decay = options?.decay ?? DEFAULT_DECAY;
-  const epsilon = options?.epsilon ?? DEFAULT_EPSILON;
-  const varStore = options?.varStore;
+  const { resolution, decay, epsilon } = validateAndExtractOptions(options);

-  // Validate parameters
-  if (resolution < 0 || resolution > 1) {
-    throw new Error("resolution must be in [0, 1]");
-  }
-  if (decay <= 0 || decay > 1) {
-    throw new Error("decay must be in (0, 1]");
-  }
-  if (epsilon < 0) {
-    throw new Error("epsilon must be >= 0");
+  // Check if root node exists
+  if (store.get(hash) === null) {
+    throw new CasNodeNotFoundError(hash);
  }

+  const varStore = options?.varStore;
+
  // If varStore provided, try template rendering first
  if (varStore !== undefined) {
    try {
@@ -97,6 +109,43 @@ export async function renderAsync(
  return renderNode(store, hash, resolution, decay, epsilon, visited);
 }

+/**
+ * Render a value directly (in-memory) without requiring it to be stored.
+ * Accepts a raw { type, value } pair. Store is optional and read-only —
+ * used only for schema lookup and expanding nested cas_ref references.
+ * No data is written to the store.
+ */
+export function renderDirect(
+  typeHash: Hash,
+  value: unknown,
+  store: Store | null,
+  options: Omit<RenderOptions, "varStore"> | null,
+): string {
+  const { resolution, decay, epsilon } = validateAndExtractOptions(options);
+
+  // Try to get schema from store to identify cas_ref fields
+  let refSet = new Set<Hash>();
+  if (store !== null) {
+    const schema = getSchema(store, typeHash);
+    if (schema !== null) {
+      refSet = new Set(collectRefs(schema, value));
+    }
+  }
+
+  const childResolution = resolution * decay;
+  const visited = new Set<Hash>();
+
+  return renderValue(
+    store ?? null,
+    value,
+    refSet,
+    childResolution,
+    decay,
+    epsilon,
+    visited,
+  );
+}
+
 /**
 * Check if a template exists for a given type
 */
@@ -116,7 +165,7 @@ async function hasTemplate(
 }

 function renderNode(
-  store: Store,
+  store: Store | null,
  hash: Hash,
  currentResolution: number,
  decay: number,
@@ -129,7 +178,7 @@ function renderNode(
  }

  // Fetch the node
-  const node = store.get(hash);
+  const node = store !== null ? store.get(hash) : null;
  if (node === null) {
    // Missing node - render as cas: reference
    return `cas:${hash}`;
@@ -142,7 +191,7 @@ function renderNode(
  visited.add(hash);

  // Get references from this node's schema
-  const nodeRefs = refs(store, node);
+  const nodeRefs = store !== null ? refs(store, node) : [];
  const refSet = new Set(nodeRefs);

  // Calculate child resolution for next level
@@ -165,7 +214,7 @@ function renderNode(
 }

 function renderValue(
-  store: Store,
+  store: Store | null,
  value: unknown,
  refHashes: Set<Hash>,
  childResolution: number,
@@ -388,6 +388,107 @@ describe("bootstrap meta-schema self-reference", () => {
    expect(dataNode.type).not.toBe(metaHash);
  });

+  // ── P1 leaf constraints ──────────────────────────────────────────────────
+
+  test("accepts schema with numeric constraints (minimum/maximum)", async () => {
+    const store = createMemoryStore();
+    const hash = await putSchema(store, {
+      type: "number",
+      minimum: 0,
+      maximum: 100,
+      exclusiveMinimum: -1,
+      exclusiveMaximum: 101,
+    });
+    expect(hash).toHaveLength(13);
+
+    // validate a conforming payload
+    const nodeHash = await store.put(hash, 42);
+    const node = store.get(nodeHash) as CasNode;
+    expect(validate(store, node)).toBe(true);
+
+    // validate a non-conforming payload
+    const badHash = await store.put(hash, 200);
+    const badNode = store.get(badHash) as CasNode;
+    expect(validate(store, badNode)).toBe(false);
+  });
+
+  test("accepts schema with string constraints (minLength/maxLength/pattern)", async () => {
+    const store = createMemoryStore();
+    const hash = await putSchema(store, {
+      type: "string",
+      minLength: 1,
+      maxLength: 10,
+      pattern: "^[a-z]+$",
+    });
+    expect(hash).toHaveLength(13);
+
+    const goodHash = await store.put(hash, "hello");
+    expect(validate(store, store.get(goodHash) as CasNode)).toBe(true);
+
+    const badHash = await store.put(hash, "HELLO");
+    expect(validate(store, store.get(badHash) as CasNode)).toBe(false);
+  });
+
+  test("accepts schema with array constraints (minItems/maxItems/uniqueItems)", async () => {
+    const store = createMemoryStore();
+    const hash = await putSchema(store, {
+      type: "array",
+      items: { type: "number" },
+      minItems: 1,
+      maxItems: 3,
+      uniqueItems: true,
+    });
+    expect(hash).toHaveLength(13);
+
+    const goodHash = await store.put(hash, [1, 2, 3]);
+    expect(validate(store, store.get(goodHash) as CasNode)).toBe(true);
+
+    const tooMany = await store.put(hash, [1, 2, 3, 4]);
+    expect(validate(store, store.get(tooMany) as CasNode)).toBe(false);
+
+    const dupes = await store.put(hash, [1, 1]);
+    expect(validate(store, store.get(dupes) as CasNode)).toBe(false);
+  });
+
+  test("rejects schema with wrong constraint types", async () => {
+    const store = createMemoryStore();
+    await expect(
+      putSchema(store, { type: "number", minimum: "zero" } as never),
+    ).rejects.toThrow();
+    await expect(
+      putSchema(store, { type: "string", maxLength: true } as never),
+    ).rejects.toThrow();
+    await expect(
+      putSchema(store, { type: "array", uniqueItems: 1 } as never),
+    ).rejects.toThrow();
+  });
+
+  test("accepts schema with nested property constraints", async () => {
+    const store = createMemoryStore();
+    const hash = await putSchema(store, {
+      type: "object",
+      properties: {
+        name: { type: "string", minLength: 1, maxLength: 50 },
+        age: { type: "number", minimum: 0, maximum: 150 },
+        scores: {
+          type: "array",
+          items: { type: "number" },
+          minItems: 1,
+          uniqueItems: true,
+        },
+      },
+      required: ["name"],
+    });
+    expect(hash).toHaveLength(13);
+
+    const good = await store.put(hash, {
+      name: "Alice",
+      age: 30,
+      scores: [95, 87],
+    });
+    expect(validate(store, store.get(good) as CasNode)).toBe(true);
+  });
+
  test("bootstrap is idempotent across putSchema calls", async () => {
    const store = createMemoryStore();
    const builtinSchemas = await bootstrap(store);
@@ -35,6 +35,17 @@ const ALLOWED_SCHEMA_KEYS = new Set([
  "enum",
  "const",
  "description",
+  // P1 leaf constraints (no collectRefs impact)
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "minItems",
+  "maxItems",
+  "uniqueItems",
 ]);

 const JSON_SCHEMA_TYPES = new Set([
@@ -126,6 +137,29 @@ function isValidSchema(value: unknown): boolean {
    if (!Array.isArray(schema.enum) || schema.enum.length === 0) return false;
  }

+  // P1 leaf constraints — type checks only
+  if ("minimum" in schema && typeof schema.minimum !== "number") return false;
+  if ("maximum" in schema && typeof schema.maximum !== "number") return false;
+  if (
+    "exclusiveMinimum" in schema &&
+    typeof schema.exclusiveMinimum !== "number"
+  )
+    return false;
+  if (
+    "exclusiveMaximum" in schema &&
+    typeof schema.exclusiveMaximum !== "number"
+  )
+    return false;
+  if ("minLength" in schema && typeof schema.minLength !== "number")
+    return false;
+  if ("maxLength" in schema && typeof schema.maxLength !== "number")
+    return false;
+  if ("pattern" in schema && typeof schema.pattern !== "string") return false;
+  if ("minItems" in schema && typeof schema.minItems !== "number") return false;
+  if ("maxItems" in schema && typeof schema.maxItems !== "number") return false;
+  if ("uniqueItems" in schema && typeof schema.uniqueItems !== "boolean")
+    return false;
+
  return true;
 }

@@ -186,7 +220,7 @@ export function validate(store: Store, node: CasNode): boolean {
 * Handles: direct format, anyOf (nullable refs), items (array refs),
 * properties (nested objects), and additionalProperties (record refs).
 */
-function collectRefs(schema: JSONSchema, value: unknown): Hash[] {
+export function collectRefs(schema: JSONSchema, value: unknown): Hash[] {
  const result: Hash[] = [];

  if (schema.format === "cas_ref") {
@@ -36,8 +36,11 @@ export class SchemaMismatchError extends Error {
 }

 export class CasNodeNotFoundError extends Error {
-  constructor(hash: string) {
-    super(`CAS node not found: ${hash}`);
+  constructor(
+    public readonly hash: string,
+    message?: string,
+  ) {
+    super(message ?? `CAS node not found: ${hash}`);
    this.name = "CasNodeNotFoundError";
  }
 }
@@ -0,0 +1,85 @@
+import { describe, expect, test } from "bun:test";
+import { bootstrap } from "./bootstrap.js";
+import { createMemoryStore } from "./store.js";
+import { wrapEnvelope } from "./wrap-envelope.js";
+
+describe("wrapEnvelope", () => {
+  test("resolves @output/put alias and returns envelope", async () => {
+    const store = createMemoryStore();
+    const aliases = await bootstrap(store);
+
+    const envelope = await wrapEnvelope(store, "@output/put", "AAAAAAAAAAAAA");
+
+    expect(envelope.type).toBe(aliases["@output/put"]);
+    expect(envelope.value).toBe("AAAAAAAAAAAAA");
+  });
+
+  test("resolves @output/has alias with boolean value", async () => {
+    const store = createMemoryStore();
+    const aliases = await bootstrap(store);
+
+    const envelope = await wrapEnvelope(store, "@output/has", true);
+
+    expect(envelope.type).toBe(aliases["@output/has"]);
+    expect(envelope.value).toBe(true);
+  });
+
+  test("resolves @output/gc alias with object value", async () => {
+    const store = createMemoryStore();
+    const aliases = await bootstrap(store);
+
+    const gcStats = { total: 100, reachable: 80, collected: 20, scanned: 5 };
+    const envelope = await wrapEnvelope(store, "@output/gc", gcStats);
+
+    expect(envelope.type).toBe(aliases["@output/gc"]);
+    expect(envelope.value).toEqual(gcStats);
+  });
+
+  test("resolves primitive alias @string", async () => {
+    const store = createMemoryStore();
+    const aliases = await bootstrap(store);
+
+    const envelope = await wrapEnvelope(store, "@string", "hello");
+
+    expect(envelope.type).toBe(aliases["@string"]);
+    expect(envelope.value).toBe("hello");
+  });
+
+  test("throws for unknown alias", async () => {
+    const store = createMemoryStore();
+    await bootstrap(store);
+
+    await expect(
+      wrapEnvelope(store, "@output/nonexistent", "value"),
+    ).rejects.toThrow("Unknown schema alias: @output/nonexistent");
+  });
+
+  test("is idempotent — same alias returns same type hash", async () => {
+    const store = createMemoryStore();
+
+    const first = await wrapEnvelope(store, "@output/verify", "ok");
+    const second = await wrapEnvelope(store, "@output/verify", "corrupted");
+
+    expect(first.type).toBe(second.type);
+    expect(first.value).toBe("ok");
+    expect(second.value).toBe("corrupted");
+  });
+
+  test("preserves complex object values without mutation", async () => {
+    const store = createMemoryStore();
+    await bootstrap(store);
+
+    const original = {
+      name: "test",
+      schema: "AAAAAAAAAAAAA",
+      value: "BBBBBBBBBBBBB",
+      created: 1000,
+      updated: 2000,
+      tags: { env: "prod" },
+      labels: ["stable"],
+    };
+    const envelope = await wrapEnvelope(store, "@output/var-set", original);
+
+    expect(envelope.value).toEqual(original);
+  });
+});
@@ -0,0 +1,19 @@
+import { bootstrap } from "./bootstrap.js";
+import type { Hash, Store } from "./types.js";
+
+/**
+ * Resolve a schema alias (e.g. "@output/put") to its hash via bootstrap,
+ * then return a typed envelope ready for store.put() or direct rendering.
+ */
+export async function wrapEnvelope(
+  store: Store,
+  schemaAlias: string,
+  value: unknown,
+): Promise<{ type: Hash; value: unknown }> {
+  const aliases = await bootstrap(store);
+  const typeHash = aliases[schemaAlias];
+  if (typeHash === undefined) {
+    throw new Error(`Unknown schema alias: ${schemaAlias}`);
+  }
+  return { type: typeHash, value };
+}
@@ -0,0 +1,8 @@
+#!/bin/bash
+# Prevent publishing packages that still reference workspace:* dependencies
+if grep -q '"workspace:' package.json 2>/dev/null; then
+  echo "❌ Found workspace:* dependencies in package.json — cannot publish directly."
+  echo "   Use 'changeset publish' which resolves workspace protocol automatically."
+  grep '"workspace:' package.json
+  exit 1
+fi
Author	SHA1	Message	Date
xingyue	bdb77fd1e3	feat: put/hash support --pipe/-p to read JSON from stdin (#83 )	2026-06-01 09:50:03 +08:00
xingyue	b7fc03fa16	Merge pull request 'fix: CLI put @schema uses putSchema() for recursive validation (#82 )' (#86 ) from fix/82-meta-schema-nested-validation into main	2026-06-01 01:39:49 +00:00
xiaoju	9367a4141a	fix: CLI put @schema uses putSchema() for recursive validation (#82 ) CLI 'ucas put @schema' now detects meta-schema target and routes through putSchema() which uses isValidSchema() — a proper recursive validator — instead of ajv against the meta-schema (which cannot express recursive constraints for nested property sub-schemas). This fixes the core issue where schemas with typed properties like {"type":"string","minLength":1} were rejected by the CLI path. Added CLI E2E test: put @schema with nested constraints (minLength, maximum, uniqueItems). 494 tests, 0 fail. Refs #82	2026-06-01 01:35:40 +00:00
xingyue	bfec74fe8e	Merge pull request 'feat: support P1 leaf JSON Schema constraints (#82 )' (#84 ) from feat/82-schema-p1-leaf-constraints into main	2026-06-01 01:26:50 +00:00
xiaoju	70af05adf5	feat: support P1 leaf JSON Schema constraints (#82 ) Add 10 new schema keywords to whitelist + meta-schema: - numeric: minimum, maximum, exclusiveMinimum, exclusiveMaximum - string: minLength, maxLength, pattern - array: minItems, maxItems, uniqueItems These are pure leaf constraints with no collectRefs() impact. 5 new tests covering validation, rejection, and nested usage. Refs #82	2026-06-01 01:14:02 +00:00
xiaoju	ceba0b5d43	chore: add prepublishOnly workspace:* guard Checks for unresolved workspace:* dependencies before publish. Changesets resolves these automatically, so normal release flow passes through. Direct npm publish with workspace deps is blocked.	2026-05-31 23:43:51 +00:00
xiaoju	a050160bee	chore: remove prepublishOnly guards Changesets already handles workspace:* → real version resolution during publish. The guard scripts are unnecessary and block the release flow.	2026-05-31 23:33:58 +00:00
xiaoju	515f4d32f9	chore: version 0.6.0 — unified envelope output (RFC #67 )	2026-05-31 23:24:59 +00:00
xiaoju	c03180e66c	Merge pull request 'feat: wrap template commands with envelope, update docs (Phase 4)' (#81 ) from fix/72-template-envelope into main	2026-05-31 16:00:32 +00:00
xiaoju	9090456ed2	feat: wrap template commands with envelope, update docs (Phase 4) Fixes #72	2026-05-31 16:00:21 +00:00
xiaoju	15ffff1fd4	Merge pull request 'feat: wrap refs/walk/gc/var with envelope (Phase 3)' (#80 ) from fix/71-refs-walk-var-envelope into main	2026-05-31 15:41:08 +00:00
xiaoju	d2b9dee4b9	feat: wrap refs/walk/gc/var with {type,value} envelope (Phase 3) Fixes #71	2026-05-31 15:41:02 +00:00
xiaoju	547c45829f	Merge pull request 'feat: wrap simple commands with envelope (Phase 2)' (#79 ) from fix/70-simple-envelope into main	2026-05-31 15:29:54 +00:00
xiaoju	d328fbe6e4	feat: wrap put/get/has/hash/verify/list with {type,value} envelope (Phase 2) Fixes #70	2026-05-31 15:29:49 +00:00
xiaoju	11bb6b3e32	Merge pull request 'feat: register 18 @output/* schemas, default templates, wrapEnvelope (Phase 1c)' (#78 ) from fix/75-output-schemas into main	2026-05-31 15:14:49 +00:00
xiaoju	0dca8a5521	feat: register 18 @output/* schemas, default templates, wrapEnvelope (Phase 1c) Fixes #75	2026-05-31 15:14:28 +00:00
xiaoju	5aad956c83	Merge pull request 'feat: remove cat/schema commands, add list --type, enhance verify (Phase 1b)' (#77 ) from fix/74-remove-cat-schema into main	2026-05-31 14:52:36 +00:00
xiaoju	038c901f4b	feat: remove cat/schema commands, add list --type, enhance verify (Phase 1b) Fixes #74	2026-05-31 14:41:38 +00:00
xiaoju	f4cf92e128	Merge pull request 'feat: auto-bootstrap CAS store on open (Phase 1a)' (#76 ) from fix/73-auto-bootstrap into main feat: auto-bootstrap CAS store on open (Phase 1a) Fixes #73	2026-05-31 13:40:43 +00:00
xiaoju	c8bf38cb81	feat: auto-bootstrap CAS store on open (Phase 1a) Changes: 1. openStore() now async, auto-creates directory and bootstraps 2. Removed shouldCreate parameter and validateStoreExists() 3. All openStore() calls now awaited 4. Deleted init and bootstrap commands 5. Removed Issue #55 store validation tests (superseded by auto-bootstrap) 6. Enhanced error handling in openStore() for permission/path issues 7. Updated e2e snapshots after fixing missed await in cmdRender Bootstrap is idempotent. Core tests using createMemoryStore() unaffected. Fixes #73 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-05-31 13:34:43 +00:00
xingyue	b93d7b229a	Merge pull request 'feat(cli): convert e2e-check scenarios to snapshot fixture tests' (#68 ) from fix/66-e2e-snapshot-tests into main	2026-05-31 11:43:32 +00:00
xingyue	9912013b0a	fix(cli): use dot notation for GC result assertions (Biome lint) Co-Authored-By: Claude Sonnet 4 <noreply@anthropic.com>	2026-05-31 19:30:31 +08:00
xingyue	2ed097e207	fix(cli): make e2e snapshots stable across machines and runs - Strip volatile fields (timestamp, created, updated) from JSON before snapshotting using a stripVolatile helper - Remove toMatchSnapshot() from test 2.1 to avoid embedding machine- specific tmp paths in the snapshot; use toContain assertions instead - Replace GC count snapshot with structural shape assertions so counts don't need to match exact phase-history state Co-Authored-By: Claude Sonnet 4 <noreply@anthropic.com>	2026-05-31 19:29:25 +08:00
xingyue	b0d5b05457	feat(cli): add e2e snapshot fixture tests for all CLI scenarios Convert 46 e2e-check workflow scenarios to fast bun test snapshot tests. 7 describe phases share a single mkdtempSync store; hashes are deterministic so cross-phase data dependencies work without re-creating data. Closes #66 Co-Authored-By: Claude Sonnet 4 <noreply@anthropic.com>	2026-05-31 19:24:17 +08:00
xiaomo	de20cfde53	Merge pull request 'refactor: e2e-check workflow 拆分为 4 角色' (#64 ) from fix/e2e-check-role-split into main	2026-05-31 10:58:50 +00:00
xingyue	9948db77ea	refactor: split e2e-check workflow into 4 roles - preparer: Docker setup, install, build, lint, unit test, init store - tester: pure CLI scenario testing (receives container + store path) - reporter: file Gitea issues (triggered by bugs or setup failures) - cleanup: stop and remove Docker container Also fixes template variable prefix (payload.name vs name).	2026-05-31 18:23:34 +08:00
xiaomo	c60f05f650	Merge pull request 'fix: validate store directory exists before CLI operations' (#63 ) from fix/55-store-path-validation-rebase into main	2026-05-31 09:20:41 +00:00
xiaoju	314b076c05	fix: validate store path before read operations (Fixes #55 ) - Add validateStoreExists() helper to check store directory existence - Modify openStore() to accept shouldCreate parameter (default: false) - Update read commands to validate store exists first - Update write commands (init, put, schema put, hash) to allow creation - Add 10 E2E tests covering all affected commands - Improve error message: "Store not found at <path>" vs "Node not found" Commands that now validate: - get, has, verify, refs, walk, cat - schema get, schema list Commands that still create: - init, put, schema put, hash - var commands (use openVarStore) Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-05-31 09:19:23 +00:00
xiaomo	664409b94a	Merge pull request 'fix: workflow frontmatter schema 加 type: object' (#56 ) from fix/workflow-frontmatter-schema into main	2026-05-31 09:16:53 +00:00
xingyue	f3f13e6f35	fix: add type: object to all oneOf variants in workflow frontmatter schemas ajv strict mode requires explicit type: object when properties/required are used. All three workflow YAMLs had this missing, causing frontmatter validation to fail with: strict mode: missing type "object" for keyword "required" Also added frontmatter output example in e2e-check.yaml procedure to prevent agents from outputting bugs as plain strings instead of objects.	2026-05-31 17:15:43 +08:00
xiaomo	10c5c8f98e	Merge pull request 'fix: clean error message for invalid schema in schema put command' (#61 ) from fix/54-schema-put-invalid-error into main	2026-05-31 09:15:37 +00:00
xiaomo	d28003779e	Merge pull request 'fix: detect missing root hash in render command' (#60 ) from fix/53-render-missing-hash-error into main	2026-05-31 09:15:35 +00:00
xiaomo	885a8e1147	Merge pull request 'test: add E2E template variable rendering tests' (#59 ) from fix/52-template-variable-rendering into main	2026-05-31 09:15:33 +00:00
xiaomo	f0ffe6b234	Merge pull request 'fix: validate payload against schema in put command' (#57 ) from fix/50-schema-validation into main	2026-05-31 09:15:28 +00:00
xiaoju	fc869cfc99	fix: resolve test failures for issue #53 Applied tester feedback to fix 5 test failures: 1. Updated error message format from "Node not found" to "CAS node not found" for consistency with existing tests in variable-store.test.ts and var.test.ts 2. Fixed CLI tests R9 and R10 to use bootstrap() directly instead of non-existent "types" command. Added imports for bootstrap and createFsStore. 3. Fixed render test 6.5 to pass actual schema Hash instead of entire bootstrap object (Record<string, Hash>) 4. Updated test expectations in render.test.ts (tests 1.5, 10.1, 10.2) to match new error message format All 390 tests now pass. Core functionality verified: - Missing root hash detection working correctly - CLI exits with code 1 on missing hash - Error message includes hash: "CAS node not found: <hash>" - Nested nodes still render as cas: references (preserved behavior) - Resolution decay behavior preserved Fixes #53 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-05-31 08:36:19 +00:00
xiaoju	7fd2013ef2	fix: validate payload against schema in put command Add schema validation to the `json-cas put` command to ensure data integrity. The CLI now validates the payload against the specified schema before storing, and exits with a non-zero code and descriptive error message if validation fails. Changes: - Add schema existence check in cmdPut() - Add payload validation before storing - Exit with error code 1 on validation failure - Provide helpful error messages indicating the file and schema - Add comprehensive test suite with 16 test scenarios covering: - Valid data (regression tests) - Type mismatches (new validation) - Schema errors (edge cases) - Integration with existing features - Error message quality The hash command continues to work without validation (dry-run consistency), and schema put continues to use its own validation. Fixes #50 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-05-31 08:24:13 +00:00
xiaoju	0b72c9400f	style: apply biome formatting fixes Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-05-31 08:21:10 +00:00
xiaoju	eb36c16420	fix: detect missing root hash in render command and exit with error When rendering a non-existent hash, the CLI now exits with code 1 and displays an error message instead of silently outputting "cas:<hash>" with exit code 0. Changes: - Updated CasNodeNotFoundError constructor signature to store hash - Added root hash existence check in render() and renderAsync() - Updated CLI error handling to catch CasNodeNotFoundError - Added comprehensive test suite for missing hash error handling - Updated existing incorrect tests (R2 and test 1.5) The fix distinguishes between: - Root hash (user-requested): Must exist or throw error - Nested hash (during traversal): Renders as cas: reference (existing behavior) - Resolution below epsilon: Renders as cas: reference (existing behavior) Fixes #53 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-05-31 08:18:15 +00:00
xiaoju	3c8b16d7b1	fix: clean error message for invalid schema in `schema put` command Fixes #54 The `json-cas schema put` command now catches SchemaValidationError and displays a clean error message instead of showing a raw stack trace. Changes: - Import SchemaValidationError from @uncaged/json-cas - Wrap putSchema() call in try-catch in cmdSchemaPut - Catch SchemaValidationError specifically and call die(e.message) - Add 5 comprehensive tests for invalid schema error handling Test cases: 1. Invalid JSON Schema type value 2. Unknown schema keys 3. Invalid nested schema 4. Non-object root schema 5. Valid schema regression test Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-05-31 08:14:23 +00:00
xiaoju	51e81c7b99	test: add E2E template variable rendering tests for issue #52 Add comprehensive test suite (Suite 9 and 10) covering template variable rendering: - Suite 9: E2E Template Variable Rendering (12 tests) - Tests correct {{ payload.* }} syntax vs incorrect direct property access - Tests primitive payloads (string, number) - Tests nested objects, arrays, null values, booleans - Tests edge cases: empty strings, zero values, special characters - Validates CLI integration flow - Suite 10: Context Variable Completeness (2 tests) - Verifies context propagation through recursive renders - Tests context isolation between parent and child nodes All tests pass. Confirms the renderNode function correctly passes node.payload to template context. Issue #52 was user error - templates require {{ payload.name }} syntax, not {{ name }}. Fixes #52 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-05-31 08:13:36 +00:00
xiaomo	2932aa5980	Merge pull request 'feat: ucas render --pipe/-p for stdin { type, value } input' (#49 ) from feat/48-render-pipe into main	2026-05-31 07:47:01 +00:00
xiaoju	a0d7b67923	fix: address PR #49 review feedback - Convention: renderDirect uses Store \| null, options \| null (no ?:) - Validation: hash format check (13-char Crockford Base32) on stdin input - DRY: remove collectRefsFromSchema, import collectRefs from schema.ts - DRY: extract validateAndExtractOptions shared by render/renderAsync/renderDirect - stdin: use process.stdin async iteration instead of /dev/stdin - UX: error on --pipe + hash conflict instead of silent ignore - Tests: add 9.10 (store present, schema missing)	2026-05-31 07:43:25 +00:00
xiaoju	7b29fe777c	chore: remove stale temp files	2026-05-31 07:34:16 +00:00
xiaoju	64b8a88bdc	feat: add renderDirect() and ucas render --pipe/-p In-memory rendering of { type, value } envelopes without store writes. Store is optional and read-only (for expanding nested cas_ref references). CLI: ucas render --pipe/-p reads JSON from stdin. Core: renderDirect(typeHash, value, store?, options?) for programmatic use. Fixes #48	2026-05-31 07:34:07 +00:00
xiaoju	4717024e9b	Merge pull request 'chore: Phase 4 cleanup — dedupe types, remove unused params, fix tests' (#47 ) from fix/46-phase4-cleanup into main	2026-05-31 07:19:42 +00:00
xiaoju	1e5f4b7c46	chore: Phase 4 cleanup — dedupe RenderOptions, remove unused param, fix test numbering 1. Deduplicate RenderOptions type - Remove duplicate definition from liquid-render.ts - Import from render.ts instead (canonical location) 2. Remove unused _globalDecay parameter - Remove from renderNode function signature - Update all call sites 3. Fix test numbering gaps - Suite 4: Renumber 4.4→4.2, 4.5→4.3 - Suite 7→6: Renumber 7.1→6.1, 7.2→6.2, 7.4→6.3 - Suite 8→7: Renumber all 8.x→7.x tests - Suite 10→8: Renumber 10.1→8.1 - Result: consecutive suite numbering (1-8) 4. CLI test status: All 95 tests pass (no pre-existing failures found) Fixes #46 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-05-31 07:11:44 +00:00
xiaoju	0a761f5289	Merge pull request 'feat: LiquidJS template rendering integration (#40 )' (#45 ) from fix/40-liquidjs-integration into main	2026-05-31 06:08:31 +00:00