notoken-core 1.0.0

package/config/playbooks.json

@@ -0,0 +1,112 @@
+{
+  "_description": "Reusable multi-step playbooks. Run with: mycli> :play <name> [env]",
+  "playbooks": [
+    {
+      "name": "health-check",
+      "description": "Full server health check — disk, memory, load, processes, services",
+      "steps": [
+        { "command": "uptime", "label": "Uptime & load" },
+        { "command": "free -h", "label": "Memory usage" },
+        { "command": "df -h", "label": "Disk usage" },
+        { "command": "ps aux --sort=-%cpu | head -10", "label": "Top CPU processes" },
+        { "command": "ps aux --sort=-%mem | head -10", "label": "Top memory processes" },
+        { "command": "ss -tlnp | head -20", "label": "Listening ports" },
+        { "command": "systemctl list-units --state=failed --no-pager 2>/dev/null || echo 'N/A'", "label": "Failed services" }
+      ]
+    },
+    {
+      "name": "disk-analysis",
+      "description": "Deep disk usage analysis — find what's consuming space",
+      "steps": [
+        { "command": "df -h", "label": "Filesystem overview" },
+        { "command": "du -sh /var/* 2>/dev/null | sort -rh | head -10", "label": "Largest dirs in /var" },
+        { "command": "du -sh /home/* 2>/dev/null | sort -rh | head -10", "label": "Largest dirs in /home" },
+        { "command": "du -sh /tmp/* 2>/dev/null | sort -rh | head -10", "label": "Largest in /tmp" },
+        { "command": "find /var/log -type f -size +100M 2>/dev/null", "label": "Large log files (>100MB)" },
+        { "command": "find /tmp -type f -mtime +7 2>/dev/null | wc -l", "label": "Old temp files (>7 days)" },
+        { "command": "journalctl --disk-usage 2>/dev/null || echo 'N/A'", "label": "Journal disk usage" }
+      ]
+    },
+    {
+      "name": "load-analysis",
+      "description": "Analyze what's causing high load — CPU, memory, I/O",
+      "steps": [
+        { "command": "uptime", "label": "Load average" },
+        { "command": "cat /proc/loadavg", "label": "Load detail" },
+        { "command": "nproc", "label": "CPU cores" },
+        { "command": "ps aux --sort=-%cpu | head -15", "label": "Top CPU consumers" },
+        { "command": "ps aux --sort=-%mem | head -15", "label": "Top memory consumers" },
+        { "command": "iostat -x 1 3 2>/dev/null || echo 'iostat not installed (sysstat)'", "label": "I/O stats" },
+        { "command": "vmstat 1 5 2>/dev/null || echo 'vmstat not available'", "label": "VM stats" }
+      ]
+    },
+    {
+      "name": "security-audit",
+      "description": "Basic security audit — open ports, auth, updates, suspicious activity",
+      "steps": [
+        { "command": "ss -tlnp", "label": "Open listening ports" },
+        { "command": "cat /etc/passwd | grep -v nologin | grep -v false | cut -d: -f1", "label": "Login-capable users" },
+        { "command": "lastlog 2>/dev/null | grep -v 'Never' | head -20", "label": "Recent logins" },
+        { "command": "last -n 10 2>/dev/null", "label": "Last 10 logins" },
+        { "command": "grep 'Failed password' /var/log/auth.log 2>/dev/null | tail -10 || grep 'Failed password' /var/log/secure 2>/dev/null | tail -10 || echo 'No auth log found'", "label": "Failed login attempts" },
+        { "command": "find / -perm -4000 -type f 2>/dev/null | head -20", "label": "SUID binaries" },
+        { "command": "apt list --upgradable 2>/dev/null | head -20 || yum check-update 2>/dev/null | head -20 || echo 'N/A'", "label": "Pending updates" },
+        { "command": "grep PermitRootLogin /etc/ssh/sshd_config 2>/dev/null || echo 'sshd_config not found'", "label": "SSH root login setting" }
+      ]
+    },
+    {
+      "name": "virus-scan",
+      "description": "Run ClamAV virus scan (installs if missing)",
+      "steps": [
+        { "command": "command -v clamscan >/dev/null || (echo 'Installing ClamAV...' && sudo apt-get install -y clamav 2>/dev/null || sudo yum install -y clamav 2>/dev/null || echo 'Install clamav manually')", "label": "Ensure ClamAV installed" },
+        { "command": "sudo freshclam 2>/dev/null || echo 'Could not update virus definitions'", "label": "Update virus definitions" },
+        { "command": "sudo clamscan -r --bell --max-filesize=100M --max-scansize=500M /home /tmp /var/www 2>/dev/null | tail -20 || echo 'Scan failed'", "label": "Scan /home, /tmp, /var/www" },
+        { "command": "sudo clamscan -r --bell --infected /etc 2>/dev/null | tail -10 || echo 'N/A'", "label": "Scan /etc (infected only)" }
+      ]
+    },
+    {
+      "name": "letsencrypt-setup",
+      "description": "Set up Let's Encrypt SSL certificate with certbot",
+      "steps": [
+        { "command": "command -v certbot >/dev/null || (echo 'Installing certbot...' && sudo apt-get update && sudo apt-get install -y certbot python3-certbot-nginx 2>/dev/null || sudo dnf install -y certbot python3-certbot-nginx 2>/dev/null || echo 'Install certbot manually')", "label": "Ensure certbot installed" },
+        { "command": "certbot --version 2>/dev/null", "label": "Certbot version" },
+        { "command": "ls /etc/letsencrypt/live/ 2>/dev/null || echo 'No existing certificates'", "label": "Existing certificates" },
+        { "command": "echo 'Run: sudo certbot --nginx -d yourdomain.com'", "label": "Next step — run certbot" },
+        { "command": "echo 'Run: sudo certbot renew --dry-run'", "label": "Test renewal" }
+      ]
+    },
+    {
+      "name": "nginx-check",
+      "description": "Nginx configuration check and status",
+      "steps": [
+        { "command": "nginx -v 2>&1", "label": "Nginx version" },
+        { "command": "sudo nginx -t 2>&1", "label": "Config syntax check" },
+        { "command": "systemctl status nginx --no-pager 2>/dev/null || service nginx status", "label": "Service status" },
+        { "command": "ls -la /etc/nginx/sites-enabled/ 2>/dev/null || ls -la /etc/nginx/conf.d/ 2>/dev/null", "label": "Enabled sites/configs" },
+        { "command": "tail -20 /var/log/nginx/error.log 2>/dev/null || echo 'No error log'", "label": "Recent errors" }
+      ]
+    },
+    {
+      "name": "docker-check",
+      "description": "Docker status, containers, images, and disk usage",
+      "steps": [
+        { "command": "docker --version 2>/dev/null || echo 'Docker not installed'", "label": "Docker version" },
+        { "command": "docker ps --format 'table {{.Names}}\\t{{.Status}}\\t{{.Ports}}' 2>/dev/null", "label": "Running containers" },
+        { "command": "docker ps -a --filter 'status=exited' --format 'table {{.Names}}\\t{{.Status}}' 2>/dev/null | head -10", "label": "Stopped containers" },
+        { "command": "docker images --format 'table {{.Repository}}\\t{{.Tag}}\\t{{.Size}}' 2>/dev/null | head -15", "label": "Images" },
+        { "command": "docker system df 2>/dev/null", "label": "Disk usage" }
+      ]
+    },
+    {
+      "name": "backup-full",
+      "description": "Full server backup — configs, data, databases",
+      "steps": [
+        { "command": "BACKUP_DIR=/backup/$(hostname)-$(date +%Y%m%d) && mkdir -p $BACKUP_DIR && echo $BACKUP_DIR", "label": "Create backup directory" },
+        { "command": "BACKUP_DIR=/backup/$(hostname)-$(date +%Y%m%d) && tar -czf $BACKUP_DIR/etc.tar.gz /etc/ 2>/dev/null && echo 'OK'", "label": "Backup /etc" },
+        { "command": "BACKUP_DIR=/backup/$(hostname)-$(date +%Y%m%d) && tar -czf $BACKUP_DIR/var-www.tar.gz /var/www/ 2>/dev/null && echo 'OK' || echo 'No /var/www'", "label": "Backup /var/www" },
+        { "command": "BACKUP_DIR=/backup/$(hostname)-$(date +%Y%m%d) && tar -czf $BACKUP_DIR/home.tar.gz /home/ 2>/dev/null && echo 'OK'", "label": "Backup /home" },
+        { "command": "BACKUP_DIR=/backup/$(hostname)-$(date +%Y%m%d) && ls -lh $BACKUP_DIR/", "label": "Backup summary" }
+      ]
+    }
+  ]
+}

package/config/rules.json

@@ -0,0 +1,100 @@
+{
+  "version": "2.0.1",
+  "intentSynonyms": {},
+  "environmentAliases": {
+    "local": [
+      "local",
+      "localhost",
+      "127.0.0.1"
+    ],
+    "dev": [
+      "dev",
+      "development"
+    ],
+    "staging": [
+      "staging",
+      "stage",
+      "stg",
+      "preprod",
+      "pre-prod"
+    ],
+    "prod": [
+      "prod",
+      "production",
+      "live",
+      "prd"
+    ]
+  },
+  "serviceAliases": {
+    "nginx": [
+      "nginx",
+      "web",
+      "webserver",
+      "web server",
+      "proxy",
+      "reverse proxy"
+    ],
+    "redis": [
+      "redis",
+      "cache",
+      "redis-server"
+    ],
+    "api": [
+      "api",
+      "backend",
+      "backend-api",
+      "server",
+      "app"
+    ],
+    "worker": [
+      "worker",
+      "background",
+      "jobs",
+      "sidekiq",
+      "queue"
+    ],
+    "postgres": [
+      "postgres",
+      "postgresql",
+      "pg",
+      "database",
+      "db"
+    ],
+    "mysql": [
+      "mysql",
+      "mariadb",
+      "maria"
+    ],
+    "mongo": [
+      "mongo",
+      "mongodb"
+    ],
+    "docker": [
+      "docker",
+      "container",
+      "containers"
+    ],
+    "sshd": [
+      "sshd",
+      "ssh",
+      "openssh"
+    ],
+    "apache": [
+      "apache",
+      "apache2",
+      "httpd"
+    ],
+    "certbot": [
+      "certbot",
+      "letsencrypt"
+    ],
+    "fail2ban": [
+      "fail2ban"
+    ],
+    "clamav": [
+      "clamav",
+      "clamscan",
+      "freshclam"
+    ]
+  }
+}

package/dist/agents/agentSpawner.d.ts

@@ -0,0 +1,56 @@
+import { EventEmitter } from "node:events";
+export type AgentStatus = "running" | "completed" | "failed" | "killed";
+export interface AgentHandle {
+    id: number;
+    name: string;
+    description: string;
+    status: AgentStatus;
+    pid?: number;
+    startedAt: Date;
+    completedAt?: Date;
+    output: string[];
+    error?: string;
+    acknowledged: boolean;
+}
+/**
+ * AgentSpawner — spawns long-running child processes (agents) in the background.
+ *
+ * Unlike TaskRunner (which runs async functions in-process), AgentSpawner
+ * forks actual child processes that can run independently. Useful for:
+ * - Long SSH sessions
+ * - Tailing logs in real-time
+ * - Monitoring tasks
+ * - Parallel multi-server operations
+ */
+export declare class AgentSpawner extends EventEmitter {
+    private agents;
+    private processes;
+    private nextId;
+    /**
+     * Spawn a new agent that runs a shell command.
+     */
+    spawnCommand(name: string, description: string, command: string, options?: {
+        cwd?: string;
+        env?: Record<string, string>;
+    }): AgentHandle;
+    /**
+     * Spawn a command using exec (simpler, no worker needed).
+     */
+    spawnShell(name: string, description: string, command: string): AgentHandle;
+    /** Kill an agent by ID. */
+    kill(id: number): boolean;
+    /** Get an agent by ID. */
+    get(id: number): AgentHandle | undefined;
+    /** List all agents. */
+    list(filter?: AgentStatus): AgentHandle[];
+    /** Get agents that finished since the user last checked. */
+    getUnacknowledged(): AgentHandle[];
+    /** Mark an agent as acknowledged. */
+    acknowledge(id: number): void;
+    acknowledgeAll(): void;
+    /** Get count of running agents. */
+    get active(): number;
+    /** Get last N lines of output from an agent. */
+    getOutput(id: number, lines?: number): string[];
+}
+export declare const agentSpawner: AgentSpawner;

package/dist/agents/agentSpawner.js

@@ -0,0 +1,180 @@
+import { fork } from "node:child_process";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { EventEmitter } from "node:events";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/**
+ * AgentSpawner — spawns long-running child processes (agents) in the background.
+ *
+ * Unlike TaskRunner (which runs async functions in-process), AgentSpawner
+ * forks actual child processes that can run independently. Useful for:
+ * - Long SSH sessions
+ * - Tailing logs in real-time
+ * - Monitoring tasks
+ * - Parallel multi-server operations
+ */
+export class AgentSpawner extends EventEmitter {
+    agents = new Map();
+    processes = new Map();
+    nextId = 1;
+    /**
+     * Spawn a new agent that runs a shell command.
+     */
+    spawnCommand(name, description, command, options = {}) {
+        const agent = {
+            id: this.nextId++,
+            name,
+            description,
+            status: "running",
+            startedAt: new Date(),
+            output: [],
+            acknowledged: false,
+        };
+        this.agents.set(agent.id, agent);
+        // Use a worker script that executes the command
+        const workerPath = resolve(__dirname, "worker.ts");
+        const child = fork(workerPath, [command], {
+            cwd: options.cwd,
+            env: { ...process.env, ...options.env },
+            stdio: ["pipe", "pipe", "pipe", "ipc"],
+            execArgv: ["--import", "tsx"],
+        });
+        agent.pid = child.pid;
+        this.processes.set(agent.id, child);
+        child.stdout?.on("data", (data) => {
+            const line = data.toString().trim();
+            if (line) {
+                agent.output.push(line);
+                this.emit("agent:output", agent, line);
+            }
+        });
+        child.stderr?.on("data", (data) => {
+            const line = data.toString().trim();
+            if (line) {
+                agent.output.push(`[err] ${line}`);
+                this.emit("agent:output", agent, `[err] ${line}`);
+            }
+        });
+        child.on("close", (code) => {
+            if (agent.status === "killed")
+                return;
+            agent.status = code === 0 ? "completed" : "failed";
+            agent.completedAt = new Date();
+            if (code !== 0)
+                agent.error = `Exit code: ${code}`;
+            this.processes.delete(agent.id);
+            this.emit("agent:done", agent);
+        });
+        child.on("error", (err) => {
+            agent.status = "failed";
+            agent.error = err.message;
+            agent.completedAt = new Date();
+            this.processes.delete(agent.id);
+            this.emit("agent:done", agent);
+        });
+        this.emit("agent:started", agent);
+        return agent;
+    }
+    /**
+     * Spawn a command using exec (simpler, no worker needed).
+     */
+    spawnShell(name, description, command) {
+        const { exec } = require("node:child_process");
+        const agent = {
+            id: this.nextId++,
+            name,
+            description,
+            status: "running",
+            startedAt: new Date(),
+            output: [],
+            acknowledged: false,
+        };
+        this.agents.set(agent.id, agent);
+        const child = exec(command, { timeout: 300_000 });
+        agent.pid = child.pid;
+        child.stdout?.on("data", (data) => {
+            const line = data.toString().trim();
+            if (line) {
+                agent.output.push(line);
+                this.emit("agent:output", agent, line);
+            }
+        });
+        child.stderr?.on("data", (data) => {
+            const line = data.toString().trim();
+            if (line) {
+                agent.output.push(`[err] ${line}`);
+                this.emit("agent:output", agent, `[err] ${line}`);
+            }
+        });
+        child.on("close", (code) => {
+            if (agent.status === "killed")
+                return;
+            agent.status = code === 0 ? "completed" : "failed";
+            agent.completedAt = new Date();
+            if (code !== 0)
+                agent.error = `Exit code: ${code}`;
+            this.emit("agent:done", agent);
+        });
+        this.emit("agent:started", agent);
+        return agent;
+    }
+    /** Kill an agent by ID. */
+    kill(id) {
+        const agent = this.agents.get(id);
+        if (!agent || agent.status !== "running")
+            return false;
+        const proc = this.processes.get(id);
+        if (proc) {
+            proc.kill("SIGTERM");
+            this.processes.delete(id);
+        }
+        // Also try killing by PID for shell-spawned agents
+        if (agent.pid) {
+            try {
+                process.kill(agent.pid, "SIGTERM");
+            }
+            catch { }
+        }
+        agent.status = "killed";
+        agent.completedAt = new Date();
+        this.emit("agent:done", agent);
+        return true;
+    }
+    /** Get an agent by ID. */
+    get(id) {
+        return this.agents.get(id);
+    }
+    /** List all agents. */
+    list(filter) {
+        const all = Array.from(this.agents.values());
+        return filter ? all.filter((a) => a.status === filter) : all;
+    }
+    /** Get agents that finished since the user last checked. */
+    getUnacknowledged() {
+        return Array.from(this.agents.values()).filter((a) => !a.acknowledged && a.status !== "running");
+    }
+    /** Mark an agent as acknowledged. */
+    acknowledge(id) {
+        const agent = this.agents.get(id);
+        if (agent)
+            agent.acknowledged = true;
+    }
+    acknowledgeAll() {
+        for (const agent of this.agents.values()) {
+            if (agent.status !== "running")
+                agent.acknowledged = true;
+        }
+    }
+    /** Get count of running agents. */
+    get active() {
+        return Array.from(this.agents.values()).filter((a) => a.status === "running").length;
+    }
+    /** Get last N lines of output from an agent. */
+    getOutput(id, lines = 20) {
+        const agent = this.agents.get(id);
+        if (!agent)
+            return [];
+        return agent.output.slice(-lines);
+    }
+}
+export const agentSpawner = new AgentSpawner();

package/dist/agents/planner.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Goal planner.
+ *
+ * Breaks complex multi-step requests into a sequence of tasks.
+ *
+ * Handles patterns like:
+ *   "check if api is down and restart it"
+ *   "deploy to staging then check the logs"
+ *   "show disk, check memory, and tail logs on prod"
+ *   "restart nginx on prod and then rollback if it fails"
+ *   "copy the config to /backup and restart nginx"
+ */
+export interface PlanStep {
+    id: number;
+    rawText: string;
+    intent: string | null;
+    fields: Record<string, unknown>;
+    confidence: number;
+    /** Condition for execution */
+    condition?: "always" | "if_success" | "if_failure";
+    /** Step IDs this step depends on */
+    dependsOn: number[];
+    status: "pending" | "running" | "completed" | "failed" | "skipped";
+    result?: string;
+    error?: string;
+}
+export interface ExecutionPlan {
+    originalText: string;
+    steps: PlanStep[];
+    isMultiStep: boolean;
+}
+/**
+ * Analyze text and determine if it's a multi-step request.
+ * If so, break it into a plan.
+ */
+export declare function createPlan(rawText: string): ExecutionPlan;
+/**
+ * Format a plan for display.
+ */
+export declare function formatPlan(plan: ExecutionPlan): string;

package/dist/agents/planner.js

@@ -0,0 +1,175 @@
+import nlp from "compromise";
+import { parseByRules } from "../nlp/ruleParser.js";
+// Conjunctions and sequencing words that split multi-step commands
+const SPLIT_PATTERNS = [
+    /\band then\b/i,
+    /\bthen\b/i,
+    /\bafter that\b/i,
+    /\bfollowed by\b/i,
+    /\bnext\b/i,
+    /,\s*(?:and\s+)?/,
+    /\band\b/i,
+];
+// Conditional patterns
+const CONDITIONAL_PATTERNS = [
+    { pattern: /\bif (?:it |that )?(?:works|succeeds|passes|is up|is running)\b/i, condition: "if_success" },
+    { pattern: /\bif (?:it |that )?(?:fails|breaks|is down|crashes|errors)\b/i, condition: "if_failure" },
+    { pattern: /\botherwise\b/i, condition: "if_failure" },
+    { pattern: /\bif not\b/i, condition: "if_failure" },
+];
+/**
+ * Analyze text and determine if it's a multi-step request.
+ * If so, break it into a plan.
+ */
+export function createPlan(rawText) {
+    const clauses = splitIntoClauses(rawText);
+    if (clauses.length <= 1) {
+        // Single step — still create a plan for consistency
+        const parsed = parseByRules(rawText);
+        return {
+            originalText: rawText,
+            isMultiStep: false,
+            steps: [{
+                    id: 1,
+                    rawText,
+                    intent: parsed?.intent ?? null,
+                    fields: parsed?.fields ?? {},
+                    confidence: parsed?.confidence ?? 0,
+                    condition: "always",
+                    dependsOn: [],
+                    status: "pending",
+                }],
+        };
+    }
+    // Multi-step: parse each clause
+    const steps = [];
+    let lastEntityContext = {};
+    for (let i = 0; i < clauses.length; i++) {
+        const clause = clauses[i];
+        const condition = detectCondition(clause.text);
+        // Inherit entities from previous steps for coreference
+        let textToParse = clause.text;
+        // Replace "it" with last known service
+        if (/\bit\b/i.test(textToParse) && lastEntityContext.service) {
+            textToParse = textToParse.replace(/\bit\b/i, lastEntityContext.service);
+        }
+        const parsed = parseByRules(textToParse);
+        // Carry forward environment and service context
+        const fields = { ...parsed?.fields ?? {} };
+        if (!fields.environment && lastEntityContext.environment) {
+            fields.environment = lastEntityContext.environment;
+        }
+        if (!fields.service && lastEntityContext.service) {
+            fields.service = lastEntityContext.service;
+        }
+        const step = {
+            id: i + 1,
+            rawText: clause.original,
+            intent: parsed?.intent ?? null,
+            fields,
+            confidence: parsed?.confidence ?? 0,
+            condition: condition ?? (i === 0 ? "always" : "if_success"),
+            dependsOn: i > 0 ? [i] : [],
+            status: "pending",
+        };
+        steps.push(step);
+        // Update entity context for next step
+        if (fields.service)
+            lastEntityContext.service = fields.service;
+        if (fields.environment)
+            lastEntityContext.environment = fields.environment;
+        if (fields.target)
+            lastEntityContext.target = fields.target;
+    }
+    return {
+        originalText: rawText,
+        isMultiStep: true,
+        steps,
+    };
+}
+/**
+ * Split a complex sentence into individual action clauses.
+ */
+function splitIntoClauses(text) {
+    // Use compromise to detect sentence/clause boundaries first
+    const doc = nlp(text);
+    const sentences = doc.sentences().out("array");
+    if (sentences.length > 1) {
+        return sentences.map((s) => ({ text: cleanClause(s), original: s }));
+    }
+    // Single sentence — try splitting on conjunctions
+    let remaining = text;
+    const parts = [];
+    for (const pattern of SPLIT_PATTERNS) {
+        const split = remaining.split(pattern).filter((s) => s.trim().length > 0);
+        if (split.length > 1) {
+            parts.push(...split);
+            remaining = "";
+            break;
+        }
+    }
+    if (parts.length === 0) {
+        return [{ text: cleanClause(text), original: text }];
+    }
+    return parts.map((p) => ({ text: cleanClause(p), original: p.trim() }));
+}
+function cleanClause(text) {
+    // Remove leading conjunctions and conditional phrases
+    return text
+        .replace(/^(and then|then|and|but|or|after that|followed by|next)\s+/i, "")
+        .replace(/\bif (?:it |that )?(?:works|succeeds|passes|fails|breaks|is down|is up)\s*/i, "")
+        .replace(/\botherwise\s*/i, "")
+        .trim();
+}
+function detectCondition(text) {
+    for (const { pattern, condition } of CONDITIONAL_PATTERNS) {
+        if (pattern.test(text))
+            return condition;
+    }
+    return undefined;
+}
+/**
+ * Format a plan for display.
+ */
+export function formatPlan(plan) {
+    const c = {
+        reset: "\x1b[0m",
+        bold: "\x1b[1m",
+        dim: "\x1b[2m",
+        green: "\x1b[32m",
+        yellow: "\x1b[33m",
+        red: "\x1b[31m",
+        cyan: "\x1b[36m",
+    };
+    const lines = [];
+    if (plan.isMultiStep) {
+        lines.push(`${c.bold}Execution Plan${c.reset} (${plan.steps.length} steps):`);
+    }
+    else {
+        lines.push(`${c.bold}Single-step command:${c.reset}`);
+    }
+    lines.push("");
+    for (const step of plan.steps) {
+        const statusIcon = step.status === "completed" ? `${c.green}✓${c.reset}` :
+            step.status === "failed" ? `${c.red}✗${c.reset}` :
+                step.status === "running" ? `${c.yellow}⟳${c.reset}` :
+                    step.status === "skipped" ? `${c.dim}⊘${c.reset}` :
+                        `${c.dim}○${c.reset}`;
+        const intentLabel = step.intent ?? `${c.red}unknown${c.reset}`;
+        const condLabel = step.condition === "if_success" ? `${c.dim}(if previous succeeds)${c.reset}` :
+            step.condition === "if_failure" ? `${c.yellow}(if previous fails)${c.reset}` : "";
+        lines.push(`  ${statusIcon} Step ${step.id}: ${c.cyan}${intentLabel}${c.reset} ${condLabel}`);
+        lines.push(`    ${c.dim}"${step.rawText}"${c.reset}`);
+        const fields = Object.entries(step.fields).filter(([, v]) => v !== undefined);
+        if (fields.length > 0) {
+            lines.push(`    ${fields.map(([k, v]) => `${k}=${v}`).join(", ")}`);
+        }
+        if (step.result) {
+            lines.push(`    ${c.green}Result: ${step.result.split("\n")[0]}${c.reset}`);
+        }
+        if (step.error) {
+            lines.push(`    ${c.red}Error: ${step.error}${c.reset}`);
+        }
+    }
+    return lines.join("\n");
+}