@hazeljs/cli 2.0.5 → 2.0.7

package/README.md

@@ -1,8 +1,8 @@
 # @hazeljs/cli
 
-**From zero to AI-powered apps in one command.**
+**Scaffold Agent OS apps and HazelJS backends.**
 
-Generate controllers, services, modules, AI agents, RAG systems — or create a complete AI-Native application with PostgreSQL, Redis, and Docker. Interactive project setup, package management, and code that follows best practices.
+DNA / Store / Skillgate / HITL live in [Meridian](https://github.com/hazel-js/hazeljs-meridian-ops) and `hazel agent new`. HTTP + HCEL templates (`--template=ai-native`) are a secondary framework path — not the Agent OS flagship.
 
 [![npm version](https://img.shields.io/npm/v/@hazeljs/cli.svg)](https://www.npmjs.com/package/@hazeljs/cli)
 [![npm downloads](https://img.shields.io/npm/dm/@hazeljs/cli)](https://www.npmjs.com/package/@hazeljs/cli)
@@ -10,13 +10,13 @@ Generate controllers, services, modules, AI agents, RAG systems — or create a
 
 ## Features
 
-- 🤖 **AI-Native Templates** - Create complete AI applications with agents, RAG, PostgreSQL, and Docker
-- 🚀 **Project Scaffolding** - Create new HazelJS applications instantly with interactive setup
-- 🎨 **Code Generation** - Generate controllers, services, AI agents, RAG systems, and 20+ component types
-- 📦 **Package Management** - Add HazelJS packages interactively with optional setup file generation
-- 🏗️ **Best Practices** - Generated code follows HazelJS conventions and AI patterns
-- 🎯 **TypeScript First** - All generated code is fully typed
-- ⚡ **Fast Development** - Reduce boilerplate and speed up development
+- 🧬 **Agent OS** — `hazel agent new` (bare / agent-os / skillgate), Store, DNA install, runs, apply
+- 🚪 **Skillgate / Gatekeeper** — `hazel skillgate from-openapi`, `hazel gatekeeper validate|simulate|explain`
+- 🧪 **Eval / benchmark** — `hazel eval`, `hazel benchmark`
+- 🚀 **App scaffolding** — `hazel new`, `hazel g app` (HTTP skeleton or `--template=ai-native`)
+- 🎨 **Code generation** — controllers, services, agents, RAG, 20+ component types
+- 📦 **Package management** — `hazel add` with optional setup files
+- Generated apps do **not** list or import `reflect-metadata` — `@hazeljs/core` loads it
 
 ## Installation
 
@@ -34,25 +34,45 @@ npm install --save-dev @hazeljs/cli
 
 ## Commands
 
-### Create a New Application
+### Agent OS (start here)
 
-**AI-Native Application (Recommended for AI Projects):**
+**Flagship teaching path** — clone [Meridian](https://github.com/hazel-js/hazeljs-meridian-ops) (`store:sync` → `platform:sync` → `dev`). The CLI is not a substitute for that app.
+
+```bash
+# Smaller Agent OS / DNA scaffold (not Meridian)
+hazel agent new my-desk --template=agent-os
+# templates: bare | agent-os | skillgate
+# agent-os includes: DNA + real @Tool app + ops stack (self-healing + predictive-scaling) + K8s manifests
+cd my-desk && npm install && npm run dev
+
+hazel agent install ./packages/support.dna.json
+hazel agent runs list
+hazel store publish | install | list
+hazel skillgate from-openapi ./openapi.yaml
+hazel gatekeeper validate
+hazel benchmark
+hazel eval
+```
+
+`hazel agent run` is a DNA smoke with stubs. Real tools and HITL = your app’s `runtime.execute` / Meridian `/api/chat`. `hazel agent apply` declares desired state — it does not restart Node.
+
+### Create a framework application (secondary)
+
+HTTP + HCEL / RAG scaffold — **not** the Agent OS flagship:
 
 ```bash
 hazel g app my-ai-app --template=ai-native
 cd my-ai-app && npm install && cp .env.example .env && docker-compose up -d && npm run dev
 ```
 
-Creates a complete AI-powered application with agents, RAG (PostgreSQL + pgvector), Redis, and Docker.
-
-**Skeleton app (quick start):**
+Skeleton API:
 
 ```bash
 hazel g app my-app
 cd my-app && npm install && npm run dev
 ```
 
-**Full setup with interactive package selection:**
+Interactive package selection:
 
 ```bash
 hazel new my-app -i
@@ -218,6 +238,17 @@ hazel g serverless handler --platform lambda
 ## Quick Reference
 
 ```bash
+# Agent OS
+hazel agent new <name> [--template agent-os|bare|skillgate]
+hazel agent install <dna>
+hazel agent run | doctor | logs
+hazel agent runs list | inspect | cancel | resume | approve
+hazel store publish | install | list
+hazel skillgate from-openapi <spec>
+hazel gatekeeper validate | simulate | explain
+hazel benchmark
+hazel eval
+
 # Project Management
 hazel new <name> [-i]                # Create new project
 hazel info                           # Show project info

package/cli-manifest.json

@@ -4,7 +4,7 @@
   "description": "Machine-readable manifest of all CLI commands and options for LLM agent tool-use",
   "cli": {
     "name": "hazel",
-    "version": "2.0.5",
+    "version": "2.0.7",
     "description": "CLI for generating HazelJS components and applications"
   },
   "commands": [
@@ -746,6 +746,12 @@
           "label": "Configuration (@hazeljs/config)",
           "description": "Environment-based configuration management"
         },
+        {
+          "shortName": "config-server",
+          "npm": "@hazeljs/config-server",
+          "label": "Git config server (@hazeljs/config-server)",
+          "description": "Git-backed distributed configuration (Spring Cloud Config style)"
+        },
         {
           "shortName": "cron",
           "npm": "@hazeljs/cron",

package/dist/commands/agent-templates.js

@@ -54,7 +54,7 @@ exports.AGENT_TEMPLATES = [
     {
         id: 'agent-os',
         label: 'Agent OS mini-app',
-        description: 'DNA + real @Agent/@Tool TypeScript app (HITL refund demo) + store lock',
+        description: 'DNA + real @Agent/@Tool app + ops stack (self-healing + predictive scaling) + K8s manifests',
     },
     {
         id: 'skillgate',
@@ -156,6 +156,235 @@ Wire real \`@Tool\` / Skillgate handlers in your Hazel app for production behavi
 `,
     };
 }
+function agentOsOpsFiles(npm, _projectName) {
+    const deployment = npm;
+    const hpaName = `${npm}-hpa`;
+    return {
+        '.env.example': `# Agent runtime
+HITL=0
+
+# Ops stack (proactive scaling + reactive self-healing)
+ENABLE_OPS_STACK=0
+K8S_DEPLOYMENT=${deployment}
+K8S_NAMESPACE=default
+K8S_HPA_NAME=${hpaName}
+PROMETHEUS_URL=http://prometheus.monitoring.svc:9090
+SLACK_BOT_TOKEN=
+PAGERDUTY_ROUTING_KEY=
+`,
+        'src/ops/stack.ts': `import { createOperationsStack } from '@hazeljs/predictive-scaling';
+import {
+  FetchKubernetesRestartClient,
+  FetchKubernetesScalingClient,
+  createSlackHealingNotifier,
+  createHealingNotifierChain,
+  InMemoryKubernetesRestartClient,
+  InMemoryKubernetesScalingClient,
+} from '@hazeljs/self-healing';
+
+export function createAgentOpsStack(appName: string) {
+  const deployment = process.env.K8S_DEPLOYMENT ?? appName;
+  const namespace = process.env.K8S_NAMESPACE ?? 'default';
+  const hpaName = process.env.K8S_HPA_NAME ?? \`\${deployment}-hpa\`;
+  const inCluster = Boolean(process.env.KUBERNETES_SERVICE_HOST);
+
+  const scalingClient = inCluster
+    ? new FetchKubernetesScalingClient()
+    : new InMemoryKubernetesScalingClient();
+  const restartClient = inCluster
+    ? new FetchKubernetesRestartClient()
+    : new InMemoryKubernetesRestartClient();
+
+  const notifications = [];
+  if (process.env.SLACK_BOT_TOKEN) {
+    notifications.push(
+      createSlackHealingNotifier({
+        token: process.env.SLACK_BOT_TOKEN,
+        channel: process.env.SLACK_ALERT_CHANNEL ?? '#ops-alerts',
+      })
+    );
+  }
+
+  return createOperationsStack({
+    healing: {
+      strategies: ['config-rollback', 'hpa-boost', 'pod-restart', 'safe-mode'],
+      aiDiagnostics: true,
+      drain: { timeoutMs: 30_000 },
+      notifyOn: ['critical-healing', 'healing-failed', 'hpa-boost', 'pod-restart'],
+      notifications: notifications.length ? createHealingNotifierChain(notifications) : undefined,
+      kubernetes: {
+        deployment,
+        namespace,
+        client: restartClient,
+        drainBeforeRestart: true,
+        hpa: {
+          name: hpaName,
+          namespace,
+          client: scalingClient,
+          boostMinReplicas: Number(process.env.HPA_BOOST_MIN ?? 4),
+          restoreAfterMs: Number(process.env.HPA_RESTORE_MS ?? 300_000),
+        },
+      },
+      performance: {
+        enabled: true,
+        autoScaleOnDegradation: true,
+        thresholds: { criticalLatencyMs: 2000, sampleSize: 20 },
+      },
+    },
+    scaling: {
+      model: 'time-series-forecast',
+      metrics: ['requests', 'latency', 'cpu'],
+      horizon: '30m',
+      confidence: 0.85,
+      capacityPerReplica: Number(process.env.CAPACITY_PER_REPLICA ?? 120),
+      hpa: {
+        name: hpaName,
+        namespace,
+        client: scalingClient,
+        maxReplicas: Number(process.env.HPA_MAX_REPLICAS ?? 50),
+      },
+    },
+    prometheus: process.env.PROMETHEUS_URL
+      ? {
+          baseUrl: process.env.PROMETHEUS_URL,
+          pollIntervalMs: 60_000,
+          queries: {
+            requests: \`sum(rate(http_requests_total{service="${deployment}"}[5m]))\`,
+            latency:
+              \`histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket{service="${deployment}"}[5m])) by (le))\`,
+            cpu: \`avg(rate(container_cpu_usage_seconds_total{pod=~"${deployment}-.*"}[5m]))\`,
+          },
+        }
+      : undefined,
+  });
+}
+
+let opsStack: ReturnType<typeof createAgentOpsStack> | null = null;
+
+export function startAgentOpsStack(appName: string) {
+  if (opsStack) return opsStack;
+  opsStack = createAgentOpsStack(appName);
+  opsStack.start();
+  return opsStack;
+}
+
+export function stopAgentOpsStack() {
+  opsStack?.stop();
+  opsStack = null;
+}
+`,
+        'deploy/kubernetes/deployment.yaml': `apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: ${deployment}
+  labels:
+    app: ${deployment}
+spec:
+  replicas: 2
+  selector:
+    matchLabels:
+      app: ${deployment}
+  template:
+    metadata:
+      labels:
+        app: ${deployment}
+    spec:
+      serviceAccountName: ${deployment}
+      containers:
+        - name: agent
+          image: ${deployment}:latest
+          env:
+            - name: ENABLE_OPS_STACK
+              value: "1"
+            - name: K8S_DEPLOYMENT
+              value: ${deployment}
+            - name: K8S_HPA_NAME
+              value: ${hpaName}
+            - name: PROMETHEUS_URL
+              value: http://prometheus.monitoring.svc:9090
+          resources:
+            requests:
+              cpu: 250m
+              memory: 512Mi
+            limits:
+              cpu: "1"
+              memory: 1Gi
+`,
+        'deploy/kubernetes/hpa.yaml': `apiVersion: autoscaling/v2
+kind: HorizontalPodAutoscaler
+metadata:
+  name: ${hpaName}
+spec:
+  scaleTargetRef:
+    apiVersion: apps/v1
+    kind: Deployment
+    name: ${deployment}
+  minReplicas: 2
+  maxReplicas: 50
+  metrics:
+    - type: Resource
+      resource:
+        name: cpu
+        target:
+          type: Utilization
+          averageUtilization: 70
+    - type: Resource
+      resource:
+        name: memory
+        target:
+          type: Utilization
+          averageUtilization: 80
+`,
+        'deploy/kubernetes/service.yaml': `apiVersion: v1
+kind: Service
+metadata:
+  name: ${deployment}
+spec:
+  selector:
+    app: ${deployment}
+  ports:
+    - port: 80
+      targetPort: 3000
+`,
+        'deploy/kubernetes/serviceaccount.yaml': `apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: ${deployment}
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: Role
+metadata:
+  name: ${deployment}-ops
+rules:
+  - apiGroups: ["autoscaling"]
+    resources: ["horizontalpodautoscalers"]
+    verbs: ["get", "patch", "update"]
+  - apiGroups: ["apps"]
+    resources: ["deployments"]
+    verbs: ["get", "patch", "update"]
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: RoleBinding
+metadata:
+  name: ${deployment}-ops
+subjects:
+  - kind: ServiceAccount
+    name: ${deployment}
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: Role
+  name: ${deployment}-ops
+`,
+        'deploy/kubernetes/kustomization.yaml': `apiVersion: kustomize.config.k8s.io/v1beta1
+kind: Kustomization
+resources:
+  - serviceaccount.yaml
+  - deployment.yaml
+  - service.yaml
+  - hpa.yaml
+`,
+    };
+}
 function agentOsFiles(projectName) {
     const dnaName = agentDnaName(projectName);
     const npm = sanitizeNpmName(projectName);
@@ -197,6 +426,8 @@ Use lookupOrder for facts. Call processRefund only after lookup. Be concise.`,
             },
             dependencies: {
                 '@hazeljs/agent': '^1.0.6',
+                '@hazeljs/self-healing': '^2.0.5',
+                '@hazeljs/predictive-scaling': '^2.0.5',
             },
             devDependencies: {
                 '@types/node': '^20.19.39',
@@ -279,9 +510,16 @@ import {
   type AgentEvent,
 } from '@hazeljs/agent';
 import { SupportAgent } from './support.agent';
+import { startAgentOpsStack, stopAgentOpsStack } from './ops/stack';
 
 async function main() {
   const input = process.argv.slice(2).join(' ') || 'Where is ORD-1001?';
+
+  if (process.env.ENABLE_OPS_STACK === '1') {
+    startAgentOpsStack('${npm}');
+    process.on('SIGINT', () => stopAgentOpsStack());
+    process.on('SIGTERM', () => stopAgentOpsStack());
+  }
   // Demo uses mock LLM. Wire OpenAI (or another provider) in production apps.
   const llm = createMockLlmProvider(
     'Used real @Tool handlers on AgentRuntime. (Replace createMockLlmProvider with your LLM.)'
@@ -326,6 +564,8 @@ main().catch((e) => {
 | \`dna/agent.marketplace.json\` | DNA / marketplace package (OpenAPI-for-agents) |
 | \`src/support.agent.ts\` | Real tool handlers |
 | \`src/main.ts\` | AgentRuntime bootstrap + optional DNA overlay |
+| \`src/ops/stack.ts\` | Predictive scaling + self-healing ops stack |
+| \`deploy/kubernetes/\` | K8s Deployment, HPA, RBAC for in-cluster ops |
 
 ## Quick start
 
@@ -343,7 +583,21 @@ npm run store:install
 \`\`\`
 
 Set \`HITL=1\` to pause on \`processRefund\` approvals.
+
+## Production ops (predictive + self-healing)
+
+\`\`\`bash
+cp .env.example .env
+ENABLE_OPS_STACK=1 npm run dev
+
+# Deploy to Kubernetes (requires kubectl + kustomize)
+kubectl apply -k deploy/kubernetes
+\`\`\`
+
+- **Proactive:** \`@hazeljs/predictive-scaling\` forecasts traffic and adjusts HPA min replicas
+- **Reactive:** \`@hazeljs/self-healing\` heals failures, drains pods, opens Slack/Jira alerts
 `,
+        ...agentOsOpsFiles(npm, projectName),
     };
 }
 function skillgateFiles(projectName) {

package/dist/commands/agent.test.js

@@ -88,8 +88,12 @@ describe('agent templates scaffold', () => {
         (0, agent_templates_1.scaffoldAgentProject)({ name: 'os-demo', destDir: dest, template: 'agent-os' });
         expect(fs.existsSync(path.join(dest, 'src/support.agent.ts'))).toBe(true);
         expect(fs.existsSync(path.join(dest, 'src/main.ts'))).toBe(true);
+        expect(fs.existsSync(path.join(dest, 'src/ops/stack.ts'))).toBe(true);
+        expect(fs.existsSync(path.join(dest, 'deploy/kubernetes/hpa.yaml'))).toBe(true);
         expect(fs.existsSync(path.join(dest, 'dna/agent.marketplace.json'))).toBe(true);
         const pkg = JSON.parse(fs.readFileSync(path.join(dest, 'package.json'), 'utf8'));
+        expect(pkg.dependencies['@hazeljs/self-healing']).toBe('^2.0.5');
+        expect(pkg.dependencies['@hazeljs/predictive-scaling']).toBe('^2.0.5');
         expect(pkg.dependencies['reflect-metadata']).toBeUndefined();
         const main = fs.readFileSync(path.join(dest, 'src/main.ts'), 'utf8');
         const agent = fs.readFileSync(path.join(dest, 'src/support.agent.ts'), 'utf8');

package/dist/commands/organism.d.ts

@@ -0,0 +1,6 @@
+import { Command } from 'commander';
+/**
+ * `hazel organism` — inspect / control organism snapshots (Phase 1).
+ * Live runtime control uses the programmatic API; CLI reads/writes local snapshots.
+ */
+export declare function registerOrganismCommand(program: Command): void;

package/dist/commands/organism.js

@@ -0,0 +1,214 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerOrganismCommand = registerOrganismCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const DEFAULT_STORE = path.join('.hazel', 'organisms.json');
+function loadStore(storePath) {
+    const resolved = path.resolve(storePath);
+    if (!fs.existsSync(resolved))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(resolved, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+function saveStore(storePath, data) {
+    const resolved = path.resolve(storePath);
+    fs.mkdirSync(path.dirname(resolved), { recursive: true });
+    fs.writeFileSync(resolved, JSON.stringify(data, null, 2));
+}
+/**
+ * `hazel organism` — inspect / control organism snapshots (Phase 1).
+ * Live runtime control uses the programmatic API; CLI reads/writes local snapshots.
+ */
+function registerOrganismCommand(program) {
+    const org = program.command('organism').description('Agentic Organism Runtime commands');
+    org
+        .command('list')
+        .description('List known organisms from the local snapshot store')
+        .option('--store <path>', 'Snapshot store path', DEFAULT_STORE)
+        .option('--json', 'Print JSON')
+        .action((opts) => {
+        const data = loadStore(opts.store);
+        const rows = Object.values(data);
+        if (opts.json) {
+            console.log(JSON.stringify({ organisms: rows }, null, 2));
+            return;
+        }
+        if (!rows.length) {
+            console.log('No organisms found. Use createOrganism() then persist a snapshot.');
+            return;
+        }
+        for (const r of rows) {
+            console.log(`${r.id}\t${r.status}\t${r.mission.objective}`);
+        }
+    });
+    org
+        .command('inspect <id>')
+        .description('Inspect an organism snapshot')
+        .option('--store <path>', 'Snapshot store path', DEFAULT_STORE)
+        .option('--json', 'Print JSON')
+        .action((id, opts) => {
+        const data = loadStore(opts.store);
+        const snap = data[id];
+        if (!snap) {
+            console.error(`Organism not found: ${id}`);
+            process.exitCode = 1;
+            return;
+        }
+        console.log(opts.json ? JSON.stringify(snap, null, 2) : formatInspect(snap));
+    });
+    org
+        .command('agents <id>')
+        .description('List agents for an organism')
+        .option('--store <path>', 'Snapshot store path', DEFAULT_STORE)
+        .option('--json', 'Print JSON')
+        .action((id, opts) => {
+        const snap = loadStore(opts.store)[id];
+        if (!snap) {
+            console.error(`Organism not found: ${id}`);
+            process.exitCode = 1;
+            return;
+        }
+        if (opts.json) {
+            console.log(JSON.stringify({ agents: snap.agents }, null, 2));
+            return;
+        }
+        for (const a of snap.agents) {
+            console.log(`${a.id}\t${a.status}\tgen=${a.generation}\t${a.name ?? ''}`);
+        }
+    });
+    org
+        .command('genealogy <id>')
+        .description('Show agent genealogy')
+        .option('--store <path>', 'Snapshot store path', DEFAULT_STORE)
+        .option('--json', 'Print JSON')
+        .action((id, opts) => {
+        const snap = loadStore(opts.store)[id];
+        if (!snap) {
+            console.error(`Organism not found: ${id}`);
+            process.exitCode = 1;
+            return;
+        }
+        console.log(opts.json
+            ? JSON.stringify(snap.genealogy ?? [], null, 2)
+            : JSON.stringify(snap.genealogy ?? [], null, 2));
+    });
+    org
+        .command('resources <id>')
+        .description('Show organism resource pool')
+        .option('--store <path>', 'Snapshot store path', DEFAULT_STORE)
+        .option('--json', 'Print JSON')
+        .action((id, opts) => {
+        const snap = loadStore(opts.store)[id];
+        if (!snap) {
+            console.error(`Organism not found: ${id}`);
+            process.exitCode = 1;
+            return;
+        }
+        console.log(JSON.stringify(snap.resources ?? {}, null, 2));
+    });
+    org
+        .command('events <id>')
+        .description('Show recent organism events')
+        .option('--store <path>', 'Snapshot store path', DEFAULT_STORE)
+        .option('--json', 'Print JSON')
+        .action((id, opts) => {
+        const snap = loadStore(opts.store)[id];
+        if (!snap) {
+            console.error(`Organism not found: ${id}`);
+            process.exitCode = 1;
+            return;
+        }
+        console.log(JSON.stringify(snap.events ?? [], null, 2));
+    });
+    for (const action of ['pause', 'resume', 'stop']) {
+        org
+            .command(`${action} <id>`)
+            .description(`${action} an organism snapshot (status flag only in Phase 1 CLI)`)
+            .option('--store <path>', 'Snapshot store path', DEFAULT_STORE)
+            .action((id, opts) => {
+            const data = loadStore(opts.store);
+            const snap = data[id];
+            if (!snap) {
+                console.error(`Organism not found: ${id}`);
+                process.exitCode = 1;
+                return;
+            }
+            snap.status =
+                action === 'pause' ? 'paused' : action === 'resume' ? 'operating' : 'terminated';
+            snap.updatedAt = new Date().toISOString();
+            data[id] = snap;
+            saveStore(opts.store, data);
+            console.log(`Organism ${id} marked ${snap.status}`);
+        });
+    }
+    org
+        .command('save-snapshot')
+        .description('Helper: write a minimal demo snapshot for CLI testing')
+        .option('--store <path>', 'Snapshot store path', DEFAULT_STORE)
+        .option('--id <id>', 'Organism id', 'demo-org')
+        .action((opts) => {
+        const data = loadStore(opts.store);
+        data[opts.id] = {
+            id: opts.id,
+            status: 'operating',
+            mission: {
+                id: 'demo',
+                objective: 'Operate customer support while maintaining 90% CSAT',
+            },
+            agents: [],
+            genealogy: [],
+            resources: { tokensRemaining: 5000000 },
+            events: [],
+            updatedAt: new Date().toISOString(),
+        };
+        saveStore(opts.store, data);
+        console.log(`Wrote snapshot ${opts.id} to ${opts.store}`);
+    });
+}
+function formatInspect(snap) {
+    return [
+        `id: ${snap.id}`,
+        `status: ${snap.status}`,
+        `mission: ${snap.mission.objective}`,
+        `agents: ${snap.agents.length}`,
+        `updatedAt: ${snap.updatedAt}`,
+    ].join('\n');
+}

package/dist/index.js

@@ -59,6 +59,7 @@ const agent_1 = require("./commands/agent");
 const skillgate_1 = require("./commands/skillgate");
 const gatekeeper_1 = require("./commands/gatekeeper");
 const store_1 = require("./commands/store");
+const organism_1 = require("./commands/organism");
 // Read version from package.json to ensure consistency
 const packageJson = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, '../package.json'), 'utf8'));
 const program = new commander_1.Command();
@@ -77,6 +78,7 @@ program
 (0, skillgate_1.registerSkillgateCommand)(program);
 (0, gatekeeper_1.registerGatekeeperCommand)(program);
 (0, store_1.registerStoreCommand)(program);
+(0, organism_1.registerOrganismCommand)(program);
 // Generate command group (unified: hazel g <type> <name> [--path] [--dry-run] [--json], or hazel g --list)
 const generateCommand = program
     .command('generate')

package/dist/utils/packages-registry.js

@@ -91,6 +91,22 @@ export const oauthImports = [
         moduleExpression: "ConfigModule.forRoot({ envFilePath: '.env' })",
         setupTemplate: null,
     },
+    {
+        shortName: 'config-server',
+        npm: '@hazeljs/config-server',
+        label: 'Git config server (@hazeljs/config-server)',
+        hint: 'import { ConfigServer } from "@hazeljs/config-server";\n  // await new ConfigServer({ git: { uri: process.env.CONFIG_GIT_URI! }, port: 8888 }).start()',
+        moduleImport: "import { ConfigServerModule } from '@hazeljs/config-server';",
+        moduleExpression: "ConfigServerModule.forRoot({ git: { uri: process.env.CONFIG_GIT_URI || '' }, port: 8888 })",
+        setupTemplate: `import { ConfigServerModule } from '@hazeljs/config-server';
+
+// Add ConfigServerModule.forRoot(...) to your HazelModule imports, then start:
+// await new ConfigServer({ git: { uri: process.env.CONFIG_GIT_URI! }, port: 8888 }).start();
+export const configServerImports = [
+  ConfigServerModule.forRoot({ git: { uri: process.env.CONFIG_GIT_URI || '' }, port: 8888 }),
+];
+`,
+    },
     {
         shortName: 'cron',
         npm: '@hazeljs/cron',
@@ -269,6 +285,26 @@ export const gatekeeper = new AgentGatekeeper({
   defaultDecision: 'deny',
   policies: [],
 });
+`,
+    },
+    {
+        shortName: 'organism',
+        npm: '@hazeljs/organism',
+        label: 'Agentic Organism Runtime (@hazeljs/organism)',
+        hint: 'import { createOrganism, OrganismRuntime } from "@hazeljs/organism";\n  // const organism = await createOrganism({ mission, genes, constitution })',
+        moduleImport: null,
+        moduleExpression: null,
+        setupTemplate: `import { createOrganism } from '@hazeljs/organism';
+
+export async function startOrganism() {
+  const organism = await createOrganism({
+    mission: { id: 'ops', objective: 'Operate within budget and constraints' },
+    genes: [],
+    limits: { maxAgents: 10, maxGenerationDepth: 3 },
+  });
+  await organism.start();
+  return organism;
+}
 `,
     },
     {
@@ -363,6 +399,37 @@ export class ExampleResilienceService {
     return 'ok';
   }
 }
+`,
+    },
+    {
+        shortName: 'self-healing',
+        npm: '@hazeljs/self-healing',
+        label: 'Self-Healing Microservices (@hazeljs/self-healing)',
+        hint: 'import { SelfHealing, SelfHeal, createHealingCoordinator } from "@hazeljs/self-healing";',
+        moduleImport: null,
+        moduleExpression: null,
+        setupTemplate: `import { createHealingCoordinator } from '@hazeljs/self-healing';
+
+export const healing = createHealingCoordinator({
+  strategies: ['config-rollback', 'hpa-boost', 'pod-restart'],
+});
+`,
+    },
+    {
+        shortName: 'predictive-scaling',
+        npm: '@hazeljs/predictive-scaling',
+        label: 'Predictive Auto-Scaling (@hazeljs/predictive-scaling)',
+        hint: 'import { PredictiveScaling, createPredictiveScaler } from "@hazeljs/predictive-scaling";',
+        moduleImport: null,
+        moduleExpression: null,
+        setupTemplate: `import { createPredictiveScaler } from '@hazeljs/predictive-scaling';
+
+// Wire hpa.client to your Kubernetes scaling client
+export const scaler = createPredictiveScaler({
+  horizon: '30m',
+  metrics: ['requests', 'latency'],
+  hpa: { name: 'api-hpa', client: scalingClient },
+});
 `,
     },
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/cli",
-  "version": "2.0.5",
+  "version": "2.0.7",
   "description": "Command-line interface for scaffolding and generating HazelJS applications and components",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -31,11 +31,11 @@
     "mustache": "^4.2.0"
   },
   "peerDependencies": {
-    "@hazeljs/eval": "^2.0.5",
-    "@hazeljs/benchmark": "^2.0.5",
-    "@hazeljs/agent": "^2.0.5",
-    "@hazeljs/skillgate": "^2.0.5",
-    "@hazeljs/agent-gatekeeper": "^2.0.5"
+    "@hazeljs/eval": "^2.0.7",
+    "@hazeljs/benchmark": "^2.0.7",
+    "@hazeljs/agent": "^2.0.7",
+    "@hazeljs/skillgate": "^2.0.7",
+    "@hazeljs/agent-gatekeeper": "^2.0.7"
   },
   "peerDependenciesMeta": {
     "@hazeljs/eval": {
@@ -55,11 +55,11 @@
     }
   },
   "devDependencies": {
-    "@hazeljs/eval": "^2.0.5",
-    "@hazeljs/benchmark": "^2.0.5",
-    "@hazeljs/agent": "^2.0.5",
-    "@hazeljs/skillgate": "^2.0.5",
-    "@hazeljs/agent-gatekeeper": "^2.0.5",
+    "@hazeljs/eval": "^2.0.7",
+    "@hazeljs/benchmark": "^2.0.7",
+    "@hazeljs/agent": "^2.0.7",
+    "@hazeljs/skillgate": "^2.0.7",
+    "@hazeljs/agent-gatekeeper": "^2.0.7",
     "@types/inquirer": "^8.2.10",
     "@types/mustache": "^4.2.5",
     "typescript": "^6.0.3"