chati-dev 4.0.3 → 4.0.5

package/bin/chati.js

@@ -338,6 +338,11 @@ Intelligence:
   npx chati-dev registry [stats|check]             Entity registry
   npx chati-dev health                             System health check
 
+License:
+  npx chati-dev activate [--key=CHATI-XXXX]        Activate license on this machine
+  npx chati-dev deactivate                         Remove license key locally
+  npx chati-dev license                            Show license status
+
 Telemetry:
   npx chati-dev telemetry                          Show telemetry status
   npx chati-dev telemetry enable                   Enable anonymous telemetry
@@ -347,6 +352,32 @@ Telemetry:
       break;
     }
 
+    case 'activate': {
+      const keyFlag = args.find(a => a.startsWith('--key='));
+      const keyArg = keyFlag ? keyFlag.replace('--key=', '') : null;
+      const { runActivate } = await import('../src/license/commands.js');
+      await runActivate(targetDir, keyArg);
+      break;
+    }
+
+    case 'deactivate': {
+      const { runDeactivate } = await import('../src/license/commands.js');
+      runDeactivate(targetDir);
+      break;
+    }
+
+    case 'license': {
+      const licSubCmd = args[1] || 'status';
+      if (licSubCmd === 'deactivate') {
+        const { runDeactivate } = await import('../src/license/commands.js');
+        runDeactivate(targetDir);
+      } else {
+        const { runLicenseStatus } = await import('../src/license/commands.js');
+        await runLicenseStatus(targetDir);
+      }
+      break;
+    }
+
     default: {
       console.error(`Unknown command: ${command}`);
       console.error("Run 'npx chati-dev --help' for usage.");

package/framework/agents/build/dev.md

@@ -54,7 +54,32 @@ Implement each task from the approved task breakdown with high quality, followin
 ```
 For each task:
   1. Announce: "Starting T{X}: {title} — implementing now..."
-  2. Read task details and acceptance criteria
+  1.5. Pre-Flight Spec Check (BEFORE any code):
+     a. Validate Given-When-Then criteria:
+        → Are all criteria specific and measurable? (not "works correctly", "looks good")
+        → If ANY criterion is vague/untestable → STOP. Escalate G01: "{criterion} is ambiguous."
+        → If task has NO criteria → STOP. Escalate G01: "T{X} has no testable acceptance criteria."
+     b. Check dependencies:
+        → For each T{x}.{y} in Dependencies: is it marked complete in tasks.md?
+        → If dependency incomplete → STOP. Escalate: "Cannot start T{X}: T{dep} not yet complete."
+     c. Set implementation strategy from task size:
+        → XS/S: standard flow — proceed to Step 2
+        → M (2-4h): output brief implementation outline (files + approach), then proceed
+        → L (4-8h): output full implementation plan, ask "[ready/clarify/skip]", wait for user
+     RULE: NEVER write code before Step 1.5 passes. If spec is unclear, fix the spec first.
+     OUTPUT: "Spec check passed. T{X} is {size} — {strategy}."
+  2. Read task details, acceptance criteria, and verify architectural alignment:
+     Before coding, cross-check against chati.dev/artifacts/3-Architecture/architecture.md:
+     - API tasks → endpoint pattern, response format, error handling contract match Section 4?
+     - Database tasks → table/column names, relationships match Section 5 (Data Model)?
+     - Auth tasks → auth approach matches Section 6 (Authentication)?
+     - New modules/components → file structure matches Section 3 (System Components)?
+     If conflict detected → STOP. Escalate G05:
+     "T{X} conflicts with architecture decision: {specific conflict}.
+      Implement per architecture.md or per task spec?"
+     RULE: architecture.md is the source of truth. NEVER implement against architectural decisions.
+     RULE: Do NOT silently reconcile conflicts — always surface them.
+     If no architecture.md present → proceed with best practices, note in handoff.
   3. Implement code
      -> Output: "Implementation done. Running self-critique (5.5)..."
   4. Run self-critique (Step 5.5) — 1 fix pass, then proceed
@@ -89,7 +114,17 @@ WHILE tasks_pending:
 
   FOR attempt IN 1..3:
     1. Read task details and acceptance criteria
-    2. Implement code
+    1.5. Pre-Flight Spec Check:
+         → If ANY criterion is vague/untestable → mark task blocked (G01), skip to next task
+         → If task has no Given-When-Then criteria → mark task blocked (G01), skip to next
+         → If dependency not complete → mark task blocked, skip to next independent task
+         → M-size tasks: output implementation outline before coding
+         → L-size tasks: output full implementation plan before coding (no user confirmation)
+    2. Verify architectural alignment (cross-check architecture.md before coding):
+         → API/DB/Auth/module tasks: verify patterns match architecture.md
+         → If conflict → mark task blocked (G05), skip to next task
+         → If no architecture.md → proceed with best practices
+    3. Implement code
        -> Output: "T{X} implementation done. Self-critique (5.5)..."
     3. Run self-critique (Step 5.5) — 1 fix pass, then proceed
        -> Output: "T{X} critique done. Running tests..."
@@ -282,9 +317,11 @@ Criteria:
 6. No lint errors
 7. Self-critique (5.5 + 6.5) completed
 8. No blockers remaining
+9. Pre-flight spec check passed: criteria were specific and testable before coding started
+10. Architectural alignment verified: no G05 conflicts, or G05 explicitly resolved before coding
 
 Score = criteria met / total criteria
-Threshold: >= 95% per task
+Threshold: >= 95% per task (minimum 9/10)
 ```
 
 ---
@@ -325,7 +362,7 @@ agents:
   dev:
     status: in_progress | completed
     score: {average across all tasks}
-    criteria_count: {total criteria across all tasks}
+    criteria_count: 10
     completed_at: "{timestamp when all tasks done}"
 ```
 

package/framework/config.yaml

@@ -1,8 +1,8 @@
 # chati.dev Configuration
-version: "4.0.3"
+version: "4.0.4"
 installed_at: "2026-02-07T10:00:00Z"
-updated_at: "2026-03-21T00:00:00Z"
-installer_version: "4.0.3"
+updated_at: "2026-03-22T00:00:00Z"
+installer_version: "4.0.4"
 project_type: greenfield
 language: en
 ides: [claude-code]

package/framework/domains/agents/dev.yaml

@@ -48,6 +48,19 @@ rules:
     text: "Iterate on implementation until acceptance criteria are met."
     priority: normal
 
+  - id: dev-spec-intake
+    text: "MUST validate task spec BEFORE writing code: verify all Given-When-Then criteria are specific and testable, check all task dependencies are complete. Escalate G01 immediately for ambiguous criteria, G02 for conflicting criteria — NEVER start coding with unclear spec."
+    priority: critical
+
+  - id: dev-size-strategy
+    text: "MUST adapt implementation approach by task size: XS/S = standard flow; M (2-4h) = output implementation outline before coding; L (4-8h) = output implementation plan and ask user confirmation before starting (autonomous mode: output plan and proceed without confirmation)."
+    priority: high
+
+  - id: dev-arch-coherence
+    text: "MUST verify implementation aligns with architecture.md before coding any API endpoints, database schemas, auth flows, or new modules. Escalate G05 immediately if conflict detected. NEVER implement against architectural decisions — always surface conflicts to user."
+    priority: high
+
   # Provider Preference (v3.0.0)
-  - dev-provider: "Default provider: claude. Can run on gemini for large codebase tasks (1M context window)."
+  - id: dev-provider
+    text: "Default provider: claude. Can run on gemini for large codebase tasks (1M context window)."
     priority: normal

package/framework/hooks/license-guard.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+/**
+ * License Guard Hook — UserPromptSubmit
+ *
+ * Validates license status before each user prompt turn.
+ * Uses a 24h cache stored in ~/.chati-dev/license.yaml (global, all projects).
+ *
+ * Behavior:
+ * - No key configured  → allow (orchestrator handles inline activation)
+ * - Cache VALID < 24h  → allow silently
+ * - Cache EXPIRED/INVALID < 24h → block with renewal message
+ * - Cache stale (> 24h) → call API, refresh cache, then allow or block
+ * - API unreachable    → fail open (allow), never block work
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const API_BASE = 'https://chati.dev/api';
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+const GLOBAL_DIR = join(homedir(), '.chati-dev');
+const LICENSE_PATH = join(GLOBAL_DIR, 'license.yaml');
+
+async function main() {
+  let input = '';
+  for await (const chunk of process.stdin) input += chunk;
+
+  try {
+    // Read global license file
+    if (!existsSync(LICENSE_PATH)) {
+      allow(); // No license configured — orchestrator handles inline activation
+      return;
+    }
+
+    const licenseRaw = readFileSync(LICENSE_PATH, 'utf-8');
+    const licenseKey = readYamlField(licenseRaw, 'key');
+
+    if (!licenseKey || licenseKey === 'null') {
+      allow();
+      return;
+    }
+
+    // Check cache validity
+    const status = readYamlField(licenseRaw, 'status');
+    const checkedAt = readYamlField(licenseRaw, 'checked_at');
+    const age = checkedAt ? Date.now() - new Date(checkedAt).getTime() : Infinity;
+
+    if (age < CACHE_TTL_MS) {
+      if (status === 'VALID') { allow(); return; }
+      if (status === 'EXPIRED' || status === 'INVALID') {
+        block(buildMessage(status, readYamlField(licenseRaw, 'reason')));
+        return;
+      }
+    }
+
+    // Cache stale — call API
+    try {
+      const machineId = await computeMachineId();
+      const res = await fetch(
+        `${API_BASE}/license/validate?key=${encodeURIComponent(licenseKey)}&machine_id=${encodeURIComponent(machineId)}`,
+        { signal: AbortSignal.timeout(5000) }
+      );
+      const data = await res.json();
+
+      // Persist updated status (keep existing key)
+      const existing = parseYaml(licenseRaw);
+      const updated = {
+        ...existing,
+        status: data.status,
+        plan: data.plan ?? '',
+        days_remaining: data.days_remaining ?? '',
+        expires_at: data.expires_at ?? '',
+        reason: data.reason ?? '',
+        checked_at: new Date().toISOString(),
+      };
+      mkdirSync(GLOBAL_DIR, { recursive: true });
+      writeFileSync(LICENSE_PATH, dumpYaml(updated));
+
+      if (data.status === 'VALID') { allow(); return; }
+      block(buildMessage(data.status, data.reason));
+    } catch {
+      allow(); // Fail open — API unreachable
+    }
+  } catch {
+    allow(); // Parse error — fail open
+  }
+}
+
+function allow() {
+  process.stdout.write(JSON.stringify({ decision: 'allow' }));
+}
+
+function block(reason) {
+  process.stdout.write(JSON.stringify({ decision: 'block', reason }));
+}
+
+function buildMessage(status, reason) {
+  if (status === 'EXPIRED') {
+    return `chati.dev license expired. Renew at https://chati.dev/pricing\nAfter renewing: npx chati-dev activate --key=YOUR-KEY`;
+  }
+  return `chati.dev license invalid${reason ? ` (${reason})` : ''}.\nRun: npx chati-dev activate --key=YOUR-KEY\nOr visit https://chati.dev/pricing`;
+}
+
+function readYamlField(raw, field) {
+  const match = raw.match(new RegExp(`^${field}:\\s*(.+)$`, 'm'));
+  return match ? match[1].trim().replace(/^["']|["']$/g, '') : null;
+}
+
+/** Minimal YAML object parser for simple key:value files */
+function parseYaml(raw) {
+  const obj = {};
+  for (const line of raw.split('\n')) {
+    const m = line.match(/^(\w+):\s*(.*)$/);
+    if (m) obj[m[1]] = m[2].trim().replace(/^["']|["']$/g, '');
+  }
+  return obj;
+}
+
+/** Minimal YAML serializer for simple flat objects */
+function dumpYaml(obj) {
+  return Object.entries(obj)
+    .map(([k, v]) => `${k}: ${v == null ? '' : String(v).includes(':') ? `'${v}'` : v}`)
+    .join('\n') + '\n';
+}
+
+async function computeMachineId() {
+  const { createHash } = await import('crypto');
+  const os = await import('os');
+  const ifaces = Object.values(os.networkInterfaces()).flat();
+  const mac = ifaces.find(i => i && !i.internal && i.mac !== '00:00:00:00:00:00')?.mac ?? 'no-mac';
+  const raw = [os.hostname(), os.platform(), os.arch(), os.cpus()[0]?.model ?? '', os.userInfo().username, mac].join('|');
+  return createHash('sha256').update(raw).digest('hex').substring(0, 16);
+}
+
+import { fileURLToPath } from 'url';
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  main();
+}

package/framework/hooks/settings.json

@@ -5,6 +5,10 @@
       {
         "matcher": ".*",
         "hooks": [
+          {
+            "type": "command",
+            "command": "node chati.dev/hooks/license-guard.js"
+          },
           {
             "type": "command",
             "command": "node chati.dev/hooks/prism-engine.js"

package/framework/orchestrator/chati.md

@@ -18,6 +18,39 @@ You are the **Chati.dev Orchestrator**, the single entry point for the Chati.dev
 
 When the user invokes `/chati`, execute this sequence:
 
+### Pre-Flight: License Check
+
+FIRST — before anything else:
+
+```
+1. Read ~/.chati-dev/license.yaml
+
+If file is MISSING or status = "MISSING":
+  Say:
+    "Welcome to chati.dev! Before we start, I need to activate your license.
+
+    Option 1 — Paste your license key below.
+    Option 2 — Get a free 14-day trial: https://chati.dev/pricing
+
+    Enter your key (or press Enter if you just received one via email):"
+
+  → User provides key
+  → Run: `npx chati-dev activate --key={key}`
+  → Re-read ~/.chati-dev/license.yaml
+  → If status = VALID: "✓ Activated! Let's build." → proceed to Step 1
+  → If error: show error message, ask to try again (max 3 attempts, then stop)
+
+If status = "EXPIRED":
+  Say:
+    "Your chati.dev license has expired.
+    Renew at https://chati.dev/pricing
+    After renewing, run: npx chati-dev activate --key=YOUR-KEY"
+  → STOP. Do not proceed.
+
+If status = "VALID":
+  → Proceed silently. Zero mention of license in normal flow.
+```
+
 ### Step 1: Load Context
 ```
 1. Read .chati/session.yaml

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chati-dev",
-  "version": "4.0.3",
+  "version": "4.0.5",
   "description": "AI-Powered Multi-Agent Orchestration System — Structured vibe coding for Full Stack Development",
   "type": "module",
   "bin": {

package/src/license/client.js

@@ -0,0 +1,138 @@
+import { homedir } from 'os';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import yaml from 'js-yaml';
+import { getMachineId, getMachineName } from './machine-id.js';
+
+const API_BASE = 'https://chati.dev/api';
+export const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24h
+
+// ---------------------------------------------------------------------------
+// Global storage — ~/.chati-dev/license.yaml
+// One activation covers ALL projects on this machine.
+// ---------------------------------------------------------------------------
+
+export function getGlobalDir() {
+  return join(homedir(), '.chati-dev');
+}
+
+export function getGlobalLicensePath() {
+  return join(getGlobalDir(), 'license.yaml');
+}
+
+function readGlobal() {
+  const p = getGlobalLicensePath();
+  if (!existsSync(p)) return {};
+  try { return yaml.load(readFileSync(p, 'utf-8')) || {}; } catch { return {}; }
+}
+
+function writeGlobal(data) {
+  mkdirSync(getGlobalDir(), { recursive: true });
+  writeFileSync(getGlobalLicensePath(), yaml.dump(data, { lineWidth: -1 }));
+}
+
+// ---------------------------------------------------------------------------
+// Key helpers
+// ---------------------------------------------------------------------------
+
+/** Returns license key or null. projectDir param accepted but unused (global storage). */
+export function getLicenseKey(_projectDir) {
+  const key = readGlobal().key;
+  return key && key !== 'null' ? key : null;
+}
+
+export function setLicenseKey(_projectDir, key) {
+  const data = readGlobal();
+  data.key = key ?? null;
+  writeGlobal(data);
+}
+
+// ---------------------------------------------------------------------------
+// Status cache (stored in same global file)
+// ---------------------------------------------------------------------------
+
+export function getLicenseStatus(_projectDir) {
+  const data = readGlobal();
+  return Object.keys(data).length ? data : null;
+}
+
+export function saveLicenseStatus(_projectDir, status) {
+  const existing = readGlobal();
+  writeGlobal({ ...existing, ...status });
+}
+
+// ---------------------------------------------------------------------------
+// API operations
+// ---------------------------------------------------------------------------
+
+/**
+ * Activate a license key on this machine.
+ * Saves key + status to ~/.chati-dev/license.yaml.
+ * projectDir param accepted but unused.
+ */
+export async function activateLicense(_projectDir, key) {
+  const machineId = getMachineId();
+  const machineName = getMachineName();
+
+  const res = await fetch(`${API_BASE}/license/activate`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ key, machine_id: machineId, machine_name: machineName }),
+    signal: AbortSignal.timeout(10000),
+  });
+
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || 'Activation failed');
+
+  writeGlobal({
+    key,
+    status: 'VALID',
+    plan: data.plan ?? 'trial',
+    days_remaining: data.days_remaining ?? null,
+    expires_at: data.expires_at ?? null,
+    checked_at: new Date().toISOString(),
+  });
+
+  return data;
+}
+
+/**
+ * Validate current license against API and refresh cache.
+ */
+export async function validateLicense(_projectDir) {
+  const key = getLicenseKey();
+  if (!key) return { status: 'MISSING' };
+
+  const machineId = getMachineId();
+  const res = await fetch(
+    `${API_BASE}/license/validate?key=${encodeURIComponent(key)}&machine_id=${encodeURIComponent(machineId)}`,
+    { signal: AbortSignal.timeout(5000) }
+  );
+  const data = await res.json();
+
+  const result = {
+    key,
+    status: data.status,
+    plan: data.plan ?? null,
+    days_remaining: data.days_remaining ?? null,
+    expires_at: data.expires_at ?? null,
+    reason: data.reason ?? null,
+    checked_at: new Date().toISOString(),
+  };
+
+  writeGlobal(result);
+  return result;
+}
+
+/**
+ * Remove license locally (does not deactivate machine slot on server).
+ */
+export function deactivateLicense(_projectDir) {
+  const data = readGlobal();
+  writeGlobal({
+    ...data,
+    key: null,
+    status: 'MISSING',
+    checked_at: new Date().toISOString(),
+  });
+}

package/src/license/commands.js

@@ -0,0 +1,96 @@
+/**
+ * License CLI command handlers.
+ * Used by bin/chati.js for: activate, deactivate, license
+ */
+
+import { text, isCancel } from '@clack/prompts';
+import { activateLicense, deactivateLicense, getLicenseKey, getLicenseStatus, validateLicense } from './client.js';
+
+// ---------------------------------------------------------------------------
+// activate
+// ---------------------------------------------------------------------------
+
+export async function runActivate(projectDir, keyArg) {
+  let key = keyArg;
+
+  if (!key) {
+    const input = await text({
+      message: 'Enter your license key (format: CHATI-XXXX-XXXX-XXXX):',
+      placeholder: 'CHATI-XXXX-XXXX-XXXX',
+      validate(v) {
+        if (!v || !v.trim()) return 'Key is required';
+        if (!v.trim().startsWith('CHATI-')) return 'Key must start with CHATI-';
+        return undefined;
+      },
+    });
+    if (isCancel(input)) {
+      console.log('Activation cancelled.');
+      return;
+    }
+    key = input.trim();
+  }
+
+  console.log(`Activating ${key}...`);
+
+  try {
+    const result = await activateLicense(projectDir, key);
+    const plan = result.plan ?? 'trial';
+    const days = result.days_remaining ?? '?';
+    console.log(`\n✓ Activated! Plan: ${plan} — ${days} day(s) remaining.`);
+    console.log(`  Key saved to chati.dev/config.yaml`);
+    console.log(`  Run /chati to start.\n`);
+  } catch (err) {
+    console.error(`\n✗ Activation failed: ${err.message}`);
+    console.error(`  Visit https://chati.dev/pricing to get a key.\n`);
+    process.exit(1);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// deactivate
+// ---------------------------------------------------------------------------
+
+export function runDeactivate(projectDir) {
+  const key = getLicenseKey(projectDir);
+  if (!key) {
+    console.log('No license key found locally. Nothing to remove.');
+    return;
+  }
+  deactivateLicense(projectDir);
+  console.log(`\n✓ License key removed locally.`);
+  console.log(`  To free up a machine slot, visit https://chati.dev/dashboard\n`);
+}
+
+// ---------------------------------------------------------------------------
+// license status
+// ---------------------------------------------------------------------------
+
+export async function runLicenseStatus(projectDir) {
+  const key = getLicenseKey(projectDir);
+
+  if (!key) {
+    console.log('\nLicense: Not activated');
+    console.log('  Get a free 14-day trial at https://chati.dev/pricing\n');
+    return;
+  }
+
+  console.log(`\nChecking license...`);
+
+  let status;
+  try {
+    status = await validateLicense(projectDir);
+  } catch {
+    // Fallback to cache
+    status = getLicenseStatus(projectDir) ?? { status: 'UNKNOWN' };
+  }
+
+  console.log('\nLicense Status');
+  console.log('='.repeat(30));
+  console.log(`  Key:     ${key}`);
+  console.log(`  Status:  ${status.status}`);
+  if (status.plan) console.log(`  Plan:    ${status.plan}`);
+  if (status.days_remaining != null) console.log(`  Days remaining: ${status.days_remaining}`);
+  if (status.expires_at) console.log(`  Expires: ${status.expires_at}`);
+  if (status.reason) console.log(`  Reason:  ${status.reason}`);
+  console.log();
+}

package/src/license/machine-id.js

@@ -0,0 +1,24 @@
+import os from 'os';
+import crypto from 'crypto';
+
+/**
+ * Generates a stable 16-char machine fingerprint.
+ * Based on: hostname, platform, arch, CPU model, username, MAC address.
+ */
+export function getMachineId() {
+  const ifaces = Object.values(os.networkInterfaces()).flat();
+  const mac = ifaces.find(i => i && !i.internal && i.mac !== '00:00:00:00:00:00')?.mac ?? 'no-mac';
+  const raw = [
+    os.hostname(),
+    os.platform(),
+    os.arch(),
+    os.cpus()[0]?.model ?? '',
+    os.userInfo().username,
+    mac,
+  ].join('|');
+  return crypto.createHash('sha256').update(raw).digest('hex').substring(0, 16);
+}
+
+export function getMachineName() {
+  return os.hostname();
+}

package/src/telemetry/sender.js

@@ -9,7 +9,7 @@
 // Default Endpoint
 // ---------------------------------------------------------------------------
 
-export const DEFAULT_ENDPOINT = 'https://chati-telemetry.vercel.app/api/events';
+export const DEFAULT_ENDPOINT = 'https://chati.dev/api/telemetry';
 
 // ---------------------------------------------------------------------------
 // Sender

package/src/wizard/index.js

@@ -11,6 +11,7 @@ import { initCollector, track as telemetryTrack, flush as telemetryFlush } from
 import { sendEvents } from '../telemetry/sender.js';
 import { getTelemetryConfig } from '../telemetry/config.js';
 import { t } from './i18n.js';
+import { getLicenseKey, activateLicense } from '../license/client.js';
 import { DEFAULT_MCPS } from '../config/mcp-configs.js';
 import { IDE_CONFIGS, IDE_TO_PROVIDER } from '../config/ide-configs.js';
 
@@ -153,6 +154,9 @@ export async function runWizard(targetDir, options = {}) {
     console.log();
     p.outro(t('installer.success'));
 
+    // License activation step
+    await runLicenseActivationStep();
+
     // Show quick start — same experience across all providers
     const invokeCmdMap = {
       'codex-cli': '$chati',
@@ -195,3 +199,40 @@ export async function runWizard(targetDir, options = {}) {
     return { success: false, error: err.message };
   }
 }
+
+async function runLicenseActivationStep() {
+  const existingKey = getLicenseKey();
+  if (existingKey) {
+    console.log(`\n  ✓ License already active on this machine (${existingKey.substring(0, 12)}...)\n`);
+    return;
+  }
+
+  console.log('\n  ┌─ License Activation ─────────────────────────────────────────┐');
+  console.log('  │  Your license key works across ALL projects on this machine.  │');
+  console.log('  │  Get a free 14-day trial at: https://chati.dev/pricing        │');
+  console.log('  └──────────────────────────────────────────────────────────────┘\n');
+
+  const keyInput = await p.text({
+    message: 'Enter your license key (press Enter to skip — activate later with: npx chati-dev activate):',
+    placeholder: 'CHATI-XXXX-XXXX-XXXX',
+  });
+
+  if (p.isCancel(keyInput) || !keyInput?.trim()) {
+    console.log('  Skipped. Run: npx chati-dev activate --key=YOUR-KEY when ready.\n');
+    return;
+  }
+
+  const activateSpinner = createSpinner('Activating license...');
+  activateSpinner.start();
+  try {
+    const result = await activateLicense(null, keyInput.trim());
+    activateSpinner.stop();
+    const plan = result.plan ?? 'trial';
+    const days = result.days_remaining ?? '?';
+    console.log(`  ✓ License activated! Plan: ${plan} — ${days} day(s) remaining.\n`);
+  } catch (err) {
+    activateSpinner.stop();
+    console.log(`  ✗ Activation failed: ${err.message}`);
+    console.log('  Run: npx chati-dev activate --key=YOUR-KEY to try again.\n');
+  }
+}