lazyclaw 3.99.28 → 4.2.1

package/cli.mjs

@@ -857,6 +857,10 @@ const SLASH_COMMANDS = [
   { cmd: '/skill',  help: 'switch active skills: /skill review,style (no arg → clear)' },
   { cmd: '/provider', help: 'switch provider: /provider openai (no arg → print current)' },
   { cmd: '/model',  help: 'switch model: /model gpt-4.1 or anthropic/claude-opus-4-7' },
+  { cmd: '/loop',   help: 'repeat one prompt: /loop "fix lint" [--max N] [--until "<regex>"]' },
+  { cmd: '/goal',   help: 'register/switch goal: /goal add NAME [--desc "..."] / /goal NAME / /goal list' },
+  { cmd: '/memory', help: 'show layered memory: /memory [core|recent|episodic [topic]]' },
+  { cmd: '/dream',  help: 'consolidate recent memory into per-topic episodic files' },
   { cmd: '/exit',   help: 'leave the chat' },
 ];
 
@@ -916,6 +920,12 @@ const SUBCOMMANDS = [
   'setup', 'dashboard',
   // v3.99.22 — multi-agent orchestrator config
   'orchestrator',
+  // v3.99.30 — /loop and /goal slash commands (in-session + detached)
+  'loop', 'loops', 'goal', 'memory',
+  // v4.0.0 — Slack Socket Mode listener (inbound DM / @-mention)
+  'slack',
+  // v4.1.0 — multi-agent slack system (Phase 9+)
+  'agent', 'team', 'task',
 ];
 
 const SUBCOMMAND_SUBS = {
@@ -932,6 +942,13 @@ const SUBCOMMAND_SUBS = {
   workspace: ['list', 'init', 'show', 'remove', 'path'],
   cron:      ['list', 'add', 'remove', 'show', 'sync', 'run'],
   orchestrator: ['status', 'set-planner', 'workers', 'set-max-subtasks', 'clear'],
+  loops:     ['list', 'show', 'kill', 'tail'],
+  goal:      ['add', 'list', 'show', 'close', 'switch', 'tick', 'channel'],
+  memory:    ['show', 'dream', 'edit'],
+  slack:     ['listen'],
+  agent:     ['add', 'list', 'show', 'edit', 'remove'],
+  team:      ['add', 'list', 'show', 'edit', 'remove'],
+  task:      ['start', 'list', 'show', 'abandon', 'done', 'remove'],
 };
 
 function bashCompletion() {
@@ -1467,129 +1484,54 @@ function _attachGhostAutocomplete(rl) {
 // Width-management rule: every inner line is forced through
 // `.padEnd(W)` so a stray width miscount can't punch the right
 // border off the box (which is exactly the bug v3.99.5 shipped:
-// two of the inner lines were 33 cols vs the others' 32, so the
-// ╮ rendered into the next line).
-// v3.99.28 — Big ASCII mascot, rebuilt on a strict 17-wide canvas so
-// every row aligns (the v3.99.26 port copied the design handoff's
-// mixed 15/16/17 widths which made the helmet drift left of the
-// body in any monospace font). Layout: pincers ◂▸ at cols 2-3 and
-// 13-14, stems │ at cols 2 and 14, helmet box from col 1 to col 15
-// (13-wide interior), body box same width directly below, legs ┃ at
-// cols 4 and 12 — symmetric on the central axis (col 8).
-const _MASCOT_W = 17;
-const _MASCOT_BIG = {
-  idle: [
-    '  ◂▸         ◂▸  ',
-    '  │           │  ',
-    '  │           │  ',
-    ' ╔═════════════╗ ',
-    ' ║             ║ ',
-    ' ╚═════════════╝ ',
-    ' ┌─────────────┐ ',
-    ' │  │       │  │ ',
-    ' ┤  │       │  ├ ',
-    ' └─────────────┘ ',
-    '    ┃       ┃    ',
-    '    ┃       ┃    ',
-  ],
-  working: [
-    '  ◂▸         ◂▸  ',
-    '  │  ···      │  ',
-    '  │           │  ',
-    ' ╔═════════════╗ ',
-    ' ║      *      ║ ',
-    ' ╚═════════════╝ ',
-    ' ┌─────────────┐ ',
-    ' │  ·       ·  │ ',
-    ' ┤             ├ ',
-    ' └─────────────┘ ',
-    '    ┃       ┃    ',
-    '    ┃       ┃    ',
-  ],
-  done: [
-    '✦ ◂▸         ◂▸ ✦',
-    '  │           │  ',
-    '  │           │  ',
-    ' ╔═════════════╗ ',
-    ' ║             ║ ',
-    ' ╚═════════════╝ ',
-    ' ┌─────────────┐ ',
-    ' │  ^       ^  │ ',
-    ' ┤    ‿‿‿‿‿    ├ ',
-    ' └─────────────┘ ',
-    '    ┃       ┃    ',
-    '    ┃       ┃    ',
-  ],
-  error: [
-    '   ▾         ▾   ',
-    '  │           │  ',
-    '  │           │  ',
-    ' ╔═════════════╗ ',
-    ' ║      ~      ║ ',
-    ' ╚═════════════╝ ',
-    ' ┌─────────────┐ ',
-    ' │  ×       ×  │ ',
-    ' ┤    ⏜⏜⏜⏜⏜    ├ ',
-    ' └─────────────┘ ',
-    '    ┃       ┃    ',
-    '    ┃       ┃    ',
-  ],
-};
-const _MASCOT_TINY = {
-  idle:    '◂▸  ◂▸\n[│  │]\n ┃  ┃ ',
-  working: '◂▸  ◂▸\n[·  ·] ···\n ┃  ┃ ',
-  done:    '◂▸  ◂▸\n[^  ^] ✓\n ┃  ┃ ',
-  error:   '▾   ▾ \n[×  ×] !\n ┃  ┃ ',
-};
-
-// Ink helpers. State picks a primary colour; the banner caller layers
-// a secondary "wordmark" right column.
-function _mascotInkers(state) {
-  const helmet = (s) => `\x1b[38;2;195;61;42m${s}\x1b[0m`;
-  const helmetDim = (s) => `\x1b[38;2;122;31;21m${s}\x1b[0m`;
-  const star = (s) => `\x1b[38;2;217;119;87m${s}\x1b[0m`;
-  const ok = (s) => `\x1b[38;2;111;185;143m${s}\x1b[0m`;
-  const err = (s) => `\x1b[38;2;230;57;70m${s}\x1b[0m`;
-  if (state === 'done') return (s) => ok(s);
-  if (state === 'error') return (s) => err(s);
-  if (state === 'working') return (s) => helmet(s);
-  return (s) => helmet(s);
-}
-
-function _renderMascot(state) {
-  const rows = _MASCOT_BIG[state] || _MASCOT_BIG.idle;
-  const ink = _mascotInkers(state);
-  return rows.map((r) => ink(r));
+// v4.2.2 — restore the original v3.99.11-era banner: a figlet
+// "lazy" wordmark (small font, 4 rows) inside a 30-col rounded box
+// with a "LazyClaw  |__/  v<ver>" caption sharing the last inner row
+// with the descender of the `y`. This is the banner that shipped
+// before the helmet-mascot / 8-bit-crab / emoji detours, and the one
+// the user kept in muscle memory.
+//
+// Layout invariant: every inner row is exactly 30 visible cells (no
+// double-width glyphs, all chars are 1 cell in any monospace font),
+// so the right edge `│` always lands in the same column.
+//
+// _renderMascot / _renderMascotTiny are kept as stubs because the
+// _renderBanner caller still passes a row array around; they no
+// longer drive separate art for working/done/error since the box-
+// banner has no good place to flash those states. The router and
+// loop runners that used to ask for a state-coloured tiny mascot can
+// keep importing the helper; it just returns the wordmark.
+
+function _renderMascot() {
+  // Banner builds its own art; this stub exists so any leftover
+  // caller doesn't crash. One element so .map() and length checks
+  // behave like the legacy shape.
+  return ['lazyclaw'];
 }
 
-// Tiny inline mascot — picked up by chat/agent helpers when they want
-// to flash a one-line status without re-rendering the whole banner.
-// Returns a string; callers add their own newline.
-function _renderMascotTiny(state) {
-  const ink = _mascotInkers(state);
-  return ink((_MASCOT_TINY[state] || _MASCOT_TINY.idle));
+function _renderMascotTiny() {
+  return 'lazyclaw';
 }
 
 function _renderBanner(version) {
+  const helmet = (s) => `\x1b[38;2;195;61;42m${s}\x1b[0m`;
   const ink = (s) => `\x1b[38;2;241;234;217m${s}\x1b[0m`;
-  const dim = (s) => `\x1b[2m${s}\x1b[0m`;
   const v = String(version || '?.?.?');
-  const left = _renderMascot('idle');
-  const right = [
-    '',
-    '',
-    '',
-    `   ${ink('lazyclaw')}  ${dim('v' + v)}`,
-    `   ${dim('a sleepy 8-bit')}`,
-    `   ${dim('terminal assistant')}`,
-    '',
-    '',
-    '',
-    '',
-    '',
-    '',
+  // Caption shares the final inner row with the `|__/` descender of
+  // the `y` from figlet-small, exactly like the v3.99.11 screenshot.
+  const cap = `  LazyClaw  |__/  v${v}`.padEnd(30, ' ').slice(0, 30);
+  const top = '╭' + '─'.repeat(30) + '╮';
+  const bot = '╰' + '─'.repeat(30) + '╯';
+  const wrap = (inner) => helmet('│') + inner + helmet('│');
+  return [
+    helmet(top),
+    wrap(helmet('   _                          ')),
+    wrap(helmet('  | |__ _ _____  _ _          ')),
+    wrap(helmet(`  | / _\` |_ / || | '_|        `)),
+    wrap(helmet(`  |_\\__,_/__\\_, |_|           `)),
+    wrap(ink(cap)),
+    helmet(bot),
   ];
-  return left.map((l, i) => '  ' + l + (right[i] || ''));
 }
 
 function _printChatBanner(activeProvName, activeModel, version) {
@@ -2367,7 +2309,12 @@ async function cmdChat(flags = {}) {
   // Persistent session ID. When --session is set we hydrate prior turns from
   // <configDir>/sessions/<id>.jsonl and append every new turn back to it.
   // Without --session, chat is in-memory only (matches phase 4 behavior).
-  const sessionId = flags.session || null;
+  // Mutable so /goal <name> can switch the working context mid-session.
+  let sessionId = flags.session || null;
+  // Currently-active goal name when the user has switched context via
+  // /goal <name>. Tracked so /status can surface it and so future ticks
+  // know which goal to attribute new turns to.
+  let activeGoalName = null;
   const cfgDir = path.dirname(configPath());
   let messages = sessionId
     ? sessionsMod.loadTurns(sessionId, cfgDir).map(t => ({ role: t.role, content: t.content }))
@@ -2598,6 +2545,376 @@ async function cmdChat(flags = {}) {
         }
         return true;
       }
+      case '/loop': {
+        // `/loop <prompt> [--max N] [--until "<regex>"]` — repeats one
+        // user prompt against the active provider in the current session.
+        // Default --max 3, hard cap 50. --until short-circuits when its
+        // regex matches the latest assistant turn. Ctrl+C aborts the
+        // current stream AND the whole loop (not just the in-flight
+        // turn). Implementation lives in loop-engine.mjs; here we wire
+        // it to the same provider streaming + buffered-writer used by a
+        // normal user turn.
+        const arg = line.slice('/loop'.length).trim();
+        const loopMod = await import('./loop-engine.mjs');
+        if (!arg) {
+          process.stdout.write(`usage: /loop <prompt> [--max N] [--until "<regex>"]\n`);
+          process.stdout.write(`  default --max ${loopMod.LOOP_MAX_DEFAULT}, ceiling ${loopMod.LOOP_MAX_CEILING}\n`);
+          process.stdout.write(`  session: ${sessionId || '(none — turns will not be persisted)'}\n`);
+          return true;
+        }
+        let parsed;
+        try { parsed = loopMod.parseLoopArgs(arg); }
+        catch (e) { process.stdout.write(`loop error: ${e?.message || e}\n`); return true; }
+        let untilRe = null;
+        try { untilRe = loopMod.compileUntil(parsed.until); }
+        catch (e) { process.stdout.write(`loop error: ${e?.message || e}\n`); return true; }
+
+        // Per-loop AbortController. Ctrl+C aborts the current provider
+        // call (via signal) AND prevents the next iteration (the engine
+        // sees signal.aborted on its loop check). Same handler shape as
+        // the normal-turn path; symmetry keeps `/exit` clean afterwards.
+        const loopAc = new AbortController();
+        const onSigint = () => {
+          loopAc.abort();
+          process.stdout.write('\n^C interrupted — loop aborted\n');
+        };
+        process.on('SIGINT', onSigint);
+
+        const sendOnce = async (msgs, signal) => {
+          let acc = '';
+          let _writeBuf = '';
+          let _writeTimer = null;
+          const _flush = () => {
+            if (_writeBuf) { process.stdout.write(_writeBuf); _writeBuf = ''; }
+            _writeTimer = null;
+          };
+          const _writeChunk = (s) => {
+            _writeBuf += s;
+            if (!_writeTimer) _writeTimer = setTimeout(_flush, 30);
+          };
+          try {
+            for await (const chunk of prov.sendMessage(msgs, {
+              apiKey: _resolveAuthKey(cfg, activeProvName),
+              model: activeModel,
+              sandbox: sandboxSpec,
+              signal,
+              onUsage: accumulateUsage,
+            })) {
+              _writeChunk(chunk);
+              acc += chunk;
+            }
+            if (_writeTimer) clearTimeout(_writeTimer);
+            _flush();
+            process.stdout.write('\n');
+            return acc;
+          } catch (err) {
+            if (_writeTimer) clearTimeout(_writeTimer);
+            _flush();
+            throw err;
+          }
+        };
+
+        if (useTerminal) _ghost.suspend();
+        // Capture the chat's existing system message (workspace / skill
+        // composition) before we let the engine touch it; we restore it
+        // after the loop so the chat continues with the same system.
+        const _sysBefore = messages.find(m => m.role === 'system')?.content ?? null;
+        const memMod = (parsed.useMemory || parsed.recall) ? await import('./memory.mjs') : null;
+        const buildSystem = memMod ? (() => {
+          // Called per iteration: memory.loadCore + recall re-read from
+          // disk every call so a parallel writer mutating core.md /
+          // episodic/* between iterations is reflected immediately.
+          const parts = [];
+          if (parsed.useMemory) {
+            const core = memMod.loadCore(cfgDir);
+            if (core && core.trim()) parts.push(core);
+          }
+          if (parsed.recall) {
+            const text = memMod.recall(parsed.recall, { topN: 3 }, cfgDir);
+            if (text && text.trim()) parts.push(text);
+          }
+          if (_sysBefore) parts.push(_sysBefore);
+          return parts.join('\n\n---\n\n');
+        }) : null;
+        try {
+          const result = await loopMod.runLoop({
+            prompt: parsed.prompt,
+            max: parsed.max,
+            until: untilRe,
+            messages,
+            sendOnce,
+            persist: (role, content) => persistTurn(role, content),
+            onIteration: ({ i, max }) => {
+              process.stderr.write(`\x1b[2m  ↻ loop iteration ${i}/${max}\x1b[22m\n`);
+            },
+            signal: loopAc.signal,
+            buildSystem,
+          });
+          charsSent += parsed.prompt.length * result.iterations;
+          if (result.stoppedBy === 'until') {
+            process.stderr.write(`\x1b[2m  ✓ loop stopped by --until\x1b[22m\n`);
+          } else if (result.stoppedBy === 'abort') {
+            process.stderr.write(`\x1b[2m  ⊘ loop aborted after ${result.iterations}/${parsed.max} iteration(s)\x1b[22m\n`);
+          }
+        } catch (err) {
+          process.stdout.write(`loop error: ${err?.message || String(err)}\n`);
+        } finally {
+          process.off('SIGINT', onSigint);
+          if (useTerminal) _ghost.resume();
+          // Restore the chat's prior system message. The engine may have
+          // overwritten messages[0] with the per-iter memory composition;
+          // we put the original (workspace / skill) back so the
+          // subsequent free-form chat turn sees the same system the user
+          // configured before /loop ran.
+          if (buildSystem) {
+            const sysIdx = messages.findIndex(m => m.role === 'system');
+            if (_sysBefore) {
+              if (sysIdx >= 0) messages[sysIdx] = { role: 'system', content: _sysBefore };
+              else messages.unshift({ role: 'system', content: _sysBefore });
+            } else if (sysIdx >= 0) {
+              messages.splice(sysIdx, 1);
+            }
+          }
+        }
+        return true;
+      }
+      case '/goal': {
+        // /goal                 → list active goals
+        // /goal <name>          → switch chat context to goal:<name>
+        // /goal add <name> [--desc "..."] [--cron "<spec>"]
+        // /goal list            → JSON of all goals
+        // /goal show <name>     → JSON of one
+        // /goal close <name> [done|abandoned]
+        const rawArg = line.slice('/goal'.length).trim();
+        const goalsMod = await import('./goals.mjs');
+        const loopMod = await import('./loop-engine.mjs');
+        if (!rawArg) {
+          const items = goalsMod.listGoals(cfgDir).filter(g => g.status === 'active');
+          if (!items.length) { process.stdout.write('no active goals\n'); }
+          else {
+            for (const g of items) {
+              process.stdout.write(`  ${g.name}${g.description ? ' — ' + g.description : ''}${g.schedule ? ' (cron: ' + g.schedule + ')' : ''}\n`);
+            }
+          }
+          return true;
+        }
+        let tokens;
+        try { tokens = loopMod.splitArgs(rawArg); }
+        catch (e) { process.stdout.write(`goal error: ${e?.message || e}\n`); return true; }
+        const sub = tokens[0];
+        const rest = tokens.slice(1);
+        if (sub === 'add') {
+          let name = null, desc = '', cron = null;
+          for (let i = 0; i < rest.length; i++) {
+            const t = rest[i];
+            if (t === '--desc') desc = rest[++i] || '';
+            else if (t === '--cron') cron = rest[++i] || null;
+            else if (t.startsWith('--')) { process.stdout.write(`goal error: unknown flag ${t}\n`); return true; }
+            else if (!name) name = t;
+            else { process.stdout.write(`goal error: unexpected arg "${t}"\n`); return true; }
+          }
+          if (!name) { process.stdout.write('usage: /goal add <name> [--desc "..."] [--cron "<spec>"]\n'); return true; }
+          try {
+            const g = goalsMod.registerGoal({ name, description: desc, schedule: cron }, cfgDir);
+            if (cron) {
+              try { await _attachGoalCron(name, cron); }
+              catch (e) { process.stdout.write(`goal warning: cron attach failed (${e?.message || e})\n`); }
+            }
+            process.stdout.write(`✓ goal ${g.name} added (status: active${cron ? `, cron: ${cron}` : ''})\n`);
+          } catch (e) { process.stdout.write(`goal error: ${e?.message || e}\n`); }
+          return true;
+        }
+        if (sub === 'list') {
+          process.stdout.write(JSON.stringify(goalsMod.listGoals(cfgDir), null, 2) + '\n');
+          return true;
+        }
+        if (sub === 'show') {
+          const name = rest[0];
+          if (!name) { process.stdout.write('usage: /goal show <name>\n'); return true; }
+          const g = goalsMod.getGoal(name, cfgDir);
+          if (!g) { process.stdout.write(`no goal "${name}"\n`); return true; }
+          process.stdout.write(JSON.stringify(g, null, 2) + '\n');
+          return true;
+        }
+        if (sub === 'close') {
+          const name = rest[0];
+          const outcome = rest[1] || 'done';
+          if (!name) { process.stdout.write('usage: /goal close <name> [done|abandoned]\n'); return true; }
+          try {
+            const g = goalsMod.closeGoal(name, outcome, cfgDir);
+            try { await _detachGoalCron(name); }
+            catch (e) { process.stdout.write(`goal warning: cron detach failed (${e?.message || e})\n`); }
+            process.stdout.write(`✓ goal ${g.name} closed (status: ${g.status})\n`);
+          } catch (e) { process.stdout.write(`goal error: ${e?.message || e}\n`); }
+          return true;
+        }
+        // Single-arg branch: switch context to goal:<name>.
+        const goalName = sub;
+        const g = goalsMod.getGoal(goalName, cfgDir);
+        if (!g) {
+          process.stdout.write(`no goal "${goalName}" — try: /goal add ${goalName} --desc "..."\n`);
+          return true;
+        }
+        if (g.status !== 'active') {
+          process.stdout.write(`goal "${goalName}" is ${g.status}; cannot switch\n`);
+          return true;
+        }
+        // Switch: replace the chat's active session id and reload turns
+        // from the goal's session. The provider, model, workspace, and
+        // skill state stay put — only the conversation surface changes.
+        sessionId = g.sessionId;
+        activeGoalName = g.name;
+        const prior = sessionsMod.loadTurns(sessionId, cfgDir);
+        messages = prior.map(t => ({ role: t.role, content: t.content }));
+        // Prepend a one-line goal note to the system message so the
+        // model sees the current objective without us having to mutate
+        // any persistent record on every switch.
+        const sysIdx = messages.findIndex(m => m.role === 'system');
+        const goalNote = `## Goal: ${g.description || g.name}`;
+        if (sysIdx >= 0) {
+          messages[sysIdx] = { role: 'system', content: `${goalNote}\n\n${messages[sysIdx].content}` };
+        } else {
+          messages.unshift({ role: 'system', content: goalNote });
+        }
+        process.stdout.write(`✓ switched to goal: ${g.name} (session: ${sessionId}, ${prior.length} prior turn(s))\n`);
+        return true;
+      }
+      case '/memory': {
+        const arg = line.slice('/memory'.length).trim();
+        const memMod = await import('./memory.mjs');
+        const tokens = arg.split(/\s+/).filter(Boolean);
+        const which = tokens[0] || 'core';
+        if (which === 'core') {
+          const body = memMod.loadCore(cfgDir);
+          process.stdout.write(body || '(empty core memory)\n');
+          return true;
+        }
+        if (which === 'recent') {
+          const items = memMod.loadRecent(20, cfgDir);
+          process.stdout.write(JSON.stringify(items, null, 2) + '\n');
+          return true;
+        }
+        if (which === 'episodic') {
+          const topic = tokens[1];
+          if (topic) {
+            const body = memMod.loadEpisodic(topic, cfgDir);
+            process.stdout.write(body || `(no episodic file "${topic}")\n`);
+          } else {
+            process.stdout.write(JSON.stringify(memMod.listEpisodic(cfgDir), null, 2) + '\n');
+          }
+          return true;
+        }
+        process.stdout.write('usage: /memory [core|recent|episodic [topic]]\n');
+        return true;
+      }
+      case '/dream': {
+        const memMod = await import('./memory.mjs');
+        process.stdout.write('  ↯ dreaming…\n');
+        try {
+          const r = await memMod.dream(sessionId, {
+            provider: prov,
+            model: activeModel,
+            apiKey: _resolveAuthKey(cfg, activeProvName),
+          }, cfgDir);
+          process.stdout.write(`✓ wrote ${r.topics.length} episodic file(s): ${r.topics.join(', ') || '(none)'}\n`);
+        } catch (e) { process.stdout.write(`dream error: ${e?.message || e}\n`); }
+        return true;
+      }
+      case '/agent': {
+        const rawArg = line.slice('/agent'.length).trim();
+        const agentsMod = await import('./agents.mjs');
+        const loopMod = await import('./loop-engine.mjs');
+        let tokens;
+        try { tokens = loopMod.splitArgs(rawArg); }
+        catch (e) { process.stdout.write(`/agent error: ${e?.message || e}\n`); return true; }
+        const sub = tokens[0];
+        const rest = tokens.slice(1);
+        const aname = rest[0];
+        try {
+          if (!sub || sub === 'list') {
+            const agents = agentsMod.listAgents(cfgDir);
+            if (agents.length === 0) process.stdout.write('no agents registered. /agent add <name> [...] to create.\n');
+            else for (const a of agents) {
+              const provLine = a.model ? `${a.provider}/${a.model}` : a.provider;
+              process.stdout.write(`• ${a.name} — ${a.displayName} — ${provLine} — tools=[${(a.tools || []).join(',')}]\n`);
+            }
+          } else if (sub === 'show') {
+            if (!aname) { process.stdout.write('usage: /agent show <name>\n'); return true; }
+            const a = agentsMod.getAgent(aname, cfgDir);
+            if (!a) process.stdout.write(`no agent "${aname}"\n`);
+            else process.stdout.write(JSON.stringify(a, null, 2) + '\n');
+          } else if (sub === 'add') {
+            if (!aname) { process.stdout.write('usage: /agent add <name> [role text…]\n'); return true; }
+            const roleText = rest.slice(1).join(' ').trim();
+            const a = agentsMod.registerAgent({ name: aname, role: roleText }, cfgDir);
+            process.stdout.write(`✓ added agent ${a.name} (tools=${a.tools.join(',')})\n`);
+          } else if (sub === 'remove' || sub === 'rm' || sub === 'delete') {
+            if (!aname) { process.stdout.write('usage: /agent remove <name>\n'); return true; }
+            agentsMod.removeAgent(aname, cfgDir);
+            process.stdout.write(`✓ removed agent ${aname}\n`);
+          } else {
+            process.stdout.write(`/agent: unknown sub "${sub}" — list|show|add|remove\n`);
+          }
+        } catch (e) {
+          process.stdout.write(`/agent error: ${e?.message || e}\n`);
+        }
+        return true;
+      }
+      case '/team': {
+        const rawArg = line.slice('/team'.length).trim();
+        const teamsMod = await import('./teams.mjs');
+        const loopMod = await import('./loop-engine.mjs');
+        let tokens;
+        try { tokens = loopMod.splitArgs(rawArg); }
+        catch (e) { process.stdout.write(`/team error: ${e?.message || e}\n`); return true; }
+        const sub = tokens[0];
+        const rest = tokens.slice(1);
+        const tname = rest[0];
+        try {
+          if (!sub || sub === 'list') {
+            const teams = teamsMod.listTeams(cfgDir);
+            if (teams.length === 0) process.stdout.write('no teams registered. /team add <name> --agents a,b --lead a [--channel #x]\n');
+            else for (const t of teams) {
+              const chLine = t.slackChannel ? ` — ${t.slackChannel}` : '';
+              process.stdout.write(`• ${t.name} — ${t.displayName} — lead=${t.lead} — agents=[${t.agents.join(',')}]${chLine}\n`);
+            }
+          } else if (sub === 'show') {
+            if (!tname) { process.stdout.write('usage: /team show <name>\n'); return true; }
+            const t = teamsMod.getTeam(tname, cfgDir);
+            if (!t) process.stdout.write(`no team "${tname}"\n`);
+            else process.stdout.write(JSON.stringify(t, null, 2) + '\n');
+          } else if (sub === 'add') {
+            // /team add <name> --agents a,b,c [--lead a] [--channel #x]
+            if (!tname) { process.stdout.write('usage: /team add <name> --agents a,b,c [--lead a] [--channel #x]\n'); return true; }
+            let agentsCsv = null, lead = null, channel = '';
+            for (let i = 1; i < rest.length; i++) {
+              const t = rest[i];
+              if (t === '--agents') agentsCsv = rest[++i] || '';
+              else if (t === '--lead') lead = rest[++i] || null;
+              else if (t === '--channel') channel = rest[++i] || '';
+              else { process.stdout.write(`/team error: unknown token "${t}"\n`); return true; }
+            }
+            if (!agentsCsv) { process.stdout.write('/team add: --agents is required\n'); return true; }
+            const agents = teamsMod.parseListFlag(agentsCsv);
+            const ch = channel ? await teamsMod.resolveSlackChannel(channel, {
+              botToken: process.env.SLACK_BOT_TOKEN || null,
+              apiBase: process.env.SLACK_API_BASE || 'https://slack.com/api',
+              logger: () => {},
+            }) : '';
+            const team = teamsMod.registerTeam({ name: tname, agents, lead, slackChannel: ch }, cfgDir);
+            process.stdout.write(`✓ added team ${team.name} (lead=${team.lead}, agents=${team.agents.join(',')})\n`);
+          } else if (sub === 'remove' || sub === 'rm' || sub === 'delete') {
+            if (!tname) { process.stdout.write('usage: /team remove <name>\n'); return true; }
+            teamsMod.removeTeam(tname, cfgDir);
+            process.stdout.write(`✓ removed team ${tname}\n`);
+          } else {
+            process.stdout.write(`/team: unknown sub "${sub}" — list|show|add|remove\n`);
+          }
+        } catch (e) {
+          process.stdout.write(`/team error: ${e?.message || e}\n`);
+        }
+        return true;
+      }
       case '/exit': {
         return 'EXIT';
       }
@@ -3483,6 +3800,1125 @@ async function cmdCron(sub, positional, flags = {}) {
   }
 }
 
+// `lazyclaw loop <prompt> [--max N] [--until "<regex>"] [--session ID]
+//                 [--detach] [--provider NAME] [--model NAME]`
+//
+// Without --detach: runs the loop in the foreground using the engine
+// from loop-engine.mjs and streams chunks to stdout (mirrors the REPL
+// /loop UX but with no surrounding chat REPL).
+//
+// With --detach: forks scripts/loop-worker.mjs in its own process group
+// (`detached: true`), prints `{loopId, pid, statePath}` and returns
+// immediately. The worker persists state under `<configDir>/loops/<id>/`.
+async function cmdLoop(prompt, flags = {}) {
+  await ensureRegistry();
+  const cfg = readConfig();
+  const cfgDir = path.dirname(configPath());
+  const loopEng = await import('./loop-engine.mjs');
+  const loopsMod = await import('./loops.mjs');
+
+  if (!prompt || typeof prompt !== 'string' || !prompt.trim()) {
+    console.error('Usage: lazyclaw loop <prompt> [--max N] [--until "<regex>"] [--session ID] [--detach]');
+    process.exit(2);
+  }
+  const max = flags.max !== undefined ? Number(flags.max) : loopEng.LOOP_MAX_DEFAULT;
+  if (!Number.isInteger(max) || max <= 0) {
+    console.error(`loop: --max must be a positive integer, got "${flags.max}"`);
+    process.exit(2);
+  }
+  if (max > loopEng.LOOP_MAX_CEILING) {
+    console.error(`loop: --max ${max} exceeds ceiling ${loopEng.LOOP_MAX_CEILING} (runaway guard)`);
+    process.exit(2);
+  }
+  let untilRe = null;
+  try { untilRe = loopEng.compileUntil(flags.until); }
+  catch (e) { console.error(`loop: ${e?.message || e}`); process.exit(2); }
+
+  const provName = flags.provider || cfg.provider || 'mock';
+  const prov = _registryMod.PROVIDERS[provName];
+  if (!prov) { console.error(`unknown provider: ${provName}`); process.exit(2); }
+  const model = flags.model || cfg.model;
+
+  const loopId = loopsMod.newLoopId();
+  const requestedSession = flags.session ? String(flags.session) : null;
+  const sessionId = requestedSession || `loop:${loopId}`;
+  const statePath = loopsMod.loopDir(loopId, cfgDir);
+
+  // Seed meta before forking so `loops list` can see the job even if the
+  // worker hasn't reached its first iteration yet.
+  loopsMod.writeMeta(loopId, {
+    prompt,
+    max,
+    until: flags.until || null,
+    sessionId,
+    sessionMode: requestedSession ? 'shared' : 'fresh',
+    provider: provName,
+    model: model || null,
+    status: 'pending',
+    startedAt: new Date().toISOString(),
+    pid: null,
+  }, cfgDir);
+
+  if (flags.detach) {
+    const { spawn } = await import('node:child_process');
+    const here = path.dirname(new URL(import.meta.url).pathname);
+    const worker = path.join(here, 'scripts', 'loop-worker.mjs');
+    const argv = [worker, '--loop-id', loopId, '--prompt', prompt,
+      '--max', String(max), '--provider', provName, '--cfg-dir', cfgDir];
+    if (flags.until) { argv.push('--until', String(flags.until)); }
+    if (requestedSession) { argv.push('--session-existing', requestedSession); }
+    if (model) { argv.push('--model', String(model)); }
+    const child = spawn(process.execPath, argv, {
+      detached: true,
+      stdio: 'ignore',
+      env: { ...process.env, LAZYCLAW_CONFIG_DIR: cfgDir },
+    });
+    child.unref();
+    loopsMod.patchMeta(loopId, { pid: child.pid, pgid: child.pid, status: 'running' }, cfgDir);
+    process.stdout.write(JSON.stringify({ loopId, pid: child.pid, statePath }) + '\n');
+    return;
+  }
+
+  // Foreground path — same engine, streaming chunks live to stdout.
+  const sessionsMod = await import('./sessions.mjs');
+  const messages = requestedSession
+    ? sessionsMod.loadTurns(sessionId, cfgDir).map(t => ({ role: t.role, content: t.content }))
+    : [];
+  loopsMod.patchMeta(loopId, { pid: process.pid, status: 'running' }, cfgDir);
+
+  const ac = new AbortController();
+  const onSig = () => ac.abort();
+  process.on('SIGINT', onSig);
+  process.on('SIGTERM', onSig);
+
+  const sendOnce = async (msgs, signal) => {
+    let acc = '';
+    for await (const chunk of prov.sendMessage(msgs, {
+      apiKey: _resolveAuthKey(cfg, provName),
+      model,
+      signal,
+    })) {
+      process.stdout.write(chunk);
+      acc += chunk;
+    }
+    process.stdout.write('\n');
+    return acc;
+  };
+  const persist = (role, content) => sessionsMod.appendTurn(sessionId, role, content, cfgDir);
+  const onIteration = ({ i, max: m, reply }) => {
+    process.stderr.write(`  ↻ loop iteration ${i}/${m}\n`);
+    loopsMod.appendIteration(loopId, { iteration: i, of: m, bytes: reply.length, preview: reply.slice(0, 200) }, cfgDir);
+  };
+
+  // Detached/foreground both honor --use-memory and --recall by
+  // rebuilding the system message before each iteration. The
+  // computation lives in memory.mjs so the same logic powers
+  // `/loop --use-memory` in the REPL.
+  const memMod = (flags['use-memory'] || flags.recall) ? await import('./memory.mjs') : null;
+  const buildSystem = memMod ? (() => {
+    const parts = [];
+    if (flags['use-memory']) {
+      const core = memMod.loadCore(cfgDir);
+      if (core && core.trim()) parts.push(core);
+    }
+    if (flags.recall) {
+      const text = memMod.recall(String(flags.recall), { topN: 3 }, cfgDir);
+      if (text && text.trim()) parts.push(text);
+    }
+    return parts.join('\n\n---\n\n');
+  }) : null;
+
+  try {
+    const result = await loopEng.runLoop({ prompt, max, until: untilRe, messages, sendOnce, persist, onIteration, signal: ac.signal, buildSystem });
+    const finalStatus = result.stoppedBy === 'abort' ? 'killed' : 'completed';
+    loopsMod.patchMeta(loopId, { status: finalStatus, finishedAt: new Date().toISOString() }, cfgDir);
+    loopsMod.writeResult(loopId, result, cfgDir);
+    process.stdout.write(JSON.stringify({ loopId, ...result }) + '\n');
+  } catch (err) {
+    loopsMod.patchMeta(loopId, { status: 'failed', finishedAt: new Date().toISOString() }, cfgDir);
+    loopsMod.writeResult(loopId, { error: err?.message || String(err) }, cfgDir);
+    console.error(`loop error: ${err?.message || err}`);
+    process.exit(1);
+  } finally {
+    process.off('SIGINT', onSig);
+    process.off('SIGTERM', onSig);
+  }
+}
+
+// Kill registry — `lazyclaw loops kill <id>` SIGTERMs once and SIGKILLs
+// on a second invocation within KILL_ESCALATE_MS. Module-scoped so two
+// rapid invocations of `cmd loops kill <id>` from the same process see
+// each other; for separate processes the worker also handles SIGKILL by
+// the OS, so the escalation is a UX nicety rather than a correctness gate.
+const _killLog = new Map();
+const KILL_ESCALATE_MS = 5000;
+
+async function cmdLoops(sub, positional, flags = {}) {
+  const loopsMod = await import('./loops.mjs');
+  const cfgDir = path.dirname(configPath());
+  switch (sub) {
+    case undefined:
+    case 'list': {
+      const items = loopsMod.listLoops(cfgDir).map(loopsMod.reconcileStatus);
+      console.log(JSON.stringify(items, null, 2));
+      return;
+    }
+    case 'show': {
+      const id = positional[0];
+      if (!id) { console.error('Usage: lazyclaw loops show <id>'); process.exit(2); }
+      const meta = loopsMod.reconcileStatus(loopsMod.readMeta(id, cfgDir));
+      if (!meta) { console.error(`no loop "${id}"`); process.exit(1); }
+      const iterations = loopsMod.readIterations(id, cfgDir);
+      const result = loopsMod.readResult(id, cfgDir);
+      console.log(JSON.stringify({ id, meta, iterations, result }, null, 2));
+      return;
+    }
+    case 'kill': {
+      const id = positional[0];
+      if (!id) { console.error('Usage: lazyclaw loops kill <id>'); process.exit(2); }
+      const meta = loopsMod.readMeta(id, cfgDir);
+      if (!meta) { console.error(`no loop "${id}"`); process.exit(1); }
+      if (!meta.pid) { console.error(`loop "${id}" has no pid`); process.exit(1); }
+      const last = _killLog.get(id) || 0;
+      const now = Date.now();
+      const escalate = (now - last) < KILL_ESCALATE_MS && last > 0;
+      const sig = escalate ? 'SIGKILL' : 'SIGTERM';
+      try { process.kill(meta.pid, sig); }
+      catch (e) {
+        if (e?.code !== 'ESRCH') throw e;
+        // Already gone — reconcile and report.
+        loopsMod.patchMeta(id, { status: 'killed', finishedAt: new Date().toISOString() }, cfgDir);
+        console.log(JSON.stringify({ id, pid: meta.pid, signal: sig, status: 'already_gone' }));
+        return;
+      }
+      _killLog.set(id, now);
+      console.log(JSON.stringify({ id, pid: meta.pid, signal: sig, escalated: escalate }));
+      return;
+    }
+    case 'tail': {
+      const id = positional[0];
+      if (!id) { console.error('Usage: lazyclaw loops tail <id>'); process.exit(2); }
+      const dir = loopsMod.loopDir(id, cfgDir);
+      const logPath = path.join(dir, 'iterations.log');
+      const fs = await import('node:fs');
+      if (!fs.existsSync(dir)) { console.error(`no loop "${id}"`); process.exit(1); }
+      // Print everything already on disk first, then poll for new lines
+      // until the worker exits / status is no longer "running".
+      let offset = 0;
+      if (fs.existsSync(logPath)) {
+        const buf = fs.readFileSync(logPath, 'utf8');
+        process.stdout.write(buf);
+        offset = buf.length;
+      }
+      const pollMs = Number(flags['poll-ms']) || 250;
+      const maxMs = Number(flags['max-wait-ms']) || 0; // 0 = wait indefinitely
+      const startedAt = Date.now();
+      while (true) {
+        await new Promise(r => setTimeout(r, pollMs));
+        let cur = '';
+        try { cur = fs.readFileSync(logPath, 'utf8'); } catch { /* file may briefly not exist */ }
+        if (cur.length > offset) {
+          process.stdout.write(cur.slice(offset));
+          offset = cur.length;
+        }
+        const meta = loopsMod.reconcileStatus(loopsMod.readMeta(id, cfgDir));
+        if (!meta || meta.status !== 'running') break;
+        if (maxMs > 0 && Date.now() - startedAt > maxMs) break;
+      }
+      return;
+    }
+    default:
+      console.error('Usage: lazyclaw loops <list|show|kill|tail> ...');
+      process.exit(2);
+  }
+}
+
+// Install (or refresh) the system scheduler entry that fires
+// `lazyclaw goal tick <name>` on a schedule. Writes to cfg.cron and to
+// the OS backend (launchd / crontab). Tests set
+// LAZYCLAW_SKIP_CRON_INSTALL=1 to skip the OS-side mutation but keep
+// the config-side wiring so `cron list` still reflects the entry.
+async function _attachGoalCron(name, schedule) {
+  const cron = await import('./cron.mjs');
+  cron.parseCronSpec(schedule); // validate before we touch state
+  const cfg = readConfig();
+  const jobName = `goal-${name}`;
+  const cmd = ['lazyclaw', 'goal', 'tick', name];
+  cron.upsertJob(cfg, jobName, schedule, cmd);
+  writeConfig(cfg);
+  if (process.env.LAZYCLAW_SKIP_CRON_INSTALL) return { jobName, skipped: true };
+  const backend = cron.pickBackend();
+  if (backend === 'launchd') cron.installLaunchdJob(jobName, schedule, cmd);
+  else cron.installCrontabJob(jobName, schedule, cmd);
+  return { jobName, skipped: false };
+}
+
+// Mirror of _attachGoalCron's removal path. Returns true when an entry
+// was actually present; false when the goal had no cron attached
+// (already-clean state, safe to call unconditionally during `close`).
+async function _detachGoalCron(name) {
+  const cron = await import('./cron.mjs');
+  const cfg = readConfig();
+  const jobName = `goal-${name}`;
+  if (!cfg.cron || !cfg.cron[jobName]) return false;
+  cron.removeJob(cfg, jobName);
+  writeConfig(cfg);
+  if (process.env.LAZYCLAW_SKIP_CRON_INSTALL) return true;
+  const backend = cron.pickBackend();
+  try {
+    if (backend === 'launchd') cron.uninstallLaunchdJob(jobName);
+    else cron.uninstallCrontabJob(jobName);
+  } catch { /* best-effort — cron sync recovers */ }
+  return true;
+}
+
+// Builds the user-side prompt the scheduler sends on every tick. Memory
+// (core + episodic matches) lands in the system slot via Phase 6's
+// buildSystem path, not here — that way a parallel writer touching
+// core.md mid-loop is reflected on the next iteration without us
+// having to rebuild this string.
+function _composeTickPrompt(goal) {
+  const parts = [];
+  parts.push(`Goal: ${goal.description || goal.name}`);
+  const recent = (goal.checkIns || []).slice(-3);
+  if (recent.length) {
+    parts.push('Recent check-ins:');
+    for (const c of recent) parts.push(`- ${c.at}: ${c.summary}`);
+  }
+  parts.push("What's the next concrete step?");
+  return parts.join('\n\n');
+}
+
+// `lazyclaw goal <add|list|show|close|switch|tick|channel> ...`
+//
+// Pure registration in Phase 3 (no cron install, no channel delivery —
+// those land in Phase 4 / Phase 8). `switch` is a no-op for the
+// detached CLI surface; it exists for symmetry with the REPL command
+// (where it changes the chat's working session) and writes nothing
+// special when invoked here — the user gets a hint pointing at /goal.
+async function cmdGoal(sub, positional, flags = {}) {
+  const goalsMod = await import('./goals.mjs');
+  const cfgDir = path.dirname(configPath());
+  switch (sub) {
+    case 'add': {
+      const name = positional[0];
+      if (!name) { console.error('Usage: lazyclaw goal add <name> [--desc "..."] [--cron "<spec>"] [--channel slack:<target>]'); process.exit(2); }
+      let g;
+      const channels = flags.channel ? [String(flags.channel)] : [];
+      try {
+        g = goalsMod.registerGoal({
+          name,
+          description: flags.desc || '',
+          schedule: flags.cron || null,
+          channels,
+        }, cfgDir);
+      } catch (e) { console.error(e?.message || e); process.exit(2); }
+      if (flags.cron) {
+        try { await _attachGoalCron(name, String(flags.cron)); }
+        catch (e) { console.error(`error attaching cron: ${e?.message || e}`); process.exit(1); }
+      }
+      console.log(JSON.stringify(g, null, 2));
+      return;
+    }
+    case undefined:
+    case 'list': {
+      const items = goalsMod.listGoals(cfgDir);
+      console.log(JSON.stringify(items, null, 2));
+      return;
+    }
+    case 'show': {
+      const name = positional[0];
+      if (!name) { console.error('Usage: lazyclaw goal show <name>'); process.exit(2); }
+      const g = goalsMod.getGoal(name, cfgDir);
+      if (!g) { console.error(`no goal "${name}"`); process.exit(1); }
+      console.log(JSON.stringify(g, null, 2));
+      return;
+    }
+    case 'close': {
+      const name = positional[0];
+      const outcome = positional[1] || 'done';
+      if (!name) { console.error('Usage: lazyclaw goal close <name> [done|abandoned]'); process.exit(2); }
+      let g;
+      try { g = goalsMod.closeGoal(name, outcome, cfgDir); }
+      catch (e) { console.error(e?.message || e); process.exit(1); }
+      // Best-effort cron detach. If the goal had no cron attached this
+      // is a no-op; if it did, both cfg.cron and the OS scheduler are
+      // cleaned in tandem so a follow-up `cron list` is empty.
+      try { await _detachGoalCron(name); }
+      catch (e) { console.error(`warn: cron detach failed: ${e?.message || e}`); }
+      console.log(JSON.stringify(g, null, 2));
+      return;
+    }
+    case 'tick': {
+      // Internal subcommand fired by the cron scheduler (or manually
+      // with --force). Exits 0 silently when the goal is not active so
+      // a stale cron entry doesn't crash the scheduler.
+      const name = positional[0];
+      if (!name) { console.error('Usage: lazyclaw goal tick <name> [--force]'); process.exit(2); }
+      const g = goalsMod.getGoal(name, cfgDir);
+      if (!g) {
+        // No goal file at all — exit 0 silently. The scheduler may be
+        // chasing a deleted goal; we don't want to noisy-log the cron
+        // path. Setting LAZYCLAW_DEBUG=1 surfaces it.
+        if (process.env.LAZYCLAW_DEBUG) console.error(`tick: no goal "${name}"`);
+        return;
+      }
+      if (g.status !== 'active') {
+        if (process.env.LAZYCLAW_DEBUG) console.error(`tick: goal "${name}" is ${g.status}, skipping`);
+        return;
+      }
+      await ensureRegistry();
+      const cfg = readConfig();
+      const provName = flags.provider || cfg.provider || 'mock';
+      const prov = _registryMod.PROVIDERS[provName];
+      if (!prov) { console.error(`unknown provider: ${provName}`); process.exit(2); }
+      const model = flags.model || cfg.model;
+
+      const memoryMod = await import('./memory.mjs');
+      const tickPrompt = _composeTickPrompt(g);
+      // Memory flows into the system slot. Per-iter rebuild is a no-op
+      // here (max=1) but matches Phase 6's contract so a future tick
+      // with max>1 behaves the same as `/loop --use-memory`.
+      const tickBuildSystem = () => memoryMod.getMemoryForGoal(g.name, g.description || '', cfgDir);
+      const loopEng = await import('./loop-engine.mjs');
+      const sessionsMod = await import('./sessions.mjs');
+      const sessionId = g.sessionId;
+      // Rehydrate prior turns so the model has full context. Tick
+      // appends the user prompt and assistant reply to this session
+      // just like `/loop --max 1` would.
+      const messages = sessionsMod.loadTurns(sessionId, cfgDir).map(t => ({ role: t.role, content: t.content }));
+
+      const sendOnce = async (msgs, signal) => {
+        let acc = '';
+        for await (const chunk of prov.sendMessage(msgs, {
+          apiKey: _resolveAuthKey(cfg, provName),
+          model,
+          signal,
+        })) {
+          acc += chunk;
+        }
+        return acc;
+      };
+      const persist = (role, content) => sessionsMod.appendTurn(sessionId, role, content, cfgDir);
+
+      let result;
+      try {
+        result = await loopEng.runLoop({
+          prompt: tickPrompt,
+          max: 1,
+          until: null,
+          messages,
+          sendOnce,
+          persist,
+          onIteration: undefined,
+          signal: undefined,
+          buildSystem: tickBuildSystem,
+        });
+      } catch (e) {
+        console.error(`tick error: ${e?.message || e}`);
+        process.exit(1);
+      }
+      goalsMod.appendCheckIn(name, result.lastReply, cfgDir);
+      // Fan-out the check-in to every registered channel. We re-read
+      // the goal to capture the freshly-appended checkIn count so the
+      // fan-out body has the canonical timestamp.
+      const refreshed = goalsMod.getGoal(name, cfgDir);
+      const channels = Array.isArray(refreshed?.channels) ? refreshed.channels : [];
+      const slackTargets = channels.filter(c => typeof c === 'string' && c.startsWith('slack:'));
+      const fanoutResults = [];
+      if (slackTargets.length > 0) {
+        // Lazy import so plain non-slack tick paths don't pay the cost.
+        const slackMod = await import('./channels/slack.mjs');
+        let slack;
+        try {
+          slack = new slackMod.SlackChannel({ requireInbound: false });
+          // Validate env BEFORE start() so a missing-secrets environment
+          // does not silently skip — instead the operator sees a clear
+          // warning and tick still succeeds (the check-in is on disk).
+          await slack.start(async () => '', { gate: null });
+        } catch (e) {
+          console.error(`warn: skipping Slack fan-out: ${e?.message || e}`);
+          slack = null;
+        }
+        if (slack) {
+          for (const target of slackTargets) {
+            const channel = target.slice('slack:'.length);
+            try {
+              await slack.send(channel, result.lastReply);
+              fanoutResults.push({ channel: target, ok: true });
+            } catch (e) {
+              fanoutResults.push({ channel: target, ok: false, error: e?.message || String(e) });
+            }
+          }
+          try { await slack.stop(); } catch { /* best-effort */ }
+        }
+      }
+      console.log(JSON.stringify({ ok: true, name, iterations: result.iterations, reply: result.lastReply, fanout: fanoutResults }));
+      return;
+    }
+    case 'switch': {
+      const name = positional[0];
+      if (!name) { console.error('Usage: lazyclaw goal switch <name>'); process.exit(2); }
+      const g = goalsMod.getGoal(name, cfgDir);
+      if (!g) { console.error(`no goal "${name}"`); process.exit(1); }
+      // Non-interactive surface: print the session id so a caller can
+      // pipe it into `lazyclaw chat --session <id>`. The REPL slash form
+      // is what mutates state in a live chat.
+      console.log(JSON.stringify({ name: g.name, sessionId: g.sessionId, status: g.status }));
+      return;
+    }
+    case 'channel': {
+      const op = positional[0];
+      const name = positional[1];
+      const target = positional[2];
+      if (!op || !name) { console.error('Usage: lazyclaw goal channel <add|remove> <name> [target]'); process.exit(2); }
+      const g = goalsMod.getGoal(name, cfgDir);
+      if (!g) { console.error(`no goal "${name}"`); process.exit(1); }
+      const cur = Array.isArray(g.channels) ? g.channels : [];
+      let next;
+      if (op === 'add') {
+        if (!target) { console.error('Usage: lazyclaw goal channel add <name> <target>'); process.exit(2); }
+        next = Array.from(new Set([...cur, target]));
+      } else if (op === 'remove') {
+        if (!target) { console.error('Usage: lazyclaw goal channel remove <name> <target>'); process.exit(2); }
+        next = cur.filter(t => t !== target);
+      } else {
+        console.error('Usage: lazyclaw goal channel <add|remove> <name> <target>'); process.exit(2);
+        return;
+      }
+      const updated = goalsMod.patchGoal(name, { channels: next }, cfgDir);
+      console.log(JSON.stringify({ name: updated.name, channels: updated.channels }));
+      return;
+    }
+    default:
+      console.error('Usage: lazyclaw goal <add|list|show|close|switch> ...');
+      process.exit(2);
+  }
+}
+
+// `lazyclaw memory <show|dream|edit> [args]`
+//
+// show core|recent|episodic [topic]    print contents to stdout
+// dream                                consolidate recent into episodic
+// edit core                            open $EDITOR on core.md
+async function cmdMemory(sub, positional, flags = {}) {
+  const memMod = await import('./memory.mjs');
+  const cfgDir = path.dirname(configPath());
+  switch (sub) {
+    case undefined:
+    case 'show': {
+      const which = positional[0] || 'core';
+      if (which === 'core') {
+        process.stdout.write(memMod.loadCore(cfgDir));
+        return;
+      }
+      if (which === 'recent') {
+        const n = flags.n !== undefined ? Number(flags.n) : 20;
+        console.log(JSON.stringify(memMod.loadRecent(n, cfgDir), null, 2));
+        return;
+      }
+      if (which === 'episodic') {
+        const topic = positional[1];
+        if (topic) { process.stdout.write(memMod.loadEpisodic(topic, cfgDir)); return; }
+        console.log(JSON.stringify(memMod.listEpisodic(cfgDir), null, 2));
+        return;
+      }
+      console.error(`unknown memory.show target: ${which} (expected: core, recent, episodic)`);
+      process.exit(2);
+      return;
+    }
+    case 'dream': {
+      await ensureRegistry();
+      const cfg = readConfig();
+      const provName = flags.provider || cfg.provider || 'mock';
+      const prov = _registryMod.PROVIDERS[provName];
+      if (!prov) { console.error(`unknown provider: ${provName}`); process.exit(2); }
+      const sid = positional[0] || flags.session || null;
+      try {
+        const result = await memMod.dream(sid, {
+          provider: prov,
+          model: flags.model || cfg.model,
+          apiKey: _resolveAuthKey(cfg, provName),
+        }, cfgDir);
+        console.log(JSON.stringify({ ok: true, ...result }, null, 2));
+      } catch (e) { console.error(`dream error: ${e?.message || e}`); process.exit(1); }
+      return;
+    }
+    case 'edit': {
+      const which = positional[0] || 'core';
+      if (which !== 'core') {
+        console.error('Only core.md is editable right now (episodic is LLM-curated, recent is append-only)');
+        process.exit(2);
+      }
+      const p = memMod.corePath(cfgDir);
+      const fs_ = await import('node:fs');
+      fs_.mkdirSync(memMod.memoryDir(cfgDir), { recursive: true });
+      if (!fs_.existsSync(p)) fs_.writeFileSync(p, '');
+      const editor = process.env.EDITOR || 'vi';
+      const { spawnSync } = await import('node:child_process');
+      // EDITOR=cat is the test-only escape hatch: spawnSync with stdio
+      // inherit makes the file's contents land on stdout and the
+      // command exits 0 without blocking.
+      const r = spawnSync(editor, [p], { stdio: 'inherit' });
+      if (r.status !== 0 && r.status !== null) {
+        console.error(`editor exited ${r.status}`);
+        process.exit(r.status);
+      }
+      return;
+    }
+    default:
+      console.error('Usage: lazyclaw memory <show|dream|edit> ...');
+      process.exit(2);
+  }
+}
+
+const AGENT_REG_SUBS = new Set(['add', 'list', 'show', 'edit', 'remove', 'rm', 'delete', 'memory', 'reflect']);
+const TEAM_SUBS = new Set(['add', 'list', 'show', 'edit', 'remove', 'rm', 'delete']);
+const TASK_SUBS = new Set(['start', 'tick', 'list', 'show', 'abandon', 'done', 'transcript', 'remove', 'rm', 'delete']);
+
+async function cmdTask(sub, positional, flags = {}) {
+  const tasksMod = await import('./tasks.mjs');
+  const teamsMod = await import('./teams.mjs');
+  const agentsMod = await import('./agents.mjs');
+  const cfgDir = path.dirname(configPath());
+  const idOrFirst = positional[0];
+
+  const emitJson = (obj) => process.stdout.write(JSON.stringify(obj, null, 2) + '\n');
+
+  // Open a thread root in Slack and return its ts (or '' if we deliberately
+  // skipped posting). Caller decides what to do with the ts.
+  const postKickoff = async ({ task, team, leadAgent }) => {
+    if (!task.slackChannel) {
+      process.stderr.write('[task] team has no slackChannel — skipping Slack post\n');
+      return '';
+    }
+    try { _loadDotenvIfAny(cfgDir); } catch { /* best-effort */ }
+    const { SlackChannel } = await import('./channels/slack.mjs');
+    const slack = new SlackChannel({ requireInbound: false });
+    try {
+      await slack.start(async () => '', {});
+    } catch (err) {
+      if (err?.code === 'SLACK_MISSING_ENV') {
+        throw new Error(`SLACK_BOT_TOKEN missing — set it in ${path.join(cfgDir, '.env')} or unset team.slackChannel`);
+      }
+      throw err;
+    }
+    try {
+      const text = tasksMod.buildKickoffMessage({
+        id: task.id,
+        title: task.title,
+        description: task.description,
+        leadDisplayName: leadAgent?.displayName || task.lead,
+        teamDisplayName: team.displayName || team.name,
+      });
+      const res = await slack.send(task.slackChannel, text);
+      return res?.ts || '';
+    } finally {
+      await slack.stop().catch(() => {});
+    }
+  };
+
+  switch (sub) {
+    case undefined:
+    case 'list': {
+      emitJson(tasksMod.listTasks(cfgDir));
+      return;
+    }
+    case 'start': {
+      const teamName = flags.team;
+      const title = flags.title;
+      if (!teamName || !title) {
+        console.error('Usage: lazyclaw task start --team <team> --title "..." [--description "..."] [--lead <agent>]');
+        process.exit(2);
+      }
+      try {
+        const team = teamsMod.getTeam(teamName, cfgDir);
+        if (!team) { console.error(`task start: no team "${teamName}"`); process.exit(2); }
+        const leadName = flags.lead || team.lead;
+        const leadAgent = agentsMod.getAgent(leadName, cfgDir);
+        // Create the task record first (status=pending) so we can roll its
+        // id into the Slack message; then post and patch in the ts.
+        const seeded = tasksMod.registerTask({
+          title,
+          description: flags.description || '',
+          team: teamName,
+          lead: leadName,
+          slackChannel: team.slackChannel,
+          status: 'pending',
+        }, cfgDir);
+        let ts = '';
+        try {
+          ts = await postKickoff({ task: seeded, team, leadAgent });
+        } catch (err) {
+          // Rollback so we don't leave orphan task records when the post fails.
+          try { tasksMod.removeTask(seeded.id, cfgDir); } catch { /* best-effort */ }
+          console.error(`task start: ${err?.message || err}`);
+          process.exit(2);
+        }
+        const turns = ts ? [{ agent: 'system', text: `Task opened by user. Lead: ${leadName}.`, ts }] : [];
+        const finalTask = tasksMod.patchTask(seeded.id, {
+          slackThreadTs: ts,
+          status: ts ? 'running' : 'pending',
+          turns,
+        }, cfgDir);
+        emitJson(finalTask);
+      } catch (err) {
+        console.error(`task start: ${err?.message || err}`);
+        process.exit(2);
+      }
+      return;
+    }
+    case 'show': {
+      if (!idOrFirst) { console.error('Usage: lazyclaw task show <id>'); process.exit(2); }
+      const t = tasksMod.getTask(idOrFirst, cfgDir);
+      if (!t) { console.error(`task show: no task "${idOrFirst}"`); process.exit(2); }
+      emitJson(t);
+      return;
+    }
+    case 'tick': {
+      const id = idOrFirst;
+      const userMsg = positional.slice(1).join(' ').trim() || flags.message || '';
+      if (!id) { console.error('Usage: lazyclaw task tick <id> [<user message>]'); process.exit(2); }
+      const task = tasksMod.getTask(id, cfgDir);
+      if (!task) { console.error(`task tick: no task "${id}"`); process.exit(2); }
+      const team = teamsMod.getTeam(task.team, cfgDir);
+      if (!team) { console.error(`task tick: team "${task.team}" disappeared`); process.exit(2); }
+      // Load all team agents in one shot — the router needs to dispatch
+      // tool-use turns through each speaker's record.
+      const agentsById = {};
+      for (const name of team.agents) {
+        const rec = agentsMod.getAgent(name, cfgDir);
+        if (!rec) { console.error(`task tick: agent "${name}" disappeared`); process.exit(2); }
+        agentsById[name] = rec;
+      }
+      try { _loadDotenvIfAny(cfgDir); } catch { /* best-effort */ }
+      const router = await import('./mas/mention_router.mjs');
+      // The runner needs a real api key for the agent's provider. We
+      // resolve the LEAD's key here on the assumption that all team
+      // members share a provider (Phase 13 simplification); future
+      // phases will resolve per-agent.
+      const cfg = readConfig();
+      const leadAgent = agentsById[team.lead];
+      const apiKey = _resolveAuthKey(cfg, leadAgent.provider);
+      // Per-provider base-url override. Mostly useful for tests that
+      // point the adapter at a local mock; production users get the
+      // built-in default by leaving these unset.
+      const baseUrl = {
+        anthropic: process.env.LAZYCLAW_ANTHROPIC_BASE_URL,
+        openai:    process.env.LAZYCLAW_OPENAI_BASE_URL,
+        gemini:    process.env.LAZYCLAW_GEMINI_BASE_URL,
+      }[leadAgent.provider] || undefined;
+      try {
+        const result = await router.runTaskTurn({
+          task, team, agentsById,
+          userMessage: userMsg || undefined,
+          configDir: cfgDir,
+          apiKey,
+          baseUrl,
+          logger: (line) => process.stderr.write(line),
+          maxAgentTurns: flags['max-turns'] ? parseInt(flags['max-turns'], 10) : undefined,
+        });
+        emitJson({ id: result.task.id, status: result.task.status, iterations: result.iterations, stoppedBy: result.stoppedBy });
+      } catch (err) {
+        console.error(`task tick: ${err?.message || err}`);
+        process.exit(2);
+      }
+      return;
+    }
+    case 'abandon':
+    case 'done': {
+      if (!idOrFirst) { console.error(`Usage: lazyclaw task ${sub} <id>`); process.exit(2); }
+      const target = sub === 'done' ? 'done' : 'abandoned';
+      try {
+        const next = tasksMod.patchTask(idOrFirst, { status: target }, cfgDir);
+        // Best-effort closing post in the original thread so anyone in
+        // the channel sees the resolution. Errors are surfaced via stderr
+        // but do NOT roll back the status change.
+        if (next.slackChannel && next.slackThreadTs) {
+          try {
+            _loadDotenvIfAny(cfgDir);
+            const { SlackChannel } = await import('./channels/slack.mjs');
+            const slack = new SlackChannel({ requireInbound: false });
+            await slack.start(async () => '', {});
+            const threadId = `${next.slackChannel}:${next.slackThreadTs}`;
+            const msg = target === 'done'
+              ? `:white_check_mark: Task *${next.title}* marked done.`
+              : `:no_entry: Task *${next.title}* abandoned.`;
+            await slack.send(threadId, msg);
+            await slack.stop().catch(() => {});
+          } catch (err) {
+            process.stderr.write(`[task] closing post failed: ${err?.message || err}\n`);
+          }
+        }
+        emitJson(next);
+      } catch (err) {
+        console.error(`task ${sub}: ${err?.message || err}`);
+        process.exit(2);
+      }
+      return;
+    }
+    case 'transcript': {
+      if (!idOrFirst) { console.error('Usage: lazyclaw task transcript <id> [--format text|md|json]'); process.exit(2); }
+      const t = tasksMod.getTask(idOrFirst, cfgDir);
+      if (!t) { console.error(`task transcript: no task "${idOrFirst}"`); process.exit(2); }
+      const fmt = String(flags.format || 'text');
+      if (fmt === 'json') { emitJson(t); return; }
+      process.stdout.write(tasksMod.formatTranscript(t, fmt));
+      return;
+    }
+    case 'remove':
+    case 'rm':
+    case 'delete': {
+      if (!idOrFirst) { console.error('Usage: lazyclaw task remove <id>'); process.exit(2); }
+      try { emitJson(tasksMod.removeTask(idOrFirst, cfgDir)); }
+      catch (err) { console.error(`task remove: ${err?.message || err}`); process.exit(2); }
+      return;
+    }
+    default:
+      console.error('Usage: lazyclaw task <start|tick|list|show|transcript|abandon|done|remove> ...');
+      process.exit(2);
+  }
+}
+
+
+
+async function cmdTeam(sub, positional, flags = {}) {
+  const teamsMod = await import('./teams.mjs');
+  const cfgDir = path.dirname(configPath());
+  const name = positional[0];
+
+  const emitJson = (obj) => process.stdout.write(JSON.stringify(obj, null, 2) + '\n');
+  const resolveChannel = async (raw) => {
+    if (!raw) return '';
+    // .env may have a SLACK_BOT_TOKEN we can use; otherwise pass through.
+    try { _loadDotenvIfAny(cfgDir); } catch { /* best-effort */ }
+    return await teamsMod.resolveSlackChannel(raw, {
+      botToken: process.env.SLACK_BOT_TOKEN || null,
+      apiBase: process.env.SLACK_API_BASE || 'https://slack.com/api',
+      logger: (line) => process.stderr.write(line),
+    });
+  };
+
+  switch (sub) {
+    case undefined:
+    case 'list': {
+      emitJson(teamsMod.listTeams(cfgDir));
+      return;
+    }
+    case 'add': {
+      if (!name) { console.error('Usage: lazyclaw team add <name> --agents a,b,c [--lead X] [--channel #shop|Cxxx] [--display "..."]'); process.exit(2); }
+      const agents = teamsMod.parseListFlag(flags.agents) || [];
+      try {
+        const channel = await resolveChannel(flags.channel || '');
+        const t = teamsMod.registerTeam({
+          name,
+          displayName: flags.display || flags['display-name'],
+          agents,
+          lead: flags.lead || null,
+          slackChannel: channel,
+        }, cfgDir);
+        emitJson(t);
+      } catch (err) {
+        console.error(`team add: ${err?.message || err}`);
+        process.exit(2);
+      }
+      return;
+    }
+    case 'show': {
+      if (!name) { console.error('Usage: lazyclaw team show <name>'); process.exit(2); }
+      const t = teamsMod.getTeam(name, cfgDir);
+      if (!t) { console.error(`team show: no team "${name}"`); process.exit(2); }
+      emitJson(t);
+      return;
+    }
+    case 'edit': {
+      if (!name) { console.error('Usage: lazyclaw team edit <name> [--agents a,b,c] [--lead X] [--channel ...] [--display "..."]'); process.exit(2); }
+      const patch = {};
+      if (flags.display !== undefined)         patch.displayName = String(flags.display);
+      if (flags['display-name'] !== undefined) patch.displayName = String(flags['display-name']);
+      if (flags.agents !== undefined)          patch.agents = teamsMod.parseListFlag(flags.agents);
+      if (flags.lead !== undefined)            patch.lead = String(flags.lead);
+      if (flags.channel !== undefined)         patch.slackChannel = await resolveChannel(flags.channel);
+      if (Object.keys(patch).length === 0) {
+        console.error('team edit: no fields to update');
+        process.exit(2);
+      }
+      try { emitJson(teamsMod.patchTeam(name, patch, cfgDir)); }
+      catch (err) { console.error(`team edit: ${err?.message || err}`); process.exit(2); }
+      return;
+    }
+    case 'remove':
+    case 'rm':
+    case 'delete': {
+      if (!name) { console.error('Usage: lazyclaw team remove <name>'); process.exit(2); }
+      try { emitJson(teamsMod.removeTeam(name, cfgDir)); }
+      catch (err) { console.error(`team remove: ${err?.message || err}`); process.exit(2); }
+      return;
+    }
+    default:
+      console.error('Usage: lazyclaw team <add|list|show|edit|remove> ...');
+      process.exit(2);
+  }
+}
+
+async function cmdAgentRegistry(sub, positional, flags = {}) {
+  const agentsMod = await import('./agents.mjs');
+  const cfgDir = path.dirname(configPath());
+  const name = positional[0];
+
+  const emitJson = (obj) => process.stdout.write(JSON.stringify(obj, null, 2) + '\n');
+
+  switch (sub) {
+    case undefined:
+    case 'list': {
+      emitJson(agentsMod.listAgents(cfgDir));
+      return;
+    }
+    case 'add': {
+      if (!name) { console.error('Usage: lazyclaw agent add <name> [--role "..."] [--provider X] [--model Y] [--display "..."] [--tools bash,read,write,grep] [--tags a,b]'); process.exit(2); }
+      const tools = agentsMod.parseToolsFlag(flags.tools);
+      try {
+        const a = agentsMod.registerAgent({
+          name,
+          displayName: flags.display || flags['display-name'],
+          role: flags.role || '',
+          provider: flags.provider || 'claude-cli',
+          model: flags.model || '',
+          tools: tools === null ? undefined : tools,
+          tags: agentsMod.parseToolsFlag(flags.tags) || [],
+        }, cfgDir);
+        emitJson(a);
+      } catch (err) {
+        console.error(`agent add: ${err?.message || err}`);
+        process.exit(2);
+      }
+      return;
+    }
+    case 'show': {
+      if (!name) { console.error('Usage: lazyclaw agent show <name>'); process.exit(2); }
+      const a = agentsMod.getAgent(name, cfgDir);
+      if (!a) { console.error(`agent show: no agent "${name}"`); process.exit(2); }
+      emitJson(a);
+      return;
+    }
+    case 'edit': {
+      if (!name) { console.error('Usage: lazyclaw agent edit <name> [--role "..."] [--provider X] [--model Y] [--display "..."] [--tools ...]'); process.exit(2); }
+      const patch = {};
+      if (flags.role !== undefined)         patch.role = String(flags.role);
+      if (flags.provider !== undefined)     patch.provider = String(flags.provider);
+      if (flags.model !== undefined)        patch.model = String(flags.model);
+      if (flags.display !== undefined)      patch.displayName = String(flags.display);
+      if (flags['display-name'] !== undefined) patch.displayName = String(flags['display-name']);
+      if (flags.tools !== undefined)        patch.tools = agentsMod.parseToolsFlag(flags.tools);
+      if (flags.tags !== undefined)         patch.tags = agentsMod.parseToolsFlag(flags.tags);
+      if (Object.keys(patch).length === 0) {
+        console.error('agent edit: no fields to update');
+        process.exit(2);
+      }
+      try { emitJson(agentsMod.patchAgent(name, patch, cfgDir)); }
+      catch (err) { console.error(`agent edit: ${err?.message || err}`); process.exit(2); }
+      return;
+    }
+    case 'remove':
+    case 'rm':
+    case 'delete': {
+      if (!name) { console.error('Usage: lazyclaw agent remove <name>'); process.exit(2); }
+      try { emitJson(agentsMod.removeAgent(name, cfgDir)); }
+      catch (err) { console.error(`agent remove: ${err?.message || err}`); process.exit(2); }
+      return;
+    }
+    case 'memory': {
+      // memory <show|edit|clear> <name>
+      const op = positional[0];
+      const memName = positional[1];
+      if (!op || !memName) {
+        console.error('Usage: lazyclaw agent memory <show|edit|clear> <name>');
+        process.exit(2);
+      }
+      const memMod = await import('./mas/agent_memory.mjs');
+      try {
+        if (op === 'show') {
+          const max = Number.isFinite(+flags['max-chars']) && +flags['max-chars'] > 0 ? +flags['max-chars'] : memMod.DEFAULT_MAX_CHARS;
+          const text = memMod.readMemory(memName, cfgDir, max);
+          if (!text) process.stderr.write(`(no memory for "${memName}")\n`);
+          else process.stdout.write(text + (text.endsWith('\n') ? '' : '\n'));
+        } else if (op === 'edit') {
+          const p = memMod.memoryPath(memName, cfgDir);
+          // Ensure file exists so $EDITOR doesn't start with a missing
+          // file warning.
+          if (!fs.existsSync(p)) {
+            fs.mkdirSync(path.dirname(p), { recursive: true });
+            fs.writeFileSync(p, `# ${memName} — memory\n\n`);
+          }
+          const editor = process.env.EDITOR || 'vi';
+          const { spawn } = await import('node:child_process');
+          await new Promise((resolve) => {
+            const ch = spawn(editor, [p], { stdio: 'inherit' });
+            ch.on('close', () => resolve());
+          });
+          process.stdout.write(`edited ${p}\n`);
+        } else if (op === 'clear') {
+          const removed = memMod.clear(memName, cfgDir);
+          process.stdout.write(removed ? `cleared memory for "${memName}"\n` : `(no memory for "${memName}")\n`);
+        } else {
+          console.error(`Usage: lazyclaw agent memory <show|edit|clear> <name>`);
+          process.exit(2);
+        }
+      } catch (err) {
+        console.error(`agent memory ${op}: ${err?.message || err}`);
+        process.exit(2);
+      }
+      return;
+    }
+    case 'reflect': {
+      const aname = positional[0];
+      const taskId = flags.task || positional[1];
+      if (!aname || !taskId) {
+        console.error('Usage: lazyclaw agent reflect <name> --task <id>');
+        process.exit(2);
+      }
+      const tasksMod = await import('./tasks.mjs');
+      const memMod = await import('./mas/agent_memory.mjs');
+      const a = agentsMod.getAgent(aname, cfgDir);
+      if (!a) { console.error(`agent reflect: no agent "${aname}"`); process.exit(2); }
+      const task = tasksMod.getTask(taskId, cfgDir);
+      if (!task) { console.error(`agent reflect: no task "${taskId}"`); process.exit(2); }
+      try { _loadDotenvIfAny(cfgDir); } catch { /* best-effort */ }
+      const cfg = readConfig();
+      const apiKey = _resolveAuthKey(cfg, a.provider);
+      const baseUrl = {
+        anthropic: process.env.LAZYCLAW_ANTHROPIC_BASE_URL,
+        openai:    process.env.LAZYCLAW_OPENAI_BASE_URL,
+        gemini:    process.env.LAZYCLAW_GEMINI_BASE_URL,
+      }[a.provider] || undefined;
+      try {
+        const body = await memMod.reflectOnce({ agent: a, task, apiKey, baseUrl });
+        if (!body || !body.trim()) {
+          process.stderr.write('reflection returned empty body — nothing to write\n');
+          return;
+        }
+        if (!flags['dry-run']) {
+          memMod.prependEntry(aname, { taskId: task.id, title: task.title, body }, cfgDir);
+        }
+        process.stdout.write(body + (body.endsWith('\n') ? '' : '\n'));
+      } catch (err) {
+        console.error(`agent reflect: ${err?.message || err}`);
+        process.exit(2);
+      }
+      return;
+    }
+    default:
+      console.error('Usage: lazyclaw agent <add|list|show|edit|remove|memory|reflect> ...');
+      process.exit(2);
+  }
+}
+
+// Best-effort .env loader for ~/.lazyclaw/.env. Only sets keys that are
+// not already present in process.env (so a shell-level export wins).
+// Lines starting with '#' are comments; values are taken verbatim and
+// stripped of surrounding double-quotes if present.
+function _loadDotenvIfAny(cfgDir) {
+  const p = path.join(cfgDir, '.env');
+  if (!fs.existsSync(p)) return { path: p, loaded: 0 };
+  let loaded = 0;
+  const raw = fs.readFileSync(p, 'utf8');
+  for (const line of raw.split(/\r?\n/)) {
+    if (!line || line.trimStart().startsWith('#')) continue;
+    const m = line.match(/^\s*([A-Z_][A-Z0-9_]*)\s*=\s*(.*)$/);
+    if (!m) continue;
+    let val = m[2].trim();
+    if (val.length >= 2 && val.startsWith('"') && val.endsWith('"')) val = val.slice(1, -1);
+    if (process.env[m[1]] === undefined) { process.env[m[1]] = val; loaded++; }
+  }
+  return { path: p, loaded };
+}
+
+async function cmdSlack(sub, positional, flags = {}) {
+  if (sub !== 'listen') {
+    console.error('Usage: lazyclaw slack listen [--provider X] [--model Y]');
+    process.exit(2);
+  }
+  await ensureRegistry();
+  const cfg = readConfig();
+  const cfgDir = path.dirname(configPath());
+
+  const envInfo = _loadDotenvIfAny(cfgDir);
+  process.stderr.write(`[slack] .env: ${envInfo.loaded} keys loaded from ${envInfo.path}\n`);
+
+  const provName = flags.provider || cfg.provider || 'mock';
+  const prov = _registryMod.PROVIDERS[provName];
+  if (!prov) { console.error(`unknown provider: ${provName}`); process.exit(2); }
+  const model = flags.model || cfg.model;
+
+  // Per-thread rolling chat history so multi-turn coherence works
+  // without committing to on-disk sessions. Capped at MAX_TURNS to
+  // bound the prompt size.
+  const threadMsgs = new Map();
+  const MAX_TURNS = 20;
+
+  const handler = async ({ threadId, text }) => {
+    const cleaned = String(text || '').replace(/<@[A-Z0-9]+>/g, '').trim();
+    // Phase 19.2: never post a placeholder ("(empty message)" / "(empty
+    // reply)") into the thread — those leaked through as visible noise
+    // when listener self-message echoes happened. Return null and let
+    // _simulateInbound's guard drop the send. Real provider errors
+    // still surface so the operator knows something went wrong.
+    if (!cleaned) {
+      process.stderr.write('[slack] dropping empty inbound (after mention strip)\n');
+      return null;
+    }
+    const msgs = threadMsgs.get(threadId) || [];
+    msgs.push({ role: 'user', content: cleaned });
+    let acc = '';
+    try {
+      for await (const chunk of prov.sendMessage(msgs, {
+        apiKey: _resolveAuthKey(cfg, provName),
+        model,
+      })) acc += chunk;
+    } catch (err) {
+      msgs.pop();
+      const why = err?.message || String(err);
+      process.stderr.write(`[slack] provider error: ${why}\n`);
+      return `(provider error: ${why})`;
+    }
+    msgs.push({ role: 'assistant', content: acc });
+    if (msgs.length > MAX_TURNS) msgs.splice(0, msgs.length - MAX_TURNS);
+    threadMsgs.set(threadId, msgs);
+    if (!acc.trim()) {
+      process.stderr.write('[slack] provider returned empty text — not posting\n');
+      return null;
+    }
+    return acc;
+  };
+
+  const { SlackChannel } = await import('./channels/slack.mjs');
+  const ch = new SlackChannel();
+  process.stderr.write(`[slack] provider=${provName} model=${model || '(default)'}\n`);
+  try {
+    await ch.start(handler);
+    await ch._connectSocketMode({ logger: (line) => process.stderr.write(line) });
+  } catch (err) {
+    if (err?.code === 'SLACK_MISSING_ENV') {
+      console.error(`slack: missing env vars: ${(err.missing || []).join(', ')}`);
+      console.error(`hint: set them in ${path.join(cfgDir, '.env')} (uncomment SLACK_APP_TOKEN / SLACK_SIGNING_SECRET)`);
+    } else {
+      console.error(`slack: ${err?.message || err}`);
+    }
+    process.exit(2);
+  }
+  process.stderr.write(`[slack] listening. Ctrl-C to stop.\n`);
+
+  await new Promise((resolve) => {
+    const onSig = async () => {
+      process.stderr.write(`\n[slack] shutting down…\n`);
+      try { await ch.stop(); } catch { /* best-effort */ }
+      resolve();
+    };
+    process.once('SIGINT', onSig);
+    process.once('SIGTERM', onSig);
+  });
+}
+
 async function cmdSkills(sub, positional, flags = {}) {
   const skillsMod = await import('./skills.mjs');
   const cfgDir = path.dirname(configPath());
@@ -4276,6 +5712,9 @@ const BOOLEAN_FLAGS = new Set([
   'with-turn-count', // sessions list: include turn count per session
   'no-probe',     // providers add: skip the /v1/models reachability probe
   'pick',         // onboard / chat: force the interactive picker even when provider already set
+  'detach',       // loop: fork worker and return immediately
+  'use-memory',   // loop: prepend core memory to each iteration
+  'force',        // goal tick --force: bypass schedule when invoked manually
 ]);
 
 function parseArgs(argv) {
@@ -4531,7 +5970,10 @@ async function _dispatchMenuChoice(argv) {
   try {
     switch (sub) {
       case 'chat':         return await cmdChat({});
-      case 'agent':        return await cmdAgent(rest[0] || '-', {});
+      case 'agent':        {
+        if (AGENT_REG_SUBS.has(rest[0])) return await cmdAgentRegistry(rest[0], rest.slice(1), {});
+        return await cmdAgent(rest[0] || '-', {});
+      }
       case 'onboard':      return await cmdOnboard({});
       case 'setup':        return await cmdSetup(undefined, rest, {});
       case 'workspace':    return await cmdWorkspace(rest[0], rest.slice(1), {});
@@ -4540,6 +5982,13 @@ async function _dispatchMenuChoice(argv) {
       case 'sessions':     return await cmdSessions(rest[0], rest.slice(1), {});
       case 'providers':    return await cmdProviders(rest[0], rest.slice(1), {});
       case 'cron':         return await cmdCron(rest[0], rest.slice(1), {});
+      case 'loop':         return await cmdLoop(rest[0] || '', {});
+      case 'loops':        return await cmdLoops(rest[0], rest.slice(1), {});
+      case 'goal':         return await cmdGoal(rest[0], rest.slice(1), {});
+      case 'memory':       return await cmdMemory(rest[0], rest.slice(1), {});
+      case 'slack':        return await cmdSlack(rest[0], rest.slice(1), {});
+      case 'team':         return await cmdTeam(rest[0], rest.slice(1), {});
+      case 'task':         return await cmdTask(rest[0], rest.slice(1), {});
       case 'auth':         return await cmdAuth(rest[0], rest.slice(1), {});
       case 'pairing':      return await cmdPairing(rest[0], rest.slice(1), {});
       case 'nodes':        return await cmdNodes(rest[0], rest.slice(1), {});
@@ -5064,6 +6513,41 @@ async function main() {
       await cmdCron(sub, rest.positional.slice(1), rest.flags);
       break;
     }
+    case 'loop': {
+      const prompt = rest.positional[0];
+      await cmdLoop(prompt, rest.flags);
+      break;
+    }
+    case 'loops': {
+      const sub = rest.positional[0];
+      await cmdLoops(sub, rest.positional.slice(1), rest.flags);
+      break;
+    }
+    case 'goal': {
+      const sub = rest.positional[0];
+      await cmdGoal(sub, rest.positional.slice(1), rest.flags);
+      break;
+    }
+    case 'memory': {
+      const sub = rest.positional[0];
+      await cmdMemory(sub, rest.positional.slice(1), rest.flags);
+      break;
+    }
+    case 'slack': {
+      const sub = rest.positional[0];
+      await cmdSlack(sub, rest.positional.slice(1), rest.flags);
+      break;
+    }
+    case 'team': {
+      const sub = rest.positional[0];
+      await cmdTeam(sub, rest.positional.slice(1), rest.flags);
+      break;
+    }
+    case 'task': {
+      const sub = rest.positional[0];
+      await cmdTask(sub, rest.positional.slice(1), rest.flags);
+      break;
+    }
     case 'setup': {
       await cmdSetup(undefined, rest.positional, rest.flags);
       break;
@@ -5077,8 +6561,12 @@ async function main() {
       break;
     }
     case 'agent': {
-      const prompt = rest.positional[0];
-      await cmdAgent(prompt, rest.flags);
+      const first = rest.positional[0];
+      if (AGENT_REG_SUBS.has(first)) {
+        await cmdAgentRegistry(first, rest.positional.slice(1), rest.flags);
+      } else {
+        await cmdAgent(first, rest.flags);
+      }
       break;
     }
     case 'doctor': {