lazyclaw 4.2.2 → 5.0.0

package/cli.mjs

@@ -4,6 +4,10 @@ import path from 'node:path';
 import fs from 'node:fs';
 import os from 'node:os';
 import { pathToFileURL } from 'node:url';
+// sandbox subcommands — list/test/add/use (Phase D).
+import { resolveSandbox, listBackends } from './sandbox/index.mjs';
+// Phase G: defaultConfigDir for personality subcommand (spec §9, decision C7).
+import { defaultConfigDir as _persDefaultCfg } from './memory.mjs';
 
 async function loadEngine() {
   return import('./workflow/persistent.mjs');
@@ -56,6 +60,17 @@ function _resolveAuthKey(cfg, provider) {
   return cfg['api-key'] || '';
 }
 
+// Per-provider base-URL override (used by tests + private gateways).
+// Single source of truth — the reflect / skill-synth / task-tick paths
+// all resolve through here so a new provider's env var lands in one spot.
+function _resolveBaseUrl(provider) {
+  return {
+    anthropic: process.env.LAZYCLAW_ANTHROPIC_BASE_URL,
+    openai:    process.env.LAZYCLAW_OPENAI_BASE_URL,
+    gemini:    process.env.LAZYCLAW_GEMINI_BASE_URL,
+  }[provider] || undefined;
+}
+
 async function importWorkflow(file) {
   const abs = path.resolve(file);
   const url = pathToFileURL(abs).href;
@@ -628,6 +643,66 @@ async function cmdResume(sessionId, file, opts = {}) {
   }
 }
 
+// --- Phase G: personality subcommand (spec §9, decision C7) -------------
+async function cmdPersonality(sub, a, b) {
+  const cfgDir = process.env.LAZYCLAW_CONFIG_DIR || _persDefaultCfg();
+  const dir = path.join(cfgDir, 'personalities');
+  fs.mkdirSync(dir, { recursive: true });
+
+  if (!sub || sub === 'list') {
+    const names = fs.existsSync(dir)
+      ? fs.readdirSync(dir).filter(f => f.endsWith('.md')).map(f => f.slice(0, -3))
+      : [];
+    if (!names.length) { console.log('No personalities installed'); return 0; }
+    for (const n of names.sort()) console.log(n);
+    return 0;
+  }
+
+  if (sub === 'show') {
+    if (!a) { console.error('Usage: lazyclaw personality show <name>'); return 2; }
+    const p = path.join(dir, `${a}.md`);
+    if (!fs.existsSync(p)) { console.error(`personality not found: ${a}`); return 1; }
+    process.stdout.write(fs.readFileSync(p, 'utf8'));
+    return 0;
+  }
+
+  if (sub === 'install') {
+    if (!a || !b) { console.error('Usage: lazyclaw personality install <name> <file>'); return 2; }
+    const dst = path.join(dir, `${a}.md`);
+    if (fs.existsSync(dst)) { console.error(`personality already installed: ${a}`); return 1; }
+    if (!fs.existsSync(b)) { console.error(`source file not found: ${b}`); return 1; }
+    fs.writeFileSync(dst, fs.readFileSync(b, 'utf8'));
+    console.log(`installed ${a}`);
+    return 0;
+  }
+
+  if (sub === 'remove') {
+    if (!a) { console.error('Usage: lazyclaw personality remove <name>'); return 2; }
+    const p = path.join(dir, `${a}.md`);
+    if (!fs.existsSync(p)) { console.error(`personality not installed: ${a}`); return 1; }
+    fs.unlinkSync(p);
+    console.log(`removed ${a}`);
+    return 0;
+  }
+
+  if (sub === 'use') {
+    if (!a) { console.error('Usage: lazyclaw personality use <name>'); return 2; }
+    const p = path.join(dir, `${a}.md`);
+    if (!fs.existsSync(p)) { console.error(`personality not installed: ${a}`); return 1; }
+    const cfgPath = path.join(cfgDir, 'config.json');
+    let cfg = {};
+    try { cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8')); } catch {}
+    cfg.persona = { ...(cfg.persona || {}), personality: a };
+    fs.mkdirSync(cfgDir, { recursive: true });
+    fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
+    console.log(`active personality: ${a}`);
+    return 0;
+  }
+
+  console.error(`Unknown personality subcommand: ${sub}`);
+  return 2;
+}
+
 async function cmdConfigEdit() {
   // Open config.json in $EDITOR (or sensible default), then validate
   // the result before letting the user walk away believing the edit
@@ -674,10 +749,10 @@ function cmdConfigSet(key, value) {
 function applyOnboardConfig(currentCfg, flags) {
   // Honors the OpenClaw-style unified provider/model string ("anthropic/claude-opus-4-7")
   // by splitting it, but explicit --provider always wins.
-  const { parseProviderModel } = require_registry_sync();
+  const { parseSlashProviderModel } = require_registry_sync();
   const next = { ...currentCfg };
   if (flags.model) {
-    const parsed = parseProviderModel(flags.model);
+    const parsed = parseSlashProviderModel(flags.model);
     if (parsed.provider && !flags.provider) next.provider = parsed.provider;
     next.model = parsed.model || flags.model;
   }
@@ -914,6 +989,8 @@ const SUBCOMMANDS = [
   'daemon', 'version', 'completion', 'help',
   'export', 'import',
   'rates',
+  // v5.0 — sandbox 6-backend (Phase D)
+  'sandbox',
   // OpenClaw-parity subsurfaces (v3.93–v3.98)
   'auth', 'pairing', 'nodes', 'message', 'workspace', 'browse', 'cron',
   // v3.99.6 — multi-step setup wizard + lazyclaw-only dashboard
@@ -924,20 +1001,31 @@ const SUBCOMMANDS = [
   'loop', 'loops', 'goal', 'memory',
   // v4.0.0 — Slack Socket Mode listener (inbound DM / @-mention)
   'slack',
+  // v4.3.0 — Telegram long-poll listener (zero-install mobile control)
+  'telegram',
+  // v4.3.0 — Matrix /sync long-poll listener
+  'matrix',
+  // v5.0 — channels plugin loader (Phase F)
+  'channels',
   // v4.1.0 — multi-agent slack system (Phase 9+)
   'agent', 'team', 'task',
+  // v5.0 Phase G — persona compose + cross-tool import (spec §9, §10)
+  'personality', 'migrate', 'hermes', 'openclaw',
+  // v5.0 Phase H1 — trajectory exporter (spec §2.7)
+  'trajectories',
 ];
 
 const SUBCOMMAND_SUBS = {
   config:    ['get', 'set', 'list', 'delete', 'unset', 'path', 'edit', 'validate'],
   sessions:  ['list', 'show', 'clear', 'export', 'search'],
-  skills:    ['list', 'show', 'install', 'remove', 'search'],
+  skills:    ['list', 'show', 'install', 'remove', 'search', 'curate', 'classify'],
   providers: ['list', 'info', 'test', 'add', 'remove', 'models'],
   rates:     ['list', 'set', 'delete', 'shape', 'validate', 'copy'],
+  sandbox:   ['list', 'test', 'add', 'use'],
   completion: ['bash', 'zsh'],
   auth:      ['list', 'add', 'remove', 'use', 'rotate'],
   pairing:   ['list', 'add', 'remove'],
-  nodes:     ['list', 'register', 'remove'],
+  nodes:     ['list', 'register', 'remove', 'pending', 'approve', 'revoke', 'devices'],
   message:   ['list', 'add', 'remove', 'send'],
   workspace: ['list', 'init', 'show', 'remove', 'path'],
   cron:      ['list', 'add', 'remove', 'show', 'sync', 'run'],
@@ -946,9 +1034,12 @@ const SUBCOMMAND_SUBS = {
   goal:      ['add', 'list', 'show', 'close', 'switch', 'tick', 'channel'],
   memory:    ['show', 'dream', 'edit'],
   slack:     ['listen'],
+  telegram:  ['listen'],
+  matrix:    ['listen'],
   agent:     ['add', 'list', 'show', 'edit', 'remove'],
   team:      ['add', 'list', 'show', 'edit', 'remove'],
   task:      ['start', 'list', 'show', 'abandon', 'done', 'remove'],
+  trajectories: ['export'],
 };
 
 function bashCompletion() {
@@ -1197,6 +1288,7 @@ const HELP_DETAILS = {
   export: 'Usage: lazyclaw export [--include-secrets] [--include-sessions] > bundle.json\n  --include-secrets keeps the raw api-key in the bundle (default redacts it).\n  --include-sessions adds full turn content (default keeps metadata only).',
   import: 'Usage: lazyclaw import [--from <path>] [--overwrite-skills] [--no-overwrite-config] [--import-sessions]\n  Reads JSON from stdin (or --from <path>). Sessions are NEVER overwritten.\n  Redacted api-keys (***REDACTED***) are dropped, never written.',
   rates: 'Usage: lazyclaw rates <list [--filter <substr>] [--limit <N>] | set <provider/model> --input <N> --output <N> [--cache-read <N>] [--cache-create <N>] [--currency USD] | delete <key> | shape | validate | copy <src> <dst> [--force]>\n  Rates are per million tokens. costFromUsage uses cfg.rates to compute the cost block in /usage and body.cost.\n  `list` accepts --filter (case-insensitive key substring) and --limit (post-filter cap), same shape sessions/skills/workflows lists use.\n  `shape` prints the reference template (zero-filled) you can copy into config.\n  `validate` checks the cfg.rates shape: required fields, non-negative numbers, known providers (warn-only).\n  `copy` clones an existing card to a new key (use when a new model launches at the same price as an old one).',
+  sandbox: 'Usage: lazyclaw sandbox <list|test|add|use> [args]\n  list             show 6 backends (local, docker, ssh, singularity, modal, daytona)\n  test <kind>      run echo through the backend (or argv-shape check for remote)\n  add <name> --kind <kind> [--image|--host|--user|--workspace|--app|--confiner ...]\n  use <profile>    set the profile as cfg.sandbox.default',
   auth: 'Usage: lazyclaw auth <list <provider> | add <provider> <key> [--label <name>] | remove <provider> <label> | use <provider> <label> | rotate <provider>>\n  Multiple keys per provider for rate-limit rotation. The active label is sent on every chat / agent call.\n  `rotate` advances the cursor to the next label; pair with a 429 hook for auto-failover.',
   pairing: 'Usage: lazyclaw pairing <list | add <id> [--label <name>] | remove <id>>\n  Sender allowlist for the messaging surface. Inbound senders not on this list are rejected.\n  Sender ids are opaque per-channel: Slack member id, Discord user id, phone number for SMS, etc.',
   nodes: 'Usage: lazyclaw nodes <list | register <id> [--platform macos|ios|android|web|cli] [--label <name>] | remove <id>>\n  Companion device registration table. CLI only — the actual mobile / menu-bar apps are out of scope here.\n  Platform is free-form lower-case; future surfaces (iOS / Android nodes) authenticate against the daemon using these ids.',
@@ -2283,6 +2375,38 @@ async function cmdChat(flags = {}) {
 
   // Top-of-session banner so the user can see at a glance what they're
   // talking to. Cheap (no provider call) and TTY-only.
+  // v5 ink splash + REPL when stdin is a real TTY and the user has not
+  // opted out via LAZYCLAW_NO_INK=1. Non-TTY pipelines and the opt-out
+  // env var fall through to the v4 figlet + readline path unchanged.
+  const __useInkSplash = process.stdout.isTTY && !process.env.LAZYCLAW_NO_INK;
+  if (__useInkSplash) {
+    try {
+      const React = (await import('react')).default;
+      const { render } = await import('ink');
+      const { ReplApp } = await import('./tui/repl.mjs');
+      const { renderSplashToString } = await import('./tui/splash.mjs');
+      // narrow-terminal fallback: <60 cols falls back to v4
+      if ((process.stdout.columns || 80) < 60) throw new Error('narrow-terminal');
+      const splashProps = {
+        provider: activeProvName, model: activeModel,
+        trainer: {}, sessionId: flags.session || '',
+        cwd: process.cwd(),
+        tools: [], skills: [],
+      };
+      void renderSplashToString; // surfaced for tests; runtime uses <Splash/>
+      const ink = render(/* @__PURE__ */ React.createElement(ReplApp, {
+        splashProps,
+        runTurn: async (_text, _signal) => { void _text; void _signal; },
+      }));
+      await ink.waitUntilExit();
+      return;
+    } catch (e) {
+      // Fall through to legacy path on any ink failure (missing import,
+      // narrow terminal, sandboxed stdout).
+      if (process.env.LAZYCLAW_DEBUG) console.error('[ink] fallback:', e.message);
+    }
+  }
+  // ─── legacy v4 path (unchanged) ─────────────────────────────────
   _printChatBanner(activeProvName, activeModel, readVersionFromRepo());
 
   const readline = await import('node:readline');
@@ -2464,8 +2588,8 @@ async function cmdChat(flags = {}) {
         }
         // Honor unified provider/model: `/model anthropic/claude-opus-4-7`
         // splits and switches both.
-        const { parseProviderModel } = _registryMod;
-        const parsed = parseProviderModel(arg);
+        const { parseSlashProviderModel } = _registryMod;
+        const parsed = parseSlashProviderModel(arg);
         if (parsed.provider) {
           const next = lookupProv(parsed.provider);
           if (!next) {
@@ -2925,6 +3049,53 @@ async function cmdChat(flags = {}) {
         }
         return true;
       }
+      case '/handoff': {
+        // /handoff <target-channel> <externalId> [--note=...] — migrates the
+        // active thread (bound to replState.channel / replState.externalId)
+        // to a new channel and posts transition stubs on both sides. In the
+        // local-only chat REPL there is no bound channel, so we surface a
+        // clear error and stay in the REPL (acceptance test §F).
+        const parts = line.trim().split(/\s+/).slice(1);
+        if (parts.length < 2) {
+          process.stderr.write('usage: /handoff <target-channel> <externalId> [--note=...]\n');
+          return true;
+        }
+        const target = parts[0];
+        const externalId = parts[1];
+        const note = (parts.find(p => p.startsWith('--note=')) || '').slice(7);
+        try {
+          const { openThreads } = await import('./channels/threads.mjs');
+          const { runHandoff } = await import('./channels/handoff.mjs');
+          const threads = openThreads(cfgDir);
+          const replState = globalThis.__lazyclawReplState || {};
+          const cur = replState.channel && replState.externalId
+            ? threads.findByExternal(replState.channel, replState.externalId)
+            : null;
+          if (!cur) {
+            process.stderr.write(
+              `handoff: no thread bound to ${replState.channel || '(none)'}:${replState.externalId || '(none)'}\n`,
+            );
+            return true;
+          }
+          const next = await runHandoff({
+            threads, channels: replState.channels || {},
+            threadId: cur.threadId, target, externalId, note,
+          });
+          process.stdout.write(`handoff -> ${next.channel}:${next.externalId} (session ${next.sessionId})\n`);
+          replState.channel = next.channel;
+          replState.externalId = next.externalId;
+        } catch (e) {
+          process.stderr.write(`handoff failed: ${e.code || 'ERR'}: ${e.message}\n`);
+        }
+        return true;
+      }
+      case '/personality': {
+        // Phase G: thin slash wrapper over cmdPersonality.
+        const tail = line.slice('/personality'.length).trim();
+        const parts = tail.split(/\s+/).filter(Boolean);
+        await cmdPersonality(parts[0] || 'list', parts[1], parts[2]);
+        return true;
+      }
       case '/exit': {
         return 'EXIT';
       }
@@ -3577,8 +3748,51 @@ async function cmdNodes(sub, positional, flags = {}) {
       console.log(JSON.stringify({ ok: true, removed: id }));
       return;
     }
+    // Device-gateway pairing (Phase 27) — distinct from the config-based
+    // `nodes register` table above. These drive the Ed25519 PairingStore
+    // a companion node authenticates against via `lazyclaw daemon`.
+    case 'pending': {
+      const { PairingStore } = await import('./gateway/device_auth.mjs');
+      const store = new PairingStore(path.dirname(configPath()));
+      console.log(JSON.stringify(store.pending(), null, 2));
+      return;
+    }
+    case 'devices': {
+      const { PairingStore } = await import('./gateway/device_auth.mjs');
+      const store = new PairingStore(path.dirname(configPath()));
+      console.log(JSON.stringify(store.devicesList(), null, 2));
+      return;
+    }
+    case 'approve': {
+      const requestId = positional[0];
+      if (!requestId) {
+        console.error('Usage: lazyclaw nodes approve <requestId>   (see `lazyclaw nodes pending`)');
+        process.exit(2);
+      }
+      const { PairingStore } = await import('./gateway/device_auth.mjs');
+      const store = new PairingStore(path.dirname(configPath()));
+      try {
+        const { deviceId } = store.approve(requestId);
+        // The token is intentionally NOT printed — the device receives its
+        // rotated token on its next /gateway/connect, so it never has to
+        // pass through a terminal / shell history.
+        console.log(JSON.stringify({ ok: true, approved: requestId, deviceId, note: 'device receives its token on next /gateway/connect' }));
+      } catch (e) { console.error(`error: ${e.message}`); process.exit(1); }
+      return;
+    }
+    case 'revoke': {
+      const deviceId = positional[0];
+      if (!deviceId) {
+        console.error('Usage: lazyclaw nodes revoke <deviceId>');
+        process.exit(2);
+      }
+      const { PairingStore } = await import('./gateway/device_auth.mjs');
+      const store = new PairingStore(path.dirname(configPath()));
+      console.log(JSON.stringify(store.revoke(deviceId)));
+      return;
+    }
     default:
-      console.error('Usage: lazyclaw nodes <list|register|remove> ...');
+      console.error('Usage: lazyclaw nodes <list|register|remove|pending|approve <requestId>|revoke <deviceId>|devices> ...');
       process.exit(2);
   }
 }
@@ -4382,7 +4596,7 @@ async function cmdMemory(sub, positional, flags = {}) {
   }
 }
 
-const AGENT_REG_SUBS = new Set(['add', 'list', 'show', 'edit', 'remove', 'rm', 'delete', 'memory', 'reflect']);
+const AGENT_REG_SUBS = new Set(['add', 'list', 'show', 'edit', 'remove', 'rm', 'delete', 'memory', 'reflect', 'skill-synth']);
 const TEAM_SUBS = new Set(['add', 'list', 'show', 'edit', 'remove', 'rm', 'delete']);
 const TASK_SUBS = new Set(['start', 'tick', 'list', 'show', 'abandon', 'done', 'transcript', 'remove', 'rm', 'delete']);
 
@@ -4510,14 +4724,36 @@ async function cmdTask(sub, positional, flags = {}) {
       const cfg = readConfig();
       const leadAgent = agentsById[team.lead];
       const apiKey = _resolveAuthKey(cfg, leadAgent.provider);
-      // Per-provider base-url override. Mostly useful for tests that
-      // point the adapter at a local mock; production users get the
-      // built-in default by leaving these unset.
-      const baseUrl = {
-        anthropic: process.env.LAZYCLAW_ANTHROPIC_BASE_URL,
-        openai:    process.env.LAZYCLAW_OPENAI_BASE_URL,
-        gemini:    process.env.LAZYCLAW_GEMINI_BASE_URL,
-      }[leadAgent.provider] || undefined;
+      // Per-provider base-url override (tests point this at a local mock;
+      // production leaves it unset for the built-in default).
+      const baseUrl = _resolveBaseUrl(leadAgent.provider);
+      // --approve-url turns on remote human-in-the-loop approval for the
+      // sensitive tools (bash/write): each such call long-polls a running
+      // daemon's `POST /exec/request`, which broadcasts to paired devices
+      // over the gateway SSE and resolves when one approves. Fail-closed —
+      // any endpoint error denies the call. Omit the flag → ungated (the
+      // historical behavior).
+      let approve;
+      if (flags['approve-url']) {
+        const approveUrl = String(flags['approve-url']).replace(/\/$/, '');
+        const approveToken = flags['approve-token'] ? String(flags['approve-token']) : '';
+        const approveTimeoutMs = flags['approve-timeout'] ? parseInt(flags['approve-timeout'], 10) : 120000;
+        approve = async ({ tool, args, agent }) => {
+          const summary = `${tool}: ${typeof args === 'object' ? JSON.stringify(args) : String(args)}`.slice(0, 400);
+          try {
+            const r = await fetch(`${approveUrl}/exec/request`, {
+              method: 'POST',
+              headers: { 'content-type': 'application/json', ...(approveToken ? { authorization: `Bearer ${approveToken}` } : {}) },
+              body: JSON.stringify({ tool, agentId: agent, summary, timeoutMs: approveTimeoutMs }),
+            });
+            if (!r.ok) return { approved: false, reason: `approval endpoint HTTP ${r.status}` };
+            const j = await r.json();
+            return { approved: !!j.approved, reason: j.reason || (j.approved ? 'approved' : 'denied') };
+          } catch (err) {
+            return { approved: false, reason: `approval request failed: ${err?.message || err}` };
+          }
+        };
+      }
       try {
         const result = await router.runTaskTurn({
           task, team, agentsById,
@@ -4527,6 +4763,7 @@ async function cmdTask(sub, positional, flags = {}) {
           baseUrl,
           logger: (line) => process.stderr.write(line),
           maxAgentTurns: flags['max-turns'] ? parseInt(flags['max-turns'], 10) : undefined,
+          approve,
         });
         emitJson({ id: result.task.id, status: result.task.status, iterations: result.iterations, stoppedBy: result.stoppedBy });
       } catch (err) {
@@ -4685,7 +4922,7 @@ async function cmdAgentRegistry(sub, positional, flags = {}) {
       return;
     }
     case 'add': {
-      if (!name) { console.error('Usage: lazyclaw agent add <name> [--role "..."] [--provider X] [--model Y] [--display "..."] [--tools bash,read,write,grep] [--tags a,b]'); process.exit(2); }
+      if (!name) { console.error('Usage: lazyclaw agent add <name> [--role "..."] [--provider X] [--model Y] [--display "..."] [--tools bash,read,write,grep,skill_view] [--tags a,b] [--skill-write auto|manual|off]'); process.exit(2); }
       const tools = agentsMod.parseToolsFlag(flags.tools);
       try {
         const a = agentsMod.registerAgent({
@@ -4696,6 +4933,7 @@ async function cmdAgentRegistry(sub, positional, flags = {}) {
           model: flags.model || '',
           tools: tools === null ? undefined : tools,
           tags: agentsMod.parseToolsFlag(flags.tags) || [],
+          skillWrite: flags['skill-write'],
         }, cfgDir);
         emitJson(a);
       } catch (err) {
@@ -4712,7 +4950,7 @@ async function cmdAgentRegistry(sub, positional, flags = {}) {
       return;
     }
     case 'edit': {
-      if (!name) { console.error('Usage: lazyclaw agent edit <name> [--role "..."] [--provider X] [--model Y] [--display "..."] [--tools ...]'); process.exit(2); }
+      if (!name) { console.error('Usage: lazyclaw agent edit <name> [--role "..."] [--provider X] [--model Y] [--display "..."] [--tools ...] [--skill-write auto|manual|off] [--memory-write auto|manual|off]'); process.exit(2); }
       const patch = {};
       if (flags.role !== undefined)         patch.role = String(flags.role);
       if (flags.provider !== undefined)     patch.provider = String(flags.provider);
@@ -4721,6 +4959,8 @@ async function cmdAgentRegistry(sub, positional, flags = {}) {
       if (flags['display-name'] !== undefined) patch.displayName = String(flags['display-name']);
       if (flags.tools !== undefined)        patch.tools = agentsMod.parseToolsFlag(flags.tools);
       if (flags.tags !== undefined)         patch.tags = agentsMod.parseToolsFlag(flags.tags);
+      if (flags['skill-write'] !== undefined)  patch.skillWrite = String(flags['skill-write']);
+      if (flags['memory-write'] !== undefined) patch.memoryWrite = String(flags['memory-write']);
       if (Object.keys(patch).length === 0) {
         console.error('agent edit: no fields to update');
         process.exit(2);
@@ -4796,11 +5036,7 @@ async function cmdAgentRegistry(sub, positional, flags = {}) {
       try { _loadDotenvIfAny(cfgDir); } catch { /* best-effort */ }
       const cfg = readConfig();
       const apiKey = _resolveAuthKey(cfg, a.provider);
-      const baseUrl = {
-        anthropic: process.env.LAZYCLAW_ANTHROPIC_BASE_URL,
-        openai:    process.env.LAZYCLAW_OPENAI_BASE_URL,
-        gemini:    process.env.LAZYCLAW_GEMINI_BASE_URL,
-      }[a.provider] || undefined;
+      const baseUrl = _resolveBaseUrl(a.provider);
       try {
         const body = await memMod.reflectOnce({ agent: a, task, apiKey, baseUrl });
         if (!body || !body.trim()) {
@@ -4817,8 +5053,50 @@ async function cmdAgentRegistry(sub, positional, flags = {}) {
       }
       return;
     }
+    case 'skill-synth': {
+      const aname = positional[0];
+      const taskId = flags.task || positional[1];
+      if (!aname || !taskId) {
+        console.error('Usage: lazyclaw agent skill-synth <name> --task <id> [--dry-run]');
+        process.exit(2);
+      }
+      const tasksMod = await import('./tasks.mjs');
+      const synthMod = await import('./mas/skill_synth.mjs');
+      const skillsMod = await import('./skills.mjs');
+      const a = agentsMod.getAgent(aname, cfgDir);
+      if (!a) { console.error(`agent skill-synth: no agent "${aname}"`); process.exit(2); }
+      const task = tasksMod.getTask(taskId, cfgDir);
+      if (!task) { console.error(`agent skill-synth: no task "${taskId}"`); process.exit(2); }
+      try { _loadDotenvIfAny(cfgDir); } catch { /* best-effort */ }
+      const cfg = readConfig();
+      const apiKey = _resolveAuthKey(cfg, a.provider);
+      const baseUrl = _resolveBaseUrl(a.provider);
+      try {
+        const result = await synthMod.synthesizeSkill({ agent: a, task, apiKey, baseUrl });
+        if (!result) {
+          process.stderr.write('skill synthesis produced nothing worth saving\n');
+          return;
+        }
+        if (!flags['dry-run']) {
+          // installSynthesized reserves a collision-free name (never
+          // clobbers a human-authored skill) and version-bumps when it
+          // improves its own prior skill.
+          const installed = synthMod.installSynthesized(
+            { name: result.name, description: result.description, body: result.body, sourceTask: task.id },
+            cfgDir,
+          );
+          emitJson({ skill: installed.skill, description: result.description, version: installed.version, path: installed.path });
+        } else {
+          process.stdout.write(result.doc + (result.doc.endsWith('\n') ? '' : '\n'));
+        }
+      } catch (err) {
+        console.error(`agent skill-synth: ${err?.message || err}`);
+        process.exit(2);
+      }
+      return;
+    }
     default:
-      console.error('Usage: lazyclaw agent <add|list|show|edit|remove|memory|reflect> ...');
+      console.error('Usage: lazyclaw agent <add|list|show|edit|remove|memory|reflect|skill-synth> ...');
       process.exit(2);
   }
 }
@@ -4929,6 +5207,165 @@ async function cmdSlack(sub, positional, flags = {}) {
   });
 }
 
+// `lazyclaw telegram listen` — zero-install mobile control surface.
+// Long-polls the Telegram Bot API (no public URL / webhook needed) and
+// pipes each inbound message through the active provider, replying in
+// the same chat. Mirrors `slack listen`. Access is gated by the existing
+// `pairing` allowlist (Telegram numeric user ids); an empty allowlist
+// means "reply to anyone who can reach the bot".
+async function cmdTelegram(sub, positional, flags = {}) {
+  if (sub !== 'listen') {
+    console.error('Usage: lazyclaw telegram listen [--provider X] [--model Y]\n  Long-polls the Telegram Bot API. Set TELEGRAM_BOT_TOKEN in ~/.lazyclaw/.env.\n  Restrict who can talk to it with `lazyclaw pairing add <telegram-user-id>`.');
+    process.exit(2);
+  }
+  await ensureRegistry();
+  const cfg = readConfig();
+  const cfgDir = path.dirname(configPath());
+
+  const envInfo = _loadDotenvIfAny(cfgDir);
+  process.stderr.write(`[telegram] .env: ${envInfo.loaded} keys loaded from ${envInfo.path}\n`);
+
+  const provName = flags.provider || cfg.provider || 'mock';
+  const prov = _registryMod.PROVIDERS[provName];
+  if (!prov) { console.error(`unknown provider: ${provName}`); process.exit(2); }
+  const model = flags.model || cfg.model;
+
+  const threadMsgs = new Map();
+  const MAX_TURNS = 20;
+
+  const handler = async ({ threadId, text }) => {
+    const cleaned = String(text || '').trim();
+    if (!cleaned) { process.stderr.write('[telegram] dropping empty inbound\n'); return null; }
+    const msgs = threadMsgs.get(threadId) || [];
+    msgs.push({ role: 'user', content: cleaned });
+    let acc = '';
+    try {
+      for await (const chunk of prov.sendMessage(msgs, { apiKey: _resolveAuthKey(cfg, provName), model })) acc += chunk;
+    } catch (err) {
+      msgs.pop();
+      const why = err?.message || String(err);
+      process.stderr.write(`[telegram] provider error: ${why}\n`);
+      return `(provider error: ${why})`;
+    }
+    msgs.push({ role: 'assistant', content: acc });
+    if (msgs.length > MAX_TURNS) msgs.splice(0, msgs.length - MAX_TURNS);
+    threadMsgs.set(threadId, msgs);
+    if (!acc.trim()) { process.stderr.write('[telegram] provider returned empty text — not posting\n'); return null; }
+    return acc;
+  };
+
+  // The pairing allowlist doubles as the Telegram sender allowlist.
+  const allowlist = (cfg.pairing || []).map((p) => String(p.id));
+  const { TelegramChannel } = await import('./channels/telegram.mjs');
+  let ch;
+  try {
+    ch = new TelegramChannel({ allowlist: allowlist.length ? allowlist : null });
+  } catch (err) {
+    console.error(`telegram: ${err?.message || err}`);
+    process.exit(2);
+  }
+  process.stderr.write(`[telegram] provider=${provName} model=${model || '(default)'} allowlist=${allowlist.length || 'open'}\n`);
+  try {
+    await ch.start(handler, { poll: true, logger: (line) => process.stderr.write(line) });
+  } catch (err) {
+    if (err?.code === 'TELEGRAM_MISSING_TOKEN') {
+      console.error('telegram: TELEGRAM_BOT_TOKEN not set');
+      console.error(`hint: add TELEGRAM_BOT_TOKEN=... to ${path.join(cfgDir, '.env')}`);
+    } else {
+      console.error(`telegram: ${err?.message || err}`);
+    }
+    process.exit(2);
+  }
+  process.stderr.write(`[telegram] listening. Ctrl-C to stop.\n`);
+
+  await new Promise((resolve) => {
+    const onSig = async () => {
+      process.stderr.write(`\n[telegram] shutting down…\n`);
+      try { await ch.stop(); } catch { /* best-effort */ }
+      resolve();
+    };
+    process.once('SIGINT', onSig);
+    process.once('SIGTERM', onSig);
+  });
+}
+
+// `lazyclaw matrix listen` — Matrix inbound over the client-server API's
+// long-poll /sync (no SDK). Mirrors `telegram listen`. Set MATRIX_HOMESERVER
+// + MATRIX_ACCESS_TOKEN (+ MATRIX_USER_ID for self-filtering) in ~/.lazyclaw/.env.
+async function cmdMatrix(sub, positional, flags = {}) {
+  if (sub !== 'listen') {
+    console.error('Usage: lazyclaw matrix listen [--provider X] [--model Y]\n  Long-polls the Matrix /sync API. Set MATRIX_HOMESERVER + MATRIX_ACCESS_TOKEN (+ MATRIX_USER_ID) in ~/.lazyclaw/.env.\n  Restrict who can talk to it with `lazyclaw pairing add <@user:server>`.');
+    process.exit(2);
+  }
+  await ensureRegistry();
+  const cfg = readConfig();
+  const cfgDir = path.dirname(configPath());
+
+  const envInfo = _loadDotenvIfAny(cfgDir);
+  process.stderr.write(`[matrix] .env: ${envInfo.loaded} keys loaded from ${envInfo.path}\n`);
+
+  const provName = flags.provider || cfg.provider || 'mock';
+  const prov = _registryMod.PROVIDERS[provName];
+  if (!prov) { console.error(`unknown provider: ${provName}`); process.exit(2); }
+  const model = flags.model || cfg.model;
+
+  const threadMsgs = new Map();
+  const MAX_TURNS = 20;
+  const handler = async ({ threadId, text }) => {
+    const cleaned = String(text || '').trim();
+    if (!cleaned) { process.stderr.write('[matrix] dropping empty inbound\n'); return null; }
+    const msgs = threadMsgs.get(threadId) || [];
+    msgs.push({ role: 'user', content: cleaned });
+    let acc = '';
+    try {
+      for await (const chunk of prov.sendMessage(msgs, { apiKey: _resolveAuthKey(cfg, provName), model })) acc += chunk;
+    } catch (err) {
+      msgs.pop();
+      const why = err?.message || String(err);
+      process.stderr.write(`[matrix] provider error: ${why}\n`);
+      return `(provider error: ${why})`;
+    }
+    msgs.push({ role: 'assistant', content: acc });
+    if (msgs.length > MAX_TURNS) msgs.splice(0, msgs.length - MAX_TURNS);
+    threadMsgs.set(threadId, msgs);
+    if (!acc.trim()) { process.stderr.write('[matrix] provider returned empty text — not posting\n'); return null; }
+    return acc;
+  };
+
+  const allowlist = (cfg.pairing || []).map((p) => String(p.id));
+  const { MatrixChannel } = await import('./channels/matrix.mjs');
+  let ch;
+  try {
+    ch = new MatrixChannel({ allowlist: allowlist.length ? allowlist : null });
+  } catch (err) {
+    console.error(`matrix: ${err?.message || err}`);
+    process.exit(2);
+  }
+  process.stderr.write(`[matrix] provider=${provName} model=${model || '(default)'} allowlist=${allowlist.length || 'open'}\n`);
+  try {
+    await ch.start(handler, { poll: true, logger: (line) => process.stderr.write(line) });
+  } catch (err) {
+    if (err?.code === 'MATRIX_MISSING_TOKEN' || err?.code === 'MATRIX_MISSING_HOMESERVER') {
+      console.error(`matrix: ${err.message}`);
+      console.error(`hint: set MATRIX_HOMESERVER and MATRIX_ACCESS_TOKEN in ${path.join(cfgDir, '.env')}`);
+    } else {
+      console.error(`matrix: ${err?.message || err}`);
+    }
+    process.exit(2);
+  }
+  process.stderr.write(`[matrix] listening. Ctrl-C to stop.\n`);
+
+  await new Promise((resolve) => {
+    const onSig = async () => {
+      process.stderr.write(`\n[matrix] shutting down…\n`);
+      try { await ch.stop(); } catch { /* best-effort */ }
+      resolve();
+    };
+    process.once('SIGINT', onSig);
+    process.once('SIGTERM', onSig);
+  });
+}
+
 async function cmdSkills(sub, positional, flags = {}) {
   const skillsMod = await import('./skills.mjs');
   const cfgDir = path.dirname(configPath());
@@ -5120,8 +5557,24 @@ async function cmdSkills(sub, positional, flags = {}) {
       console.log(JSON.stringify({ query, regex: useRegex, matches }, null, 2));
       return;
     }
+    case 'curate': {
+      // Lifecycle sweep: agent-authored skills unused >90d move into
+      // skills/.archive/ (recoverable). Human-authored skills are never
+      // moved. The real clock is injected here; the module stays pure.
+      const curator = await import('./skills_curator.mjs');
+      const r = curator.curate(cfgDir, Date.now());
+      console.log(JSON.stringify(r, null, 2));
+      return;
+    }
+    case 'classify': {
+      const name = positional[0];
+      if (!name) { console.error('Usage: lazyclaw skills classify <name>'); process.exit(2); }
+      const curator = await import('./skills_curator.mjs');
+      console.log(JSON.stringify({ name, state: curator.classify(name, cfgDir, Date.now()), usage: curator.usageOf(name, cfgDir) }, null, 2));
+      return;
+    }
     default:
-      console.error('Usage: lazyclaw skills <list|show <name>|install <name> [--from path]|remove <name>|search <query> [--regex]>');
+      console.error('Usage: lazyclaw skills <list|show <name>|install <name> [--from path]|remove <name>|search <query> [--regex]|curate|classify <name>>');
       process.exit(2);
   }
 }
@@ -5662,10 +6115,118 @@ async function cmdSessions(sub, positional, flags = {}) {
   }
 }
 
+// sandbox subcommands — list/test/add/use (Phase D).
+async function cmdSandbox(args, flags = {}) {
+  const sub = args[0];
+
+  if (!sub || sub === 'list') {
+    for (const kind of listBackends()) process.stdout.write(`${kind}\n`);
+    return 0;
+  }
+
+  if (sub === 'test') {
+    const name = args[1];
+    if (!name) { process.stderr.write('usage: lazyclaw sandbox test <kind|profile>\n'); return 2; }
+    const cfg = _sandboxLoadConfigOrEmpty();
+    // If `name` looks like a known kind, route to that kind. If it
+    // is not a known kind AND not a profile in cfg, treat as an
+    // unknown identifier and report SANDBOX_BAD_KIND.
+    const isKind = listBackends().includes(name);
+    const profile = cfg.sandbox && cfg.sandbox.profiles && cfg.sandbox.profiles[name];
+    if (!isKind && !profile) {
+      process.stderr.write(`SANDBOX_BAD_KIND: unknown sandbox kind or profile "${name}"\n`);
+      return 1;
+    }
+    let sb;
+    try {
+      const synthCfg = isKind
+        ? { sandbox: { default: name, ...cfg.sandbox } }
+        : cfg;
+      sb = resolveSandbox(synthCfg);
+    } catch (e) {
+      process.stderr.write(`${e.code || 'SANDBOX_ERR'}: ${e.message}\n`); return 1;
+    }
+    if (sb.spec.kind !== 'local' && sb.spec.kind !== 'docker') {
+      // Remote/serverless backends just construct argv in unit tests;
+      // we report "shape-ok" without actually executing.
+      process.stdout.write(`ok ${sb.spec.kind} (argv-shape)\n`);
+      return 0;
+    }
+    const sess = await sb.open();
+    try {
+      const r = await sess.exec(['echo', 'lazyclaw-sandbox-test']);
+      if (r.code !== 0 || !/lazyclaw-sandbox-test/.test(r.stdout)) {
+        process.stderr.write(`fail ${name}: exit=${r.code} stdout=${r.stdout}\n`); return 1;
+      }
+      process.stdout.write(`ok ${name}\n`);
+      return 0;
+    } finally { await sess.close(); }
+  }
+
+  if (sub === 'add') {
+    const name = args[1];
+    if (!name) { process.stderr.write('usage: lazyclaw sandbox add <name> --kind <kind> [...]\n'); return 2; }
+    const opts = {};
+    if (flags.kind) opts.kind = flags.kind;
+    if (flags.image) opts.image = flags.image;
+    if (flags.host) opts.host = flags.host;
+    if (flags.user) opts.user = flags.user;
+    if (flags.workspace) opts.workspace = flags.workspace;
+    if (flags.app) opts.app = flags.app;
+    if (flags.confiner) opts.confiner = flags.confiner;
+    if (!listBackends().includes(opts.kind)) {
+      process.stderr.write(`unknown kind "${opts.kind}"\n`); return 1;
+    }
+    const cfg = _sandboxLoadConfigOrEmpty();
+    cfg.sandbox = cfg.sandbox || {};
+    cfg.sandbox.profiles = cfg.sandbox.profiles || {};
+    cfg.sandbox.profiles[name] = opts;
+    _sandboxSaveConfig(cfg);
+    process.stdout.write(`added profile ${name} (${opts.kind})\n`);
+    return 0;
+  }
+
+  if (sub === 'use') {
+    const name = args[1];
+    if (!name) { process.stderr.write('usage: lazyclaw sandbox use <profile>\n'); return 2; }
+    const cfg = _sandboxLoadConfigOrEmpty();
+    const prof = cfg.sandbox && cfg.sandbox.profiles && cfg.sandbox.profiles[name];
+    if (!prof) { process.stderr.write(`no profile "${name}"\n`); return 1; }
+    cfg.sandbox = cfg.sandbox || {};
+    cfg.sandbox.default = prof.kind;
+    cfg.sandbox[prof.kind] = { ...(cfg.sandbox[prof.kind] || {}), ...prof, kind: undefined };
+    delete cfg.sandbox[prof.kind].kind;
+    _sandboxSaveConfig(cfg);
+    process.stdout.write(`using profile ${name} (${prof.kind})\n`);
+    return 0;
+  }
+
+  process.stderr.write(`unknown subcommand "${sub}". Try: list | test | add | use\n`);
+  return 2;
+}
+
+function _sandboxLoadConfigOrEmpty() {
+  const p = process.env.LAZYCLAW_CONFIG || configPath();
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch { return {}; }
+}
+
+function _sandboxSaveConfig(cfg) {
+  const p = process.env.LAZYCLAW_CONFIG || configPath();
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(cfg, null, 2));
+}
+
 function cmdConfigGet(key) {
   const cfg = readConfig();
-  if (key) console.log(JSON.stringify({ key, value: cfg[key] ?? null }));
-  else console.log(JSON.stringify(cfg));
+  if (!key) { console.log(JSON.stringify(cfg)); return; }
+  let value = cfg;
+  for (const seg of String(key).split('.')) {
+    if (value && typeof value === 'object' && seg in value) value = value[seg];
+    else { value = null; break; }
+  }
+  console.log(JSON.stringify({ key, value }));
 }
 
 // Structural integrity check across the whole config. Distinct from
@@ -5997,6 +6558,8 @@ async function _dispatchMenuChoice(argv) {
       case 'goal':         return await cmdGoal(rest[0], rest.slice(1), {});
       case 'memory':       return await cmdMemory(rest[0], rest.slice(1), {});
       case 'slack':        return await cmdSlack(rest[0], rest.slice(1), {});
+      case 'telegram':     return await cmdTelegram(rest[0], rest.slice(1), {});
+      case 'matrix':       return await cmdMatrix(rest[0], rest.slice(1), {});
       case 'team':         return await cmdTeam(rest[0], rest.slice(1), {});
       case 'task':         return await cmdTask(rest[0], rest.slice(1), {});
       case 'auth':         return await cmdAuth(rest[0], rest.slice(1), {});
@@ -6024,6 +6587,8 @@ async function _dispatchMenuChoice(argv) {
       case 'inspect':      return await cmdInspect(rest[0], {});
       case 'export':       return await cmdExport({});
       case 'version':      return await cmdVersion();
+      // Phase G — persona compose subcommand (spec §9, decision C7).
+      case 'personality':  return await cmdPersonality(rest[0], rest[1], rest[2]);
       // help <cmd> is the safe fallback for commands that need real
       // arguments (run / resume / clear / validate / graph / daemon /
       // import / completion). Print the usage so the user can re-launch
@@ -6460,6 +7025,105 @@ async function main() {
       }
       break;
     }
+    case 'personality': {
+      // Phase G: persona compose subcommand (spec §9, decision C7).
+      process.exit(await cmdPersonality(rest.positional[0], rest.positional[1], rest.positional[2]));
+      break;
+    }
+    case 'migrate': {
+      // Phase A baseline accepts `lazyclaw migrate v5`; Phase G adds the
+      // bare `lazyclaw migrate` and `lazyclaw migrate rollback` forms.
+      const target = rest.positional[0];
+      if (target === 'rollback') {
+        const mod = await import('./scripts/migrate-v5.mjs');
+        try {
+          const { restoredFrom } = mod.rollback();
+          console.log(`rolled back from ${restoredFrom}`);
+          process.exit(0);
+        } catch (e) {
+          console.error(`migrate failed: ${e.message}`);
+          process.exit(1);
+        }
+        break;
+      }
+      const mod = await import('./scripts/migrate-v5.mjs');
+      // `migrate v5` keeps the Phase-A behaviour (verbose JSON); the
+      // bare `migrate` form uses the Phase-G human summary.
+      if (target === 'v5') {
+        const r = await mod.migrateV5();
+        console.log(JSON.stringify(r, null, 2));
+        process.exit(r.ok ? 0 : 1);
+      }
+      try {
+        const { backupDir } = mod.migrate();
+        console.log(`migrated; backup at ${backupDir}`);
+        process.exit(0);
+      } catch (e) {
+        console.error(`migrate failed: ${e.message}`);
+        process.exit(1);
+      }
+      break;
+    }
+    case 'hermes': {
+      // Phase G: import a Hermes Agent install (spec §10).
+      if (rest.positional[0] !== 'import') {
+        console.error('Usage: lazyclaw hermes import [--from <dir>]');
+        process.exit(2);
+      }
+      const from = rest.flags.from;
+      const mod = await import('./scripts/hermes-import.mjs');
+      try {
+        const { src, dst, counts } = mod.importHermes({ from });
+        console.log(`hermes import: ${src} → ${dst}`);
+        console.log(`  skills: ${counts.skills}  skins: ${counts.skins}`);
+        process.exit(0);
+      } catch (e) { console.error(`hermes import failed: ${e.message}`); process.exit(1); }
+      break;
+    }
+    case 'openclaw': {
+      // Phase G: import an OpenClaw install (spec §10).
+      if (rest.positional[0] !== 'import') {
+        console.error('Usage: lazyclaw openclaw import [--from <dir>]');
+        process.exit(2);
+      }
+      const from = rest.flags.from;
+      const mod = await import('./scripts/openclaw-import.mjs');
+      try {
+        const { src, dst, counts } = mod.importOpenclaw({ from });
+        console.log(`openclaw import: ${src} → ${dst}  skills:${counts.skills}`);
+        process.exit(0);
+      } catch (e) { console.error(`openclaw import failed: ${e.message}`); process.exit(1); }
+      break;
+    }
+    case 'trajectories': {
+      // Phase H1: read-only trajectory exporter (spec §2.7).
+      // Usage: lazyclaw trajectories export --format <atropos|axolotl|openai-ft|jsonl>
+      //          [--since 7d] [--filter "outcome=done"] [--out ./dir]
+      if (rest.positional[0] !== 'export') {
+        console.error('Usage: lazyclaw trajectories export --format <atropos|axolotl|openai-ft|jsonl> [--since 7d] [--filter "outcome=done"] [--out <dir>]');
+        process.exit(2);
+      }
+      const mod = await import('./mas/trajectory_export.mjs');
+      const format = rest.flags.format || 'jsonl';
+      if (!mod.FORMATS.includes(format)) {
+        console.error(`trajectories export: unknown format "${format}" — choose ${mod.FORMATS.join('|')}`);
+        process.exit(2);
+      }
+      try {
+        const r = await mod.exportTrajectories({
+          format,
+          since: rest.flags.since,
+          filter: mod.parseFilterArg(rest.flags.filter),
+          outDir: rest.flags.out,
+        });
+        console.log(`exported ${r.count} trajectories (${r.format}) → ${r.outFile}`);
+        process.exit(0);
+      } catch (e) {
+        console.error(`trajectories export failed: ${e.message}`);
+        process.exit(1);
+      }
+      break;
+    }
     case 'chat': {
       await cmdChat(rest.flags);
       break;
@@ -6489,6 +7153,10 @@ async function main() {
       await cmdRates(sub, rest.positional.slice(1), rest.flags);
       break;
     }
+    case 'sandbox': {
+      process.exit(await cmdSandbox(rest.positional, rest.flags));
+      break;
+    }
     case 'auth': {
       const sub = rest.positional[0];
       await cmdAuth(sub, rest.positional.slice(1), rest.flags);
@@ -6548,6 +7216,16 @@ async function main() {
       await cmdSlack(sub, rest.positional.slice(1), rest.flags);
       break;
     }
+    case 'telegram': {
+      const sub = rest.positional[0];
+      await cmdTelegram(sub, rest.positional.slice(1), rest.flags);
+      break;
+    }
+    case 'matrix': {
+      const sub = rest.positional[0];
+      await cmdMatrix(sub, rest.positional.slice(1), rest.flags);
+      break;
+    }
     case 'team': {
       const sub = rest.positional[0];
       await cmdTeam(sub, rest.positional.slice(1), rest.flags);
@@ -6566,6 +7244,31 @@ async function main() {
       await cmdDashboard(rest.flags);
       break;
     }
+    case 'channels': {
+      const sub = (rest.positional[0] || 'list').toLowerCase();
+      const { createLoader, listInstalled } = await import('./channels/loader.mjs');
+      const cfgDir = path.dirname(configPath());
+      const loader = createLoader({ configDir: cfgDir });
+      if (sub === 'install') {
+        const name = rest.positional[1];
+        if (!name) { process.stderr.write('usage: lazyclaw channels install <@lazyclaw/channel-name>\n'); process.exit(2); }
+        const info = await loader.install(name);
+        process.stdout.write(`installed ${info.name}@${info.version}\n`);
+        break;
+      }
+      if (sub === 'remove' || sub === 'uninstall') {
+        const name = rest.positional[1];
+        if (!name) { process.stderr.write('usage: lazyclaw channels remove <@lazyclaw/channel-name>\n'); process.exit(2); }
+        await loader.remove(name);
+        process.stdout.write(`removed ${name}\n`);
+        break;
+      }
+      // list
+      const rows = listInstalled(cfgDir);
+      if (!rows.length) { process.stdout.write('no channel plugins installed\n'); break; }
+      for (const r of rows) process.stdout.write(`${r.name}\t${r.version}\n`);
+      break;
+    }
     case 'daemon': {
       await cmdDaemon(rest.flags);
       break;