lazyclaw 4.2.2 → 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'],
@@ -3577,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);
   }
 }
@@ -4382,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']);
 
@@ -4510,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,
@@ -4527,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) {
@@ -4685,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({
@@ -4696,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) {
@@ -4712,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);
@@ -4721,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);
@@ -4796,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()) {
@@ -4817,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);
   }
 }
@@ -4929,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());
@@ -5120,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);
   }
 }
@@ -5997,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), {});
@@ -6548,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);

package/daemon.mjs

@@ -21,6 +21,8 @@ import { withFallback } from './providers/fallback.mjs';
 import { withResponseCache } from './providers/cache.mjs';
 import { costFromUsage, RATE_CARD_SHAPE } from './providers/rates.mjs';
 import { composeSystemPrompt, listSkills, loadSkill, skillPath, installSkill, removeSkill } from './skills.mjs';
+import { ChallengeRegistry } from './gateway/device_auth.mjs';
+import { createGateway } from './gateway/http_gateway.mjs';
 import { TokenBucketLimiter } from './ratelimit.mjs';
 import { createLogger } from './logger.mjs';
 import { summarizeState, listSessions as listWorkflowSessions, loadStateFile as loadWorkflowState, aggregateNodeStats } from './workflow/summary.mjs';
@@ -321,6 +323,11 @@ export function makeHandler(ctx) {
     costsByCurrency: /** @type {Record<string, number>} */({}),
     tokensTotal: { inputTokens: 0, outputTokens: 0 },
   };
+  // Device gateway (Phase 27). The ChallengeRegistry is a per-process
+  // singleton: a challenge minted by one request is consumed by a later
+  // one, so it must outlive a single call.
+  const gwConfigDir = typeof ctx.sessionsDirGetter === 'function' ? ctx.sessionsDirGetter() : undefined;
+  const gateway = createGateway({ configDir: gwConfigDir, challengeRegistry: new ChallengeRegistry(), heartbeatMs: 25000 });
   return async function handler(req, res) {
     // Capture method+path before any handler logic runs; req.url survives
     // the response but capturing now keeps the log line stable even if a
@@ -361,6 +368,31 @@ export function makeHandler(ctx) {
       if (!isOriginAllowed(req, allowedOrigins, allowLoopback)) {
         return writeJson(res, 403, { error: 'forbidden origin' });
       }
+      // Device gateway (Phase 27) — routed BEFORE the shared auth-token
+      // gate. Companion-node auth is the gateway's own Ed25519 device-auth
+      // (challenge/sign/approve + bearer token); the only unauthenticated
+      // route, /gateway/connect/challenge, returns nothing but a random
+      // nonce. The bypass decision uses the NORMALIZED pathname (the same
+      // one the gateway routes on) so a dot-segment path like
+      // `/gateway/../sessions` can't skip the auth-token gate — it
+      // normalizes to `/sessions`, fails this prefix test, and falls
+      // through to the protected handler. When the limiter is enabled,
+      // gateway traffic uses its own key namespace so an unauthenticated
+      // flood can't drain the authenticated user's per-IP budget.
+      let gwPath = '';
+      try { gwPath = new URL(req.url || '/', 'http://localhost').pathname; } catch { gwPath = ''; }
+      if (gwPath.startsWith('/gateway/')) {
+        if (limiter) {
+          const key = 'gw:' + (req.socket?.remoteAddress || 'no-socket');
+          const verdict = limiter.consume(key);
+          if (!verdict.allowed) {
+            metrics.rateLimitDenied += 1;
+            const retrySeconds = Math.max(1, Math.ceil(verdict.retryAfterMs / 1000));
+            return writeJson(res, 429, { error: 'rate limit exceeded', retryAfterMs: verdict.retryAfterMs }, { 'retry-after': String(retrySeconds) });
+          }
+        }
+        return await gateway.handle(req, res, { readBody: readTextBody });
+      }
       // Authentication gate — when authToken is set, every request must
       // present `Authorization: Bearer <token>`. This is opt-in because
       // the default deployment is loopback-only single-user; the token
@@ -430,6 +462,26 @@ export function makeHandler(ctx) {
         }
         case route === 'GET /version':
           return writeJson(res, 200, { version: ctx.version(), nodeVersion: process.version, platform: `${process.platform}-${process.arch}` });
+        case route === 'POST /exec/request': {
+          // Remote exec-approval bridge. This route is AUTH-TOKEN-GATED
+          // (above), so only the trusted local operator/CLI can REQUEST an
+          // approval; a paired mobile device RESOLVES it over the gateway
+          // (POST /gateway/exec/resolve). The route long-polls: it awaits
+          // the device's decision (or the approval's timeout) and returns
+          // { approved, by, reason }.
+          let body;
+          try { body = await readJson(req); }
+          catch (e) { return writeJson(res, 400, { error: `invalid JSON body: ${e.message}` }); }
+          if (!body || typeof body.tool !== 'string' || !body.tool) {
+            return writeJson(res, 400, { error: 'tool is required' });
+          }
+          const { promise } = gateway.requestApproval(
+            { tool: body.tool, args: body.args, agentId: body.agentId, summary: body.summary },
+            { timeoutMs: Number.isFinite(+body.timeoutMs) ? +body.timeoutMs : undefined },
+          );
+          const result = await promise;
+          return writeJson(res, 200, result);
+        }
         case route === 'GET /health':
           // Conventional liveness check — always 200 if the process
           // is alive enough to hit the route. No config inspection
@@ -1486,6 +1538,52 @@ export function makeHandler(ctx) {
             }, m.headers || {});
           }
         }
+        case route === 'POST /inbound': {
+          // Generic inbound bridge — a stable, channel-agnostic relay
+          // target so ANY platform (a Discord/WhatsApp/etc. bot the user
+          // runs elsewhere) can forward a message in and get one reply,
+          // without lazyclaw shipping that platform's SDK. Auth-token
+          // gated like every non-gateway route; additionally pairing-gated
+          // on senderId when a pairing allowlist is configured.
+          const breach = checkCostCap(metrics, costCap);
+          if (breach) return writeJson(res, 402, { error: 'cost cap exceeded', currency: breach.currency, spent: breach.spent, cap: breach.cap });
+          let body;
+          try { body = await readJson(req); }
+          catch (e) { return writeJson(res, 400, { error: `invalid JSON body: ${e.message}` }); }
+          const text = typeof body.text === 'string' ? body.text.trim() : '';
+          if (!text) return writeJson(res, 400, { error: 'text is required' });
+          const cfg = ctx.readConfig();
+          // Pairing gate: when the operator has paired any senders, the
+          // relay must identify an allowlisted senderId.
+          const allow = Array.isArray(cfg.pairing) ? cfg.pairing.map((p) => String(p && p.id)) : [];
+          if (allow.length > 0) {
+            const sender = String(body.senderId || '');
+            if (!sender || !allow.includes(sender)) return writeJson(res, 403, { error: 'sender not paired' });
+          }
+          const provName = body.provider || cfg.provider || 'mock';
+          const resolved = resolveProvider(body, provName, cachedByName, logger);
+          if (resolved.error) return writeJson(res, 400, { error: resolved.error });
+          let acc = '';
+          let inboundUsage = null;
+          try {
+            for await (const chunk of resolved.provider.sendMessage(
+              [{ role: 'user', content: text }],
+              { apiKey: cfg['api-key'], model: body.model || cfg.model, onUsage: (u) => { inboundUsage = u; } },
+            )) acc += chunk;
+          } catch (err) {
+            const m = statusForProviderError(err);
+            return writeJson(res, m.status, { error: err?.message || String(err), code: err?.code || null }, m.headers || {});
+          }
+          // Feed the running spend total so the cost cap can actually trip
+          // on /inbound traffic (mirrors POST /agent / POST /chat).
+          if (inboundUsage && cfg.rates) {
+            try {
+              const c = costFromUsage({ provider: provName, model: body.model || cfg.model, usage: inboundUsage }, cfg.rates);
+              if (c) accumulateMetricsFromCost(metrics, inboundUsage, c);
+            } catch { /* cost is best-effort; never block a reply on it */ }
+          }
+          return writeJson(res, 200, { reply: acc, threadId: body.threadId || null });
+        }
         case route === 'POST /agent': {
           const breach = checkCostCap(metrics, costCap);
           if (breach) {