lazyclaw 5.0.8 → 5.1.0

package/README.md

@@ -29,14 +29,20 @@ Four things no other terminal agent CLI does together:
 3. **Cross-channel handoff.** `/handoff slack <channel-id>` moves the live conversation; context follows.
 4. **Six sandbox backends, one API.** `local` / `docker` / `ssh` / `singularity` / `modal` / `daytona`.
 
+## What's new in 5.0.x
+
+The 5.0.3 → 5.0.9 maintenance line is mostly a launcher and splash overhaul. `lazyclaw` with no arguments now drops you straight into chat — the arrow-key picker has moved to `lazyclaw menu`. The splash itself is responsive: a Larry-3D gradient wordmark, braille-rendered sloth hero, a tool catalog driven by `mas/tools/registry.mjs` (no more hand-edited lists), grouped skills, and a Hermes-style status bar that auto-collapses to a single column on narrow terminals.
+
+Per-release notes live in [CHANGELOG.md](./CHANGELOG.md).
+
 ## Known limitations (v5.1 roadmap)
 
 Calibrate expectations before reading the rest:
 
-- `recall` is callable from inside chat today; the top-level `lazyclaw recall ...` CLI shape ships in v5.1.
+- Recall today is reachable via `lazyclaw loop --recall "<query>" ...` and `lazyclaw goal ... --recall "<query>"`; the `/recall` slash command and top-level `lazyclaw recall ...` CLI shape both ship in v5.1.
 - `lazyclaw sandbox` exposes `list | test | add | use`; the `sandbox run --backend ...` shape lands in v5.1.
 - `codex-cli` and `gemini-cli` provider modules are tracked but not yet registered in the main runtime.
-- E2E matrix ships with 32 of 48 flows marked `test.skip` pending v5.1 wiring; the min-green-set is documented in `tests/e2e/phaseH-e2e-matrix.spec.ts`.
+- The E2E matrix in `tests/e2e/phaseH-e2e-matrix.spec.ts` still has a number of flows marked `test.skip` pending v5.1 wiring; the min-green-set is documented at the top of that file.
 
 ## Install
 
@@ -54,9 +60,10 @@ npm install && npm link
 
 ```bash
 lazyclaw version
-# → { "version": "5.0.0", "nodeVersion": "v20.11.0", "platform": "darwin" }
 ```
 
+Output reports the current installed version, Node version, and platform. See [CHANGELOG.md](./CHANGELOG.md) for release notes.
+
 Requires **Node 18+**. macOS / Linux / WSL are first-class. Native PowerShell runs but ghost-text and the ANSI banner fall back to plain prompts.
 
 ## First run
@@ -69,6 +76,8 @@ lazyclaw onboard         # arrow-key picker; defaults to claude-cli (no key)
 <img src="docs/screenshots/onboard.png" alt="lazyclaw onboard --non-interactive" width="720">
 
 ```bash
+lazyclaw                 # no-arg → chat (since v5.0.6)
+lazyclaw menu            # arrow-key launcher (formerly the no-arg default)
 lazyclaw status          # → { provider, model, hasApiKey }
 lazyclaw doctor          # validates config + provider registry + index.db
 ```
@@ -124,10 +133,16 @@ Plus two meta-providers, usable in either slot:
 
 ## What it ships
 
-### Around 50 tools plus MCP
-A unified registry covers fs, exec, web, os, coding, git (5 read + 2 sensitive), scheduling, delegation, media, ha, clarify, browser, and learning groups. Sensitive tools route through an approval hook. Bring external servers in over stdio MCP.
+### Tool registry — 12 categories plus MCP
+
+A single registry (`mas/tools/registry.mjs`) aggregates every first-party tool across twelve categories:
+
+`agents` · `browser` · `coding` · `exec` · `fs` · `git` · `iot` · `learning` · `media` · `net` · `os` · `scheduling`
+
+Tools flagged `sensitive: true` (writes, network egress, shell exec, sensitive git ops) route through an approval hook before execution. The splash renderer, the agent toolset resolver, and the runtime all read from the same registry, so a new tool group lights up everywhere at once. External servers extend the registry over stdio MCP.
 
 ### Channels that hand off
+
 First-class channels for Slack, Discord, Telegram, Matrix, Email, and Voice. Signal and WhatsApp ship as full implementations with external runtime dependencies (`signal-cli` for Signal; `whatsapp-web.js` browser automation with QR-on-first-run for WhatsApp). Move a live conversation between any two with `/handoff <target> <externalId>` — no other agent CLI does cross-channel handoff.
 
 ```bash
@@ -139,19 +154,23 @@ lazyclaw channels install @lazyclaw/channel-discord
 Slack is built-in and does not need `channels install`. The plugin loader expects `@lazyclaw/channel-<name>` npm package names.
 
 ### Personas that compose
+
 Swap personality per channel without losing session memory. Layers compose top-down: global SOUL → workspace SOUL → active personality → agent role → user model (USER.md) → skill bank → memory core → recent trajectory tail. See [docs/persona-cookbook.md](./docs/persona-cookbook.md).
 
 ### Loops and scheduled goals
+
 Durable foreground or `--detach` loops; cron-scheduled goals with channel fan-out. State lives in `~/.lazyclaw/loops/<id>/` and survives restart. See [docs/loop-goal-preflight.md](./docs/loop-goal-preflight.md).
 
 ### A TUI that ghosts the right answer
-Ink-based UI with two-column splash, sloth ASCII banner, Cursor-style ghost autocomplete (`→` accepts, `Tab` cycles), interrupt-and-redirect REPL, multiline editor, and a fixed 4-line footer with live cost rate cards.
+
+Ink-based UI with a responsive splash (Larry-3D gradient wordmark, sloth braille hero, grouped subcommand catalog, registry-backed tool list, filename-grouped skills, Hermes-style status bar — auto-collapses to single-column on narrow terminals), Cursor-style ghost autocomplete (`→` accepts, `Tab` cycles), interrupt-and-redirect REPL, and multiline editor.
 
 ## Command reference
 
 | Command | Purpose |
 |---|---|
-| `lazyclaw` | Interactive menu; type a slash command or pick a subcommand |
+| `lazyclaw` | No-arg → drops into chat (since v5.0.6) |
+| `lazyclaw menu` | Arrow-key launcher (formerly the no-arg default) |
 | `lazyclaw onboard` | Arrow-key setup; writes `~/.lazyclaw/config.json` |
 | `lazyclaw status` | Print active provider / model / masked key |
 | `lazyclaw doctor` | Validate config, provider registry, FTS5 index |
@@ -163,7 +182,9 @@ Ink-based UI with two-column splash, sloth ASCII banner, Cursor-style ghost auto
 | `lazyclaw channels install\|list\|remove` | Channel plugin lifecycle (`@lazyclaw/channel-<name>`) |
 | `lazyclaw trajectories export --format ...` | Export to atropos / axolotl / openai-ft / jsonl |
 | `lazyclaw personality use\|list\|show` | Activate / inspect personas |
+| `lazyclaw dashboard` | Local web UI on `127.0.0.1:19600` |
 | `lazyclaw migrate v5` | v4 → v5 with backup |
+| `lazyclaw recall` | (v5.1) Top-level recall over the FTS5 index — today, use `loop`/`goal` with `--recall "<query>"` |
 | `lazyclaw version` / `lazyclaw help` | Version + subcommand help |
 
 In-REPL slash commands include `/help`, `/status`, `/provider`, `/model`, `/skill`, `/loop`, `/goal`, `/memory`, `/agent`, `/team`, `/handoff`, `/personality`, `/exit`. Depth lives in `lazyclaw <cmd> --help` and the docs below.
@@ -189,7 +210,7 @@ Full guide: [docs/migration-v4-to-v5.md](./docs/migration-v4-to-v5.md).
 |---|---|---|
 | Start a chat | `lazyclaw chat` | `@lazyclaw <message>` |
 | Hand off to another surface | `/handoff slack <channel-id>` | `/handoff tui <thread-id>` |
-| Recall across history | `/recall "<query>"` inside chat (top-level CLI v5.1) | `/recall "<query>"` inside chat |
+| Recall across history | `lazyclaw loop --recall "<query>" ...` (slash + top-level v5.1) | `lazyclaw loop --recall "<query>" ...` (channel-side `/recall` v5.1) |
 | Switch persona | `/personality use terse` | `/personality use terse` |
 | Switch model | `/model <name>` | `/model <name>` |
 | Show status | `lazyclaw status` | `@lazyclaw status` |

package/cli.mjs

@@ -1299,7 +1299,7 @@ const HELP_DETAILS = {
   browse: 'Usage: lazyclaw browse <url> [--max-bytes <N>] [--timeout-ms <N>] [--user-agent <ua>] [--meta]\n  Fetches the URL and emits Markdown on stdout. Pipes cleanly into `agent`:\n      lazyclaw browse https://example.com/docs | lazyclaw agent -\n  Strips <script>/<style>/<svg>/comments, prefers <main>/<article>, falls back to <body>.\n  --max-bytes caps the body read (default 2 MB) so a misconfigured upstream can\'t OOM the process.\n  --meta prints { url, title, bytes, truncated } as JSON to stderr alongside the markdown on stdout.',
   cron: 'Usage: lazyclaw cron <list | add <name> "<cron-spec>" -- <cmd> ... | remove <name> | show <name> | sync | run <name>>\n  Schedule recurring agent runs. macOS uses launchd (~/Library/LaunchAgents/com.lazyclaw.<name>.plist); Linux / WSL uses the user crontab.\n  Cron spec is the standard 5-field form (minute hour dom month dow). Supports *, range a-b, list a,b,c, step */N.\n  add: pass the command after `--`. Typical use:\n      lazyclaw cron add daily-summary "0 9 * * 1-5" -- lazyclaw agent "Summarise today\'s TODOs"\n  list / show: read from cfg.cron[name] (config is the source of truth).\n  sync: re-installs every job in cfg.cron into the system scheduler — handy after a reinstall.\n  run: one-shot in-process execution of the named job; the OS scheduler does the same thing on its trigger.\n  Logs: ~/.lazyclaw/logs/cron-<name>.{out,err}.log (macOS launchd path).',
   setup: 'Usage: lazyclaw setup [--skip-test]\n  OpenClaw-style multi-step first-run wizard. Walks through:\n    1. Provider + model + api-key (delegates to onboard --pick)\n    2. Optional workspace init  (AGENTS.md / SOUL.md / TOOLS.md)\n    3. Optional skill bundle install from GitHub\n    4. Optional outbound webhook (Slack / Discord)\n    5. Reachability test against the picked provider\n  Each optional step takes Enter or "skip" to bypass. Re-runnable safely.\n  Also fires automatically on first run when `lazyclaw` is invoked with no config.',
-  dashboard: 'Usage: lazyclaw dashboard [--port <N>] [--no-open]\n  Launches the lazyclaw-only web UI on http://127.0.0.1:<port> (default 19600) and opens it in the default browser.\n  Wraps `lazyclaw daemon` + a static HTML; no Python / lazyclaude dashboard required.\n  Tabs: Chat · Sessions · Skills · Workspace · Providers · Status. Each tab calls existing daemon endpoints.\n  --no-open keeps the browser closed (handy for SSH / headless / dev). The bound URL is always printed to stdout.',
+  dashboard: 'Usage: lazyclaw dashboard [--port <N>] [--no-open]\n  Launches the lazyclaw-only web UI on http://127.0.0.1:<port> (default 19600) and opens it in the default browser.\n  Wraps `lazyclaw daemon` + a static HTML; no Python / lazyclaude dashboard required.\n  See web/dashboard.html for the current tab set (v5: Chat / Sessions / Workflows / Skills / Providers / Rates / Metrics / Doctor / Config / Status / Agents / Teams / Tasks / Trainer / Recall / Sandbox / Channels).\n  --no-open keeps the browser closed (handy for SSH / headless / dev). The bound URL is always printed to stdout.',
   orchestrator: 'Usage: lazyclaw orchestrator <status | set-planner <provider[:model]> | workers add <spec> | workers remove <spec> | workers set <spec,spec,...> | workers clear | set-max-subtasks <N> | clear>\n  Read/write cfg.orchestrator without editing config.json by hand.\n  status               — print {planner, workers, maxSubtasks} as JSON; lists registered providers for reference.\n  set-planner          — replace the planner spec ("provider" or "provider:model"). "orchestrator" itself is rejected (self-recursion).\n  workers add          — append a worker (idempotent — duplicates skipped).\n  workers remove       — drop a worker by exact match. Idempotent.\n  workers set          — replace the whole list (comma-separated specs).\n  workers clear        — empty the workers list.\n  set-max-subtasks <N> — cap subtasks per request, clamped 1..10 (default 5).\n  clear                — delete the cfg.orchestrator block entirely.\n  Pair with: `lazyclaw config set provider orchestrator` to route chats through it.',
 };
 
@@ -1658,7 +1658,17 @@ async function _renderV5Banner(version) {
   if (!a) return _renderBanner(version); // missing tarball asset → v4 figlet
   const v = String(version || '?.?.?');
   const rows = [];
-  for (const r of a.wordmark.rows) rows.push(_orange('  ' + r));
+  const palette = a.wordmark.palette || [];
+  const gradient = a.wordmark.gradient || [];
+  function tint(idx, s) {
+    const hex = palette[idx] || '#FFB347';
+    const m = /^#?([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i.exec(hex);
+    if (!m) return _orange(s);
+    const [, r, g, b] = m;
+    const R = parseInt(r, 16), G = parseInt(g, 16), B = parseInt(b, 16);
+    return `\x1b[38;2;${R};${G};${B}m${s}\x1b[0m`;
+  }
+  a.wordmark.rows.forEach((r, i) => rows.push(tint(gradient[i] ?? 1, '  ' + r)));
   rows.push('');
   for (const r of a.banner.rows) rows.push(_orange('  ' + r));
   rows.push(_orange('  ' + `lazyclaw v${v}`));

package/daemon.mjs

@@ -20,7 +20,10 @@ import { withRateLimitRetry } from './providers/retry.mjs';
 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 { composeSystemPrompt, listSkills, loadSkill, skillPath, installSkill, removeSkill, parseFrontmatter, defaultConfigDir as skillsDefaultConfigDir } from './skills.mjs';
+import * as indexDb from './mas/index_db.mjs';
+import * as skillSynth from './mas/skill_synth.mjs';
+import { listBackends as sandboxListBackends } from './sandbox/index.mjs';
 import { ChallengeRegistry } from './gateway/device_auth.mjs';
 import { createGateway } from './gateway/http_gateway.mjs';
 import { TokenBucketLimiter } from './ratelimit.mjs';
@@ -331,11 +334,22 @@ export function makeHandler(ctx) {
   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.
+  // v5 dashboard polls GET /skills/suggestions; we also keep a small
+  // ring buffer here so the UI can fetch the most recent N without
+  // having to subscribe to the SSE bus.
+  const SUGG_RING_MAX = 50;
+  const nudgeSuggestionsRing = [];
   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 }); }
+      try {
+        nudgeSuggestionsRing.unshift(event);
+        if (nudgeSuggestionsRing.length > SUGG_RING_MAX) {
+          nudgeSuggestionsRing.length = SUGG_RING_MAX;
+        }
+      } catch { /* ignore */ }
     },
     logger,
   });
@@ -843,10 +857,38 @@ export function makeHandler(ctx) {
         }
         case route === 'GET /status': {
           const cfg = ctx.readConfig();
+          // v5: surface a one-line summary of trainer / index / sandbox so
+          // the dashboard banner doesn't need three more round-trips.
+          const trainerCfg = (cfg.trainer && typeof cfg.trainer === 'object') ? cfg.trainer : {};
+          const sandboxBackend = (cfg.sandbox && typeof cfg.sandbox === 'object' && cfg.sandbox.default) || 'local';
+          let indexRows = null;
+          try {
+            const db = indexDb.openIndex(gwConfigDir, { runIntegrityCheck: false });
+            const r = db.prepare(
+              "SELECT (SELECT COUNT(*) FROM fts_sessions) + (SELECT COUNT(*) FROM fts_skills) " +
+              " + (SELECT COUNT(*) FROM fts_trajectories) + (SELECT COUNT(*) FROM fts_memories) AS n"
+            ).get();
+            indexRows = r && typeof r.n === 'number' ? r.n : null;
+          } catch { /* index may not exist yet */ }
+          // Migration backup path is conventionally <configDir>/backup-v4/.
+          let migrateBackup = null;
+          try {
+            const p = nodePath.join(gwConfigDir || skillsDefaultConfigDir(), 'backup-v4');
+            if (fs.existsSync(p)) migrateBackup = p;
+          } catch { /* ignore */ }
           return writeJson(res, 200, {
             provider: cfg.provider || null,
             model: cfg.model || null,
             keyMasked: maskApiKey(cfg['api-key']),
+            v5: {
+              trainer: {
+                provider: trainerCfg.provider || null,
+                model: trainerCfg.model || null,
+              },
+              sandboxBackend,
+              indexRows,
+              migrateBackup,
+            },
           });
         }
         case route === 'GET /config/validate': {
@@ -945,6 +987,28 @@ export function makeHandler(ctx) {
           if (cfg.provider && !Object.prototype.hasOwnProperty.call(PROVIDERS, cfg.provider)) {
             issues.push(`unknown provider "${cfg.provider}"`);
           }
+          // v5: FTS5 index integrity. Failure here is degraded-not-fatal —
+          // surfaced as an issue but doesn't take the daemon down.
+          let indexBlock = null;
+          try {
+            const integ = indexDb.integrityCheck(gwConfigDir);
+            const db = indexDb.openIndex(gwConfigDir, { runIntegrityCheck: false });
+            const rowCounts = {};
+            for (const t of ['fts_sessions', 'fts_skills', 'fts_trajectories', 'fts_memories']) {
+              try { rowCounts[t] = db.prepare(`SELECT COUNT(*) AS n FROM ${t}`).get().n; }
+              catch { rowCounts[t] = null; }
+            }
+            indexBlock = {
+              ok: !!integ.ok,
+              result: integ.result || null,
+              rowCounts,
+              lastRebuiltAt: ctx.indexLastRebuiltAt || null,
+            };
+            if (!integ.ok) issues.push(`FTS5 index integrity_check returned ${integ.result}`);
+          } catch (e) {
+            indexBlock = { ok: false, error: e?.message || String(e), rowCounts: {}, lastRebuiltAt: null };
+            issues.push(`FTS5 index unavailable: ${e?.message || e}`);
+          }
           const ok = issues.length === 0;
           return writeJson(res, ok ? 200 : 503, {
             ok,
@@ -955,6 +1019,7 @@ export function makeHandler(ctx) {
             platform: `${process.platform}-${process.arch}`,
             issues,
             knownProviders: Object.keys(PROVIDERS),
+            index: indexBlock,
             timestamp: new Date().toISOString(),
           });
         }
@@ -984,12 +1049,42 @@ export function makeHandler(ctx) {
             return writeJson(res, 400, { error: `invalid sortBy: ${sortBy} (expected: mtime, turn-count, bytes, id)` });
           }
           const withCount = url.searchParams.get('withTurnCount') === 'true' || sortBy === 'turn-count';
+          // v5: surface trainerHandled / agentName / trajectoryId per row.
+          // Source: the last turn's metadata if persisted; otherwise null.
+          // We're surgical here — we read the metadata only when withTurnCount
+          // is already paying the load cost, OR when the dashboard explicitly
+          // asks via ?withV5=true. Keeps the default GET /sessions cheap.
+          const withV5 = url.searchParams.get('withV5') === 'true' || withCount;
           let out = list.map(s => {
             const base = { id: s.id, bytes: s.bytes, mtime: new Date(s.mtimeMs).toISOString(), _mtimeMs: s.mtimeMs };
             if (withCount) {
               try { base.turnCount = ctx.sessionsMod.loadTurns(s.id, cfgDir).length; }
               catch { base.turnCount = null; }
             }
+            if (withV5) {
+              try {
+                const turns = ctx.sessionsMod.loadTurns(s.id, cfgDir);
+                // Newest turn carries the freshest annotations. Fall back to
+                // any earlier turn that has the field set so a long session
+                // doesn't drop its trainer/agent attribution.
+                let trainerHandled = false;
+                let trainedBy = null;
+                let agentName = null;
+                let trajectoryId = null;
+                for (let i = turns.length - 1; i >= 0; i--) {
+                  const t = turns[i] || {};
+                  if (!trajectoryId && t.trajectoryId) trajectoryId = String(t.trajectoryId);
+                  if (!agentName && t.agent) agentName = String(t.agent);
+                  if (!trainedBy && t.trainedBy) { trainedBy = String(t.trainedBy); trainerHandled = true; }
+                  if (t.trainerHandled) trainerHandled = true;
+                  if (trajectoryId && agentName && trainedBy) break;
+                }
+                base.trainerHandled = !!trainerHandled;
+                base.trainedBy = trainedBy;
+                base.agentName = agentName;
+                base.trajectoryId = trajectoryId;
+              } catch { /* missing metadata is non-fatal */ }
+            }
             return base;
           });
           if (sortBy) {
@@ -1301,9 +1396,99 @@ export function makeHandler(ctx) {
             const n = parseInt(limitStr, 10);
             if (Number.isFinite(n) && n > 0) items = items.slice(0, n);
           }
-          return writeJson(res, 200, items.map(s => ({
-            name: s.name, bytes: s.bytes, summary: s.summary,
-          })));
+          // v5: include frontmatter fields the dashboard renders as badges.
+          // listSkills() currently only surfaces name/summary/etc., so we
+          // re-parse the body once per skill to extract trained_by /
+          // confidence / cross_cli_tested / group. Cheap (markdown files,
+          // already cached by the OS).
+          const out = items.map((s) => {
+            let meta = {};
+            try {
+              const body = loadSkill(s.name, cfgDir);
+              meta = parseFrontmatter(body).meta || {};
+            } catch { /* unreadable → empty meta */ }
+            const xcli = meta.cross_cli_tested;
+            return {
+              name: s.name,
+              bytes: s.bytes,
+              summary: s.summary,
+              description: meta.description || s.description || '',
+              group: meta.group || '',
+              trained_by: meta.trained_by || (meta.created_by === 'agent' ? 'agent' : ''),
+              confidence: meta.confidence !== undefined && meta.confidence !== ''
+                ? Number(meta.confidence)
+                : null,
+              cross_cli_tested: xcli === 'true' || xcli === true ? true
+                : (Array.isArray(xcli) ? xcli : null),
+              version: meta.version || s.version || '',
+              created_by: meta.created_by || '',
+            };
+          });
+          return writeJson(res, 200, out);
+        }
+        case route === 'GET /skills/suggestions': {
+          // Ring buffer of nudge.suggest_skill events. Dashboard polls this
+          // since the SSE bus is deferred to v5.1.
+          return writeJson(res, 200, { suggestions: nudgeSuggestionsRing.slice(0, 20) });
+        }
+        case route === 'POST /skills/synth': {
+          // Body: { sessionId: '<id>' [, outcome] [, trainedBy] [, model] }
+          // Runs mas/skill_synth.synthesizeSkill against the named session.
+          // We assemble a minimal agent stub from cfg.provider/model and an
+          // empty role — the synth pipeline expects an agent object, but
+          // most callers will want "use my default provider".
+          let body;
+          try { body = await readJson(req); }
+          catch (e) { return writeJson(res, 400, { error: e?.message || String(e) }); }
+          const sessionId = body && String(body.sessionId || '').trim();
+          if (!sessionId) return writeJson(res, 400, { error: 'sessionId is required' });
+          const cfg = ctx.readConfig();
+          const provider = body.provider || cfg.provider;
+          const model = body.model || cfg.model;
+          if (!provider) return writeJson(res, 400, { error: 'no provider configured — set cfg.provider or pass body.provider' });
+          // Pull the session turns and build a minimal task shape.
+          let turns;
+          try { turns = ctx.sessionsMod.loadTurns(sessionId, gwConfigDir); }
+          catch (e) { return writeJson(res, 404, { error: `session not found: ${sessionId}` }); }
+          if (!Array.isArray(turns) || turns.length === 0) {
+            return writeJson(res, 400, { error: `session "${sessionId}" has no turns` });
+          }
+          const task = {
+            id: sessionId,
+            title: turns[0]?.content?.slice(0, 80) || sessionId,
+            turns: turns.map((t) => ({
+              agent: t.role === 'user' ? 'user' : (t.role === 'system' ? 'system' : 'assistant'),
+              text: String(t.content || ''),
+            })),
+          };
+          const agent = { provider, model, role: '' };
+          try {
+            const apiKey = cfg['api-key'] || null;
+            const result = await skillSynth.synthesizeSkill({
+              agent, task, apiKey,
+              outcome: body.outcome || 'done',
+              trainedBy: body.trainedBy || null,
+              trainedOnModel: model || null,
+            });
+            if (!result) return writeJson(res, 200, { ok: false, message: 'synth produced no skill (model returned NONE)' });
+            // Mirror the CLI synth flow: installSynthesized() handles slug
+            // reservation, agent-overwrite protection, and FTS5 mirror.
+            const install = skillSynth.installSynthesized({
+              name: result.name,
+              description: result.description,
+              body: result.body,
+              sourceTask: sessionId,
+              createdBy: 'agent',
+            }, gwConfigDir);
+            return writeJson(res, 200, {
+              ok: true,
+              name: install?.skill || result.name,
+              description: result.description,
+              path: install?.path || null,
+            });
+          } catch (e) {
+            return writeJson(res, 500, { error: e?.message || String(e), code: e?.code });
+          }
         }
         case route === 'GET /skills/search': {
           // Mirror of `lazyclaw skills search`. ?q=<query> required;
@@ -1887,6 +2072,194 @@ export function makeHandler(ctx) {
           }
         }
 
+        // ── v5 dashboard surfaces ────────────────────────────────────
+        case route === 'GET /trainer/status': {
+          // Reads cfg.trainer.{provider, model, schedule, budget, recipe}
+          // and reports last-run state from <configDir>/trainer-state.json
+          // if present. No standalone trainer module yet; this is a thin
+          // config-surface endpoint the dashboard reads at refresh.
+          const cfg = ctx.readConfig();
+          const t = (cfg.trainer && typeof cfg.trainer === 'object') ? cfg.trainer : {};
+          let lastRunAt = null, callsToday = null;
+          try {
+            const statePath = nodePath.join(gwConfigDir || skillsDefaultConfigDir(), 'trainer-state.json');
+            if (fs.existsSync(statePath)) {
+              const st = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+              lastRunAt = st?.lastRunAt || null;
+              // callsToday: count entries whose ts is within the current
+              // UTC day. State writer is the (future) trainer; reader
+              // tolerates absence.
+              const today = new Date().toISOString().slice(0, 10);
+              if (Array.isArray(st?.calls)) {
+                callsToday = st.calls.filter((c) => String(c.ts || '').startsWith(today)).length;
+              } else if (typeof st?.callsToday === 'number') {
+                callsToday = st.callsToday;
+              }
+            }
+          } catch { /* missing/corrupt state → null */ }
+          return writeJson(res, 200, {
+            provider: t.provider || null,
+            model: t.model || null,
+            schedule: t.schedule || null,
+            budget: t.budget != null ? Number(t.budget) : null,
+            recipe: t.recipe || null,
+            lastRunAt,
+            callsToday,
+          });
+        }
+        case route === 'POST /trainer/sync': {
+          // Stub: a real trainer scheduler lands in v5.1. For now we
+          // record the trigger in trainer-state.json so the dashboard's
+          // "Sync now" button has feedback, and a future trainer reads
+          // the queue. Surfacing it here keeps the API stable across the
+          // transition.
+          try {
+            const dir = gwConfigDir || skillsDefaultConfigDir();
+            fs.mkdirSync(dir, { recursive: true });
+            const statePath = nodePath.join(dir, 'trainer-state.json');
+            let st = {};
+            if (fs.existsSync(statePath)) {
+              try { st = JSON.parse(fs.readFileSync(statePath, 'utf8')); } catch { st = {}; }
+            }
+            st.lastSyncRequestAt = new Date().toISOString();
+            st.syncQueued = (st.syncQueued || 0) + 1;
+            fs.writeFileSync(statePath, JSON.stringify(st, null, 2));
+            return writeJson(res, 200, { ok: true, message: 'sync queued', queued: st.syncQueued });
+          } catch (e) {
+            return writeJson(res, 500, { error: e?.message || String(e) });
+          }
+        }
+        case route === 'GET /recall': {
+          // GET /recall?q=...&scope=sessions|skills|trajectories|memories|all&k=N
+          const q = url.searchParams.get('q');
+          if (!q) return writeJson(res, 400, { error: 'missing q query parameter' });
+          const scopeParam = url.searchParams.get('scope') || 'all';
+          const scope = scopeParam === 'all'
+            ? ['sessions', 'skills', 'trajectories', 'memories']
+            : scopeParam.split(',').map((x) => x.trim()).filter(Boolean);
+          const kParam = url.searchParams.get('k');
+          const k = kParam ? Math.max(1, Math.min(50, parseInt(kParam, 10) || 10)) : 10;
+          try {
+            const r = indexDb.recall(q, { configDir: gwConfigDir, scope, k });
+            return writeJson(res, 200, r);
+          } catch (e) {
+            return writeJson(res, 500, { error: e?.message || String(e) });
+          }
+        }
+        case route === 'GET /sandbox': {
+          const cfg = ctx.readConfig();
+          const sb = (cfg.sandbox && typeof cfg.sandbox === 'object') ? cfg.sandbox : {};
+          const active = sb.default || 'local';
+          const profiles = sandboxListBackends().map((name) => {
+            const section = sb[name];
+            const configured = !!section && typeof section === 'object';
+            let summary = '';
+            if (configured) {
+              if (name === 'docker' && section.image) summary = `image: ${section.image}`;
+              else if (name === 'ssh' && section.host) summary = `host: ${section.host}`;
+              else if (name === 'singularity' && section.image) summary = `image: ${section.image}`;
+              else if (name === 'modal' && section.app) summary = `app: ${section.app}`;
+              else if (name === 'daytona' && section.workspace) summary = `workspace: ${section.workspace}`;
+              else if (name === 'local' && section.confiner) summary = `confiner: ${section.confiner}`;
+            }
+            return { name, configured, summary };
+          });
+          return writeJson(res, 200, { profiles, active });
+        }
+        case req.method === 'POST' && /^\/sandbox\/([^/]+)\/test$/.test(url.pathname): {
+          // POST /sandbox/<name>/test — opens a session against the named
+          // backend, runs `echo hello`, returns { ok, durationMs, stdout }.
+          const name = url.pathname.match(/^\/sandbox\/([^/]+)\/test$/)[1];
+          try {
+            const sandboxMod = await import('./sandbox/index.mjs');
+            const cfg = ctx.readConfig();
+            // Synthesise a one-off cfg.sandbox.default override so we can
+            // test a backend without mutating the user's persisted choice.
+            const probeCfg = {
+              ...cfg,
+              sandbox: { ...(cfg.sandbox || {}), default: name },
+            };
+            const t0 = Date.now();
+            const box = sandboxMod.resolveSandbox(probeCfg, null);
+            const sess = await box.open();
+            let result;
+            try {
+              result = await sess.exec(['echo', 'hello'], { stdio: 'pipe' });
+            } finally {
+              try { await sess.close(); } catch { /* ignore */ }
+            }
+            const durationMs = Date.now() - t0;
+            const ok = result.code === 0;
+            return writeJson(res, ok ? 200 : 500, {
+              ok,
+              durationMs,
+              code: result.code,
+              stdout: String(result.stdout || '').slice(0, 200),
+              stderr: String(result.stderr || '').slice(0, 200),
+            });
+          } catch (e) {
+            return writeJson(res, 500, { ok: false, error: e?.message || String(e), code: e?.code });
+          }
+        }
+        case route === 'POST /sandbox/use': {
+          if (typeof ctx.writeConfig !== 'function') {
+            return writeJson(res, 405, { error: 'mutation disabled' });
+          }
+          let body;
+          try { body = await readJson(req); }
+          catch (e) { return writeJson(res, 400, { error: e?.message || String(e) }); }
+          const name = body && String(body.name || '').trim();
+          if (!name) return writeJson(res, 400, { error: 'name is required' });
+          if (!sandboxListBackends().includes(name)) {
+            return writeJson(res, 400, { error: `unknown sandbox backend: ${name}` });
+          }
+          const cfg = ctx.readConfig();
+          cfg.sandbox = { ...(cfg.sandbox || {}), default: name };
+          ctx.writeConfig(cfg);
+          return writeJson(res, 200, { ok: true, active: name });
+        }
+        case route === 'GET /channels': {
+          // Aggregate cfg.channels.<name> + any channel-specific runtime
+          // state we expose. Keeps the dashboard from having to know
+          // each channel module's shape.
+          const cfg = ctx.readConfig();
+          const chCfg = (cfg.channels && typeof cfg.channels === 'object') ? cfg.channels : {};
+          // Known built-in channel names (matches channels/ + channels-*).
+          const KNOWN = ['slack', 'matrix', 'telegram', 'discord', 'email', 'signal', 'whatsapp', 'voice', 'http'];
+          const out = [];
+          for (const name of KNOWN) {
+            const sec = chCfg[name];
+            if (!sec && !cfg[`${name}-bot-token`] && !cfg[`${name}-token`]) continue;
+            out.push({
+              name,
+              enabled: !!(sec && (sec.enabled !== false)),
+              lastInboundAt: sec?.lastInboundAt || null,
+              boundAgent: sec?.agent || sec?.boundAgent || null,
+            });
+          }
+          // Surface any additional configured channels we didn't enumerate.
+          for (const name of Object.keys(chCfg)) {
+            if (KNOWN.includes(name)) continue;
+            const sec = chCfg[name] || {};
+            out.push({
+              name,
+              enabled: sec.enabled !== false,
+              lastInboundAt: sec.lastInboundAt || null,
+              boundAgent: sec.agent || sec.boundAgent || null,
+            });
+          }
+          return writeJson(res, 200, { channels: out });
+        }
+        case route === 'POST /index/rebuild': {
+          try {
+            indexDb.rebuild(gwConfigDir);
+            ctx.indexLastRebuiltAt = new Date().toISOString();
+            return writeJson(res, 200, { ok: true, rebuiltAt: ctx.indexLastRebuiltAt });
+          } catch (e) {
+            return writeJson(res, 500, { ok: false, error: e?.message || String(e) });
+          }
+        }
+
         default:
           return writeJson(res, 404, { error: 'not found', route });
       } /* eslint-disable-line no-fallthrough */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazyclaw",
-  "version": "5.0.8",
+  "version": "5.1.0",
   "description": "Lazy, elegant terminal CLI for chatting with Claude / OpenAI / Gemini / Ollama, orchestrating multi-step LLM workflows, and running multi-agent Slack teams with cross-task memory. Banner-on-launch, slash-command ghost autocomplete, persistent sessions, local HTTP gateway.",
   "keywords": [
     "claude",