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
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: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 · 2026-05-31 23:33:58 +00:00 · 2026-05-31 23:24:59 +00:00
17 changed files with 760 additions and 322 deletions
@@ -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"
  }
 }
@@ -2,66 +2,78 @@

 exports[`Phase 1: CAS Core 1.6 get returns node JSON (snapshot) 1`] = `
 {
-  "type": "ASE7K6A0HG8W9",
+  "type": "2NHHHE9NR0FVT",
  "value": {
    "payload": {
      "age": 30,
      "name": "Alice",
    },
-    "type": "7XX5H51CVD9H0",
+    "type": "3K9ETAPGFPE32",
  },
 }
 `;

 exports[`Phase 1: CAS Core 1.9 verify returns ok for valid node 1`] = `
 {
-  "type": "8E2M8H30BHXS8",
+  "type": "BZ3TV0PTATA52",
  "value": "ok",
 }
 `;

-exports[`Phase 1: CAS Core 1.10 refs lists direct references (snapshot) 1`] = `""`;
+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`] = `"ERARPP19YJT05"`;
+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": "E1D32N3GT69Q8",
+  "type": "EMX6HW4CECBGK",
  "value": {
    "labels": [],
    "name": "myapp/config",
-    "schema": "7XX5H51CVD9H0",
+    "schema": "3K9ETAPGFPE32",
    "tags": {},
-    "value": "ERARPP19YJT05",
+    "value": "A0QKG4ERMXSFG",
  },
 }
 `;

 exports[`Phase 3: Variable System 3.2 var get returns variable 1`] = `
 {
-  "type": "E1D32N3GT69Q8",
+  "type": "F68GWJAT9H6HP",
  "value": {
    "labels": [],
    "name": "myapp/config",
-    "schema": "7XX5H51CVD9H0",
+    "schema": "3K9ETAPGFPE32",
    "tags": {},
-    "value": "ERARPP19YJT05",
+    "value": "A0QKG4ERMXSFG",
  },
 }
 `;

 exports[`Phase 3: Variable System 3.3 var list shows all variables 1`] = `
 {
-  "type": "E1D32N3GT69Q8",
+  "type": "A4TV1FVBBNG5M",
  "value": [
    {
      "labels": [],
      "name": "myapp/config",
-      "schema": "7XX5H51CVD9H0",
+      "schema": "3K9ETAPGFPE32",
      "tags": {},
-      "value": "ERARPP19YJT05",
+      "value": "A0QKG4ERMXSFG",
    },
  ],
 }
@@ -69,14 +81,14 @@ exports[`Phase 3: Variable System 3.3 var list shows all variables 1`] = `

 exports[`Phase 3: Variable System 3.4 var list prefix filters by prefix 1`] = `
 {
-  "type": "E1D32N3GT69Q8",
+  "type": "A4TV1FVBBNG5M",
  "value": [
    {
      "labels": [],
      "name": "myapp/config",
-      "schema": "7XX5H51CVD9H0",
+      "schema": "3K9ETAPGFPE32",
      "tags": {},
-      "value": "ERARPP19YJT05",
+      "value": "A0QKG4ERMXSFG",
    },
  ],
 }
@@ -84,48 +96,48 @@ exports[`Phase 3: Variable System 3.4 var list prefix filters by prefix 1`] = `

 exports[`Phase 3: Variable System 3.5 var set upsert updates existing variable 1`] = `
 {
-  "type": "E1D32N3GT69Q8",
+  "type": "EMX6HW4CECBGK",
  "value": {
    "labels": [],
    "name": "myapp/config",
-    "schema": "7XX5H51CVD9H0",
+    "schema": "3K9ETAPGFPE32",
    "tags": {},
-    "value": "F68P1BZ46YDXM",
+    "value": "FNDM9C6P23238",
  },
 }
 `;

 exports[`Phase 3: Variable System 3.6 var tag adds kv tag and label 1`] = `
 {
-  "type": "E1D32N3GT69Q8",
+  "type": "92JS8RXGKDKC2",
  "value": {
    "labels": [
      "important",
    ],
    "name": "myapp/config",
-    "schema": "7XX5H51CVD9H0",
+    "schema": "3K9ETAPGFPE32",
    "tags": {
      "env": "prod",
    },
-    "value": "ERARPP19YJT05",
+    "value": "A0QKG4ERMXSFG",
  },
 }
 `;

 exports[`Phase 3: Variable System 3.7 var list --tag env:prod filters by kv tag 1`] = `
 {
-  "type": "E1D32N3GT69Q8",
+  "type": "A4TV1FVBBNG5M",
  "value": [
    {
      "labels": [
        "important",
      ],
      "name": "myapp/config",
-      "schema": "7XX5H51CVD9H0",
+      "schema": "3K9ETAPGFPE32",
      "tags": {
        "env": "prod",
      },
-      "value": "ERARPP19YJT05",
+      "value": "A0QKG4ERMXSFG",
    },
  ],
 }
@@ -133,18 +145,18 @@ exports[`Phase 3: Variable System 3.7 var list --tag env:prod filters by kv tag

 exports[`Phase 3: Variable System 3.8 var list --tag important filters by label 1`] = `
 {
-  "type": "E1D32N3GT69Q8",
+  "type": "A4TV1FVBBNG5M",
  "value": [
    {
      "labels": [
        "important",
      ],
      "name": "myapp/config",
-      "schema": "7XX5H51CVD9H0",
+      "schema": "3K9ETAPGFPE32",
      "tags": {
        "env": "prod",
      },
-      "value": "ERARPP19YJT05",
+      "value": "A0QKG4ERMXSFG",
    },
  ],
 }
@@ -152,63 +164,77 @@ exports[`Phase 3: Variable System 3.8 var list --tag important filters by label

 exports[`Phase 3: Variable System 3.9 var tag remove deletes label 1`] = `
 {
-  "type": "E1D32N3GT69Q8",
+  "type": "92JS8RXGKDKC2",
  "value": {
    "labels": [],
    "name": "myapp/config",
-    "schema": "7XX5H51CVD9H0",
+    "schema": "3K9ETAPGFPE32",
    "tags": {
      "env": "prod",
    },
-    "value": "ERARPP19YJT05",
+    "value": "A0QKG4ERMXSFG",
  },
 }
 `;

 exports[`Phase 3: Variable System 3.10 var delete removes variable 1`] = `
 {
-  "type": "E1D32N3GT69Q8",
+  "type": "00YH4RTNVWTRB",
  "value": [
    {
      "labels": [],
      "name": "myapp/config",
-      "schema": "7XX5H51CVD9H0",
+      "schema": "3K9ETAPGFPE32",
      "tags": {
        "env": "prod",
      },
-      "value": "ERARPP19YJT05",
+      "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=7XX5H51CVD9H0"`;
+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`] = `
-"{
-  "schemaHash": "7XX5H51CVD9H0",
-  "contentHash": "FC8WACA792B6F"
-}"
+{
+  "type": "DTNQZ90QQHA6D",
+  "value": {
+    "contentHash": "DBBPX5JJ74SWZ",
+    "schemaHash": "3K9ETAPGFPE32",
+  },
+}
 `;

-exports[`Phase 4: Template System 4.2 template get returns template text 1`] = `"Name: {{ payload.name }}, Age: {{ payload.age }}"`;
+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`] = `
-"[
-  {
-    "schemaHash": "7XX5H51CVD9H0",
-    "preview": "Name: {{ payload.name }}, Age: {{ payload.age }}"
-  }
-]"
+{
+  "type": "6RZCT3XX4J8BC",
+  "value": [
+    {
+      "contentHash": "DBBPX5JJ74SWZ",
+      "schemaHash": "3K9ETAPGFPE32",
+    },
+  ],
+}
 `;

 exports[`Phase 4: Template System 4.4 template delete removes template 1`] = `
-"{
-  "deleted": true
-}"
+{
+  "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: 7XX5H51CVD9H0"`;
+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!"`;

@@ -223,27 +249,31 @@ exports[`Phase 7: Edge Cases 7.4 var set name with invalid chars errors 1`] = `"
 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>       Store node, print { type, value } envelope (value=hash)
-  get <hash>                        Print node as { type, value } envelope
-  has <hash>                        Print { type, value } envelope (value=boolean)
-  verify <hash>                     Verify integrity + schema → { type, value } (value=ok/corrupted/invalid)
-  refs <hash>                       List direct cas_ref edges
-  walk <hash> [--format tree]       Recursive traversal
-  hash <type-hash> <file.json>      Compute hash without storing → { type, value } envelope
-  render <hash> [options]           Render node as YAML with resolution decay
-  render --pipe/-p [options]        Render { type, value } from stdin
-  list --type <hash-or-alias>       List hashes for a type → { type, value } envelope (value=string[])
-  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>       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>      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)
@@ -224,6 +224,39 @@ describe("@ Alias Resolution - put", () => {
    expect(exitCode).not.toBe(0);
    expect(stderr.length).toBeGreaterThan(0);
  });
+
+  test("ucas put @schema with nested type constraints should succeed", async () => {
+    await runCliAlias("init");
+
+    const schemaFile = join(testDir, "constrained-schema.json");
+    writeFileSync(
+      schemaFile,
+      JSON.stringify({
+        type: "object",
+        properties: {
+          name: { type: "string", minLength: 1, maxLength: 50 },
+          age: { type: "number", minimum: 0, maximum: 150 },
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            minItems: 1,
+            uniqueItems: true,
+          },
+        },
+        required: ["name"],
+      }),
+    );
+
+    const { stdout, stderr, exitCode } = await runCliAlias(
+      "put",
+      "@schema",
+      schemaFile,
+    );
+
+    expect(exitCode).toBe(0);
+    expect(stderr).toBe("");
+    expect(envValue(stdout)).toMatch(/^[0-9A-HJKMNP-TV-Z]{13}$/);
+  });
 });

 describe("@ Alias Resolution - hash", () => {
@@ -59,6 +59,23 @@ 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", () => {
@@ -336,27 +353,29 @@ describe("Phase 4: Template System", () => {
      tmplFile,
    ]);
    expect(exitCode).toBe(0);
-    expect(stdout).toMatchSnapshot();
+    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(stdout).toBe("Name: {{ payload.name }}, Age: {{ payload.age }}");
-    expect(stdout).toMatchSnapshot();
+    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(stdout).toMatchSnapshot();
+    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(stdout).toMatchSnapshot();
+    expect(stripVolatile(stdout)).toMatchSnapshot();
  });

  test("4.5 template get deleted template returns not found", async () => {
@@ -420,7 +439,7 @@ describe("Phase 6: GC", () => {
    const { exitCode, stdout } = await runCli(["gc"]);
    expect(exitCode).toBe(0);
    // Assert structural shape only — exact counts depend on phase history
-    const result = JSON.parse(stdout) as Record<string, unknown>;
+    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");
@@ -520,3 +539,92 @@ describe("Phase 7: Edge Cases", () => {
    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)");
+  });
+});
@@ -3,7 +3,7 @@
 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,
@@ -145,55 +145,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 = await 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[] }
@@ -237,6 +188,23 @@ async function cmdPut(args: string[]): Promise<void> {
  const payload = readJsonFile(file);
  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) {
@@ -296,9 +264,7 @@ async function cmdRefs(args: string[]): Promise<void> {
  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> {
@@ -314,15 +280,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 =
@@ -333,10 +300,13 @@ 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));
  }
 }

@@ -471,7 +441,8 @@ async function cmdVarSet(args: string[]): Promise<void> {
    die("Usage: json-cas var set <name> <hash> [--tag <tag>...]");
  }

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

  try {
    // Parse tags/labels from --tag flags
@@ -498,8 +469,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 ||
@@ -522,15 +492,15 @@ async function cmdVarGet(args: string[]): Promise<void> {
    die("Usage: json-cas var get <name> --schema <hash>");
  }

-  const varStore = await 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();
  }
@@ -544,19 +514,18 @@ async function cmdVarDelete(args: string[]): Promise<void> {
    die("Usage: json-cas var delete <name> [--schema <hash>]");
  }

-  const varStore = await 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) {
@@ -581,7 +550,8 @@ async function cmdVarTag(args: string[]): Promise<void> {
    die("Usage: json-cas var tag <name> --schema <hash> <operations...>");
  }

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

  try {
    const { tags, labels, deleteNames } = parseTagsLabels(tagArgs);
@@ -592,8 +562,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 ||
@@ -613,7 +582,8 @@ async function cmdVarList(args: string[]): Promise<void> {
  const schema = flags.schema as string | undefined;
  const tagFlags = flags.tag;

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

  try {
    // Parse tags/labels from --tag flags
@@ -635,8 +605,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}`);
@@ -705,10 +674,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}`);
@@ -744,8 +715,9 @@ 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();
  }
@@ -762,24 +734,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();
  }
@@ -800,7 +760,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}`);
@@ -817,7 +779,7 @@ async function cmdGc(_args: string[]): Promise<void> {

  try {
    const stats = gc(store, varStore);
-    out(stats);
+    out(await wrapEnvelope(store, "@output/gc", stats));
  } finally {
    varStore.close();
  }
@@ -837,27 +799,31 @@ 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:
-  put <type-hash> <file.json>       Store node, print { type, value } envelope (value=hash)
-  get <hash>                        Print node as { type, value } envelope
-  has <hash>                        Print { type, value } envelope (value=boolean)
-  verify <hash>                     Verify integrity + schema → { type, value } (value=ok/corrupted/invalid)
-  refs <hash>                       List direct cas_ref edges
-  walk <hash> [--format tree]       Recursive traversal
-  hash <type-hash> <file.json>      Compute hash without storing → { type, value } envelope
-  render <hash> [options]           Render node as YAML with resolution decay
-  render --pipe/-p [options]        Render { type, value } from stdin
-  list --type <hash-or-alias>       List hashes for a type → { type, value } envelope (value=string[])
-  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>       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>      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)
@@ -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,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",
@@ -60,6 +60,17 @@ 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;

@@ -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;
 }

@@ -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
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