total-recall-brain 3.26.0 → 3.28.0

package/src/cli/mesh.mjs

@@ -41,12 +41,20 @@ function printHelp() {
   Usage: total-recall mesh <command> [options]
 
     status                 Control-server reachability and credential state
+    doctor                 Probe reachability & compute capabilities across all nodes
     nodes                  List mesh nodes and how to reach each one
     ssh <node> [cmd…]      Open a session using the node's recorded access
+    exec <node> <cmd…>     Execute a command on a node non-interactively (--json)
     access <node>          Show resolved access for a node
     access <node> --user <u> [--port <n>] [--host <h>] [--identity <path>]
                            Record how to reach a node
     access import          Propose access from ~/.ssh/config (--apply to save)
+    ping [node]            Measure round-trip latency to a node (or all nodes) (--json)
+    leader                 Show cluster leader election status and current leader (--json)
+    enroll [options]       Enroll this node on the mesh control server
+                             --status   show current enrollment state
+                             --server   control-server URL
+                             --force    re-enroll even if already connected
     preauthkey             Mint an enrollment key for 'tailscale up --authkey'
                              --reusable   usable by more than one node
                              --ephemeral  node is removed when it goes offline
@@ -124,6 +132,91 @@ export default async function meshCli(argv = []) {
       return;
     }
 
+    if (command === 'doctor' || command === 'diagnostics') {
+      console.log('\n🩺 Total Recall — Mesh Diagnostics & Compute Capability Audit\n');
+      const enriched = listEnrichedMeshNodes(vaultRoot);
+      const isJson = args.includes('--json');
+
+      const stripAnsi = (s) => String(s || '').replace(/\x1b\[[0-9;]*m/g, '');
+      const pad = (s, l) => String(s || '') + ' '.repeat(Math.max(0, l - stripAnsi(s).length));
+      const probeNodes = enriched.filter(n => n.ip);
+      const results = [];
+
+      for (const node of probeNodes) {
+        const resolved = resolveNodeAccess(node);
+        const nodeInfo = {
+          hostname: node.hostname,
+          ip: node.ip,
+          self: !!node.self,
+          online: !!node.online,
+          sshConfigured: resolved.complete,
+          sshTarget: resolved.target,
+          runtimes: [],
+          harnesses: [],
+          reachable: false,
+          error: null
+        };
+
+        if (node.self) {
+          try {
+            const { detectHarnesses } = await import('../core/meta-harness.mjs');
+            nodeInfo.harnesses = detectHarnesses().filter(h => h.available).map(h => h.id);
+          } catch {}
+          nodeInfo.runtimes = ['node', 'git'];
+          nodeInfo.reachable = true;
+        } else if (resolved.complete) {
+          try {
+            const probeCmd = 'echo "agy=$(which agy 2>/dev/null) claude=$(which claude 2>/dev/null) codex=$(which codex 2>/dev/null) gemini=$(which gemini 2>/dev/null) ollama=$(which ollama 2>/dev/null) docker=$(which docker 2>/dev/null) node=$(which node 2>/dev/null) git=$(which git 2>/dev/null)"';
+            const { execMeshCommand } = await import('../core/mesh.mjs');
+            const res = await execMeshCommand(node.hostname, probeCmd, { vaultRoot, timeoutMs: 4000 });
+            nodeInfo.reachable = res.success;
+            if (res.success) {
+              const parts = res.stdout.split(/\s+/);
+              for (const part of parts) {
+                const [k, v] = part.split('=');
+                if (v && v.trim()) {
+                  if (['agy', 'claude', 'codex', 'gemini', 'ollama'].includes(k)) {
+                    nodeInfo.harnesses.push(k);
+                  } else {
+                    nodeInfo.runtimes.push(k);
+                  }
+                }
+              }
+            } else {
+              nodeInfo.error = res.stderr || 'Probe failed';
+            }
+          } catch (err) {
+            nodeInfo.reachable = false;
+            nodeInfo.error = err.message;
+          }
+        } else {
+          nodeInfo.reachable = false;
+          nodeInfo.error = 'No recorded SSH login';
+        }
+
+        results.push(nodeInfo);
+      }
+
+      if (isJson) {
+        console.log(JSON.stringify(results, null, 2));
+        return;
+      }
+
+      console.log('┌──────────────────────────────────────────┬────────────────┬──────────────────┬──────────────────┬──────────────────────────────────────┬──────────────────────────┐');
+      console.log(`│ ${pad('Node', 40)} │ ${pad('Mesh IP', 14)} │ ${pad('Role', 16)} │ ${pad('Mesh SSH', 16)} │ ${pad('Harnesses', 36)} │ ${pad('Runtimes', 24)} │`);
+      console.log('├──────────────────────────────────────────┼────────────────┼──────────────────┼──────────────────┼──────────────────────────────────────┼──────────────────────────┤');
+
+      for (const r of results) {
+        const roleStr = r.self ? '\x1b[36mLocal (Self)\x1b[0m' : (r.online ? '\x1b[32mOnline Peer\x1b[0m' : '\x1b[90mOffline\x1b[0m');
+        const sshStr = r.self ? '—' : (r.reachable ? '\x1b[32mReachable ✅\x1b[0m' : '\x1b[31mUnreachable ❌\x1b[0m');
+        const hStr = r.harnesses.length ? r.harnesses.join(', ') : '—';
+        const runStr = r.runtimes.length ? r.runtimes.join(', ') : '—';
+        console.log(`│ ${pad(r.hostname, 40)} │ ${pad(r.ip, 14)} │ ${pad(roleStr, 16)} │ ${pad(sshStr, 16)} │ ${pad(hStr, 36)} │ ${pad(runStr, 24)} │`);
+      }
+      console.log('└──────────────────────────────────────────┴────────────────┴──────────────────┴──────────────────┴──────────────────────────────────────┴──────────────────────────┘\n');
+      return;
+    }
+
     if (command === 'nodes') {
       // The control server is the authoritative registry, but local discovery
       // plus the vault can already answer "what is on my mesh and how do I
@@ -226,6 +319,33 @@ export default async function meshCli(argv = []) {
       return;
     }
 
+    if (command === 'exec') {
+      const target = args.shift();
+      if (!target || !args.length) {
+        fail('`exec` requires a node name and a command.', 'Example: total-recall mesh exec macmini uptime');
+        return;
+      }
+      const jsonMode = args.includes('--json');
+      const filteredArgs = args.filter((a) => a !== '--json');
+      const cmd = filteredArgs.join(' ');
+
+      try {
+        const { execMeshCommand } = await import('../core/mesh.mjs');
+        const res = await execMeshCommand(target, cmd, { vaultRoot });
+        if (jsonMode) {
+          console.log(JSON.stringify(res, null, 2));
+        } else {
+          if (res.stdout) console.log(res.stdout);
+          if (res.stderr) console.error(res.stderr);
+        }
+        process.exitCode = res.exitCode;
+      } catch (err) {
+        fail(`Execution failed: ${err.message}`);
+      }
+      return;
+    }
+
+
     if (command === 'access') {
       const target = args.shift();
       if (!target) {
@@ -329,6 +449,172 @@ export default async function meshCli(argv = []) {
       return;
     }
 
+    if (command === 'leader') {
+      const { getLeaderInfo, isLeader } = await import('../core/leader-election.mjs');
+      const leaderInfo = await getLeaderInfo();
+      const thisIsLeader = await isLeader();
+      if (args.includes('--json')) {
+        console.log(JSON.stringify({ leader: leaderInfo, is_current_node_leader: thisIsLeader }, null, 2));
+        return;
+      }
+      if (!leaderInfo) {
+        console.log('No leader elected (no mesh nodes online).');
+        return;
+      }
+      console.log(`👑 Current Cluster Leader: ${leaderInfo.hostname} (${leaderInfo.ip})`);
+      console.log(`   Strategy: ${leaderInfo.strategy}`);
+      console.log(`   Local node: ${thisIsLeader ? 'LEADER (this node runs cluster workloads)' : 'FOLLOWER'}`);
+      return;
+    }
+
+    if (command === 'ping' || command === 'latency') {
+      const target = args.find((a) => !a.startsWith('-'));
+      const isJson = args.includes('--json');
+      const { getMeshPeers, findMeshNode } = await import('../core/mesh.mjs');
+      const { throttledFetch } = await import('../core/throttled-fetch.mjs');
+
+      const port = Number(process.env.TR_SERVER_PORT || process.env.PORT || 3000);
+
+      if (target) {
+        const node = findMeshNode(target, vaultRoot);
+        if (!node) {
+          fail(`No mesh node matches "${target}".`);
+          return;
+        }
+        if (node.self) {
+          if (isJson) {
+            console.log(JSON.stringify({ node: node.hostname, ip: node.ip, latency_ms: 0, self: true, reachable: true }, null, 2));
+          } else {
+            console.log(`📍 ${node.hostname} (${node.ip}) is this local node (0 ms).`);
+          }
+          return;
+        }
+        if (!node.ip || !node.online) {
+          if (isJson) {
+            console.log(JSON.stringify({ node: node.hostname, ip: node.ip, latency_ms: null, reachable: false, status: 'offline' }, null, 2));
+          } else {
+            console.log(`⚠️  ${node.hostname} (${node.ip || 'no IP'}) is offline.`);
+          }
+          return;
+        }
+
+        const start = Date.now();
+        try {
+          const res = await throttledFetch(`http://${node.ip}:${port}/health`, {}, 5000);
+          const ms = Date.now() - start;
+          const ok = res.ok || res.status === 200;
+          if (isJson) {
+            console.log(JSON.stringify({ node: node.hostname, ip: node.ip, latency_ms: ok ? ms : null, reachable: ok, status: res.status }, null, 2));
+          } else {
+            console.log(`✅ ${node.hostname} (${node.ip}): ${ms} ms (status: ${res.status})`);
+          }
+        } catch (err) {
+          const { spawnSync } = await import('node:child_process');
+          const pingResult = spawnSync('ping', ['-c', '1', '-W', '2', node.ip], { encoding: 'utf8', timeout: 3000 });
+          const ms = Date.now() - start;
+          if (pingResult.status === 0) {
+            if (isJson) {
+              console.log(JSON.stringify({ node: node.hostname, ip: node.ip, latency_ms: ms, reachable: true, method: 'icmp' }, null, 2));
+            } else {
+              console.log(`✅ ${node.hostname} (${node.ip}): ${ms} ms (ICMP)`);
+            }
+          } else {
+            if (isJson) {
+              console.log(JSON.stringify({ node: node.hostname, ip: node.ip, latency_ms: null, reachable: false, error: err.message }, null, 2));
+            } else {
+              console.log(`❌ ${node.hostname} (${node.ip}): unreachable (${err.message})`);
+            }
+          }
+        }
+        return;
+      }
+
+      const peers = getMeshPeers({ includeSelf: true });
+      const results = [];
+      for (const peer of peers) {
+        if (peer.self) {
+          results.push({ hostname: peer.hostname, ip: peer.ip, latency_ms: 0, status: 'self' });
+          continue;
+        }
+        if (!peer.ip || !peer.online) {
+          results.push({ hostname: peer.hostname, ip: peer.ip, latency_ms: null, status: 'offline' });
+          continue;
+        }
+        const start = Date.now();
+        try {
+          const res = await throttledFetch(`http://${peer.ip}:${port}/health`, {}, 4000);
+          const ms = Date.now() - start;
+          const ok = res.ok || res.status === 200;
+          results.push({ hostname: peer.hostname, ip: peer.ip, latency_ms: ok ? ms : null, status: ok ? 'online' : 'error' });
+        } catch {
+          const { spawnSync } = await import('node:child_process');
+          const pingResult = spawnSync('ping', ['-c', '1', '-W', '2', peer.ip], { encoding: 'utf8', timeout: 2000 });
+          const ms = Date.now() - start;
+          results.push({ hostname: peer.hostname, ip: peer.ip, latency_ms: pingResult.status === 0 ? ms : null, status: pingResult.status === 0 ? 'icmp' : 'unreachable' });
+        }
+      }
+
+      if (isJson) {
+        console.log(JSON.stringify(results, null, 2));
+        return;
+      }
+
+      console.log('┌──────────────────────────────────────────┬────────────────┬──────────────┬──────────────┐');
+      console.log('│ Node                                     │ Mesh IP        │ Latency      │ Status       │');
+      console.log('├──────────────────────────────────────────┼────────────────┼──────────────┼──────────────┤');
+      for (const r of results) {
+        const lat = r.latency_ms != null ? `${r.latency_ms} ms` : '—';
+        console.log(`│ ${String(r.hostname || '').padEnd(40)} │ ${String(r.ip || '-').padEnd(14)} │ ${lat.padEnd(12)} │ ${r.status.padEnd(12)} │`);
+      }
+      console.log('└──────────────────────────────────────────┴────────────────┴──────────────┴──────────────┘');
+      return;
+    }
+
+    if (command === 'enroll') {
+      const { getEnrollmentStatus, enrollThisNode } = await import('../core/mesh-enroll.mjs');
+      if (args.includes('--status')) {
+        const status = await getEnrollmentStatus({ brainDir });
+        console.log(JSON.stringify(status, null, 2));
+        return;
+      }
+
+      const readOption = (flag) => {
+        const index = args.indexOf(flag);
+        return index === -1 ? null : args[index + 1] || null;
+      };
+      const server = readOption('--server');
+      const user = readOption('--user');
+      const force = args.includes('--force');
+
+      console.log('Initiating mesh enrollment...');
+      const result = await enrollThisNode({
+        brainDir,
+        loginServer: server,
+        user,
+        force,
+      });
+
+      if (args.includes('--json')) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+
+      if (result.ok) {
+        if (result.reason === 'already-enrolled') {
+          console.log(`✅ Already enrolled on mesh (${result.state}). Use --force to re-enroll.`);
+        } else {
+          console.log(`✅ Successfully enrolled on mesh (${result.state}).`);
+        }
+      } else if (result.interactiveUrl) {
+        console.log(`⚠️  Interactive authorization required.`);
+        console.log(`   Open this URL in your browser to approve:`);
+        console.log(`   ${result.interactiveUrl}`);
+      } else {
+        fail(result.reason || 'Enrollment failed', result.hint);
+      }
+      return;
+    }
+
     if (command !== 'policy') {
       fail(`Unknown mesh command: ${command}`, 'Run `total-recall mesh --help`.');
       return;

package/src/cli/plugin/create.mjs

@@ -0,0 +1,186 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { validatePluginManifest } from "../../core/plugin-loader.mjs";
+
+function toTitleCase(kebab) {
+  return kebab
+    .split("-")
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(" ");
+}
+
+export async function createPlugin(args = []) {
+  const isGlobal = args.includes("--global") || args.includes("-g");
+  const withCli = args.includes("--with-cli");
+  const withGenerator = args.includes("--with-generator");
+
+  let name = null;
+  let description = null;
+  let category = null;
+
+  const cleanArgs = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--global" || arg === "-g" || arg === "--with-cli" || arg === "--with-generator") {
+      continue;
+    }
+    if (arg === "--name" && args[i + 1]) {
+      name = args[i + 1];
+      i++;
+      continue;
+    }
+    if (arg === "--description" && args[i + 1]) {
+      description = args[i + 1];
+      i++;
+      continue;
+    }
+    if (arg === "--category" && args[i + 1]) {
+      category = args[i + 1];
+      i++;
+      continue;
+    }
+    cleanArgs.push(arg);
+  }
+
+  const id = cleanArgs[0];
+  if (!id) {
+    console.error("❌ Error: Missing plugin id.");
+    console.error("   Usage: total-recall plugin create <id> [--name <name>] [--description <desc>] [--category <cat>] [--with-cli] [--with-generator] [--global]\n");
+    process.exit(1);
+  }
+
+  const ID_PATTERN = /^[a-z][a-z0-9-]{1,63}$/;
+  if (!ID_PATTERN.test(id)) {
+    console.error(`❌ Error: Invalid plugin id "${id}". Must be lowercase kebab-case (^[a-z][a-z0-9-]{1,63}$)`);
+    process.exit(1);
+  }
+
+  const pluginsBaseDir = isGlobal
+    ? path.join(os.homedir(), ".agent", "plugins")
+    : path.join(process.cwd(), ".agent", "plugins");
+
+  const pluginDir = path.join(pluginsBaseDir, id);
+  if (fs.existsSync(pluginDir)) {
+    console.error(`❌ Error: Plugin directory already exists at ${pluginDir}`);
+    process.exit(1);
+  }
+
+  fs.mkdirSync(pluginDir, { recursive: true });
+
+  const pluginName = name || toTitleCase(id);
+  const pluginDesc = description || `${pluginName} extension for Total Recall AI OS`;
+
+  const manifest = {
+    $schema: "https://github.com/total-recall/total-recall/blob/main/metadata.plugin.schema.json",
+    id,
+    name: pluginName,
+    version: "1.0.0",
+    description: pluginDesc,
+    author: "Total Recall Ecosystem",
+    license: "MIT"
+  };
+
+  if (category) {
+    manifest.ssss_schemas = {
+      categories: [
+        {
+          name: category,
+          description: `Custom ${category} memory nodes for ${pluginName}`,
+          node_type: "memory"
+        }
+      ]
+    };
+  }
+
+  if (withCli) {
+    manifest.cli = {
+      command: id,
+      handler: "./cli.mjs",
+      subcommands: [
+        { name: "status", description: `Show ${pluginName} status` }
+      ]
+    };
+
+    const cliContent = `#!/usr/bin/env node
+export async function run(argv = []) {
+  const args = Array.isArray(argv) ? argv.slice(2) : [];
+  const sub = args[0] || "status";
+  console.log(\`⚡ \${sub.toUpperCase()} from plugin: ${id}\`);
+  console.log("Plugin is active and responding to CLI dispatch.");
+}
+export default run;
+`;
+    fs.writeFileSync(path.join(pluginDir, "cli.mjs"), cliContent, "utf8");
+  }
+
+  if (withGenerator) {
+    manifest.compile = {
+      generator: "./generator.mjs",
+      auto: true
+    };
+
+    const generatorContent = `/**
+ * Context generator for ${pluginName}.
+ * Invoked during evolving context compilation.
+ */
+export async function generateContext({ projectRoot, nodes = [] }) {
+  return \`#### ${pluginName} Context\n- Status: Operational\n- Active nodes: \${nodes.length}\n\`;
+}
+export default generateContext;
+`;
+    fs.writeFileSync(path.join(pluginDir, "generator.mjs"), generatorContent, "utf8");
+  }
+
+  manifest.tasks = [
+    {
+      intent: `Periodic health verification for ${id}`,
+      schedule: "0 * * * *"
+    }
+  ];
+
+  const validation = validatePluginManifest(manifest);
+  if (!validation.valid) {
+    console.error("❌ Validation failed for generated manifest:", validation.errors);
+    fs.rmSync(pluginDir, { recursive: true, force: true });
+    process.exit(1);
+  }
+
+  fs.writeFileSync(
+    path.join(pluginDir, "plugin.json"),
+    JSON.stringify(manifest, null, 2) + "\n",
+    "utf8"
+  );
+
+  const lines = [
+    `# ${pluginName}`,
+    "",
+    `> ${pluginDesc}`,
+    "",
+    "## Installation",
+    "",
+    "```bash",
+    `npx total-recall plugin install ./.agent/plugins/${id} --link`,
+    "```",
+    "",
+    "## Features",
+    "",
+    `- **Identifier**: \`${id}\``,
+    "- **Version**: 1.0.0"
+  ];
+  if (category) lines.push(`- **SSSS Category**: \`${category}\``);
+  if (withCli) lines.push(`- **CLI Command**: \`npx total-recall ${id}\``);
+  lines.push("");
+
+  fs.writeFileSync(path.join(pluginDir, "README.md"), lines.join("\n"), "utf8");
+
+  console.log(`\n🎉 Successfully scaffolded plugin "${pluginName}"!`);
+  console.log(`   Location: \x1b[36m${pluginDir}\x1b[0m`);
+  console.log(`   Manifest: \x1b[33m${path.join(pluginDir, "plugin.json")}\x1b[0m`);
+  if (withCli) {
+    console.log(`   CLI Handler: \x1b[32m${path.join(pluginDir, "cli.mjs")}\x1b[0m`);
+  }
+  console.log(`\nNext steps:`);
+  console.log(`   Inspect: \x1b[32mnpx total-recall plugin info ${id}\x1b[0m`);
+  console.log(`   List:    \x1b[32mnpx total-recall plugin list\x1b[0m\n`);
+}

package/src/cli/plugin/index.mjs

@@ -0,0 +1,139 @@
+import { listPlugins } from './list.mjs';
+import { installPlugin } from './install.mjs';
+import { removePlugin } from './remove.mjs';
+import { searchCatalog } from './search.mjs';
+import { createPlugin } from './create.mjs';
+import { getPlugin } from '../../core/plugin-loader.mjs';
+
+function printHelp() {
+  console.log(`
+🔌 Total Recall — Plugin Management System
+
+Usage:
+  npx total-recall plugin <command> [options]
+
+Commands:
+  search [query]            Search plugin catalog (--json for pipelines)
+  catalog                   Browse the full catalog
+  list                      List all installed plugins (project & global)
+  create <id>               Scaffold a new plugin manifest and directory
+                              --name <name>         Human-readable plugin name
+                              --description <desc>  Plugin purpose & capability
+                              --category <cat>      Declare an SSSS memory category
+                              --with-cli            Generate CLI command handler
+                              --with-generator      Generate context generator
+                              --global, -g          Create in ~/.agent/plugins/
+  install <path|git-url>    Install or link a plugin
+                              --link, -l    Symlink local directory instead of copying
+                              --global, -g  Install to ~/.agent/plugins/
+  remove <id>               Uninstall or unlink an installed plugin
+  info <id>                 Inspect detailed manifest for an installed plugin
+
+Examples:
+  npx total-recall plugin list
+  npx total-recall plugin create system-monitor --with-cli --category system-metrics
+  npx total-recall plugin install ./path/to/my-plugin --link
+  npx total-recall plugin install https://github.com/org/scientific-frontiers.git
+  npx total-recall plugin info scientific-frontiers
+  npx total-recall plugin remove scientific-frontiers
+`);
+}
+
+export async function run(argv = []) {
+  let args = argv;
+  if (Array.isArray(args) && args[0]?.endsWith('node')) {
+    args = args.slice(2);
+  }
+  if (args[0] === 'plugin' || args[0] === 'plugins') {
+    args = args.slice(1);
+  }
+
+  const command = args[0];
+  const rest = args.slice(1);
+
+  if (command === 'search' || command === 'catalog' || command === 'find') {
+    await searchCatalog(rest);
+    return;
+  }
+
+  if (command === 'create' || command === 'new' || command === 'init') {
+    await createPlugin(rest);
+    return;
+  }
+
+  if (!command || command === 'list') {
+    await listPlugins(rest);
+    return;
+  }
+
+  if (command === 'install' || command === 'add') {
+    await installPlugin(rest);
+    return;
+  }
+
+  if (command === 'remove' || command === 'rm' || command === 'uninstall') {
+    await removePlugin(rest);
+    return;
+  }
+
+  if (command === 'info' || command === 'show') {
+    const id = rest[0];
+    if (!id) {
+      console.error('❌ Error: Missing plugin ID. Usage: total-recall plugin info <id>');
+      process.exit(1);
+    }
+    const plugin = getPlugin(id, process.cwd());
+    if (!plugin) {
+      console.error(`❌ Plugin '${id}' not found.`);
+      process.exit(1);
+    }
+
+    console.log(`\n🔌 Plugin: ${plugin.manifest.name || plugin.id}`);
+    console.log(`   ID:          ${plugin.id}`);
+    console.log(`   Version:     v${plugin.manifest.version || '0.0.0'}`);
+    console.log(`   Description: ${plugin.manifest.description || '—'}`);
+    console.log(`   Directory:   ${plugin.dir}`);
+    console.log(`   Valid:       ${plugin.valid ? '✅ Yes' : '❌ No'}`);
+
+    if (plugin.manifest.cli?.command) {
+      console.log(`   CLI Command: total-recall ${plugin.manifest.cli.command}`);
+    }
+
+    const cats = plugin.manifest.ssss_schemas?.categories || [];
+    if (cats.length > 0) {
+      console.log(`   SSSS Categories:`);
+      for (const c of cats) {
+        console.log(`     - ${c.name} (${c.node_type || 'memory'}): ${c.description || ''}`);
+      }
+    }
+
+    const tasks = plugin.manifest.tasks || [];
+    if (tasks.length > 0) {
+      console.log(`   Background Tasks:`);
+      for (const t of tasks) {
+        console.log(`     - [${t.schedule}] ${t.intent}`);
+      }
+    }
+
+    const hooks = plugin.manifest.hooks || {};
+    if (Object.keys(hooks).length > 0) {
+      console.log(`   Lifecycle Hooks:`);
+      for (const [h, script] of Object.entries(hooks)) {
+        console.log(`     - ${h}: ${script}`);
+      }
+    }
+    console.log();
+    return;
+  }
+
+  if (command === '--help' || command === '-h' || command === 'help') {
+    printHelp();
+    return;
+  }
+
+  console.error(`❌ Unknown plugin command: '${command}'`);
+  printHelp();
+  process.exit(1);
+}
+
+export default run;