@morphism-systems/cli 0.1.0 → 0.1.3

package/README.md

@@ -17,10 +17,30 @@ morphism score       # Compute maturity score
 morphism doctor      # Health check
 ```
 
+## Example Output
+
+```bash
+$ morphism validate
+κ = 0.0000 | δ = 0.0000
+Maturity: optimizing | Converging: true
+Violations: 0
+Governance validation: PASS
+
+$ morphism score
+Maturity score: 125/125
+
+$ morphism doctor
+✓ AGENTS.md exists
+✓ SSOT.md exists
+✓ GUIDELINES.md exists
+✓ .morphism/config.json valid
+Health check: PASS
+```
+
 ## Why Morphism
 
 Governance-as-code with mathematical guarantees. [Learn more](https://morphism.systems).
 
 ## License
 
-MIT
+Business Source License 1.1 (BUSL-1.1) — Change Date 2030-02-20, Change License Apache 2.0

package/dist/index.js

@@ -33,30 +33,155 @@ function init(cwd) {
 }
 
 // src/commands/validate.ts
-import { execSync } from "child_process";
-function validate(cwd) {
+import { execFileSync } from "child_process";
+async function validate(cwd, opts = {}) {
+  const format = opts.format ?? "text";
+  const proofDir = opts.proofDir ?? ".morphism/proofs";
+  const isJson = format === "json";
+  let pipelinePassed = false;
   try {
-    const result = execSync("python3 scripts/verify_pipeline.py", {
+    const result = execFileSync("python", ["scripts/verify_pipeline.py"], {
       cwd,
       encoding: "utf-8",
       timeout: 3e4
     });
-    console.log(result);
-    console.log("Governance validation: PASS");
+    if (!isJson) console.log(result);
+    pipelinePassed = true;
   } catch (err) {
     const error = err;
-    if (error.stdout) console.log(error.stdout);
-    if (error.stderr) console.error(error.stderr);
-    console.error("Governance validation: FAIL");
+    if (!isJson) {
+      if (error.stdout) console.log(error.stdout);
+      if (error.stderr) console.error(error.stderr);
+      console.error("Governance validation: FAIL (pipeline)");
+    }
+    if (isJson) {
+      console.log(JSON.stringify({
+        passed: false,
+        kappa: 1,
+        delta: 1,
+        maturity_level: "initial",
+        converging: false,
+        violation_count: 1,
+        summary: "Pipeline verification failed"
+      }));
+    }
     process.exit(1);
   }
+  let maturityScore = 0;
+  try {
+    const scoreResult = execFileSync("python", ["scripts/maturity_score.py", "--ci", "--threshold", "0"], {
+      cwd,
+      encoding: "utf-8",
+      timeout: 3e4
+    });
+    const totalMatch = scoreResult.match(/total:\s*(\d+)\/(\d+)/);
+    if (totalMatch) {
+      maturityScore = parseInt(totalMatch[1]);
+    }
+  } catch {
+  }
+  try {
+    let commitSha = opts.commit;
+    if (!commitSha) {
+      commitSha = execFileSync("git", ["rev-parse", "HEAD"], {
+        cwd,
+        encoding: "utf-8",
+        timeout: 5e3
+      }).trim();
+    }
+    const modPath = "@morphism-systems/mcp-server/governance-loop";
+    const { runGovernanceLoop } = await import(
+      /* webpackIgnore: true */
+      modPath
+    ).catch(() => {
+      return { runGovernanceLoop: null };
+    });
+    if (!runGovernanceLoop) {
+      if (isJson) {
+        console.log(JSON.stringify({
+          passed: pipelinePassed,
+          kappa: 0,
+          delta: 0,
+          maturity_level: maturityScore >= 100 ? "converged" : "maturing",
+          maturity_score: maturityScore,
+          converging: true,
+          violation_count: 0,
+          summary: "Pipeline passed; categorical validation skipped (mcp-server not available)"
+        }));
+      } else {
+        console.log("Categorical validation: skipped (mcp-server not available)");
+        console.log("Governance validation: PASS (pipeline only)");
+      }
+      return;
+    }
+    const result = await runGovernanceLoop({
+      commitSha,
+      events: [],
+      policies: [],
+      kappaHistory: [],
+      dimensionScores: {
+        policy: 1,
+        git_hook: 1,
+        ci_workflow: 1,
+        ssot_atom: 1,
+        document: 1,
+        security_gate: 1,
+        runbook: 1
+      },
+      writeProof: true,
+      proofDir
+    });
+    if (isJson) {
+      console.log(JSON.stringify({
+        passed: result.passed,
+        kappa: result.kappa,
+        delta: result.delta,
+        maturity_level: result.maturityLevel,
+        maturity_score: maturityScore,
+        converging: result.converging,
+        violation_count: result.violationCount,
+        proof_path: result.proofPath ?? null,
+        summary: result.summary
+      }));
+    } else {
+      console.log(`\u03BA = ${result.kappa.toFixed(4)} | \u03B4 = ${result.delta.toFixed(4)}`);
+      console.log(`Maturity: ${result.maturityLevel} | Converging: ${result.converging}`);
+      console.log(`Violations: ${result.violationCount}`);
+      if (result.proofPath) {
+        console.log(`Proof: ${result.proofPath}`);
+      }
+      console.log(result.summary);
+    }
+    if (!result.passed) {
+      if (!isJson) console.error("Governance validation: FAIL (categorical)");
+      process.exit(1);
+    }
+    if (!isJson) console.log("Governance validation: PASS");
+  } catch (err) {
+    const error = err;
+    if (isJson) {
+      console.log(JSON.stringify({
+        passed: pipelinePassed,
+        kappa: 0,
+        delta: 0,
+        maturity_level: maturityScore >= 100 ? "converged" : "maturing",
+        maturity_score: maturityScore,
+        converging: true,
+        violation_count: 0,
+        summary: `Pipeline passed; categorical validation skipped (${error.message ?? "unknown error"})`
+      }));
+    } else {
+      console.log(`Categorical validation: skipped (${error.message ?? "unknown error"})`);
+      console.log("Governance validation: PASS (pipeline only)");
+    }
+  }
 }
 
 // src/commands/score.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync } from "child_process";
 function score(cwd, threshold) {
   try {
-    const result = execSync2(
+    const result = execSync(
       `python3 scripts/maturity_score.py --ci --threshold ${threshold}`,
       { cwd, encoding: "utf-8", timeout: 3e4 }
     );
@@ -72,7 +197,7 @@ function score(cwd, threshold) {
 // src/commands/doctor.ts
 import { existsSync as existsSync2 } from "fs";
 import { join as join2 } from "path";
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync2 } from "child_process";
 function doctor(cwd) {
   const checks = [
     {
@@ -91,10 +216,15 @@ function doctor(cwd) {
       name: "Python available",
       test: () => {
         try {
-          execSync3("python3 --version", { encoding: "utf-8", timeout: 5e3 });
+          execSync2("python --version", { encoding: "utf-8", timeout: 5e3 });
           return true;
         } catch {
-          return false;
+          try {
+            execSync2("python3 --version", { encoding: "utf-8", timeout: 5e3 });
+            return true;
+          } catch {
+            return false;
+          }
         }
       }
     },
@@ -118,13 +248,89 @@ function doctor(cwd) {
   }
 }
 
+// src/commands/status.ts
+import { execSync as execSync3 } from "child_process";
+import { readdirSync } from "fs";
+import { join as join3 } from "path";
+function tryExec(cmd, cwd) {
+  try {
+    return execSync3(cmd, { cwd, encoding: "utf-8", timeout: 15e3 }).trim();
+  } catch {
+    return null;
+  }
+}
+function status(cwd) {
+  let maturity = "?/?";
+  const scoreOut = tryExec("python scripts/maturity_score.py --ci --threshold 0", cwd);
+  if (scoreOut) {
+    const m = scoreOut.match(/Maturity score:\s*(\d+)\s*\/\s*(\d+)/);
+    if (m) maturity = `${m[1]}/${m[2]}`;
+  }
+  let driftCount = "?";
+  const driftOut = tryExec(
+    `python -c "from morphism.healing.drift_scanner import DriftScanner; print(len(DriftScanner().scan()))"`,
+    cwd
+  );
+  if (driftOut) driftCount = driftOut;
+  let proofCount = 0;
+  try {
+    const proofsDir = join3(cwd, ".morphism", "proofs");
+    proofCount = readdirSync(proofsDir).filter((f) => f.endsWith(".json")).length;
+  } catch {
+  }
+  console.log(`Maturity: ${maturity}  |  Drift: ${driftCount} items  |  Proofs: ${proofCount}`);
+}
+
+// src/commands/diff.ts
+import { execSync as execSync4 } from "child_process";
+function tryExec2(cmd, cwd) {
+  try {
+    return execSync4(cmd, { cwd, encoding: "utf-8", timeout: 15e3 }).trim();
+  } catch {
+    return null;
+  }
+}
+function diff(cwd, since) {
+  const ref = since ?? "HEAD~1";
+  const changedFiles = tryExec2(`git diff --name-only ${ref} -- docs/ AGENTS.md SSOT.md GUIDELINES.md .morphism/ scripts/`, cwd);
+  if (!changedFiles) {
+    console.log("No governance changes detected (or git not available).");
+    return;
+  }
+  const files = changedFiles.split("\n").filter(Boolean);
+  if (files.length === 0) {
+    console.log(`No governance files changed since ${ref}.`);
+    return;
+  }
+  console.log(`Governance changes since ${ref}:`);
+  console.log();
+  for (const f of files) {
+    const stat = tryExec2(`git diff --stat ${ref} -- "${f}"`, cwd);
+    console.log(`  ${f}`);
+    if (stat) {
+      const lastLine = stat.split("\n").pop();
+      if (lastLine) console.log(`    ${lastLine.trim()}`);
+    }
+  }
+  console.log();
+  console.log(`${files.length} governance file(s) changed.`);
+  const driftOut = tryExec2(
+    `python -c "from morphism.healing.drift_scanner import DriftScanner; items = DriftScanner().scan(); print(f'{len(items)} drift items')"`,
+    cwd
+  );
+  if (driftOut) {
+    console.log(`Current drift: ${driftOut}`);
+  }
+}
+
 // src/commands/scaffold.ts
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, existsSync as existsSync3 } from "fs";
-import { join as join3, dirname } from "path";
+import { join as join4, dirname } from "path";
+import { input, select, confirm } from "@inquirer/prompts";
 function writeFiles(cwd, files) {
   let created = 0;
   for (const [relPath, content] of Object.entries(files)) {
-    const fullPath = join3(cwd, relPath);
+    const fullPath = join4(cwd, relPath);
     if (existsSync3(fullPath)) {
       console.log(`  skip: ${relPath} (already exists)`);
       continue;
@@ -538,7 +744,7 @@ Scaffolded ${created} file(s) using '${template}' template`);
 }
 function scaffoldMonorepo(cwd, name) {
   console.log(`Scaffolding monorepo '${name}'...`);
-  const targetDir = join3(cwd, name);
+  const targetDir = join4(cwd, name);
   mkdirSync2(targetDir, { recursive: true });
   const files = monorepoFiles(name);
   const created = writeFiles(targetDir, files);
@@ -619,17 +825,873 @@ Scaffolded ${created} governance file(s)`);
   console.log("  2. Review AGENTS.md and customize invariants");
   console.log("  3. Push to trigger governance CI checks");
 }
+async function promptTierVariables(tier, defaults) {
+  const projectName = await input({
+    message: "Project name:",
+    default: defaults.projectName
+  });
+  const description = await input({
+    message: "Brief project description:",
+    default: `A ${TIER_LABELS[tier]} project`
+  });
+  const vars = { projectName, description };
+  if (tier === 1) {
+    vars.framework = await select({
+      message: "Frontend framework:",
+      choices: [
+        { value: "React 18", name: "React 18" },
+        { value: "Next.js 15", name: "Next.js 15" },
+        { value: "Vue 3", name: "Vue 3" },
+        { value: "Svelte 5", name: "Svelte 5" },
+        { value: "Astro", name: "Astro" }
+      ],
+      default: "React 18"
+    });
+    vars.styling = await select({
+      message: "Styling solution:",
+      choices: [
+        { value: "Tailwind CSS", name: "Tailwind CSS" },
+        { value: "CSS Modules", name: "CSS Modules" },
+        { value: "Styled Components", name: "Styled Components" },
+        { value: "Vanilla CSS", name: "Vanilla CSS" }
+      ],
+      default: "Tailwind CSS"
+    });
+    vars.nodeVersion = await input({ message: "Node.js version:", default: "20" });
+  }
+  if (tier === 2) {
+    vars.domain = await input({
+      message: "Research domain (e.g., quantum mechanics, ML, physics):",
+      default: "scientific computing"
+    });
+    vars.moduleName = await input({
+      message: "Main Python module name:",
+      default: projectName.toLowerCase().replace(/[^a-z0-9_]/g, "_")
+    });
+  }
+  if (tier === 3) {
+    vars.buildSystem = await select({
+      message: "Build system:",
+      choices: [
+        { value: "Turborepo", name: "Turborepo" },
+        { value: "Nx", name: "Nx" },
+        { value: "Lerna", name: "Lerna" },
+        { value: "Make", name: "Make" }
+      ],
+      default: "Turborepo"
+    });
+    vars.buildCommand = await input({
+      message: "Build command:",
+      default: vars.buildSystem === "Turborepo" ? "npx turbo build" : "npm run build"
+    });
+  }
+  const addOptional = await confirm({ message: "Add org/maintainer info?", default: false });
+  if (addOptional) {
+    vars.githubOrg = await input({ message: "GitHub org/user:", default: "alawein" });
+    vars.maintainer = await input({ message: "Maintainer name:", default: "" });
+  }
+  return vars;
+}
+var TIER_LABELS = {
+  1: "Web Application (Tier 1)",
+  2: "Research / Python (Tier 2)",
+  3: "Governance / Monorepo (Tier 3)"
+};
+function tierClaudeTemplate(tier, projectName, date, vars) {
+  if (tier === 1) {
+    const framework = vars?.framework ?? "React 18";
+    const styling = vars?.styling ?? "Tailwind CSS";
+    const desc2 = vars?.description ?? `a web application built with TypeScript`;
+    return `# Claude Code Configuration \u2014 ${projectName}
+
+**Project Type:** Web Application (Product)
+**Last Updated:** ${date}
+
+---
+
+## Project Context
+
+This is **${projectName}** \u2014 ${desc2}.
+
+**Quick Reference:**
+- **Tech Stack:** ${framework}, TypeScript (strict mode), ${styling}
+- **Build:** \`npm run build\`
+- **Dev:** \`npm run dev\`
+- **Type Check:** \`npm run typecheck\`
+- **Lint:** \`npm run lint\`
+
+---
+
+## Session Bootstrap
+
+1. \`git log --oneline -10\` \u2014 recent work
+2. \`git status\` \u2014 current state
+3. Read GUIDELINES.md for code style
+4. \`npm install && npm run dev\`
+
+## Core Rules
+
+1. TypeScript \`strict: true\` at all times
+2. Functional components only (no class components)
+3. No \`any\` types without justification
+4. Run \`npm run typecheck\` before committing
+5. Follow GUIDELINES.md
+
+## Work Style
+
+- Execute, do not plan
+- One change at a time
+- If stuck >2 tool calls, ask
+
+## Test Gates
+
+\`\`\`bash
+npm run typecheck && npm run lint && npm run build
+\`\`\`
+
+---
+
+**Template:** morphism-systems/.morphism/templates/projects/product-web/
+**Generated by:** \`morphism scaffold tier 1\`
+`;
+  }
+  if (tier === 2) {
+    const domain = vars?.domain ?? "scientific computing";
+    const moduleName = vars?.moduleName ?? projectName.toLowerCase().replace(/[^a-z0-9_]/g, "_");
+    const desc2 = vars?.description ?? `a Python research project`;
+    return `# Claude Code Configuration \u2014 ${projectName}
+
+**Project Type:** Research / Scientific Computing
+**Last Updated:** ${date}
+
+---
+
+## Project Context
+
+This is **${projectName}** \u2014 ${desc2}.
+**Domain:** ${domain}
+**Module:** \`${moduleName}\`
+
+**Quick Reference:**
+- **Tech Stack:** Python 3.11+, pytest, mypy (strict), Ruff
+- **Install:** \`pip install -e ".[dev]"\`
+- **Type Check:** \`mypy src/\`
+- **Lint:** \`ruff check src/ && ruff format src/\`
+- **Test:** \`pytest tests/ -v\`
+
+---
+
+## Session Bootstrap
+
+1. \`git log --oneline -10\` \u2014 recent work
+2. \`git status\` \u2014 current state
+3. Read AGENTS.md for mission and scope
+4. Examine \`pyproject.toml\` for dependencies
+
+## Core Rules
+
+1. Complete type hints on every function (mypy strict)
+2. Google-style docstrings with examples
+3. >90% test coverage
+4. No \`Any\` without justification
+5. Dependencies pinned with version bounds
+
+## Work Style
+
+- Execute, do not plan
+- One change at a time
+- If stuck >2 tool calls, ask
+
+## Test Gates
+
+\`\`\`bash
+mypy src/ && ruff check src/ && pytest tests/ -v
+\`\`\`
+
+---
+
+**Template:** morphism-systems/.morphism/templates/projects/research-math/
+**Generated by:** \`morphism scaffold tier 2\`
+`;
+  }
+  const buildSystem = vars?.buildSystem ?? "Turborepo";
+  const buildCommand = vars?.buildCommand ?? "npx turbo build";
+  const desc = vars?.description ?? `a governance framework or monorepo project`;
+  return `# Claude Code Configuration \u2014 ${projectName}
+
+**Project Type:** Governance / Monorepo
+**Last Updated:** ${date}
+
+---
+
+## Project Context
+
+This is **${projectName}** \u2014 ${desc}.
+
+**Quick Reference:**
+- **Tech Stack:** Multi-language (TypeScript + Python)
+- **Build System:** ${buildSystem} (\`${buildCommand}\`)
+- **Type Check:** TypeScript strict + mypy strict
+- **Testing:** >95% coverage for governance paths
+
+---
+
+## Session Bootstrap
+
+1. \`git log --oneline -15\` \u2014 recent work
+2. \`git status\` \u2014 current state
+3. Read SSOT.md \u2014 single source of truth
+4. Read AGENTS.md \u2014 kernel invariants
+5. Read GUIDELINES.md \u2014 code style
+
+## Core Rules
+
+1. NEVER weaken kernel invariants
+2. Every code change updates SSOT/AGENTS/GUIDELINES as needed
+3. Cross-package changes require full test verification
+4. Governance verification must pass before commit
+5. Drift detection must report zero violations
+
+## Work Style
+
+- Execute, do not plan
+- One change at a time
+- If stuck >2 tool calls, ask
+
+## Test Gates
+
+\`\`\`bash
+# TypeScript
+npx turbo typecheck && npx turbo lint && npx turbo test
+# Python
+ruff check src/ && mypy src/ && pytest tests/
+# Governance
+python scripts/verify_pipeline.py
+\`\`\`
+
+---
+
+**Template:** morphism-systems/.morphism/templates/projects/tool-cli/
+**Generated by:** \`morphism scaffold tier 3\`
+`;
+}
+function tierAgentsTemplate(tier, projectName, date) {
+  const tierLabel = tier === 1 ? "Web" : tier === 2 ? "Research" : "Governance";
+  return `# Project Agents: Mission, Scope & Governance \u2014 ${projectName}
+
+**Status:** Active
+**Tier:** ${tier} (${tierLabel})
+**Last Updated:** ${date}
+
+---
+
+## 1. Mission Statement
+
+[Describe what ${projectName} does and who it serves]
+
+## 2. Scope
+
+### What This Project Is
+- [In-scope item 1]
+- [In-scope item 2]
+
+### What This Project Is NOT
+- [Out-of-scope item 1]
+
+## 3. Core Rules
+
+${tier === 1 ? `- R1: TypeScript strict mode
+- R2: Functional components only
+- R3: No breaking changes without version bump
+- R4: ESLint + Prettier before merge
+- R5: Auto-deploy to Vercel on main` : tier === 2 ? `- R1: mypy strict on all code
+- R2: Google-style docstrings on all functions
+- R3: >90% test coverage
+- R4: Dependencies pinned with bounds
+- R5: Reproducible results (seeds, dates, parameters)` : `- R1: All kernel invariants (I-1 through I-7) hold
+- R2: SSOT.md and AGENTS.md updated with every change
+- R3: Drift detection passes before merge
+- R4: Maturity score maintained
+- R5: Cross-package changes require full test suite`}
+
+## 4. Dependencies
+
+[List external and internal dependencies]
+
+## 5. Reading Order
+
+1. This file (AGENTS.md)
+2. README.md
+3. GUIDELINES.md
+4. CONTRIBUTING.md
+5. CLAUDE.md
+
+---
+
+**Generated by:** \`morphism scaffold tier ${tier}\`
+`;
+}
+function tierGuidelinesTemplate(projectName, tier, date) {
+  const isTS = tier === 1 || tier === 3;
+  const isPY = tier === 2 || tier === 3;
+  let content = `# Development Guidelines \u2014 ${projectName}
+
+**Last Updated:** ${date}
+
+---
+
+## Branching Strategy
+
+Format: \`type/short-description\`
+Types: feat/, fix/, docs/, refactor/, test/, chore/, perf/
+
+## Commit Conventions
+
+Follow [Conventional Commits](https://www.conventionalcommits.org/).
+Format: \`type(scope): subject\`
+
+`;
+  if (isTS) {
+    content += `## TypeScript Style
+
+- Naming: PascalCase (components), camelCase (utils), UPPER_SNAKE (constants)
+- Line length: 100 max, 2-space indent, semicolons required
+- Types: strict mode, no \`any\` without justification
+
+\`\`\`bash
+npm run typecheck && npm run lint -- --fix && npm run format
+\`\`\`
+
+`;
+  }
+  if (isPY) {
+    content += `## Python Style
+
+- Naming: snake_case (functions), PascalCase (classes), UPPER_SNAKE (constants)
+- Line length: 100 max, 4-space indent (PEP 8)
+- Types: mypy strict, Google-style docstrings
+
+\`\`\`bash
+mypy src/ && ruff check src/ --fix && ruff format src/
+\`\`\`
+
+`;
+  }
+  content += `## Code Review Checklist
+
+- [ ] Types correct (no \`any\`)
+- [ ] Tests included
+- [ ] Lint passes
+- [ ] Docs updated
+- [ ] Scope aligns with AGENTS.md
+
+---
+
+**Generated by:** \`morphism scaffold tier ${tier}\`
+`;
+  return content;
+}
+function tierContributingTemplate(projectName, tier) {
+  return `# Contributing to ${projectName}
+
+## Getting Started
+
+1. Fork and clone the repository
+2. Set up local environment:
+${tier === 1 ? `   \`\`\`bash
+   npm install
+   npm run dev
+   \`\`\`` : tier === 2 ? `   \`\`\`bash
+   python -m venv venv
+   source venv/bin/activate  # Windows: venv\\Scripts\\activate
+   pip install -e ".[dev]"
+   \`\`\`` : `   \`\`\`bash
+   npm install
+   pip install -e ".[dev]"
+   \`\`\``}
+3. Verify setup passes all checks
+
+## Workflow
+
+1. Create branch: \`git checkout -b feat/your-feature\`
+2. Make changes following GUIDELINES.md
+3. Run quality checks
+4. Commit with conventional commits
+5. Push and create PR
+
+## Code of Conduct
+
+Be respectful, constructive, and inclusive.
+
+---
+
+**Generated by:** \`morphism scaffold tier ${tier}\`
+`;
+}
+function tierCITemplate(tier, projectName) {
+  if (tier === 1) {
+    return `name: CI \u2014 ${projectName}
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: 'npm'
+      - run: npm ci
+      - run: npm run typecheck
+      - run: npm run lint
+      - run: npm run build
+      - run: npm run test -- --run
+        if: always()
+`;
+  }
+  if (tier === 2) {
+    return `name: CI \u2014 ${projectName}
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.11', '3.12', '3.13']
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v4
+        with:
+          python-version: \${{ matrix.python-version }}
+          cache: 'pip'
+      - run: pip install -e ".[dev]"
+      - run: mypy src/
+      - run: ruff check src/ && ruff format --check src/
+      - run: pytest tests/ -v --cov=src/ --cov-report=xml
+`;
+  }
+  return `name: CI \u2014 ${projectName}
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: 'npm'
+      - uses: actions/setup-python@v4
+        with:
+          python-version: '3.12'
+      - run: npm ci
+      - run: npx turbo build
+      - run: npx turbo typecheck
+      - run: npx turbo lint
+      - run: npx turbo test
+      - run: pip install -e ".[dev]"
+      - run: ruff check src/ && mypy src/ && pytest tests/
+`;
+}
+function githubTemplateFiles(projectName) {
+  return {
+    ".github/ISSUE_TEMPLATE/bug_report.md": `---
+name: Bug Report
+about: Report a bug or unexpected behavior
+title: "[BUG] "
+labels: bug
+---
+
+## Description
+<!-- Brief description of the bug -->
+
+## Steps to Reproduce
+1.
+2.
+3.
+
+## Expected Behavior
+<!-- What should happen -->
+
+## Actual Behavior
+<!-- What actually happens -->
+
+## Environment
+- **Project:** ${projectName}
+- **OS:**
+- **Version:**
+`,
+    ".github/ISSUE_TEMPLATE/feature_request.md": `---
+name: Feature Request
+about: Suggest an idea
+title: "[FEATURE] "
+labels: enhancement
+---
+
+## Description
+<!-- Clear description of the feature -->
+
+## Motivation
+<!-- Why is this needed? -->
+
+## Proposed Solution
+<!-- How should it work? -->
+
+## Acceptance Criteria
+- [ ] Criterion 1
+- [ ] Criterion 2
+`,
+    ".github/pull_request_template.md": `## Description
+<!-- What does this PR do? -->
+
+## Type of Change
+- [ ] Bug fix
+- [ ] New feature
+- [ ] Documentation
+- [ ] Refactoring
+
+## Checklist
+- [ ] Follows GUIDELINES.md
+- [ ] Tests included
+- [ ] Lint passes
+- [ ] Types correct
+- [ ] Docs updated
+`
+  };
+}
+async function scaffoldTier(cwd, tier, options = {}) {
+  if (tier < 1 || tier > 3) {
+    console.error(`Invalid tier: ${tier}. Must be 1, 2, or 3.`);
+    console.error("  1 = Web Application (React/Vite/TypeScript)");
+    console.error("  2 = Research / Python (pytest/mypy/Ruff)");
+    console.error("  3 = Governance / Monorepo (multi-language)");
+    process.exit(1);
+  }
+  const defaultName = options.name || cwd.split(/[\\/]/).pop() || "project";
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  let vars;
+  if (options.interactive) {
+    console.log(`
+  Morphism Scaffold \u2014 Interactive Mode (Tier ${tier})
+`);
+    vars = await promptTierVariables(tier, { projectName: defaultName });
+    console.log();
+  }
+  const projectName = vars?.projectName ?? defaultName;
+  const tierLabel = TIER_LABELS[tier];
+  console.log(`Scaffolding ${tierLabel} governance for '${projectName}'...`);
+  const files = {
+    "CLAUDE.md": tierClaudeTemplate(tier, projectName, date, vars),
+    "GUIDELINES.md": tierGuidelinesTemplate(projectName, tier, date)
+  };
+  if (tier >= 2) {
+    files["AGENTS.md"] = tierAgentsTemplate(tier, projectName, date);
+    files["CONTRIBUTING.md"] = tierContributingTemplate(projectName, tier);
+  }
+  if (options.ci !== false) {
+    files[".github/workflows/ci.yml"] = tierCITemplate(tier, projectName);
+  }
+  if (options.github !== false) {
+    Object.assign(files, githubTemplateFiles(projectName));
+  }
+  if (tier === 3) {
+    files[".morphism/config.json"] = JSON.stringify(
+      {
+        version: "0.1.0",
+        governance: { kernel: "morphism-kernel", invariants: 7, tenets: 10 },
+        metrics: { convergence_threshold: 1, drift_threshold: 15 }
+      },
+      null,
+      2
+    ) + "\n";
+  }
+  const created = writeFiles(cwd, files);
+  console.log(`
+Scaffolded ${created} file(s) for ${tierLabel}`);
+  console.log(`
+Files generated:`);
+  console.log(`  - CLAUDE.md (AI agent configuration for tier ${tier})`);
+  console.log(`  - GUIDELINES.md (code style & conventions)`);
+  if (tier >= 2) {
+    console.log(`  - AGENTS.md (mission, scope, governance)`);
+    console.log(`  - CONTRIBUTING.md (contribution workflow)`);
+  }
+  if (options.ci !== false) console.log(`  - .github/workflows/ci.yml`);
+  if (options.github !== false) {
+    console.log(`  - .github/ISSUE_TEMPLATE/bug_report.md`);
+    console.log(`  - .github/ISSUE_TEMPLATE/feature_request.md`);
+    console.log(`  - .github/pull_request_template.md`);
+  }
+  console.log(`
+Next steps:`);
+  console.log(`  1. Review and customize each generated file`);
+  console.log(`  2. Fill in [bracketed sections] and project-specific details`);
+  console.log(`  3. Run your project's test suite to verify nothing breaks`);
+  console.log(`  4. Commit: git add . && git commit -m "chore: onboard to morphism governance (tier ${tier})"`);
+}
+
+// src/commands/entropy.ts
+import { execSync as execSync5 } from "child_process";
+import fs from "fs";
+import path from "path";
+function measureEntropy(text, base = 2) {
+  const escapedText = text.replace(/'/g, `'"'"'`);
+  try {
+    const out = execSync5(
+      `python3 -c "
+import sys
+sys.path.insert(0, 'src')
+from morphism.entropy.llm_entropy import measure_text_entropy, classify_entropy_level
+e = measure_text_entropy('${escapedText}', base=${base})
+c = classify_entropy_level(e)
+print(f'{e}|{c.value}')
+"`,
+      { encoding: "utf-8", timeout: 1e4 }
+    );
+    const [entropyStr, classification] = out.trim().split("|");
+    const entropy = parseFloat(entropyStr);
+    return {
+      entropy,
+      classification,
+      interpretation: interpretEntropy(entropy)
+    };
+  } catch {
+    return measureEntropyJS(text, base);
+  }
+}
+function compareEntropy(text1, text2) {
+  const result1 = measureEntropy(text1);
+  const result2 = measureEntropy(text2);
+  const delta = result2.entropy - result1.entropy;
+  const percentChange = result1.entropy > 0 ? delta / result1.entropy * 100 : 0;
+  return {
+    text1: { entropy: result1.entropy, classification: result1.classification },
+    text2: { entropy: result2.entropy, classification: result2.classification },
+    comparison: {
+      delta,
+      direction: delta > 0 ? "increased" : delta < 0 ? "decreased" : "unchanged",
+      percent_change: percentChange
+    },
+    recommendation: getRecommendation(delta, result1.entropy, result2.entropy)
+  };
+}
+function entropyReport(filePaths, options = {}) {
+  const artifacts = [];
+  for (const filePath of filePaths) {
+    try {
+      const content = fs.readFileSync(filePath, "utf-8");
+      const ext = path.extname(filePath);
+      const type = getFileType(ext);
+      artifacts.push({ name: filePath, content, type });
+    } catch {
+      console.error(`Warning: Could not read file ${filePath}`);
+    }
+  }
+  const measurements = artifacts.map((a) => ({
+    name: a.name,
+    type: a.type,
+    ...measureEntropy(a.content)
+  }));
+  const avgEntropy = measurements.reduce((sum, m) => sum + m.entropy, 0) / measurements.length;
+  const maxEntropy = Math.max(...measurements.map((m) => m.entropy));
+  const minEntropy = Math.min(...measurements.map((m) => m.entropy));
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          summary: {
+            num_artifacts: measurements.length,
+            average_entropy: avgEntropy,
+            max_entropy: maxEntropy,
+            min_entropy: minEntropy,
+            entropy_range: maxEntropy - minEntropy
+          },
+          artifacts: measurements
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  console.log("\n=== Entropy Report ===\n");
+  console.log(`Analyzed ${measurements.length} artifacts
+`);
+  console.log("Summary:");
+  console.log(`  Average entropy: ${avgEntropy.toFixed(3)}`);
+  console.log(`  Range: ${minEntropy.toFixed(3)} - ${maxEntropy.toFixed(3)}`);
+  console.log("\nArtifacts:");
+  const nameWidth = Math.max(20, ...measurements.map((m) => m.name.length));
+  for (const m of measurements) {
+    const bar = getEntropyBar(m.entropy);
+    console.log(
+      `  ${m.name.padEnd(nameWidth)}  ${m.entropy.toFixed(3)}  ${m.classification.padEnd(10)}  ${bar}`
+    );
+  }
+  if (options.verbose) {
+    console.log("\nInterpretations:");
+    for (const m of measurements) {
+      console.log(`  ${m.name}:`);
+      console.log(`    ${m.interpretation}`);
+    }
+  }
+}
+function entropyMeasureCli(text, options) {
+  const base = options.base ?? 2;
+  const result = measureEntropy(text, base);
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log("\n=== Entropy Measurement ===\n");
+  console.log(`Entropy: ${result.entropy.toFixed(3)} bits`);
+  console.log(`Classification: ${result.classification}`);
+  console.log(`
+${result.interpretation}`);
+  const bar = getEntropyBar(result.entropy);
+  console.log(`
+Visual: ${bar}`);
+}
+function entropyCompareCli(text1, text2, options) {
+  const result = compareEntropy(text1, text2);
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log("\n=== Entropy Comparison ===\n");
+  console.log(`Text 1: ${result.text1.entropy.toFixed(3)} bits (${result.text1.classification})`);
+  console.log(`Text 2: ${result.text2.entropy.toFixed(3)} bits (${result.text2.classification})`);
+  console.log(`
+Delta: ${result.comparison.delta > 0 ? "+" : ""}${result.comparison.delta.toFixed(3)} bits`);
+  console.log(`Change: ${result.comparison.percent_change.toFixed(1)}% ${result.comparison.direction}`);
+  console.log(`
+${result.recommendation}`);
+}
+function entropyReportCli(files, options) {
+  entropyReport(files, options);
+}
+function interpretEntropy(entropy) {
+  if (entropy < 1) {
+    return "Very low entropy: highly predictable/deterministic content";
+  }
+  if (entropy < 2) {
+    return "Low entropy: mostly predictable with some variation";
+  }
+  if (entropy < 3) {
+    return "Moderate entropy: balanced predictability and variation";
+  }
+  if (entropy < 4) {
+    return "High entropy: significant variation/uncertainty";
+  }
+  return "Very high entropy: highly unpredictable content";
+}
+function getRecommendation(delta, _e1, _e2) {
+  if (Math.abs(delta) < 0.1) {
+    return "Entropy levels are similar; content complexity is comparable";
+  }
+  if (delta > 1) {
+    return "Significant entropy increase: second text is much more complex/uncertain";
+  }
+  if (delta > 0) {
+    return "Moderate entropy increase: second text has more variation";
+  }
+  if (delta < -1) {
+    return "Significant entropy decrease: second text is much more deterministic";
+  }
+  return "Moderate entropy decrease: second text is more predictable";
+}
+function measureEntropyJS(text, base) {
+  const freq = {};
+  for (const char of text) {
+    freq[char] = (freq[char] || 0) + 1;
+  }
+  const len = text.length;
+  let entropy = 0;
+  for (const count of Object.values(freq)) {
+    const p = count / len;
+    entropy -= p * Math.log(p);
+  }
+  entropy = entropy / Math.log(base);
+  return {
+    entropy,
+    classification: classifyEntropy(entropy),
+    interpretation: interpretEntropy(entropy)
+  };
+}
+function classifyEntropy(entropy) {
+  if (entropy < 1) return "VERY_LOW";
+  if (entropy < 2) return "LOW";
+  if (entropy < 3) return "MODERATE";
+  if (entropy < 4) return "HIGH";
+  return "VERY_HIGH";
+}
+function getEntropyBar(entropy, width = 20) {
+  const normalized = Math.min(entropy / 5, 1);
+  const filled = Math.round(normalized * width);
+  const empty = width - filled;
+  return "[" + "#".repeat(filled) + "-".repeat(empty) + "]";
+}
+function getFileType(ext) {
+  const types = {
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".py": "python",
+    ".md": "markdown",
+    ".json": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".txt": "text"
+  };
+  return types[ext.toLowerCase()] || "unknown";
+}
 
 // src/index.ts
 var program = new Command();
-program.name("morphism").description("Morphism governance CLI").version("0.1.0");
+program.name("morphism").description("Morphism governance CLI").version("0.1.3");
 program.command("init").description("Initialize .morphism/ config in the current project").action(() => init(process.cwd()));
-program.command("validate").description("Run the governance validation pipeline").action(() => validate(process.cwd()));
+program.command("validate").description("Run the governance validation pipeline").option("--full", "Run full validation including categorical loop").option("--commit <sha>", "Git commit SHA to validate").option("--proof-dir <dir>", "Directory for proof witnesses", ".morphism/proofs").option("--format <fmt>", "Output format: text or json", "text").action(async (opts) => validate(process.cwd(), opts));
 program.command("score").description("Compute the governance maturity score").option("-t, --threshold <n>", "Minimum passing score", "60").action((opts) => score(process.cwd(), parseInt(opts.threshold)));
 program.command("doctor").description("Health check \u2014 verify governance setup").action(() => doctor(process.cwd()));
+program.command("status").description("One-line governance summary: maturity, drift, proofs").action(() => status(process.cwd()));
+program.command("diff").description("Show governance delta since last commit").option("--since <ref>", "Git ref to compare against", "HEAD~1").action((opts) => diff(process.cwd(), opts.since));
 var scaffoldCmd = program.command("scaffold").description("Scaffold projects, packages, and governance files");
 scaffoldCmd.command("monorepo <name>").description("Generate a full Morphism-governed monorepo").action((name) => scaffoldMonorepo(process.cwd(), name));
 scaffoldCmd.command("package <name>").description("Add a new package to an existing monorepo").action((name) => scaffoldPackage(process.cwd(), name));
 scaffoldCmd.command("governance").description("Add governance files (AGENTS.md, SSOT.md, GUIDELINES.md, .morphism/) to an existing project").action(() => scaffoldGovernance(process.cwd()));
+scaffoldCmd.command("tier <tier>").description("Generate tier-specific governance files (1=web, 2=research, 3=governance)").option("-n, --name <name>", "Project name (defaults to directory name)").option("-i, --interactive", "Prompt for project-specific values").option("--no-ci", "Skip CI workflow generation").option("--no-github", "Skip GitHub issue/PR templates").action(
+  async (tier, opts) => scaffoldTier(process.cwd(), parseInt(tier), {
+    name: opts.name,
+    interactive: opts.interactive === true,
+    ci: opts.ci !== false,
+    github: opts.github !== false
+  })
+);
 scaffoldCmd.command("legacy <template>").description("Legacy scaffold templates (ts-project, py-project)").action((template) => scaffold(process.cwd(), template));
+var entropyCmd = program.command("entropy").description("Measure and analyze entropy of text/artifacts");
+entropyCmd.command("measure <text>").description("Measure entropy of text content").option("--base <n>", "Logarithm base (2=bits, e=nats)", "2").option("--json", "Output as JSON").action((text, opts) => entropyMeasureCli(text, { base: parseInt(opts.base), json: opts.json }));
+entropyCmd.command("compare <text1> <text2>").description("Compare entropy between two texts").option("--json", "Output as JSON").action((text1, text2, opts) => entropyCompareCli(text1, text2, { json: opts.json }));
+entropyCmd.command("report <files...>").description("Generate entropy report for files").option("--json", "Output as JSON").option("-v, --verbose", "Include detailed interpretations").action((files, opts) => entropyReportCli(files, { json: opts.json, verbose: opts.verbose }));
 program.parse();

package/package.json

@@ -1,36 +1,38 @@
-{
-  "name": "@morphism-systems/cli",
-  "version": "0.1.0",
-  "description": "Morphism governance CLI — init, validate, score, doctor",
-  "type": "module",
-  "main": "dist/index.js",
-  "bin": {
-    "morphism": "dist/index.js"
-  },
-  "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "lint": "echo 'no lint configured'"
-  },
-  "keywords": [
-    "morphism",
-    "governance",
-    "cli",
-    "ai-governance",
-    "category-theory"
-  ],
-  "license": "BUSL-1.1",
-  "publishConfig": {
-    "access": "public"
-  },
-  "dependencies": {
-    "commander": "^13.1.0",
-    "chalk": "^5.4.0"
-  },
-  "devDependencies": {
-    "tsup": "^8.4.0",
-    "typescript": "^5.8.3",
-    "vitest": "^3.0.0"
-  }
-}
+{
+  "name": "@morphism-systems/cli",
+  "version": "0.1.3",
+  "description": "Morphism governance CLI — init, validate, score, doctor",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "morphism": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "lint": "echo 'no lint configured'"
+  },
+  "keywords": [
+    "morphism",
+    "governance",
+    "cli",
+    "ai-governance",
+    "category-theory"
+  ],
+  "license": "BUSL-1.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.3.0",
+    "chalk": "^5.4.0",
+    "commander": "^13.1.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.0.0"
+  }
+}