lazyclaw 4.2.1 → 4.3.0

package/cli.mjs

@@ -56,6 +56,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;
@@ -924,6 +935,10 @@ 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',
   // v4.1.0 — multi-agent slack system (Phase 9+)
   'agent', 'team', 'task',
 ];
@@ -931,13 +946,13 @@ const SUBCOMMANDS = [
 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'],
   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,6 +961,8 @@ 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'],
@@ -1484,28 +1501,28 @@ function _attachGhostAutocomplete(rl) {
 // Width-management rule: every inner line is forced through
 // `.padEnd(W)` so a stray width miscount can't punch the right
 // border off the box (which is exactly the bug v3.99.5 shipped:
-// v4.2.2 — restore the original v3.99.11-era banner: a figlet
-// "lazy" wordmark (small font, 4 rows) inside a 30-col rounded box
-// with a "LazyClaw  |__/  v<ver>" caption sharing the last inner row
-// with the descender of the `y`. This is the banner that shipped
-// before the helmet-mascot / 8-bit-crab / emoji detours, and the one
-// the user kept in muscle memory.
+// v4.2.2 — boxed figlet "lazy" wordmark, single-colour orange. The
+// previous mixed-colour banner (helmet-red letter art + ink-beige
+// caption) read as "two banners glued together" because the colour
+// changed mid-box. We use one warm orange (#F08246) for everything —
+// border, letter art, caption — so the eye reads it as one badge.
 //
-// Layout invariant: every inner row is exactly 30 visible cells (no
-// double-width glyphs, all chars are 1 cell in any monospace font),
-// so the right edge `│` always lands in the same column.
+// Letter art is figlet "standard" (6 rows) rather than the v3.99.11
+// "small" (4 rows), because small renders as a pixel mush in most
+// terminal fonts. Standard's strokes are wide enough that the
+// letters read as `l a z y` even at small terminal sizes.
 //
-// _renderMascot / _renderMascotTiny are kept as stubs because the
-// _renderBanner caller still passes a row array around; they no
-// longer drive separate art for working/done/error since the box-
-// banner has no good place to flash those states. The router and
-// loop runners that used to ask for a state-coloured tiny mascot can
-// keep importing the helper; it just returns the wordmark.
+// Layout invariant: every inner row is exactly INNER_W visible cells
+// (no double-width glyphs, all chars are 1 cell in any monospace
+// font), so the right edge `│` always lands in the same column.
+//
+// _renderMascot / _renderMascotTiny are kept as stubs so any leftover
+// caller doesn't crash; no state-coloured art is produced any more.
+
+const _ORANGE_RGB = '241;130;70';  // #F18246
+function _orange(s) { return `\x1b[38;2;${_ORANGE_RGB}m${s}\x1b[0m`; }
 
 function _renderMascot() {
-  // Banner builds its own art; this stub exists so any leftover
-  // caller doesn't crash. One element so .map() and length checks
-  // behave like the legacy shape.
   return ['lazyclaw'];
 }
 
@@ -1513,39 +1530,49 @@ function _renderMascotTiny() {
   return 'lazyclaw';
 }
 
+// figlet "standard" "lazy", trimmed of leading blank line. Each row
+// is left-padded by two spaces inside the box, and every row is then
+// padded to INNER_W cells.
+const _LAZY_STANDARD = [
+  ' _                  ',
+  '| | __ _ _____   _  ',
+  '| |/ _` |_  / | | | ',
+  '| | (_| |/ /| |_| | ',
+  '|_|\\__,_/___|\\__, | ',
+  '             |___/  ',
+];
+
+const _INNER_W = 32;  // 2 left pad + 20 letter art + caption headroom
+
 function _renderBanner(version) {
-  const helmet = (s) => `\x1b[38;2;195;61;42m${s}\x1b[0m`;
-  const ink = (s) => `\x1b[38;2;241;234;217m${s}\x1b[0m`;
   const v = String(version || '?.?.?');
-  // Caption shares the final inner row with the `|__/` descender of
-  // the `y` from figlet-small, exactly like the v3.99.11 screenshot.
-  const cap = `  LazyClaw  |__/  v${v}`.padEnd(30, ' ').slice(0, 30);
-  const top = '╭' + '─'.repeat(30) + '╮';
-  const bot = '╰' + '─'.repeat(30) + '╯';
-  const wrap = (inner) => helmet('│') + inner + helmet('│');
+  const cap = `  LazyClaw  v${v}`;
+  const padInner = (s) => '  ' + s.padEnd(_INNER_W - 2, ' ');
+  const wrap = (inner) => _orange('│') + _orange(inner) + _orange('│');
+  const top = _orange('╭' + '─'.repeat(_INNER_W) + '╮');
+  const bot = _orange('╰' + '─'.repeat(_INNER_W) + '╯');
   return [
-    helmet(top),
-    wrap(helmet('   _                          ')),
-    wrap(helmet('  | |__ _ _____  _ _          ')),
-    wrap(helmet(`  | / _\` |_ / || | '_|        `)),
-    wrap(helmet(`  |_\\__,_/__\\_, |_|           `)),
-    wrap(ink(cap)),
-    helmet(bot),
+    top,
+    ..._LAZY_STANDARD.map((row) => wrap(padInner(row))),
+    wrap(padInner(cap)),
+    bot,
   ];
 }
 
 function _printChatBanner(activeProvName, activeModel, version) {
   if (!process.stdout.isTTY) return;
-  const dim = (s) => `\x1b[2m${s}\x1b[0m`;
-  const ok = (s) => `\x1b[32m${s}\x1b[0m`;
+  // Single-hue header: labels dim-orange, values/emphasis full-orange, so the
+  // four caption rows below the box read as part of the same warm badge.
+  const dimOrange = (s) => `\x1b[2m\x1b[38;2;${_ORANGE_RGB}m${s}\x1b[0m`;
+  const orange = _orange;
   const lines = [
     '',
     ..._renderBanner(version),
     '',
-    `  ${dim('provider ·')} ${ok(activeProvName)}`,
-    `  ${dim('model    ·')} ${ok(activeModel || '(default)')}`,
-    `  ${dim('slash    ·')} /help · /model · /provider · /exit`,
-    `  ${dim('hint     ·')} → ${dim('to accept the suggested command,')} Tab ${dim('to cycle')}`,
+    `  ${dimOrange('provider ·')} ${orange(activeProvName)}`,
+    `  ${dimOrange('model    ·')} ${orange(activeModel || '(default)')}`,
+    `  ${dimOrange('slash    ·')} ${orange('/help · /model · /provider · /exit')}`,
+    `  ${dimOrange('hint     ·')} ${orange('→')} ${dimOrange('to accept the suggested command,')} ${orange('Tab')} ${dimOrange('to cycle')}`,
     '',
   ];
   process.stdout.write(lines.join('\n') + '\n');
@@ -3567,8 +3594,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);
   }
 }
@@ -4372,7 +4442,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']);
 
@@ -4500,14 +4570,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,
@@ -4517,6 +4609,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) {
@@ -4675,7 +4768,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({
@@ -4686,6 +4779,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) {
@@ -4702,7 +4796,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);
@@ -4711,6 +4805,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);
@@ -4786,11 +4882,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()) {
@@ -4807,8 +4899,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);
   }
 }
@@ -4919,6 +5053,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());
@@ -5110,8 +5403,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);
   }
 }
@@ -5987,6 +6296,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), {});
@@ -6538,6 +6849,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);