@llm-dev-ops/agentics-cli 1.4.14 → 1.4.16

package/dist/cli/index.js

@@ -17,7 +17,7 @@ import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createCommandParser, SUPPORTED_COMMANDS } from '../modules/command-parser.js';
 import { createOutputRenderer } from '../modules/output-renderer.js';
-import { CLIError, errorHandler, toError } from '../errors/index.js';
+import { CLIError, ServiceError, errorHandler, toError } from '../errors/index.js';
 import { LocalhostInProductionError } from '../config/endpoints.js';
 import { EXIT_CODES, parseFlexibleInput, isNaturalLanguage } from '../types/index.js';
 // ============================================================================
@@ -72,6 +72,24 @@ import { executeDiligenceCommand } from '../commands/diligence.js';
 import { executeUsageCommand, executeUsageHistoryCommand, executeUsageLimitsCommand, executeUsageResetCommand, formatUsageForDisplay, formatHistoryForDisplay, formatLimitsForDisplay, } from '../commands/usage.js';
 import { executePolicyListCommand, executePolicyInspectCommand, executePolicyCreateCommand, executePolicyEditCommand, executePolicyDeleteCommand, executePolicyEnableCommand, executePolicyDisableCommand, executePolicyDryRunCommand, executePolicyScopeCommand, formatPolicyForDisplay, formatPoliciesListForDisplay, formatDryRunForDisplay, formatScopeForDisplay, } from '../commands/policy.js';
 import { executeErpListCommand, executeErpInspectCommand, executeErpSurfaceCommand, executeErpMapCommand, executeErpExportCommand, formatErpListForDisplay, formatErpInspectForDisplay, formatErpSurfaceForDisplay, formatErpMapForDisplay, formatErpExportForDisplay, } from '../commands/erp.js';
+import { executeReadinessShowCommand, executeReadinessExplainCommand, formatReadinessForDisplay, formatReadinessExplainForDisplay, } from '../commands/readiness.js';
+import { executeDemoStartCommand, } from '../commands/demo.js';
+import { executeAgentsListCommand, executeAgentsHealthCommand, executeAgentsInvokeCommand, executeNaturalLanguageRoute, formatAgentsListForDisplay, formatAgentResultForDisplay, formatNaturalLanguageRouteForDisplay, AGENT_DOMAINS, } from '../commands/agents.js';
+// ============================================================================
+// Utility Helpers
+// ============================================================================
+/**
+ * Slugify a description string into a short kebab-case policy name.
+ * Takes the first ~40 characters, lowercases, replaces non-alphanum with hyphens,
+ * collapses runs, and trims leading/trailing hyphens.
+ */
+function slugifyPolicyName(description) {
+    return description
+        .slice(0, 40)
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
 // ============================================================================
 // CONTROL PLANE HARDENING GATES
 // ============================================================================
@@ -95,12 +113,16 @@ import { enforceOutputFormatGate, requiresStructuredOutput, getDefaultFormat } f
 import { enforceArgumentGuard, requiresArgumentValidation } from '../gates/argument-guard.js';
 // Lineage Gate - Enforces simulation traceability per ADR-004
 import { enforceLineageGate, requiresLineageValidation } from '../gates/lineage-gate.js';
+// Readiness Gate - Enforces execution safety when execution-gated
+import { enforceReadinessGate, requiresReadinessValidation } from '../gates/readiness-gate.js';
 // Help Renderer - Schema-driven help from COMMAND_REGISTRY (ADR-002 Decision 1)
 import { renderHelp } from '../modules/help-renderer.js';
 // Synthesis Router - ADR-006/007/008 Claude Code integration
 import { routeSynthesis, isDecisionGrade } from '../synthesis/router.js';
 import { createArtifactWriter } from '../synthesis/artifact-writer.js';
 import { lookupCommand } from '../contracts/adr-command-semantics.js';
+// Dynamic routing — resolves downstream repos/agents based on request content
+// dynamic-router import removed — routing is now platform-side
 // ============================================================================
 // Synthesis Artifact Persistence (ADR-008)
 // ============================================================================
@@ -202,12 +224,12 @@ async function main() {
     // execution is explicitly enabled. Only identity/help commands are allowed
     // when execution is disabled. This gate does NOT check entitlements, usage,
     // or billing - it is a binary on/off switch.
-    enforceExecutionGate(parsed.command);
+    await enforceExecutionGate(parsed.command);
     // ============================================================================
     // GATE 2: AUTHENTICATION SESSION GATE - Requires valid credentials
     // ============================================================================
     // CLI requires authenticated session for ALL operational commands.
-    // Checks platform credentials first, then falls back to GCP credentials.
+    // Checks platform credentials (API key, internal key, or stored login).
     // CRITICAL: No anonymous operations are permitted.
     if (requiresAuthentication(parsed.command)) {
         await enforceAuthSessionGate();
@@ -254,6 +276,17 @@ async function main() {
     if (requiresLineageValidation(parsed.command, parsed.subcommand)) {
         enforceLineageGate(parsed);
     }
+    // ============================================================================
+    // GATE 7: READINESS GATE - Enforces execution safety
+    // ============================================================================
+    // Write-path commands (deploy run, deploy rollback) are blocked when the
+    // platform readiness state is not EXECUTION_READY. This gate reads from
+    // ~/.agentics/exports/decision-readiness/readiness-state.json and prevents
+    // production writes until all prerequisites are met.
+    // CRITICAL: No ERP writes or production deployments without readiness.
+    if (requiresReadinessValidation(parsed.command, parsed.subcommand)) {
+        enforceReadinessGate(parsed);
+    }
     // Dispatch to command handlers
     try {
         let result = null;
@@ -462,16 +495,28 @@ async function main() {
                             },
                         });
                         if (synthesisResult) {
-                            // Create the simulation using the synthesis output as metadata
+                            // Extract actual synthesis content (scenario, steps, etc.)
+                            const synthData = synthesisResult.data;
+                            const scenario = synthData?.['scenario'];
+                            const synthDescription = (scenario?.['description'] ??
+                                synthData?.['description'] ??
+                                parsed.options['description'] ??
+                                simName);
+                            const synthName = (scenario?.['name'] ??
+                                synthData?.['name'] ??
+                                simName);
+                            // Create the simulation record with synthesis-derived content
                             const simCreateResult = await executeSimulateCreateCommand({
-                                name: simName,
-                                description: parsed.options['description'],
+                                name: synthName || simName,
+                                description: synthDescription,
                                 plan_id: parsed.options['plan-id'],
                                 iterations: parsed.options['iterations'] ? parseInt(parsed.options['iterations'], 10) : undefined,
                                 metadata: {
                                     ...(parsed.options['metadata'] ? JSON.parse(parsed.options['metadata']) : {}),
                                     synthesis_run_id: synthesisResult.runId,
                                     synthesis_model: synthesisResult.model,
+                                    // Store the full synthesis content in metadata
+                                    synthesis_data: synthData,
                                 },
                             }, options);
                             // Persist synthesis artifacts (ADR-008)
@@ -488,9 +533,12 @@ async function main() {
                                 orgId: 'cli-org',
                                 traceId: options.trace_id ?? '',
                             });
+                            // Routing profile is now platform-side — not resolved locally.
                             if (options.format === 'json') {
+                                // Output the FULL synthesis content — not just the CRUD record
                                 console.log(JSON.stringify({
                                     simulation: simCreateResult.simulation,
+                                    data: synthData,
                                     synthesis: {
                                         run_id: synthesisResult.runId,
                                         model: synthesisResult.model,
@@ -820,7 +868,7 @@ async function main() {
                     process.exit(EXIT_CODES.SUCCESS);
                 }
                 // Default quantify behavior (execute via orchestration)
-                const quantifyInput = parsed.positionalArgs[0] ?? '';
+                const quantifyInput = parsed.positionalArgs[0] ?? parsed.subcommand ?? '';
                 const quantifyFlexibleInput = parseFlexibleInput(quantifyInput);
                 result = await executeQuantifyCommand({
                     simRef: isNaturalLanguage(quantifyFlexibleInput)
@@ -934,7 +982,7 @@ async function main() {
                     process.exit(EXIT_CODES.SUCCESS);
                 }
                 // Default deploy behavior (execute via orchestration)
-                const deployInput = parsed.positionalArgs[0] ?? '';
+                const deployInput = parsed.positionalArgs[0] ?? parsed.subcommand ?? '';
                 const deployFlexibleInput = parseFlexibleInput(deployInput);
                 result = await executeDeployCommand({
                     simRef: isNaturalLanguage(deployFlexibleInput)
@@ -1023,7 +1071,9 @@ async function main() {
                     process.exit(EXIT_CODES.SUCCESS);
                 }
                 // Default export behavior (execute via orchestration)
-                const exportInput = parsed.positionalArgs[0] ?? '';
+                // Note: parser consumes first arg as subcommand for commands with subcommands,
+                // so use subcommand as input if it wasn't a known subcommand and no positional args
+                const exportInput = parsed.positionalArgs[0] ?? parsed.subcommand ?? '';
                 const exportFlexibleInput = parseFlexibleInput(exportInput);
                 result = await executeExportCommand({
                     intentRef: isNaturalLanguage(exportFlexibleInput)
@@ -1158,6 +1208,78 @@ async function main() {
                 console.error('Supported subcommands: list, inspect, surface, map, export');
                 process.exit(EXIT_CODES.USAGE_ERROR);
             }
+            case 'readiness': {
+                // Handle readiness subcommands: show, explain
+                if (parsed.subcommand === 'show' || !parsed.subcommand) {
+                    const scenario = parsed.positionalArgs[0] ?? '';
+                    const readinessResult = await executeReadinessShowCommand({ scenario }, options);
+                    if (options.format === 'json') {
+                        console.log(JSON.stringify({
+                            state: readinessResult.state,
+                            found: readinessResult.found,
+                            scenario: readinessResult.scenario,
+                            timing: readinessResult.timing,
+                        }, null, parsed.flags['pretty'] ? 2 : 0));
+                    }
+                    else {
+                        console.log(formatReadinessForDisplay(readinessResult));
+                    }
+                    if (options.verbose) {
+                        console.error(`Query completed in ${readinessResult.timing}ms`);
+                    }
+                    process.exit(EXIT_CODES.SUCCESS);
+                }
+                if (parsed.subcommand === 'explain') {
+                    const scenario = parsed.positionalArgs[0] ?? '';
+                    const explainResult = await executeReadinessExplainCommand({ scenario }, options);
+                    // explain is always human-readable — no JSON mode
+                    console.log(formatReadinessExplainForDisplay(explainResult));
+                    if (options.verbose) {
+                        console.error(`Query completed in ${explainResult.timing}ms`);
+                    }
+                    process.exit(EXIT_CODES.SUCCESS);
+                }
+                // Unknown readiness subcommand
+                console.error(`Unknown readiness subcommand: ${parsed.subcommand}`);
+                console.error('Supported subcommands: show, explain');
+                process.exit(EXIT_CODES.USAGE_ERROR);
+            }
+            case 'demo': {
+                // Demo mode: read-only, gate-exempt, human-readable only
+                const executionKeywords = ['execute', 'run', 'deploy', 'rollback', 'unlock', 'force', 'override'];
+                if (parsed.subcommand && executionKeywords.includes(parsed.subcommand.toLowerCase())) {
+                    console.error(`Demo mode does not support "${parsed.subcommand}".`);
+                    console.error('');
+                    console.error('Demo mode is a read-only walkthrough of the platform. It cannot:');
+                    console.error('  - Execute deployments');
+                    console.error('  - Unlock the execution gate');
+                    console.error('  - Write to any system');
+                    console.error('  - Modify the readiness state');
+                    console.error('');
+                    console.error('Usage: agentics demo start [scenario]');
+                    process.exit(EXIT_CODES.USAGE_ERROR);
+                }
+                if (parsed.subcommand !== 'start' && parsed.subcommand) {
+                    console.error(`Unknown demo subcommand: ${parsed.subcommand}`);
+                    console.error('Usage: agentics demo start [scenario]');
+                    console.error('');
+                    console.error('Demo mode is read-only. The only valid subcommand is "start".');
+                    process.exit(EXIT_CODES.USAGE_ERROR);
+                }
+                const demoScenario = parsed.positionalArgs[0] ?? '';
+                const demoResult = await executeDemoStartCommand({
+                    scenario: demoScenario,
+                    extraArgs: parsed.subcommand ? parsed.positionalArgs : [],
+                });
+                // Demo is always human-readable — never JSON
+                console.log(demoResult.output);
+                if (options.verbose) {
+                    console.error(`Demo completed in ${demoResult.timing}ms`);
+                }
+                console.log('');
+                console.log('This demo is read-only. No systems were contacted. No data was written.');
+                process.exit(EXIT_CODES.SUCCESS);
+            }
             case 'diligence': {
                 const diligenceInput = parsed.positionalArgs[0] ?? '';
                 const diligenceFlexibleInput = parseFlexibleInput(diligenceInput);
@@ -1298,10 +1420,16 @@ async function main() {
                     process.exit(EXIT_CODES.SUCCESS);
                 }
                 if (parsed.subcommand === 'create') {
-                    const policyName = parsed.options['name'] ?? parsed.positionalArgs[0] ?? '';
+                    const positionalDesc = parsed.positionalArgs[0];
+                    const explicitName = parsed.options['name'];
+                    const explicitDesc = parsed.options['description'];
+                    // Derive description: --description flag > positional arg > fallback to name
+                    const description = explicitDesc ?? positionalDesc ?? explicitName ?? '';
+                    // Derive name: --name flag > slugified description
+                    const policyName = explicitName ?? slugifyPolicyName(description);
                     const policyCreateResult = await executePolicyCreateCommand({
                         name: policyName,
-                        description: parsed.options['description'],
+                        description,
                         type: parsed.options['type'],
                         rules: parsed.options['rules'] ? JSON.parse(parsed.options['rules']) : undefined,
                         metadata: parsed.options['metadata'] ? JSON.parse(parsed.options['metadata']) : undefined,
@@ -1449,10 +1577,166 @@ async function main() {
                 console.error('Supported subcommands: list, inspect, create, edit, delete, enable, disable, dry-run, scope');
                 process.exit(EXIT_CODES.USAGE_ERROR);
             }
-            default:
+            case 'agents': {
+                // Subcommand: list
+                if (parsed.subcommand === 'list' || (!parsed.subcommand && parsed.positionalArgs.length === 0)) {
+                    const listResult = await executeAgentsListCommand(options);
+                    if (options.format === 'json') {
+                        console.log(JSON.stringify(listResult, null, parsed.flags['pretty'] ? 2 : 0));
+                    }
+                    else {
+                        console.log(formatAgentsListForDisplay(listResult));
+                    }
+                    if (options.verbose) {
+                        console.error(`Listed ${listResult.totalDomains} domains (${listResult.totalAgents} agents) in ${listResult.timing}ms`);
+                    }
+                    process.exit(EXIT_CODES.SUCCESS);
+                }
+                // Subcommand: health <domain>
+                if (parsed.subcommand === 'health') {
+                    const domain = parsed.positionalArgs[0];
+                    if (!domain) {
+                        console.error('Usage: agentics agents health <domain>');
+                        console.error(`Valid domains: ${Object.keys(AGENT_DOMAINS).join(', ')}`);
+                        process.exit(EXIT_CODES.USAGE_ERROR);
+                    }
+                    const healthResult = await executeAgentsHealthCommand(domain, options);
+                    if (options.format === 'json') {
+                        console.log(JSON.stringify(healthResult, null, parsed.flags['pretty'] ? 2 : 0));
+                    }
+                    else {
+                        const status = healthResult.healthy ? 'HEALTHY' : 'UNHEALTHY';
+                        console.log(`${domain}: ${status} (${healthResult.timing}ms)`);
+                        console.log(JSON.stringify(healthResult.response, null, 2));
+                    }
+                    process.exit(healthResult.healthy ? EXIT_CODES.SUCCESS : EXIT_CODES.GENERAL_ERROR);
+                }
+                // Subcommand: invoke <domain> <agent> [payload]
+                if (parsed.subcommand === 'invoke') {
+                    const domain = parsed.positionalArgs[0];
+                    const agent = parsed.positionalArgs[1];
+                    const payloadStr = parsed.positionalArgs[2];
+                    if (!domain || !agent) {
+                        console.error('Usage: agentics agents invoke <domain> <agent> [json-payload]');
+                        console.error(`Valid domains: ${Object.keys(AGENT_DOMAINS).join(', ')}`);
+                        if (domain && AGENT_DOMAINS[domain]) {
+                            console.error(`Valid agents for ${domain}: ${AGENT_DOMAINS[domain].agents.join(', ')}`);
+                        }
+                        process.exit(EXIT_CODES.USAGE_ERROR);
+                    }
+                    let payload = {};
+                    if (payloadStr) {
+                        try {
+                            payload = JSON.parse(payloadStr);
+                        }
+                        catch {
+                            console.error(`Invalid JSON payload: ${payloadStr}`);
+                            process.exit(EXIT_CODES.USAGE_ERROR);
+                        }
+                    }
+                    const invokeResult = await executeAgentsInvokeCommand(domain, agent, payload, options);
+                    if (options.format === 'json') {
+                        console.log(JSON.stringify(invokeResult, null, parsed.flags['pretty'] ? 2 : 0));
+                    }
+                    else {
+                        console.log(formatAgentResultForDisplay(invokeResult));
+                    }
+                    if (options.verbose) {
+                        console.error(`Agent ${domain}/${agent} responded in ${invokeResult.timing}ms (HTTP ${invokeResult.status})`);
+                    }
+                    process.exit(EXIT_CODES.SUCCESS);
+                }
+                // Unknown subcommand
+                console.error(`Unknown agents subcommand: ${parsed.subcommand}`);
+                console.error('Supported subcommands: list, health, invoke');
+                process.exit(EXIT_CODES.USAGE_ERROR);
+            }
+            case 'ask': {
+                // Natural language routing: agentics ask "check this for injection attacks"
+                const queryParts = [];
+                if (parsed.subcommand)
+                    queryParts.push(parsed.subcommand);
+                queryParts.push(...parsed.positionalArgs);
+                const nlQuery = queryParts.join(' ').trim();
+                if (!nlQuery) {
+                    console.error('Usage: agentics ask "<natural language query>"');
+                    console.error('');
+                    console.error('Examples:');
+                    console.error('  agentics ask "check this prompt for injection attacks"');
+                    console.error('  agentics ask "how much am I spending on AI"');
+                    console.error('  agentics ask "detect anomalies in my latency metrics"');
+                    process.exit(EXIT_CODES.USAGE_ERROR);
+                }
+                try {
+                    const routeResult = await executeNaturalLanguageRoute(nlQuery, options);
+                    if (options.format === 'json') {
+                        console.log(JSON.stringify({
+                            query: nlQuery,
+                            intent: routeResult.intent,
+                            result: routeResult.invocation,
+                            timing: routeResult.timing,
+                        }, null, parsed.flags['pretty'] ? 2 : 0));
+                    }
+                    else {
+                        console.log(formatNaturalLanguageRouteForDisplay(routeResult));
+                    }
+                    if (options.verbose) {
+                        console.error(`NL routing completed in ${routeResult.timing}ms`);
+                    }
+                    process.exit(EXIT_CODES.SUCCESS);
+                }
+                catch (error) {
+                    if (error instanceof ServiceError && error.message.includes('unavailable')) {
+                        console.error('Natural language routing unavailable (copilot service unreachable).');
+                        console.error('');
+                        console.error('Use explicit agent invocation instead:');
+                        console.error('  agentics agents list                          # show available agents');
+                        console.error('  agentics agents invoke <domain> <agent> \'{}\'  # invoke directly');
+                        process.exit(EXIT_CODES.SERVICE_UNAVAILABLE);
+                    }
+                    throw error;
+                }
+            }
+            default: {
+                // Before failing, attempt NL routing for unrecognized multi-word input
+                const nlParts = [parsed.command];
+                if (parsed.subcommand)
+                    nlParts.push(parsed.subcommand);
+                nlParts.push(...parsed.positionalArgs);
+                const nlFallback = nlParts.join(' ').trim();
+                // Only attempt NL for inputs that look like natural language (not typos)
+                const looksLikeNL = nlFallback.includes(' ') || nlFallback.length > 20;
+                if (looksLikeNL) {
+                    try {
+                        // Auth is required for NL routing (calls copilot-agents)
+                        await enforceAuthSessionGate();
+                        console.error(`Unknown command '${parsed.command}'. Attempting natural language routing...`);
+                        console.error('');
+                        const routeResult = await executeNaturalLanguageRoute(nlFallback, options);
+                        if (options.format === 'json') {
+                            console.log(JSON.stringify({
+                                query: nlFallback,
+                                intent: routeResult.intent,
+                                result: routeResult.invocation,
+                                timing: routeResult.timing,
+                            }, null, parsed.flags['pretty'] ? 2 : 0));
+                        }
+                        else {
+                            console.log(formatNaturalLanguageRouteForDisplay(routeResult));
+                        }
+                        process.exit(EXIT_CODES.SUCCESS);
+                    }
+                    catch {
+                        // NL routing failed -- fall through to standard error
+                    }
+                }
                 console.error(`Unknown command: ${parsed.command}`);
                 console.error(`Supported commands: ${SUPPORTED_COMMANDS.join(', ')}`);
+                console.error('');
+                console.error('Or use natural language:');
+                console.error('  agentics ask "your question here"');
                 process.exit(EXIT_CODES.USAGE_ERROR);
+            }
         }
         // Output result (skip for commands that handle their own output)
         if (result) {
@@ -1503,7 +1787,16 @@ function gatherStatusState() {
         simulations: 0,
         deployments: 0,
         policies: 0,
+        erp: 0,
+        artifacts: 0,
+        inspections: 0,
+        totalRuns: 0,
         tools: 48,
+        agentsRunning: 0,
+        agentsAvailable: 100,
+        activeAgentTypes: [],
+        activeCalls: 0,
+        activeCallServices: [],
     };
     // Auth & identity
     try {
@@ -1519,6 +1812,15 @@ function gatherStatusState() {
         }
     }
     catch { /* not logged in */ }
+    // Identity file (display name, org, role)
+    try {
+        const idRaw = fs.readFileSync(path.join(agenticsDir, 'identity.json'), 'utf-8');
+        const id = JSON.parse(idRaw);
+        state.displayName = id.user?.display_name;
+        state.orgName = id.org?.org_name;
+        state.role = id.role;
+    }
+    catch { /* no identity */ }
     // Check internal allowlist for tier override
     if (state.authenticated && state.email) {
         try {
@@ -1532,14 +1834,16 @@ function gatherStatusState() {
         }
         catch { /* no allowlist */ }
     }
-    // Count runs (plans, simulations, deployments)
+    // Count runs by category + artifacts
     try {
         const runsDir = path.join(agenticsDir, 'runs');
         if (fs.existsSync(runsDir)) {
             const entries = fs.readdirSync(runsDir);
+            state.totalRuns = entries.length;
             for (const entry of entries) {
                 try {
-                    const metaPath = path.join(runsDir, entry, 'meta.json');
+                    const entryDir = path.join(runsDir, entry);
+                    const metaPath = path.join(entryDir, 'meta.json');
                     if (fs.existsSync(metaPath)) {
                         const meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
                         const cmd = meta.command ?? meta.type ?? '';
@@ -1549,7 +1853,14 @@ function gatherStatusState() {
                             state.simulations++;
                         else if (cmd.includes('deploy'))
                             state.deployments++;
-                    }
+                        else if (cmd.includes('erp'))
+                            state.erp++;
+                        else if (cmd.includes('inspect') || cmd.includes('query'))
+                            state.inspections++;
+                    }
+                    // Count artifact files (everything except meta.json)
+                    const files = fs.readdirSync(entryDir);
+                    state.artifacts += files.filter(f => f !== 'meta.json').length;
                 }
                 catch { /* skip bad entry */ }
             }
@@ -1564,6 +1875,53 @@ function gatherStatusState() {
         }
     }
     catch { /* no policies */ }
+    // Running agents (tracked via per-agent JSON files in ~/.agentics/agents/)
+    try {
+        const agentsTrackDir = path.join(agenticsDir, 'agents');
+        if (fs.existsSync(agentsTrackDir)) {
+            const agentFiles = fs.readdirSync(agentsTrackDir).filter(f => f.endsWith('.json'));
+            state.agentsRunning = agentFiles.length;
+            const types = new Set();
+            for (const file of agentFiles) {
+                try {
+                    const raw = fs.readFileSync(path.join(agentsTrackDir, file), 'utf-8');
+                    const data = JSON.parse(raw);
+                    if (data.type)
+                        types.add(data.type);
+                }
+                catch { /* skip bad file */ }
+            }
+            state.activeAgentTypes = Array.from(types);
+        }
+    }
+    catch { /* no agents dir */ }
+    // Active downstream calls (tracked via per-call JSON files in ~/.agentics/calls/)
+    try {
+        const callsDir = path.join(agenticsDir, 'calls');
+        if (fs.existsSync(callsDir)) {
+            const callFiles = fs.readdirSync(callsDir).filter(f => f.endsWith('.json'));
+            state.activeCalls = callFiles.length;
+            const services = new Set();
+            for (const file of callFiles) {
+                try {
+                    const raw = fs.readFileSync(path.join(callsDir, file), 'utf-8');
+                    const data = JSON.parse(raw);
+                    if (data.service) {
+                        const short = data.service
+                            .replace(/^agentics-simulation-/, '')
+                            .replace(/^agentics-deployment-/, '')
+                            .replace(/^agentics-org-/, '')
+                            .replace(/^agentics-/, '')
+                            .replace(/^enterprise-/, '');
+                        services.add(short);
+                    }
+                }
+                catch { /* skip bad file */ }
+            }
+            state.activeCallServices = Array.from(services);
+        }
+    }
+    catch { /* no calls dir */ }
     return state;
 }
 function printStatusLine(jsonMode) {
@@ -1572,25 +1930,70 @@ function printStatusLine(jsonMode) {
         console.log(JSON.stringify({ name: 'agentics-cli', version: VERSION, ...s }));
         return;
     }
+    // ANSI colors (matching claude-flow CLI style)
+    const R = '\x1b[0m';
+    const D = '\x1b[2m';
+    const PP = '\x1b[1;35m'; // bright purple
+    const CC = '\x1b[1;36m'; // bright cyan
+    const BB = '\x1b[1;34m'; // bright blue
+    const GG = '\x1b[1;32m'; // bright green
+    const YY = '\x1b[1;33m'; // bright yellow
+    const WW = '\x1b[1;37m'; // bright white
+    const cn = '\x1b[0;36m'; // cyan (labels)
+    const sep = `${D}\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${R}`;
+    const pipe = `  ${D}\u2502${R}  `;
     if (!s.authenticated) {
-        console.log('\u25CB Agentics | not authenticated | run: agentics login');
+        const lines = [
+            `${PP}\u258A Agentics.dev v${VERSION}${R}  ${D}\u25C7 not authenticated${R}`,
+            sep,
+            `${cn}Run ${WW}agentics login${R}${cn} to get started${R}`,
+            sep,
+        ];
+        console.log(lines.join('\n'));
         return;
     }
-    const user = s.email ? s.email.split('@')[0] : 'user';
+    const user = s.displayName
+        ?? (s.email ? s.email.split('@')[0] ?? 'user' : 'user');
     const tierBadge = s.tier === 'internal' ? 'INT'
         : s.tier === 'paid' ? 'PRO'
             : s.tier === 'free' ? 'FREE'
                 : 'ACT';
-    const parts = [
-        `\u25C8 Agentics [${tierBadge}]`,
-        user,
-        `Plans:${s.plans}`,
-        `Sims:${s.simulations}`,
-        `Deploy:${s.deployments}`,
-        `Policy:${s.policies}`,
-        `Tools:${s.tools}`,
-    ];
-    console.log(parts.join(' | '));
+    // Header: ▊ Agentics v1.4.5  ● user  │  PRO  │  owner
+    let header = `${PP}\u258A Agentics.dev v${VERSION}${R}`;
+    header += `  ${CC}\u25CF ${user}${R}`;
+    header += pipe + `${BB}${tierBadge}${R}`;
+    if (s.role)
+        header += pipe + `${D}${s.role}${R}`;
+    if (s.orgName)
+        header += pipe + `${D}${s.orgName}${R}`;
+    // Line 1: 🤖 Agents  ● [2] coder,tester  │  ⇅ Calls [1] planner  │  📋 Plans 0  🧪 Simulate 0  🚀 Deploy 0
+    const agentOn = s.agentsRunning > 0;
+    const agentDot = agentOn ? `${GG}\u25C9${R}` : `${D}\u25CB${R}`;
+    const agentClr = agentOn ? GG : D;
+    let line1 = `${YY}\uD83E\uDD16 Agents${R}  ${agentDot} [${agentClr}${s.agentsRunning}${R}]`;
+    if (s.activeAgentTypes.length > 0) {
+        line1 += ` ${D}${s.activeAgentTypes.join(',')}${R}`;
+    }
+    if (s.activeCalls > 0) {
+        line1 += pipe + `${CC}\u21C5 Calls${R} [${CC}${s.activeCalls}${R}]`;
+        if (s.activeCallServices.length > 0) {
+            line1 += ` ${D}${s.activeCallServices.join(',')}${R}`;
+        }
+    }
+    line1 += pipe;
+    line1 += `${cn}\uD83D\uDCCB Plans${R} ${WW}${s.plans}${R}`;
+    line1 += `  ${cn}\uD83E\uDDEA Simulate${R} ${WW}${s.simulations}${R}`;
+    line1 += `  ${cn}\uD83D\uDE80 Deploy${R} ${WW}${s.deployments}${R}`;
+    // Line 2: 📜 Policy 0  🏭 ERP 0  │  📦 Artifacts 0  🔍 Inspect 0  📊 Usage 0
+    let line2 = `${cn}\uD83D\uDCDC Policy${R} ${WW}${s.policies}${R}`;
+    line2 += `  ${cn}\uD83C\uDFED ERP${R} ${WW}${s.erp}${R}`;
+    line2 += pipe;
+    line2 += `${cn}\uD83D\uDCE6 Artifacts${R} ${WW}${s.artifacts}${R}`;
+    line2 += `  ${cn}\uD83D\uDD0D Inspect${R} ${WW}${s.inspections}${R}`;
+    line2 += `  ${cn}\uD83D\uDCCA Usage${R} ${WW}${s.totalRuns}${R}`;
+    line2 += pipe;
+    line2 += `${D}\uD83D\uDEE0\uFE0F  ${s.tools} tools${R}`;
+    console.log([header, sep, line1, line2, sep].join('\n'));
 }
 // ============================================================================
 // Help Output