@brik64/cli 0.1.0-beta.0

package/.brik/manifest.json

@@ -0,0 +1,36 @@
+{
+  "schema": "brik64.cli_project_manifest.v1",
+  "project": "brik64-cli",
+  "cliVersion": "0.1.0-beta.0",
+  "semanticSourceStatus": "candidate_pcd_seed",
+  "semanticSourceRoot": "pcd/",
+  "compositionPcd": "pcd/cli_polymer.pcd",
+  "bootstrapEntrypoint": "src/brik.js",
+  "publicBinaryName": "brik",
+  "claimBoundary": {
+    "releaseAuthorized": false,
+    "fixpointClaimAuthorized": false,
+    "n5ClaimAuthorized": false,
+    "formalCertificationAuthorized": false,
+    "rustIndependenceClaimAuthorized": false
+  },
+  "methodologyTransition": {
+    "target": "pcd_first_cli_iteration",
+    "requiredBeforePublicBeta": [
+      "pcd_semantic_source_complete",
+      "pcd_polymer_composition_report_present",
+      "pcd_certification_report_present",
+      "brik_compiler_build_report_present",
+      "macos_arm64_execution_report_present",
+      "linux_distro_execution_reports_present",
+      "windows_x64_execution_report_present",
+      "release_claim_boundary_gate_pass"
+    ],
+    "currentStatus": "bootstrap_non_release"
+  },
+  "certification": {
+    "certifiesFormalCorrectness": false,
+    "certifiesTests": false,
+    "certifiesFixpoint": false
+  }
+}

package/LICENSE

@@ -0,0 +1,6 @@
+All rights reserved.
+
+This public beta repository is published for evaluation of the BRIK64 CLI 0.1
+candidate and its bounded local workflow. Use, redistribution, commercial use,
+and derivative works require a separate license from BRIK64 unless a later
+release explicitly states otherwise.

package/README.md

@@ -0,0 +1,12 @@
+# BRIK CLI
+
+This repository is the iteration surface for the BRIK64 CLI.
+
+`brik64-prod` remains the authority for methodology, evidence gates, claim
+boundaries and release certification. This repo is for CLI source, packaging,
+platform builds, local tests and versioned beta artifacts.
+
+Current status: public beta pre-release candidate for `0.1.0-beta.0`.
+Do not claim npm publication, GitHub Release publication, universal platform
+support, N5 authorization, formal certification or production readiness unless
+the corresponding `brik64-prod` release gates and public manifests pass.

package/docs/BRIK_METHODOLOGY_TRANSITION.md

@@ -0,0 +1,31 @@
+# BRIK CLI Methodology Transition
+
+## Rule
+
+The initial beta can use scaffold and operational artifacts while the CLI is
+being made usable. Once the beta CLI is functionally validated, CLI semantics
+must move to BRIK64 methodology:
+
+1. create `.brik` project metadata;
+2. generate CLI PCDs as the semantic source;
+3. certify candidate PCDs through the active prod gates;
+4. compile the CLI through the approved compiler path;
+5. make future CLI iterations by modifying PCD logic, not by treating emitted
+   target code as the semantic source.
+
+## Boundary
+
+This document does not claim current fixpoint, N5 authorization, public beta
+release readiness or Rust independence.
+
+The transition is blocked until the initial CLI beta has real platform evidence
+and `brik64-prod` release gates allow promotion.
+
+## Required Evidence Before Stronger Claims
+
+- `.brik` manifest for the CLI repo.
+- PCD source set for CLI logic.
+- PCD certification reports.
+- Compiler provenance report.
+- Platform execution reports.
+- Fixpoint/reproducibility evidence under the active methodology.

package/docs/LINUX_HETZNER_TESTING.md

@@ -0,0 +1,27 @@
+# Linux Hetzner Testing
+
+Hetzner is the Linux test surface for the CLI beta.
+
+Scope:
+- Debian x64 native artifact execution.
+- Ubuntu x64 native artifact execution.
+- Fedora x64 native artifact execution.
+- Alpine x64 musl only with a separate musl artifact or explicit unsupported
+  decision.
+
+Required evidence per supported distro:
+- distro identity (`/etc/os-release`);
+- architecture (`uname -m`);
+- native binary path;
+- no wrapper evidence;
+- `brik --version` output;
+- BRIK64 ASCII startup output;
+- command-contract smoke;
+- PCD/certify/emit workflow smoke;
+- behavior PASS report.
+
+Boundary:
+- No universal Linux claim.
+- No public release authorization.
+- No N5, fixpoint or release-readiness claim from a distro smoke alone.
+- Windows remains waiting for a real PC/runner.

package/docs/MACOS_LOCAL_TESTING.md

@@ -0,0 +1,27 @@
+# macOS Local Testing
+
+This machine is the local macOS test surface for the CLI beta.
+
+Current local platform:
+- OS: macOS / Darwin
+- Architecture: arm64
+
+Scope:
+- local CLI execution;
+- local install path checks;
+- local command-contract checks;
+- no public release authorization.
+
+Out of scope:
+- macOS x64 runner evidence;
+- Windows evidence;
+- universal macOS artifact claims;
+- fixpoint, N5 or release claims.
+
+Required evidence before marking macOS local ready:
+- local binary path;
+- `brik --version` output;
+- BRIK64 ASCII startup output;
+- command-contract smoke;
+- PCD/certify/emit local workflow smoke;
+- report stored under `evidence/macos-local/`.

package/docs/PLATFORM_MATRIX.md

@@ -0,0 +1,12 @@
+# Platform Matrix
+
+| Platform | Status | Required Evidence |
+| --- | --- | --- |
+| macOS arm64 local | pending | local binary execution report |
+| Linux Debian x64 | pending | native binary, no wrapper, behavior PASS |
+| Linux Ubuntu x64 | pending | native binary, no wrapper, behavior PASS |
+| Linux Fedora x64 | pending | native binary, no wrapper, behavior PASS |
+| Linux Alpine x64 musl | pending | separate musl artifact or explicit unsupported decision |
+| Windows x64 | waiting | real PC/runner metadata and execution report |
+
+Do not collapse these into "all Linux" or "all platforms" claims.

package/docs/REPO_BOUNDARY.md

@@ -0,0 +1,30 @@
+# BRIK CLI Repository Boundary
+
+## Lives Here
+
+- CLI source code.
+- CLI tests and fixtures.
+- Platform packaging scripts.
+- Local beta artifacts.
+- Per-version changelogs.
+
+## Does Not Live Here
+
+- Private engines.
+- Claim-bearing certification authority.
+- Public release authorization.
+- N-level claims.
+- Prod evidence source of truth.
+
+## Authority Split
+
+- `brik64-cli`: implementation and packaging iteration.
+- `brik64-prod`: gates, evidence, methodology, release decision and claim
+  boundary.
+
+## Platform Scope
+
+- macOS local testing can run on the current development machine.
+- Linux testing should run on the Hetzner runner and must be split by distro
+  family rather than claimed as universal Linux support.
+- Windows testing remains pending until a real Windows PC/runner is available.

package/evidence/.gitkeep

@@ -0,0 +1 @@
+

package/evidence/compiled-cli-polymer/brik_cli_polymer.bir.artifact_manifest.json

@@ -0,0 +1,31 @@
+{
+  "schema_version": "brik64.generated_artifact_manifest.v1",
+  "kind": "brik64.bir_artifact_manifest.v1",
+  "source_pcd": "/Users/carlosjperez/Documents/GitHub/brik64-cli/pcd/cli_polymer.pcd",
+  "source_pcd_sha256": "sha256:776bbd5a15357bf47350a81011f1d12bdf4a04fb843cd035c39f9b3985cb9196",
+  "artifact": "/Users/carlosjperez/Documents/GitHub/brik64-prod/out/pit-cycle/BRIK-CLI-BRIKC-COMPILE-EXECUTION-R156-20260601/artifacts/brik_cli_polymer.bir",
+  "artifact_sha256": "sha256:37c86b45fb810658459f5c88e9e92ab68945bb11b91179bb0ca0de15c0eec065",
+  "target": "bir",
+  "claim_authority": "non_claim_artifact_binding",
+  "public_claims_allowed": false,
+  "certifies_tests": false,
+  "bir_metadata": {
+    "schema_version": "brik64.numeric_domain_bir_metadata.v1",
+    "module": "brik_cli_polymer",
+    "string_table_entries": 3,
+    "numeric_domain_profile_hash_bound_to_bir": true,
+    "numeric_domain_profile_hashes": [],
+    "numeric_domain_metadata_strings": [
+      "BRIK64-NUMERIC-DOMAIN-PROFILE-BINDING:v1",
+      "numeric_domain_profile_required=false",
+      "numeric_domain_profile_count=0"
+    ]
+  },
+  "numeric_domain": {
+    "schema_version": "brik64.numeric_domain_artifact_binding.v1",
+    "profile_required": false,
+    "numeric_domain_profile_hashes": [],
+    "validation_issues": [],
+    "guard_stability_findings": []
+  }
+}

package/evidence/compiled-cli-polymer/brik_cli_polymer.bir.asm

@@ -0,0 +1,76 @@
+; BIR Module: brik_cli_polymer
+; Version: 1
+; Inputs: []
+; Output: Some("tmp_CMP_6")
+; Vars: 13 slots
+; Strings: 3 entries
+; Instructions: 67
+
+  0000: PUSH_I64 0
+  0001: STORE $0
+  0002: JUMP +63
+fn::brik_cli_polymer:
+  0003: STORE $5
+  0004: STORE $4
+  0005: STORE $3
+  0006: STORE $2
+  0007: LOAD $3
+  0008: PUSH_I64 0
+  0009: CMP_EQ
+  0010: STORE $6
+  0011: LOAD $6
+  0012: JUMP_IF_NOT +3
+  0013: PUSH_I64 64
+  0014: RET
+  0015: LOAD $2
+  0016: PUSH_I64 1
+  0017: CMP_EQ
+  0018: STORE $7
+  0019: LOAD $7
+  0020: JUMP_IF_NOT +3
+  0021: PUSH_I64 0
+  0022: RET
+  0023: LOAD $2
+  0024: PUSH_I64 2
+  0025: CMP_EQ
+  0026: STORE $8
+  0027: LOAD $8
+  0028: JUMP_IF_NOT +27
+  0029: LOAD $4
+  0030: PUSH_I64 0
+  0031: CMP_EQ
+  0032: STORE $9
+  0033: LOAD $9
+  0034: JUMP_IF_NOT +3
+  0035: PUSH_I64 67
+  0036: RET
+  0037: LOAD $5
+  0038: PUSH_I64 1
+  0039: CMP_LT
+  0040: STORE $10
+  0041: LOAD $10
+  0042: JUMP_IF_NOT +3
+  0043: PUSH_I64 65
+  0044: RET
+  0045: LOAD $5
+  0046: PUSH_I64 3
+  0047: CMP_GT
+  0048: STORE $11
+  0049: LOAD $11
+  0050: JUMP_IF_NOT +3
+  0051: PUSH_I64 65
+  0052: RET
+  0053: PUSH_I64 1
+  0054: RET
+  0055: LOAD $2
+  0056: PUSH_I64 64
+  0057: CMP_EQ
+  0058: STORE $12
+  0059: LOAD $12
+  0060: JUMP_IF_NOT +3
+  0061: PUSH_I64 64
+  0062: RET
+  0063: PUSH_I64 0
+  0064: RET
+  0065: LOAD $12
+  0066: HALT

package/evidence/compiled-cli-polymer/brik_cli_polymer.cert.json

@@ -0,0 +1,36 @@
+{
+  "version": "1.0.0",
+  "generator": "brikc v5.0.0-beta.1",
+  "timestamp": "2026-06-01T09:27:14Z",
+  "issuer": "BRIK-64 v5.0.0-beta.1",
+  "valid_from": "2026-06-01T09:27:14Z",
+  "verification_url": "https://registry.brik64.dev/cert/341eff541ce59269",
+  "signature": "341eff541ce592695ffc34374513e0998ae6d98e571cc29d098b7c572161fe60",
+  "source": {
+    "file": "/Users/carlosjperez/Documents/GitHub/brik64-cli/pcd/cli_polymer.pcd",
+    "hash_sha256": "776bbd5a15357bf47350a81011f1d12bdf4a04fb843cd035c39f9b3985cb9196",
+    "language": "pcd"
+  },
+  "certification": {
+    "phi_c": 1.0,
+    "level": "CORE",
+    "monomers_used": [],
+    "monomer_names": [],
+    "domain_safe": true,
+    "deterministic": true,
+    "total_statements": 0
+  },
+  "target": {
+    "language": "bir",
+    "file": "/Users/carlosjperez/Documents/GitHub/brik64-prod/out/pit-cycle/BRIK-CLI-BRIKC-COMPILE-EXECUTION-R156-20260601/artifacts/brik_cli_polymer.bir",
+    "hash_sha256": "37c86b45fb810658459f5c88e9e92ab68945bb11b91179bb0ca0de15c0eec065",
+    "lines": 3
+  },
+  "chain": {
+    "source_hash": "776bbd5a15357bf47350a81011f1d12bdf4a04fb843cd035c39f9b3985cb9196",
+    "pcd_hash": "776bbd5a15357bf47350a81011f1d12bdf4a04fb843cd035c39f9b3985cb9196",
+    "plan_hash": "c82803e958cd599179090285b9994f310fe2bfdda8c9951d5cbabc036b026c6a",
+    "target_hash": "37c86b45fb810658459f5c88e9e92ab68945bb11b91179bb0ca0de15c0eec065",
+    "compiler_version": "5.0.0-beta.1"
+  }
+}

package/evidence/compiled-cli-polymer/package.manifest.json

@@ -0,0 +1,24 @@
+{
+  "schemaVersion": "brik64.cli_bir_candidate_package_manifest.v1",
+  "generatedAt": "2026-06-01T09:36:21Z",
+  "source_compile_report": "out/pit-cycle/BRIK-CLI-BRIKC-COMPILE-EXECUTION-R156-20260601/brik_cli_brikc_compile_execution_report.json",
+  "artifact_kind": "cli_polymer_candidate_bir_package",
+  "artifacts": {
+    "bir": {
+      "path": "brik_cli_polymer.bir",
+      "sha256": "37c86b45fb810658459f5c88e9e92ab68945bb11b91179bb0ca0de15c0eec065"
+    },
+    "certificate": {
+      "path": "brik_cli_polymer.cert.json",
+      "sha256": "0ca22bebf3caf1e4bce7673b90805b54685f8310c517921ef0af29eefbf9ddab"
+    }
+  },
+  "claim_boundary": {
+    "package_only": true,
+    "executable_binary": false,
+    "semantic_execution": false,
+    "fixpoint": false,
+    "release": false,
+    "n5": false
+  }
+}

package/evidence/pcd-certificates/cli_certify_emit.pcd.cert.json

@@ -0,0 +1,24 @@
+{
+  "schemaVersion": "brik64.cli_local_candidate_certificate.v1",
+  "generatedAt": "2026-06-03T05:06:50Z",
+  "pcd": {
+    "path": "pcd/cli_certify_emit.pcd",
+    "sha256": "1d73245ebee8592a4eeacdb4b99398baf7c5ddfa3c88c5927f924a871eee7147"
+  },
+  "certificate": {
+    "kind": "local_candidate_certificate",
+    "status": "candidate_only",
+    "certifiesFormalCorrectness": false,
+    "certifiesTests": false,
+    "certifiesFixpoint": false,
+    "certifiesN5": false,
+    "permitsCompile": false
+  },
+  "claim_boundary": {
+    "formal_certification_allowed": false,
+    "public_beta_allowed": false,
+    "release_allowed": false,
+    "n5_claim_allowed": false,
+    "rust_independence_claim_allowed": false
+  }
+}

package/evidence/pcd-certificates/cli_core.pcd.cert.json

@@ -0,0 +1,24 @@
+{
+  "schemaVersion": "brik64.cli_local_candidate_certificate.v1",
+  "generatedAt": "2026-06-03T05:06:50Z",
+  "pcd": {
+    "path": "pcd/cli_core.pcd",
+    "sha256": "c1d3167109d842c5b321ed541604bdcff2c7be7865b2aac8116f1db03b557944"
+  },
+  "certificate": {
+    "kind": "local_candidate_certificate",
+    "status": "candidate_only",
+    "certifiesFormalCorrectness": false,
+    "certifiesTests": false,
+    "certifiesFixpoint": false,
+    "certifiesN5": false,
+    "permitsCompile": false
+  },
+  "claim_boundary": {
+    "formal_certification_allowed": false,
+    "public_beta_allowed": false,
+    "release_allowed": false,
+    "n5_claim_allowed": false,
+    "rust_independence_claim_allowed": false
+  }
+}

package/evidence/pcd-certificates/cli_init_policy.pcd.cert.json

@@ -0,0 +1,24 @@
+{
+  "schemaVersion": "brik64.cli_local_candidate_certificate.v1",
+  "generatedAt": "2026-06-03T05:06:50Z",
+  "pcd": {
+    "path": "pcd/cli_init_policy.pcd",
+    "sha256": "fae8cf2f18ba00b337236a46ee7d212b1437c7b4eae812ca1e3506651ffdb31d"
+  },
+  "certificate": {
+    "kind": "local_candidate_certificate",
+    "status": "candidate_only",
+    "certifiesFormalCorrectness": false,
+    "certifiesTests": false,
+    "certifiesFixpoint": false,
+    "certifiesN5": false,
+    "permitsCompile": false
+  },
+  "claim_boundary": {
+    "formal_certification_allowed": false,
+    "public_beta_allowed": false,
+    "release_allowed": false,
+    "n5_claim_allowed": false,
+    "rust_independence_claim_allowed": false
+  }
+}

package/evidence/pcd-certificates/cli_polymer.pcd.cert.json

@@ -0,0 +1,24 @@
+{
+  "schemaVersion": "brik64.cli_local_candidate_certificate.v1",
+  "generatedAt": "2026-06-03T05:06:50Z",
+  "pcd": {
+    "path": "pcd/cli_polymer.pcd",
+    "sha256": "776bbd5a15357bf47350a81011f1d12bdf4a04fb843cd035c39f9b3985cb9196"
+  },
+  "certificate": {
+    "kind": "local_candidate_certificate",
+    "status": "candidate_only",
+    "certifiesFormalCorrectness": false,
+    "certifiesTests": false,
+    "certifiesFixpoint": false,
+    "certifiesN5": false,
+    "permitsCompile": false
+  },
+  "claim_boundary": {
+    "formal_certification_allowed": false,
+    "public_beta_allowed": false,
+    "release_allowed": false,
+    "n5_claim_allowed": false,
+    "rust_independence_claim_allowed": false
+  }
+}

package/evidence/pcd-seed/README.md

@@ -0,0 +1,7 @@
+# PCD Seed Evidence Boundary
+
+This directory is reserved for future reports generated from the candidate PCD
+source in `pcd/`.
+
+No report in this directory currently authorizes a public beta, fixpoint claim,
+N5 claim, formal certification claim, or Rust-independence claim.

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@brik64/cli",
+  "version": "0.1.0-beta.0",
+  "private": false,
+  "description": "BRIK64 CLI 0.1 public beta scaffold for local PCD workflows and bounded evidence review.",
+  "homepage": "https://docs.brik64.com/cli/install",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/brik64/brik64-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/brik64/brik64-cli/issues"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "bin": {
+    "brik": "src/brik.js"
+  },
+  "scripts": {
+    "test": "bash tests/smoke.sh"
+  }
+}

package/packaging/.gitkeep

@@ -0,0 +1 @@
+

package/packaging/macos-local/README.md

@@ -0,0 +1,15 @@
+# macOS Local Bootstrap Wrapper
+
+This directory contains a local macOS bootstrap wrapper for testing:
+
+```bash
+export PATH="/Users/carlosjperez/Documents/GitHub/brik64-cli/packaging/macos-local:$PATH"
+brik --version
+```
+
+Boundary:
+- bootstrap wrapper only;
+- depends on local Node.js;
+- not a native final artifact;
+- not public release evidence;
+- not post-beta `.brik`/PCD semantic source.

package/packaging/macos-local/brik

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_DIR="$(cd "$SCRIPT_DIR/../.." && pwd)"
+exec node "$REPO_DIR/src/brik.js" "$@"

package/pcd/README.md

@@ -0,0 +1,24 @@
+# BRIK CLI PCD Seed
+
+This directory contains candidate semantic PCD seeds for the local `brik` CLI.
+They are not release artifacts and do not certify formal correctness, N5 status,
+fixpoint, or Rust independence.
+
+Current status:
+
+- Source of truth for executable behavior remains `src/brik.js`.
+- These PCD files define the transition contract for moving CLI iteration to a
+  PCD-first BRIK64 methodology.
+- `cli_polymer.pcd` is the candidate composition contract that binds the CLI
+  command PCD seeds before any future compile route.
+- Any future public beta claim must be backed by fresh compiler, certificate,
+  platform execution, and release-boundary reports.
+
+Required next methodology step:
+
+1. Complete candidate PCD coverage for all CLI behavior.
+2. Certify candidate PCDs with the active private gate stack.
+3. Validate the polymer/composition PCD against the certified command PCDs.
+4. Compile the CLI through the BRIK compiler path.
+5. Run macOS, Linux distro, and Windows execution reports.
+6. Promote only if the release claim boundary gate passes.

package/pcd/cli_certify_emit.pcd

@@ -0,0 +1,32 @@
+// brik64.pcd_file.v1
+// name: brik_cli_certify_emit
+// status: candidate_pcd_seed
+// certifiesFormalCorrectness: false
+// certifiesTests: false
+// certifiesFixpoint: false
+// commands = "certify,emit"
+// supported_emit_targets = "ts,rust,python"
+// certificate_kind = "local_candidate_certificate"
+// fail_closed_on missing_certificate
+// claim_boundary = "local_candidate_only"
+
+PC brik_cli_certify_emit {
+    fn brik_cli_certify_emit(pcd_present, certificate_present, target_code, tests_requested) {
+        if (pcd_present == 0) {
+            return 64;
+        }
+        if (certificate_present == 0) {
+            return 67;
+        }
+        if (target_code < 1) {
+            return 65;
+        }
+        if (target_code > 3) {
+            return 65;
+        }
+        if (tests_requested == 1) {
+            return 2;
+        }
+        return 1;
+    }
+}

package/pcd/cli_core.pcd

@@ -0,0 +1,30 @@
+// brik64.pcd_file.v1
+// name: brik_cli_core
+// status: candidate_pcd_seed
+// certifiesFormalCorrectness: false
+// certifiesTests: false
+// certifiesFixpoint: false
+// product = "brik64-cli"
+// cli_version = "0.1.0-beta.0"
+// public_binary = "brik"
+// execution_status = "bootstrap_non_release"
+// ascii_banner = "BRIK64"
+// claim_boundary = "local_candidate_only"
+
+PC brik_cli_core {
+    fn brik_cli_core(command_code, json_mode, ci_mode) {
+        if (json_mode == 1) {
+            return 0;
+        }
+        if (ci_mode == 1) {
+            return 0;
+        }
+        if (command_code == 0) {
+            return 1;
+        }
+        if (command_code == 64) {
+            return 64;
+        }
+        return 0;
+    }
+}

package/pcd/cli_init_policy.pcd

@@ -0,0 +1,30 @@
+// brik64.pcd_file.v1
+// name: brik_cli_init_policy
+// status: candidate_pcd_seed
+// certifiesFormalCorrectness: false
+// certifiesTests: false
+// certifiesFixpoint: false
+// command = "init"
+// writes = ".brik/manifest.json"
+// protected_file = "AGENTS.md"
+// agent_instruction_policy = "consent_required"
+// invariant creates_agents_md == false
+// invariant existing_agents_md_must_not_be_overwritten == true
+// claim_boundary = "local_candidate_only"
+
+PC brik_cli_init_policy {
+    fn brik_cli_init_policy(workspace_readable, has_brik_dir, has_agents_md, consent_given) {
+        if (workspace_readable == 0) {
+            return 64;
+        }
+        if (has_brik_dir == 1) {
+            return 0;
+        }
+        if (has_agents_md == 1) {
+            if (consent_given == 0) {
+                return 1;
+            }
+        }
+        return 0;
+    }
+}

package/pcd/cli_polymer.pcd

@@ -0,0 +1,52 @@
+// brik64.pcd_file.v1
+// name: brik_cli_polymer
+// status: candidate_pcd_seed
+// certifiesFormalCorrectness: false
+// certifiesTests: false
+// certifiesFixpoint: false
+// product = "brik64-cli"
+// cli_version = "0.1.0-beta.0"
+// composition_kind = "polymer"
+// source_units = "cli_core.pcd,cli_init_policy.pcd,cli_certify_emit.pcd"
+// compile_status = "not_compiled"
+// certificate_status = "candidate_only"
+// reads "pcd/cli_core.pcd"
+// reads "pcd/cli_init_policy.pcd"
+// reads "pcd/cli_certify_emit.pcd"
+// requires ascii_banner == "BRIK64"
+// requires agent_instruction_policy == "consent_required"
+// requires existing_agents_md_must_not_be_overwritten == true
+// requires certificate_before_emit == true
+// requires supported_emit_targets == "ts,rust,python"
+// invariant compile_requires_certified_pcd_batch == true
+// invariant compile_requires_polymer_contract == true
+// invariant public_claim_allowed == false
+// polymer brik_cli_candidate
+// claim_boundary = "local_candidate_only"
+
+PC brik_cli_polymer {
+    fn brik_cli_polymer(command_code, workspace_readable, certificate_present, target_code) {
+        if (workspace_readable == 0) {
+            return 64;
+        }
+        if (command_code == 1) {
+            return 0;
+        }
+        if (command_code == 2) {
+            if (certificate_present == 0) {
+                return 67;
+            }
+            if (target_code < 1) {
+                return 65;
+            }
+            if (target_code > 3) {
+                return 65;
+            }
+            return 1;
+        }
+        if (command_code == 64) {
+            return 64;
+        }
+        return 0;
+    }
+}

package/src/.gitkeep

@@ -0,0 +1 @@
+

package/src/brik.js

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+process.stdout.on('error', (error) => {
+  if (error.code === 'EPIPE') process.exit(0);
+  throw error;
+});
+
+const version = '0.1.0-beta.0';
+const ascii = [
+  ' ____  ____  ___ _  __ __   _  _ ',
+  '| __ )|  _ \\|_ _| |/ // /_ | || |',
+  "|  _ \\| |_) || || ' /| '_ \\| || |_",
+  '| |_) |  _ < | || . \\| (_) |__   _|',
+  '|____/|_| \\_\\___|_|\\_\\\\___/   |_|  ',
+].join('\n');
+
+function sha256(value) {
+  return crypto.createHash('sha256').update(value).digest('hex');
+}
+
+function printBanner() {
+  process.stdout.write(`${ascii}\n`);
+  process.stdout.write(`BRIK64 CLI ${version}\n`);
+  process.stdout.write('status=bootstrap_non_release\n');
+}
+
+function help() {
+  printBanner();
+  process.stdout.write('\ncommands:\n');
+  process.stdout.write('  init                 create .brik metadata only\n');
+  process.stdout.write('  certify <file.pcd>   write local candidate certificate\n');
+  process.stdout.write('  emit <file.pcd>      emit only when local certificate exists\n');
+  process.stdout.write('       --target <ts|rust|python> --out <dir> --tests\n');
+  process.stdout.write('  --version            print version\n');
+}
+
+function readFileRequired(file) {
+  if (!file) {
+    process.stderr.write('missing_file_argument\n');
+    process.exit(64);
+  }
+  if (!fs.existsSync(file)) {
+    process.stderr.write(`file_not_found:${file}\n`);
+    process.exit(66);
+  }
+  return fs.readFileSync(file, 'utf8');
+}
+
+function init() {
+  const brikDir = path.resolve('.brik');
+  fs.mkdirSync(brikDir, { recursive: true });
+  const manifestPath = path.join(brikDir, 'manifest.json');
+  if (!fs.existsSync(manifestPath)) {
+    fs.writeFileSync(manifestPath, JSON.stringify({
+      schemaVersion: 'brik64.cli_project_manifest.v1',
+      cliVersion: version,
+      createdBy: 'brik64-cli-bootstrap',
+      claimBoundary: {
+        publicBetaAllowed: false,
+        releaseAllowed: false,
+        generatedAgentsFile: false
+      }
+    }, null, 2) + '\n');
+  }
+  process.stdout.write(`created=${path.relative(process.cwd(), manifestPath)}\n`);
+}
+
+function certPathFor(file) {
+  return `${file}.cert.json`;
+}
+
+function parseEmitOptions(args) {
+  const options = { target: null, outDir: null, tests: false };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '--target') {
+      options.target = args[index + 1];
+      index += 1;
+    } else if (arg === '--out') {
+      options.outDir = args[index + 1];
+      index += 1;
+    } else if (arg === '--tests') {
+      options.tests = true;
+    } else {
+      process.stderr.write(`unknown_emit_option:${arg}\n`);
+      process.exit(64);
+    }
+  }
+  return options;
+}
+
+function targetSpec(target) {
+  const specs = {
+    ts: {
+      program: 'program.ts',
+      test: 'program.test.ts',
+      code: (hash) => [
+        '// BRIK64 bootstrap emission candidate',
+        '// claim: local candidate only',
+        `export const pcdSha256 = "${hash}";`,
+        'export function run(): string {',
+        '  return `brik:${pcdSha256}`;',
+        '}',
+        '',
+      ].join('\n'),
+      testCode: (hash) => [
+        'import { pcdSha256, run } from "./program";',
+        '',
+        'if (pcdSha256 !== "' + hash + '") throw new Error("pcd hash mismatch");',
+        'if (run() !== `brik:${pcdSha256}`) throw new Error("run mismatch");',
+        'console.log("brik64 generated ts test: PASS");',
+        '',
+      ].join('\n'),
+    },
+    rust: {
+      program: 'program.rs',
+      test: 'program_test.rs',
+      code: (hash) => [
+        '// BRIK64 bootstrap emission candidate',
+        '// claim: local candidate only',
+        `pub const PCD_SHA256: &str = "${hash}";`,
+        'pub fn run() -> String {',
+        '    format!("brik:{}", PCD_SHA256)',
+        '}',
+        '',
+      ].join('\n'),
+      testCode: (hash) => [
+        `const PCD_SHA256: &str = "${hash}";`,
+        'fn run() -> String {',
+        '    format!("brik:{}", PCD_SHA256)',
+        '}',
+        '',
+        'fn main() {',
+        `    assert_eq!(PCD_SHA256, "${hash}");`,
+        '    assert_eq!(run(), format!("brik:{}", PCD_SHA256));',
+        '    println!("brik64 generated rust test: PASS");',
+        '}',
+        '',
+      ].join('\n'),
+    },
+    python: {
+      program: 'program.py',
+      test: 'test_program.py',
+      code: (hash) => [
+        '# BRIK64 bootstrap emission candidate',
+        '# claim: local candidate only',
+        `PCD_SHA256 = "${hash}"`,
+        '',
+        'def run():',
+        '    return f"brik:{PCD_SHA256}"',
+        '',
+      ].join('\n'),
+      testCode: (hash) => [
+        'from program import PCD_SHA256, run',
+        '',
+        `assert PCD_SHA256 == "${hash}"`,
+        'assert run() == f"brik:{PCD_SHA256}"',
+        'print("brik64 generated python test: PASS")',
+        '',
+      ].join('\n'),
+    },
+  };
+  return specs[target] || null;
+}
+
+function certify(file) {
+  const source = readFileRequired(file);
+  const cert = {
+    schemaVersion: 'brik64.cli_local_candidate_certificate.v1',
+    cliVersion: version,
+    pcd: file,
+    semantic_pcd_sha256: sha256(source),
+    certifiesFormalCorrectness: false,
+    certifiesTests: false,
+    claimBoundary: {
+      localCandidateOnly: true,
+      publicBetaAllowed: false,
+      releaseAllowed: false
+    }
+  };
+  const certPath = certPathFor(file);
+  fs.writeFileSync(certPath, JSON.stringify(cert, null, 2) + '\n');
+  process.stdout.write(`certificate=${certPath}\n`);
+}
+
+function emit(file, args = []) {
+  const source = readFileRequired(file);
+  const certPath = certPathFor(file);
+  if (!fs.existsSync(certPath)) {
+    process.stderr.write(`certificate_required:${certPath}\n`);
+    process.exit(67);
+  }
+  const cert = JSON.parse(fs.readFileSync(certPath, 'utf8'));
+  if (cert.semantic_pcd_sha256 !== sha256(source)) {
+    process.stderr.write('certificate_hash_mismatch\n');
+    process.exit(68);
+  }
+  const options = parseEmitOptions(args);
+  if (options.target || options.outDir || options.tests) {
+    const spec = targetSpec(options.target);
+    if (!spec) {
+      process.stderr.write('unsupported_target\n');
+      process.exit(69);
+    }
+    if (!options.outDir) {
+      process.stderr.write('missing_out_dir\n');
+      process.exit(64);
+    }
+    fs.mkdirSync(options.outDir, { recursive: true });
+    fs.writeFileSync(path.join(options.outDir, spec.program), spec.code(cert.semantic_pcd_sha256));
+    if (options.tests) {
+      fs.writeFileSync(path.join(options.outDir, spec.test), spec.testCode(cert.semantic_pcd_sha256));
+    }
+    process.stdout.write(`generated=${path.join(options.outDir, spec.program)}\n`);
+    if (options.tests) process.stdout.write(`tests=${path.join(options.outDir, spec.test)}\n`);
+    return;
+  }
+  process.stdout.write('// BRIK64 bootstrap emission candidate\n');
+  process.stdout.write('// claim: local candidate only\n');
+  process.stdout.write(`// pcd_sha256=${cert.semantic_pcd_sha256}\n`);
+}
+
+function main() {
+  const [cmd, file, ...args] = process.argv.slice(2);
+  if (!cmd || cmd === '--help' || cmd === 'help') return help();
+  if (cmd === '--version' || cmd === 'version') {
+    printBanner();
+    return;
+  }
+  if (cmd === 'init') return init();
+  if (cmd === 'certify') return certify(file);
+  if (cmd === 'emit') return emit(file, args);
+  process.stderr.write(`unknown_command:${cmd}\n`);
+  process.exit(2);
+}
+
+main();

package/tests/.gitkeep

@@ -0,0 +1 @@
+

package/tests/smoke.sh

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+BRIK="$ROOT_DIR/src/brik.js"
+tmpdir="$(mktemp -d)"
+cleanup() { rm -rf "$tmpdir"; }
+trap cleanup EXIT
+
+node "$BRIK" --version | grep -q "BRIK64 CLI 0.1.0-beta.0"
+node "$BRIK" --help | grep -q "status=bootstrap_non_release"
+
+(
+  cd "$tmpdir"
+  node "$BRIK" init
+  test -f .brik/manifest.json
+  test ! -f AGENTS.md
+)
+
+cat >"$tmpdir/program.pcd" <<'PCD'
+program sample
+monomer ADD
+PCD
+
+if node "$BRIK" emit "$tmpdir/program.pcd" >/tmp/brik-emit.out 2>/tmp/brik-emit.err; then
+  echo "emit should require certificate" >&2
+  exit 1
+fi
+grep -q "certificate_required" /tmp/brik-emit.err
+
+node "$BRIK" certify "$tmpdir/program.pcd"
+node "$BRIK" emit "$tmpdir/program.pcd" | grep -q "pcd_sha256="
+
+for target in ts rust python; do
+  out="$tmpdir/out-$target"
+  node "$BRIK" emit "$tmpdir/program.pcd" --target "$target" --out "$out" --tests >/tmp/brik-emit-$target.out
+  grep -q "generated=" "/tmp/brik-emit-$target.out"
+  grep -q "tests=" "/tmp/brik-emit-$target.out"
+done
+
+test -f "$tmpdir/out-ts/program.ts"
+test -f "$tmpdir/out-ts/program.test.ts"
+test -f "$tmpdir/out-rust/program.rs"
+test -f "$tmpdir/out-rust/program_test.rs"
+test -f "$tmpdir/out-python/program.py"
+test -f "$tmpdir/out-python/test_program.py"
+
+if node "$BRIK" emit "$tmpdir/program.pcd" --target go --out "$tmpdir/out-go" --tests >/tmp/brik-emit-go.out 2>/tmp/brik-emit-go.err; then
+  echo "unsupported target should fail closed" >&2
+  exit 1
+fi
+grep -q "unsupported_target" /tmp/brik-emit-go.err
+
+echo "brik64-cli bootstrap smoke: PASS"