lazyclaw 4.3.0 → 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');
@@ -639,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
@@ -685,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;
   }
@@ -925,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
@@ -939,8 +1005,14 @@ const SUBCOMMANDS = [
   '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 = {
@@ -949,6 +1021,7 @@ const SUBCOMMAND_SUBS = {
   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'],
@@ -966,6 +1039,7 @@ const SUBCOMMAND_SUBS = {
   agent:     ['add', 'list', 'show', 'edit', 'remove'],
   team:      ['add', 'list', 'show', 'edit', 'remove'],
   task:      ['start', 'list', 'show', 'abandon', 'done', 'remove'],
+  trajectories: ['export'],
 };
 
 function bashCompletion() {
@@ -1214,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.',
@@ -2300,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');
@@ -2481,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) {
@@ -2942,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';
       }
@@ -5961,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
@@ -6325,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
@@ -6761,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;
@@ -6790,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);
@@ -6877,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;

package/daemon.mjs

@@ -28,6 +28,7 @@ import { createLogger } from './logger.mjs';
 import { summarizeState, listSessions as listWorkflowSessions, loadStateFile as loadWorkflowState, aggregateNodeStats } from './workflow/summary.mjs';
 import { validateConfig } from './config-validate.mjs';
 import { validateRates } from './rates-validate.mjs';
+import * as nudge from './mas/nudge.mjs';
 
 // Resolve the provider for a request. Composes opt-in wrappers in this
 // order (innermost first):
@@ -328,6 +329,18 @@ export function makeHandler(ctx) {
   // 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 });
+  // Phase B nudge loop — scans recent.jsonl every 5 min and pushes
+  // nudge.suggest_skill onto the SSE bus so the curator can prompt.
+  const _nudgeLoop = nudge.startNudgeLoop({
+    configDir: gwConfigDir,
+    emit: (event) => {
+      try { gateway.broadcast?.('nudge.suggest_skill', event); }
+      catch (err) { logger?.warn?.('nudge_emit_failed', { err: err.message }); }
+    },
+    logger,
+  });
+  process.on('SIGTERM', () => { _nudgeLoop.stop(); });
+  process.on('SIGINT', () => { _nudgeLoop.stop(); });
   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

package/mas/agent_turn.mjs

@@ -25,6 +25,7 @@ import * as anthropic from '../providers/tool_use/anthropic.mjs';
 import * as openai from '../providers/tool_use/openai.mjs';
 import * as gemini from '../providers/tool_use/gemini.mjs';
 import * as claudeCli from '../providers/tool_use/claude_cli.mjs';
+import { put as _trajPut } from './trajectory_store.mjs';
 
 export class AgentTurnError extends Error {
   constructor(message, code) {
@@ -71,6 +72,7 @@ export async function runAgentTurn({
   maxIterations = DEFAULT_MAX_ITERATIONS,
   signal,
   approve,
+  trajectoryRef,
 } = {}) {
   if (!agent) throw new AgentTurnError('agent is required', 'NO_AGENT');
   const adapter = adapterFor(agent.provider);
@@ -92,6 +94,29 @@ export async function runAgentTurn({
   const toolCalls = [];
   let iterations = 0;
   let lastText = '';
+  if (trajectoryRef && !trajectoryRef.startedAt) trajectoryRef.startedAt = Date.now();
+
+  const _maybePersistTrajectory = async (outcome) => {
+    if (!trajectoryRef) return;
+    try {
+      await _trajPut({
+        taskId, agentName: agent.name || 'agent',
+        workerProvider: agent.provider, workerModel: agent.model,
+        startedAt: trajectoryRef.startedAt || Date.now(),
+        endedAt: Date.now(),
+        systemPrompt: agent.role || '',
+        userMessages: userMessage ? [String(userMessage)] : [],
+        turns: toolCalls.map((c, i) => ({
+          turnIdx: i, role: 'tool', content: '',
+          toolCalls: [{ name: c.name, args: c.input, result: JSON.stringify(c.result), success: c.ok, durationMs: 0 }],
+        })).concat(lastText ? [{
+          turnIdx: toolCalls.length, role: 'assistant', content: lastText, toolCalls: [],
+        }] : []),
+        finalAnswer: lastText,
+        outcome,
+      }, { configDir });
+    } catch { /* trajectory failure must not break the agent turn */ }
+  };
 
   while (iterations < maxIterations) {
     if (signal?.aborted) return { text: lastText, iterations, stoppedBy: 'abort', toolCalls };
@@ -103,6 +128,7 @@ export async function runAgentTurn({
     if (resp.text) lastText = resp.text;
 
     if (resp.kind === 'final') {
+      await _maybePersistTrajectory('done');
       return { text: resp.text || '', iterations, stoppedBy: 'final', toolCalls };
     }
 
@@ -140,9 +166,11 @@ export async function runAgentTurn({
     // model so it can recover. Only an extraordinary error (e.g. the
     // provider returned a malformed envelope) bails out here.
     if (toolErrored && process.env.LAZYCLAW_TOOL_STRICT === '1') {
+      await _maybePersistTrajectory('failed');
       return { text: lastText, iterations, stoppedBy: 'tool_error', toolCalls };
     }
   }
 
+  await _maybePersistTrajectory('abandoned');
   return { text: lastText, iterations, stoppedBy: 'budget', toolCalls };
 }