lazyclaw 6.0.1 → 6.1.0

package/commands/setup_channels.mjs

@@ -0,0 +1,207 @@
+// commands/setup_channels.mjs — Hermes-style "where will you run it?"
+// onboarding step plus the outbound-webhook step, split out of
+// commands/setup.mjs (CLAUDE.md §7: one file = one responsibility, and to
+// keep setup.mjs under its size-gate ceiling).
+//
+// Credentials are written to <cfgDir>/.env (0600) — the same file the
+// channel modules read via dotenv_min. Metadata (enabled / boundAgent) is
+// written to cfg.channels.<name>, the exact shape daemon/routes/ops.mjs
+// and the dashboard read. Plugin channels are recorded the same way with an
+// honest "needs a plugin package" notice — we never pretend a channel works
+// when it requires an uninstalled package or an external binary.
+import { readConfig, writeConfig } from '../lib/config.mjs';
+import { writeDotenvMerge } from '../dotenv_min.mjs';
+import { messageAdd } from '../config_features.mjs';
+
+// fields[].key is the answer key; .env is the env var it maps to; .secret
+// masks it on echo; .optional lets the user skip it.
+export const CHANNEL_CATALOG = [
+  { name: 'slack',    builtin: true,  label: 'Slack',
+    fields: [
+      { key: 'token', env: 'SLACK_BOT_TOKEN', prompt: 'Bot token (xoxb-…)', secret: true },
+      { key: 'appToken', env: 'SLACK_APP_TOKEN', prompt: 'App-level token (xapp-…, for inbound / Socket Mode)', secret: true, optional: true },
+    ] },
+  { name: 'telegram', builtin: true,  label: 'Telegram',
+    fields: [{ key: 'token', env: 'TELEGRAM_BOT_TOKEN', prompt: 'Bot token (from @BotFather)', secret: true }] },
+  { name: 'matrix',   builtin: true,  label: 'Matrix',
+    fields: [
+      { key: 'homeserver', env: 'MATRIX_HOMESERVER', prompt: 'Homeserver URL (https://matrix.org)' },
+      { key: 'token',      env: 'MATRIX_ACCESS_TOKEN', prompt: 'Access token', secret: true },
+      { key: 'userId',     env: 'MATRIX_USER_ID', prompt: 'User id (@you:matrix.org)' },
+    ] },
+  { name: 'http',     builtin: true,  label: 'HTTP (generic inbound endpoint)', fields: [] },
+  { name: 'discord',  builtin: false, plugin: '@lazyclaw/channel-discord', label: 'Discord',
+    fields: [{ key: 'token', env: 'DISCORD_BOT_TOKEN', prompt: 'Bot token', secret: true }] },
+  { name: 'email',    builtin: false, plugin: '@lazyclaw/channel-email', label: 'Email (IMAP/SMTP)',
+    fields: [
+      { key: 'host', env: 'EMAIL_IMAP_HOST', prompt: 'IMAP host' },
+      { key: 'user', env: 'EMAIL_IMAP_USER', prompt: 'IMAP user' },
+      { key: 'pass', env: 'EMAIL_IMAP_PASS', prompt: 'IMAP password', secret: true },
+    ] },
+  { name: 'signal',   builtin: false, plugin: '@lazyclaw/channel-signal', label: 'Signal (needs signal-cli)',
+    fields: [{ key: 'account', env: 'SIGNAL_ACCOUNT', prompt: 'Signal account (+15551234567)' }] },
+  { name: 'voice',    builtin: false, plugin: '@lazyclaw/channel-voice', label: 'Voice (Whisper transcription)',
+    fields: [{ key: 'apiKey', env: 'OPENAI_API_KEY', prompt: 'OpenAI API key (whisper)', secret: true }] },
+  { name: 'whatsapp', builtin: false, plugin: '@lazyclaw/channel-whatsapp', label: 'WhatsApp (web session)',
+    fields: [] },
+];
+
+export function channelByName(name) {
+  return CHANNEL_CATALOG.find((c) => c.name === name) || null;
+}
+
+// Pure: turn collected answers into { envVars, channelConfig, needsPlugin }.
+// Empty/whitespace answers are dropped so a skipped optional field doesn't
+// write an empty env var.
+export function buildChannelEntry(name, answers = {}) {
+  const spec = channelByName(name);
+  if (!spec) throw new Error(`unknown channel: ${name}`);
+  const envVars = {};
+  for (const f of spec.fields) {
+    const v = (answers[f.key] == null ? '' : String(answers[f.key])).trim();
+    if (v) envVars[f.env] = v;
+  }
+  return {
+    envVars,
+    channelConfig: { enabled: true },
+    needsPlugin: spec.builtin ? null : spec.plugin,
+  };
+}
+
+// Side-effecting persist used by the interactive step (and unit-tested with a
+// temp cfgDir). Writes creds to <cfgDir>/.env and metadata to cfg.channels.
+// readConfig()/writeConfig() resolve configPath() fresh on every call (it
+// reads LAZYCLAW_CONFIG_DIR at use-time, nothing import-cached), so they
+// target <cfgDir>/config.json when the caller has pointed the env var there.
+export function persistChannel(cfgDir, name, answers) {
+  const entry = buildChannelEntry(name, answers);
+  if (Object.keys(entry.envVars).length) writeDotenvMerge(cfgDir, entry.envVars);
+  const cfg = readConfig();
+  cfg.channels = cfg.channels && typeof cfg.channels === 'object' ? cfg.channels : {};
+  cfg.channels[name] = { ...(cfg.channels[name] || {}), ...entry.channelConfig };
+  writeConfig(cfg);
+  return entry;
+}
+
+const mask = (v) => {
+  const s = String(v);
+  return s.length <= 4 ? '••••' : `${s.slice(0, 3)}…${s.slice(-2)}`;
+};
+
+// Interactive channel step. `prompt(label)` resolves to a trimmed string;
+// `write(text)` sinks UI output (defaults to process.stdout). Returns
+// { skipped, channel?, needsPlugin? }. Never echoes a secret field value.
+export async function runChannelStep({ cfgDir, prompt, colors, write = (s) => process.stdout.write(s) }) {
+  const { dim, ok, warn } = colors;
+  const list = CHANNEL_CATALOG.map((c) => `${c.name}${c.builtin ? '' : ' *'}`).join(' · ');
+  write(`  ${dim('Where will you talk to the agent? Built-in: slack/telegram/matrix/http. (* = needs a plugin package.)')}\n`);
+  write(`  ${dim(list)}\n\n`);
+  const pick = (await prompt('  channel (Enter to skip): ')).trim().toLowerCase();
+  if (!pick) { write(`  ${dim('— skipped —')}\n\n`); return { skipped: true }; }
+  const spec = channelByName(pick);
+  if (!spec) { write(`  ${warn('skipped:')} unknown channel "${pick}"\n\n`); return { skipped: true }; }
+
+  const answers = {};
+  for (const f of spec.fields) {
+    const v = (await prompt(`  ${spec.label} — ${f.prompt}${f.optional ? ' (optional)' : ''}: `)).trim();
+    if (v) answers[f.key] = v;
+  }
+  try {
+    const entry = persistChannel(cfgDir, pick, answers);
+    const credKeys = Object.keys(entry.envVars);
+    write(`  ${ok('✓ channel enabled:')} ${pick}  ${credKeys.length ? dim(`creds: ${credKeys.join(', ')}`) : ''}\n`);
+    for (const f of spec.fields) {
+      if (f.secret && answers[f.key]) write(`    ${dim(`${f.env} = ${mask(answers[f.key])}  (stored in ${cfgDir}/.env, 0600)`)}\n`);
+    }
+    if (entry.needsPlugin) {
+      write(`  ${warn('plugin required:')} ${entry.needsPlugin}\n`);
+      write(`    ${dim(`install with: lazyclaw channels install ${entry.needsPlugin}  (or npm install --prefix ${cfgDir} ${entry.needsPlugin})`)}\n`);
+    }
+    write('\n');
+    return { skipped: false, channel: pick, needsPlugin: entry.needsPlugin };
+  } catch (e) {
+    write(`  ${warn('skipped:')} ${e?.message || e}\n\n`);
+    return { skipped: true };
+  }
+}
+
+// Outbound webhook step (moved verbatim-in-spirit from setup.mjs).
+export async function runWebhookStep({ prompt, colors, write = (s) => process.stdout.write(s) }) {
+  const { dim, ok, warn } = colors;
+  write(`  ${dim('Outbound webhook for `lazyclaw message send <name> <text>`. Slack / Discord Incoming Webhook URLs work as-is.')}\n\n`);
+  const hookName = (await prompt('  webhook name (Enter to skip): ')).trim();
+  if (!hookName) { write(`  ${dim('— skipped —')}\n\n`); return { skipped: true }; }
+  const hookUrl = (await prompt('  webhook URL: ')).trim();
+  if (!hookUrl) { write(`  ${warn('skipped:')} URL required\n\n`); return { skipped: true }; }
+  try {
+    const fresh = readConfig();
+    messageAdd(fresh, hookName, hookUrl);
+    writeConfig(fresh);
+    write(`  ${ok('✓ webhook saved:')} ${hookName}\n\n`);
+    return { skipped: false, name: hookName };
+  } catch (e) {
+    write(`  ${warn('skipped:')} ${e?.message || e}\n\n`);
+    return { skipped: true };
+  }
+}
+
+// Context-window step (asked right after the model pick): how much past
+// conversation to keep each turn — a sliding history budget, NOT the model's
+// hard limit. Enter on both prompts keeps the defaults.
+export async function runContextStep({ prompt, colors, write = (s) => process.stdout.write(s) }) {
+  const { dim, ok } = colors;
+  const cf = await import('../config_features.mjs');
+  const cur = cf.chatWindowGet(readConfig());
+  write(`  ${dim(`Context window — how much past conversation to send each turn (sliding budget, not the model's hard limit). Now: ${cur.turns} turns · ${cur.tokens} tokens.`)}\n\n`);
+  const turnsRaw = (await prompt(`  turns to keep (Enter = ${cur.turns}): `)).trim();
+  const tokensRaw = (await prompt(`  token budget (Enter = ${cur.tokens}): `)).trim();
+  if (!turnsRaw && !tokensRaw) { write(`  ${dim('— kept defaults —')}\n\n`); return { skipped: true }; }
+  const turns = parseInt(turnsRaw, 10);
+  const tokens = parseInt(tokensRaw, 10);
+  const cfg = readConfig();
+  cf.chatWindowSet(cfg, {
+    ...(Number.isFinite(turns) && turns > 0 ? { turns } : {}),
+    ...(Number.isFinite(tokens) && tokens >= 256 ? { tokens } : {}),
+  });
+  writeConfig(cfg);
+  const w = cf.chatWindowGet(cfg);
+  write(`  ${ok('✓ context window:')} ${w.turns} turns · ${w.tokens} tokens\n`);
+  write(`  ${dim('change later: /context turns <N> | tokens <N>')}\n\n`);
+  return { skipped: false, ...w };
+}
+
+// Optional orchestration step: enable the multi-agent planner+workers pipeline.
+// Defaults the planner to the configured provider and workers to [planner];
+// the user can layer more workers later via /orchestrator or the CLI.
+export async function runOrchestratorStep({ prompt, colors, write = (s) => process.stdout.write(s) }) {
+  const { dim, ok } = colors;
+  const cf = await import('../config_features.mjs');
+  // Reuse the same searchable provider/model picker as the model step, so
+  // planner + workers are chosen from a list (arrow keys / filter), not typed.
+  const { _pickProviderInteractive } = await import('../tui/pickers.mjs');
+  const toSpec = (p) => (p && p.provider) ? (p.model ? `${p.provider}:${p.model}` : p.provider) : null;
+  write(`  ${dim('Multi-agent: a planner splits your task into subtasks, workers run them in parallel, then a synthesis step merges the results. Skip for a single agent.')}\n\n`);
+  const yn = (await prompt('  enable orchestration? [y/N] ')).trim().toLowerCase();
+  if (yn !== 'y' && yn !== 'yes') { write(`  ${dim('— skipped —')}\n\n`); return { skipped: true }; }
+  const cfg = readConfig();
+  const base = cfg.provider && cfg.provider !== 'orchestrator' ? cfg.provider : 'claude-cli';
+  // Planner — pick from the provider/model list (Esc keeps the default).
+  write(`  ${dim('Pick the PLANNER (decomposes the task):')}\n`);
+  const planner = toSpec(await _pickProviderInteractive()) || base;
+  // Workers — pick one or more from the same list.
+  const workers = [];
+  let more = true;
+  while (more) {
+    write(`  ${dim(`Pick a WORKER (runs the subtasks)${workers.length ? ` — ${workers.length} added` : ''}:`)}\n`);
+    const spec = toSpec(await _pickProviderInteractive());
+    if (spec && !workers.includes(spec)) workers.push(spec);
+    more = ((await prompt('  add another worker? [y/N] ')).trim().toLowerCase().startsWith('y'));
+  }
+  if (!workers.length) workers.push(planner);
+  cf.orchestratorSet(cfg, { planner, workers });
+  cf.orchestratorEnable(cfg, true);
+  writeConfig(cfg);
+  write(`  ${ok('✓ orchestration enabled:')} planner ${planner} · workers ${workers.join(', ')}\n`);
+  write(`  ${dim('change later: /orchestrator  or  lazyclaw orchestrator status')}\n\n`);
+  return { skipped: false, planner, workers };
+}

package/config_features.mjs

@@ -239,3 +239,109 @@ export async function messageSend(cfg, name, text, opts = {}) {
   }
   return { ok: true, kind: hook.kind, status: res.status };
 }
+
+// ── Channels — built-in channel config (cfg.channels.<name>) ────────────
+// KNOWN_CHANNELS mirrors channels/ (built-in) + channels-* (plugins). Single
+// source of truth: the daemon /channels route, the CLI `channels` command, and
+// the in-chat /channels slash all read it so the three views can't drift.
+export const KNOWN_CHANNELS = ['slack', 'matrix', 'telegram', 'discord', 'email', 'signal', 'whatsapp', 'voice', 'http'];
+
+// A channel counts as "configured" when it has a cfg.channels.<name> section
+// or a legacy <name>-bot-token / <name>-token key. Returns one row per
+// configured channel: { name, enabled, boundAgent, lastInboundAt }. Matches
+// the daemon /channels route's enabled semantics exactly.
+export function channelStatusList(cfg) {
+  const chCfg = (cfg.channels && typeof cfg.channels === 'object') ? cfg.channels : {};
+  const out = [];
+  for (const name of KNOWN_CHANNELS) {
+    const sec = chCfg[name];
+    if (!sec && !cfg[`${name}-bot-token`] && !cfg[`${name}-token`]) continue;
+    out.push({
+      name,
+      enabled: !!(sec && (sec.enabled !== false)),
+      boundAgent: sec?.agent || sec?.boundAgent || null,
+      lastInboundAt: sec?.lastInboundAt || null,
+    });
+  }
+  // Surface any additional configured channels not in the known list.
+  for (const name of Object.keys(chCfg)) {
+    if (KNOWN_CHANNELS.includes(name)) continue;
+    const sec = chCfg[name] || {};
+    out.push({
+      name,
+      enabled: sec.enabled !== false,
+      boundAgent: sec.agent || sec.boundAgent || null,
+      lastInboundAt: sec.lastInboundAt || null,
+    });
+  }
+  return out;
+}
+
+// Enable/disable a channel. Mutates cfg.channels.<name>.enabled; the caller
+// persists via writeConfig. Returns cfg for chaining.
+export function channelSetEnabled(cfg, name, enabled) {
+  if (!name) throw new Error('channel name is required');
+  cfg.channels = (cfg.channels && typeof cfg.channels === 'object') ? cfg.channels : {};
+  cfg.channels[name] = { ...(cfg.channels[name] || {}), enabled: !!enabled };
+  return cfg;
+}
+
+// ── Chat context window (cfg.chat.window{Turns,Tokens}) ─────────────────
+// The sliding history budget sent to the model each turn (NOT the model's hard
+// context limit). Shared by the /context slash, the setup step, the status bar,
+// and applyChatWindow so all four agree. Defaults mirror chat_window.mjs.
+const _CTX_DEFAULT_TURNS = Number(process.env.LAZYCLAW_CHAT_WINDOW_TURNS) || 20;
+const _CTX_DEFAULT_TOKENS = Number(process.env.LAZYCLAW_CHAT_WINDOW_TOKENS) || 8000;
+export function chatWindowGet(cfg) {
+  const c = (cfg && cfg.chat && typeof cfg.chat === 'object') ? cfg.chat : {};
+  return { turns: Number(c.windowTurns) || _CTX_DEFAULT_TURNS, tokens: Number(c.windowTokens) || _CTX_DEFAULT_TOKENS };
+}
+export function chatWindowSet(cfg, { turns, tokens } = {}) {
+  cfg.chat = (cfg.chat && typeof cfg.chat === 'object') ? cfg.chat : {};
+  if (turns !== undefined) cfg.chat.windowTurns = turns;
+  if (tokens !== undefined) cfg.chat.windowTokens = tokens;
+  return cfg;
+}
+
+// ── Orchestrator — multi-agent config (cfg.orchestrator) ────────────────
+// Shared by the setup wizard, the /orchestrator slash, and the CLI so the
+// "planner + workers" config has one shape. Orchestration is ACTIVE only when
+// cfg.provider === 'orchestrator' AND there is at least one worker.
+export function orchestratorGet(cfg) {
+  const o = (cfg.orchestrator && typeof cfg.orchestrator === 'object') ? cfg.orchestrator : {};
+  const workers = Array.isArray(o.workers) ? o.workers : [];
+  return {
+    planner: o.planner || null,
+    workers,
+    maxSubtasks: Number.isFinite(o.maxSubtasks) ? o.maxSubtasks : 5,
+    active: cfg.provider === 'orchestrator' && workers.length > 0,
+  };
+}
+
+// Merge planner / workers / maxSubtasks into cfg.orchestrator (only the keys
+// provided). Returns cfg.
+export function orchestratorSet(cfg, { planner, workers, maxSubtasks } = {}) {
+  cfg.orchestrator = (cfg.orchestrator && typeof cfg.orchestrator === 'object') ? cfg.orchestrator : {};
+  if (planner !== undefined) cfg.orchestrator.planner = planner;
+  if (workers !== undefined) cfg.orchestrator.workers = workers;
+  if (maxSubtasks !== undefined) cfg.orchestrator.maxSubtasks = maxSubtasks;
+  return cfg;
+}
+
+// Turn orchestration on/off by routing cfg.provider. Enabling stashes the
+// previous real provider so disabling can restore it (else falls back to the
+// planner's base provider, then claude-cli).
+export function orchestratorEnable(cfg, enabled) {
+  if (enabled) {
+    if (cfg.provider && cfg.provider !== 'orchestrator') {
+      cfg.orchestrator = (cfg.orchestrator && typeof cfg.orchestrator === 'object') ? cfg.orchestrator : {};
+      cfg.orchestrator._prevProvider = cfg.provider;
+    }
+    cfg.provider = 'orchestrator';
+  } else {
+    const o = (cfg.orchestrator && typeof cfg.orchestrator === 'object') ? cfg.orchestrator : {};
+    const plannerBase = String(o.planner || '').split(':')[0];
+    cfg.provider = o._prevProvider || plannerBase || 'claude-cli';
+  }
+  return cfg;
+}

package/daemon/lib/inbound_dedup.mjs

@@ -0,0 +1,108 @@
+// daemon/lib/inbound_dedup.mjs — idempotency store for POST /inbound.
+//
+// A channel retry (Slack event redelivery, a listener restart replaying its
+// backlog, app_mention+message double-fire arriving from two listener
+// processes) must not run the provider twice or append duplicate turns to the
+// session. Callers claim `${channel}:${messageId}` BEFORE persisting the user
+// turn, record the reply after, and a duplicate replays the recorded reply.
+//
+// Persistence: append-only JSONL at <cfgDir>/inbound_seen.jsonl (0600 — the
+// recorded replies are conversation content), loaded on open, compacted to
+// the newest `cap` entries when the file grows past 4×cap lines. Pending
+// (claimed-but-unrecorded) keys are memory-only with a TTL so a crash between
+// claim and record can never permanently wedge a message id.
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+const DEFAULT_CAP = 500;
+const DEFAULT_PENDING_TTL_MS = 120_000;
+// Replays only need enough of the reply to repost it; cap what we persist so
+// a pathological multi-MB reply can't balloon the store.
+const MAX_PERSISTED_REPLY = 16_384;
+
+// One instance per config dir — the daemon is long-lived and the store keeps
+// its working set in memory; reopening per request would re-read the file.
+const _instances = new Map();
+export function _resetDedupCache() { _instances.clear(); }
+
+export function openDedup(cfgDir, { cap = DEFAULT_CAP, pendingTtlMs = DEFAULT_PENDING_TTL_MS, now = Date.now } = {}) {
+  const existing = _instances.get(cfgDir);
+  if (existing) return existing;
+
+  const file = path.join(cfgDir, 'inbound_seen.jsonl');
+  /** @type {Map<string, {reply: string, threadId: string|null, sessionId: string|null, at: number}>} */
+  const entries = new Map(); // insertion order == age order
+  /** @type {Map<string, number>} pending claim -> claimed-at ms */
+  const pending = new Map();
+
+  const load = () => {
+    let raw;
+    try { raw = fs.readFileSync(file, 'utf8'); }
+    catch { return; }
+    for (const line of raw.split('\n')) {
+      if (!line.trim()) continue;
+      appendedLines++;
+      let rec;
+      try { rec = JSON.parse(line); } catch { continue; } // skip corrupt lines
+      if (!rec || typeof rec.key !== 'string') continue;
+      entries.delete(rec.key); // re-insert to refresh age order
+      entries.set(rec.key, { reply: rec.reply ?? '', threadId: rec.threadId ?? null, sessionId: rec.sessionId ?? null, at: rec.at ?? 0 });
+    }
+    trim();
+  };
+
+  const trim = () => {
+    while (entries.size > cap) {
+      const oldest = entries.keys().next().value;
+      entries.delete(oldest);
+    }
+  };
+
+  // Appended-lines counter (seeded by load) instead of re-reading the file on
+  // every record — the store may see one append per inbound message.
+  let appendedLines = 0;
+  const compactIfNeeded = () => {
+    if (appendedLines <= cap * 4) return;
+    const out = [...entries.entries()]
+      .map(([key, e]) => JSON.stringify({ key, ...e }))
+      .join('\n') + '\n';
+    try {
+      fs.writeFileSync(file, out, { mode: 0o600 });
+      appendedLines = entries.size;
+    } catch { /* compaction is best-effort */ }
+  };
+
+  const store = {
+    claim(key) {
+      const hit = entries.get(key);
+      if (hit) return { dup: true, pending: false, entry: hit };
+      const claimedAt = pending.get(key);
+      if (claimedAt != null && now() - claimedAt < pendingTtlMs) {
+        return { dup: true, pending: true, entry: null };
+      }
+      pending.set(key, now());
+      return { dup: false, pending: false, entry: null };
+    },
+    record(key, { reply = '', threadId = null, sessionId = null } = {}) {
+      pending.delete(key);
+      const bounded = String(reply).length > MAX_PERSISTED_REPLY
+        ? String(reply).slice(0, MAX_PERSISTED_REPLY) + '\n…(truncated for replay)'
+        : reply;
+      const entry = { reply: bounded, threadId, sessionId, at: now() };
+      entries.delete(key);
+      entries.set(key, entry);
+      trim();
+      try {
+        fs.appendFileSync(file, JSON.stringify({ key, ...entry }) + '\n', { mode: 0o600 });
+        appendedLines++;
+      } catch { /* persistence is best-effort; memory dedup still holds */ }
+      compactIfNeeded();
+    },
+    release(key) { pending.delete(key); },
+  };
+
+  load();
+  _instances.set(cfgDir, store);
+  return store;
+}

package/daemon/lib/learn_queue.mjs

@@ -0,0 +1,46 @@
+// daemon/lib/learn_queue.mjs — bounded, serialised runner for the /inbound
+// post-task learning hook.
+//
+// runLearning fires up to two trainer LLM completions (skill synthesis + the
+// user model) and, with trainer 'auto', may spawn a claude-cli subprocess —
+// per call, with no throttle of its own. A channel message burst hitting
+// POST /inbound must not fan that out unbounded, so learning jobs run one at
+// a time and the waiting line is capped: when it is full the newest job is
+// DROPPED (learning is best-effort; the trajectory of a dropped turn is
+// simply not recorded — the next turn learns again).
+
+const MAX_DEPTH = 8;
+
+let _running = false;
+const _waiting = [];
+let _dropped = 0;
+
+function _drain() {
+  if (_running) return;
+  const job = _waiting.shift();
+  if (!job) return;
+  _running = true;
+  Promise.resolve()
+    .then(job)
+    .catch(() => { /* learning is best-effort */ })
+    .finally(() => { _running = false; _drain(); });
+}
+
+// Enqueue a learning job (a function returning a promise). Returns true when
+// accepted, false when the queue was full and the job was dropped.
+export function enqueueLearning(job) {
+  if (_waiting.length >= MAX_DEPTH) {
+    _dropped++;
+    if (_dropped === 1 || _dropped % 50 === 0) {
+      process.stderr.write(`[learn] queue full — dropped ${_dropped} learning job(s) so far (burst protection)\n`);
+    }
+    return false;
+  }
+  _waiting.push(job);
+  _drain();
+  return true;
+}
+
+// Test hooks.
+export function _learnQueueStats() { return { running: _running, waiting: _waiting.length, dropped: _dropped }; }
+export function _resetLearnQueue() { _waiting.length = 0; _running = false; _dropped = 0; }

package/daemon/routes/_deps.mjs

@@ -34,3 +34,9 @@ export { resolveProvider } from '../lib/provider.mjs';
 // persistent thread/session and re-point them across channels.
 export { openThreads } from '../../channels/threads.mjs';
 export { handoffWithRollback } from '../../channels/handoff.mjs';
+// Phase 4 — /inbound idempotency: dedup retried/redelivered channel messages
+// by their native message id so the provider runs once per message.
+export { openDedup } from '../lib/inbound_dedup.mjs';
+// Phase 4 — serialised, depth-capped runner for the /inbound learning hook
+// (a message burst must not fan out unbounded trainer calls).
+export { enqueueLearning } from '../lib/learn_queue.mjs';

package/daemon/routes/conversation.mjs

@@ -1,7 +1,7 @@
 // Daemon route handlers (conversation), extracted verbatim from makeHandler (D5).
 // Each handler takes the per-request dispatch context `c` and returns the
 // HTTP response. Bodies are unchanged; only the dispatch wrapper is new.
-import { fs, nodePath, PROVIDERS, PROVIDER_INFO, maskApiKey, costFromUsage, RATE_CARD_SHAPE, composeSystemPrompt, listSkills, loadSkill, skillPath, installSkill, removeSkill, parseFrontmatter, skillsDefaultConfigDir, indexDb, skillSynth, sandboxListBackends, summarizeState, listWorkflowSessions, loadWorkflowState, aggregateNodeStats, validateConfig, validateRates, fileExists, readJson, readTextBody, writeJson, writeSseHead, writeSse, statusForProviderError, checkCostCap, accumulateMetricsFromCost, resolveProvider, openThreads, handoffWithRollback } from './_deps.mjs';
+import { fs, nodePath, PROVIDERS, PROVIDER_INFO, maskApiKey, costFromUsage, RATE_CARD_SHAPE, composeSystemPrompt, listSkills, loadSkill, skillPath, installSkill, removeSkill, parseFrontmatter, skillsDefaultConfigDir, indexDb, skillSynth, sandboxListBackends, summarizeState, listWorkflowSessions, loadWorkflowState, aggregateNodeStats, validateConfig, validateRates, fileExists, readJson, readTextBody, writeJson, writeSseHead, writeSse, statusForProviderError, checkCostCap, accumulateMetricsFromCost, resolveProvider, openThreads, handoffWithRollback, openDedup, enqueueLearning } from './_deps.mjs';
 import { randomBytes } from 'node:crypto';
 
 // F5 — mint a fresh session id for a newly-seen channel:externalId binding.
@@ -165,6 +165,35 @@ export async function inbound(c) {
           const cfgDir = ctx.sessionsDirGetter();
           const channel = (typeof body.channel === 'string' && body.channel) ? body.channel : null;
           const externalId = (body.externalId != null && String(body.externalId)) ? String(body.externalId) : null;
+          // Phase 4 — idempotency. When the relay supplies the native message
+          // id, claim a key BEFORE any turn is persisted: a recorded duplicate
+          // replays the prior reply (no provider call, no double appendTurn);
+          // an in-flight duplicate answers empty so the listener stays silent
+          // while the first request finishes. The key is scoped to the
+          // CONVERSATION (`channel:externalId:messageId`) so a colliding or
+          // forged messageId from another conversation can never replay this
+          // one's reply or sessionId.
+          const messageId = (body.messageId != null && String(body.messageId)) ? String(body.messageId) : null;
+          let dedup = null;
+          let dedupKey = null;
+          if (channel && messageId) {
+            dedup = openDedup(cfgDir);
+            dedupKey = `${channel}:${externalId || ''}:${messageId}`;
+            const seen = dedup.claim(dedupKey);
+            if (seen.dup) {
+              if (seen.pending) return writeJson(res, 200, { reply: '', threadId: body.threadId || null, duplicate: true });
+              const e = seen.entry;
+              const dupOut = { reply: e.reply, threadId: e.threadId, duplicate: true };
+              if (e.sessionId) dupOut.sessionId = e.sessionId;
+              return writeJson(res, 200, dupOut);
+            }
+          }
+          // Everything from here to record() must free the pending claim on
+          // ANY failure (not just provider errors) — otherwise a thrown
+          // loadTurns/appendTurn would wedge the message id for the whole
+          // pending TTL and retries would be silently dropped.
+          let dedupRecorded = false;
+          try {
           let threads = null;
           let bound = null;
           let sessionId = null;
@@ -193,6 +222,8 @@ export async function inbound(c) {
               { apiKey: cfg['api-key'], model: body.model || cfg.model, onUsage: (u) => { inboundUsage = u; } },
             )) acc += chunk;
           } catch (err) {
+            // A provider failure must stay retryable, not poison the message
+            // id — the outer finally releases the claim.
             const m = statusForProviderError(err);
             return writeJson(res, m.status, { error: err?.message || String(err), code: err?.code || null }, m.headers || {});
           }
@@ -211,16 +242,45 @@ export async function inbound(c) {
           }
           const out = { reply: acc, threadId: bound ? bound.threadId : (body.threadId || null) };
           if (sessionId) out.sessionId = sessionId;
+          if (dedup) { dedup.record(dedupKey, { reply: acc, threadId: out.threadId, sessionId }); dedupRecorded = true; }
+          if (sessionId) {
+            // Phase 4 — close the post-task learning loop on channel turns,
+            // mirroring the chat REPL's fire-and-forget hook (run_turn.mjs).
+            // Only session-bound turns learn (a stateless one-shot relay is
+            // not a conversation); trainer resolution inside runLearning
+            // handles cfg.trainer 'auto' -> claude-cli ($0) routing. The
+            // dedup short-circuit above guarantees at most one learning pass
+            // per native message id, and enqueueLearning serialises the runs
+            // (concurrency 1, bounded depth) so a message burst can't fan out
+            // unbounded trainer LLM calls / claude-cli subprocesses.
+            const learnTurns = [
+              { agent: 'user', text, ts: new Date().toISOString() },
+              { agent: 'chat', text: acc, ts: new Date().toISOString() },
+            ];
+            enqueueLearning(() =>
+              import('../../mas/learning.mjs')
+                .then((mod) => mod.runLearning('post-task', {
+                  agent: { name: 'chat', provider: provName, model: body.model || cfg.model, role: '' },
+                  task: { id: sessionId, title: '(channel turn)', turns: learnTurns },
+                  configDir: cfgDir,
+                  cfg,
+                })));
+          }
           return writeJson(res, 200, out);
+          } finally {
+            if (dedup && !dedupRecorded) dedup.release(dedupKey);
+          }
 }
 
 export async function handoff(c) {
   const { ctx, res, req } = c;
           // F6 — re-point a thread to a new channel/externalId so a later
           // inbound on the target resumes the SAME session (context follows).
-          // The daemon has no live per-channel send map, so it migrates the
-          // binding directly with no notifier; once a send adapter is injected,
-          // a failed target notify rolls the binding back (channels/handoff.mjs).
+          // When the in-process gateway registered a live sender for the
+          // target channel (ctx.channelSenders), the target gets a resume
+          // marker and a FAILED notify rolls the binding back (502). Without
+          // a sender (bare daemon) the migration persists silently — the
+          // session still follows on the next inbound.
           let body;
           try { body = await readJson(req); }
           catch (e) { return writeJson(res, 400, { error: `invalid JSON body: ${e.message}` }); }
@@ -232,10 +292,14 @@ export async function handoff(c) {
           }
           const cfgDir = ctx.sessionsDirGetter();
           const threads = openThreads(cfgDir);
+          const liveSend = (ctx.channelSenders && typeof ctx.channelSenders.get === 'function')
+            ? ctx.channelSenders.get(target)
+            : undefined;
           try {
             const next = await handoffWithRollback({
               threads, threadId, target, externalId,
               note: typeof body.note === 'string' ? body.note : '',
+              send: liveSend,
             });
             return writeJson(res, 200, {
               threadId: next.threadId, channel: next.channel,

package/daemon/routes/ops.mjs

@@ -3,6 +3,12 @@
 // HTTP response. Bodies are unchanged; only the dispatch wrapper is new.
 import { fs, nodePath, PROVIDERS, PROVIDER_INFO, maskApiKey, costFromUsage, RATE_CARD_SHAPE, composeSystemPrompt, listSkills, loadSkill, skillPath, installSkill, removeSkill, parseFrontmatter, skillsDefaultConfigDir, indexDb, skillSynth, sandboxListBackends, summarizeState, listWorkflowSessions, loadWorkflowState, aggregateNodeStats, validateConfig, validateRates, fileExists, readJson, readTextBody, writeJson, writeSseHead, writeSse, statusForProviderError, checkCostCap, accumulateMetricsFromCost, resolveProvider } from './_deps.mjs';
 
+// Channel meta + status now live in config_features.mjs (single source for the
+// daemon route, the CLI `channels` command, and the /channels slash). Re-export
+// KNOWN_CHANNELS so existing importers (the drift-guard test) keep working.
+export { KNOWN_CHANNELS } from '../../config_features.mjs';
+import { channelStatusList } from '../../config_features.mjs';
+
 export async function trainerStatus(c) {
   const { ctx, logger, metrics, gateway, costCap, cachedByName, gwConfigDir, nudgeSuggestionsRing, workflowStateDir, req, res, method, path, route, url, sessionMatch, providerMatch, providerTestMatch, sessionExportMatch, skillMatch, workflowMatch, configKeyMatch, ratesKeyMatch } = c;
           // Reads cfg.trainer.{provider, model, schedule, budget, recipe}
@@ -138,36 +144,10 @@ export async function sandboxUse(c) {
 
 export async function channels(c) {
   const { ctx, logger, metrics, gateway, costCap, cachedByName, gwConfigDir, nudgeSuggestionsRing, workflowStateDir, req, res, method, path, route, url, sessionMatch, providerMatch, providerTestMatch, sessionExportMatch, skillMatch, workflowMatch, configKeyMatch, ratesKeyMatch } = c;
-          // Aggregate cfg.channels.<name> + any channel-specific runtime
-          // state we expose. Keeps the dashboard from having to know
-          // each channel module's shape.
+          // Aggregate cfg.channels.<name> via the shared status helper so the
+          // dashboard, CLI, and /channels slash all report identically.
           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 });
+          return writeJson(res, 200, { channels: channelStatusList(cfg) });
 }
 
 export async function indexRebuild(c) {