lazyclaw 5.0.9 → 5.2.0

package/README.md

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

package/agents.mjs

@@ -80,13 +80,15 @@ function defaultShape(name) {
     // for `lazyclaw agent reflect`; 'off' disables writes entirely.
     memoryWrite: 'auto',
     memoryMaxChars: 12 * 1024,
-    // Phase 20 — self-improving skill synthesis trigger. 'manual'
-    // (default) means a skill is only written when the user runs
-    // `lazyclaw agent skill-synth`; 'auto' fires synthesis on terminal
-    // `done` alongside reflection; 'off' disables it. Defaults to
-    // 'manual' (unlike memoryWrite) because a synthesised SKILL.md
-    // feeds every future agent's prompt, so we keep it opt-in.
-    skillWrite: 'manual',
+    // v5 Group A (M3) — self-improving skill synthesis trigger.
+    // Default flipped to 'auto' so the learning loop actually closes
+    // end-to-end on a fresh install: every agent that finishes a task
+    // contributes a SKILL.md unless the operator explicitly opted out
+    // ('manual' waits for `lazyclaw agent skill-synth`; 'off' disables).
+    // The canonical post-task hook (mas/learning.mjs) also reads
+    // `(skillWrite ?? 'auto')`, so v4 records that pre-date this field
+    // get the new default without a forced migration.
+    skillWrite: 'auto',
     createdAt: new Date().toISOString(),
     updatedAt: new Date().toISOString(),
   };
@@ -114,7 +116,7 @@ export function registerAgent({ name, displayName, role = '', provider = 'claude
   if (!VALID_MEMORY_WRITE.includes(mw)) {
     throw new AgentError(`memoryWrite must be one of ${VALID_MEMORY_WRITE.join(', ')}`, 'AGENT_BAD_MEMORY_WRITE');
   }
-  const sw = skillWrite ?? 'manual';
+  const sw = skillWrite ?? 'auto';
   if (!VALID_SKILL_WRITE.includes(sw)) {
     throw new AgentError(`skillWrite must be one of ${VALID_SKILL_WRITE.join(', ')}`, 'AGENT_BAD_SKILL_WRITE');
   }

package/chat_window.mjs

@@ -0,0 +1,39 @@
+// Group B / M6 — chat sliding window helper.
+//
+// A multi-day chat session accumulates hundreds of turns; without a
+// cap the prompt grows linearly and the Anthropic prompt cache
+// breakpoint advances past the useful prefix. The window keeps the
+// last N turns (default 20) AND honours a token budget (default ~8K
+// chars-as-tokens, since `inputTokens` from the model isn't available
+// pre-call). The system message at index 0 is always preserved — it's
+// the agent.role + workspace + skills index that the static cache
+// prefix depends on.
+//
+// Env overrides let operators stretch the window for long-running
+// research sessions without recompiling. Lives in its own file so it
+// can be imported by tests without invoking cli.mjs::main().
+
+export const CHAT_WINDOW_TURNS = Number(process.env.LAZYCLAW_CHAT_WINDOW_TURNS) || 20;
+export const CHAT_WINDOW_TOKEN_BUDGET = Number(process.env.LAZYCLAW_CHAT_WINDOW_TOKENS) || 8000;
+
+// Trim a hydrated messages[] array to fit the sliding window. Returns
+// { messages, dropped } so the caller can log a one-shot "dropped N
+// older turns" line at session start. The first message is preserved
+// when its role is 'system' (cacheable static prefix). Token budget
+// is approximated as 4 chars/token — accurate enough for a soft cap
+// when the goal is "don't pay for messages the model won't use".
+export function applyChatWindow(messages, { turns = CHAT_WINDOW_TURNS, tokens = CHAT_WINDOW_TOKEN_BUDGET } = {}) {
+  if (!Array.isArray(messages) || messages.length === 0) return { messages, dropped: 0 };
+  const out = [...messages];
+  const sys = out[0]?.role === 'system' ? out.shift() : null;
+  const before = out.length;
+  // Turn count cap: drop oldest non-system turns until length ≤ turns.
+  while (out.length > turns) out.shift();
+  // Token budget cap: estimate 4 chars / token, then trim from the
+  // front (oldest) until estimated tokens ≤ budget.
+  const estTokens = (arr) => Math.ceil(arr.reduce((n, m) => n + String(m.content || '').length, 0) / 4);
+  while (out.length > 1 && estTokens(out) > tokens) out.shift();
+  const dropped = before - out.length;
+  if (sys) out.unshift(sys);
+  return { messages: out, dropped };
+}

package/cli.mjs

@@ -8,6 +8,12 @@ import { pathToFileURL } from 'node:url';
 import { resolveSandbox, listBackends } from './sandbox/index.mjs';
 // Phase G: defaultConfigDir for personality subcommand (spec §9, decision C7).
 import { defaultConfigDir as _persDefaultCfg } from './memory.mjs';
+// Group B / M6 — chat sliding window. Lives in its own module so
+// tests can import the helper without invoking cli.mjs::main().
+import { applyChatWindow as _applyChatWindow, CHAT_WINDOW_TURNS, CHAT_WINDOW_TOKEN_BUDGET } from './chat_window.mjs';
+// v5 Group C (C7) — shared chat-turn streaming closure. Single source
+// of truth for both the ink REPL path and the legacy readline path.
+import { makeRunTurn as _chatRunTurnFactory } from './tui/run_turn.mjs';
 
 async function loadEngine() {
   return import('./workflow/persistent.mjs');
@@ -858,6 +864,58 @@ async function cmdDoctor() {
   if (cfg.provider && !PROVIDERS_HAS(_registryMod.PROVIDERS, cfg.provider)) {
     issues.push(`unknown provider "${cfg.provider}" — registered: ${Object.keys(_registryMod.PROVIDERS).join(', ')}`);
   }
+  // C12 — MinGit / Windows safety net. mas/tools/git.mjs shells out to
+  // `git`; on a stripped Windows PATH (no Git-for-Windows installed) or
+  // a minimal Docker base image, that spawnSync ENOENTs and any agent
+  // task touching the git tool fails opaquely. Probe up-front so
+  // `lazyclaw doctor` surfaces a clean diagnostic and the operator can
+  // install the binary before they trip over it.
+  let gitInfo = null;
+  try {
+    const { spawnSync } = await import('node:child_process');
+    const gitExe = process.env.GIT_EXECUTABLE || 'git';
+    const probe = spawnSync(gitExe, ['--version'], { encoding: 'utf8' });
+    if (probe.error && probe.error.code === 'ENOENT') {
+      issues.push('git binary not found on PATH — `mas/tools/git.mjs` will fail. Install Git: macOS `xcode-select --install`; Linux `apt install git` / `yum install git`; Windows Git-for-Windows (https://git-scm.com/download/win). Or set the GIT_EXECUTABLE env var to an explicit path.');
+      gitInfo = { ok: false, code: 'ENOENT' };
+    } else if (probe.status !== 0) {
+      issues.push(`git --version exited ${probe.status} (${(probe.stderr || '').trim().slice(0, 200)})`);
+      gitInfo = { ok: false, status: probe.status, stderr: (probe.stderr || '').trim().slice(0, 200) };
+    } else {
+      gitInfo = { ok: true, version: (probe.stdout || '').trim() };
+    }
+  } catch (e) {
+    gitInfo = { ok: false, error: e?.message || String(e) };
+  }
+  // m11 — stale index probe. mas/index_db.mjs write-through hooks
+  // log failures to <configDir>/index-failures.jsonl; surface a recent
+  // count so the operator notices a silently-degraded index. Best-effort:
+  // missing file → 0 failures (the common case).
+  let indexInfo = null;
+  try {
+    const cfgDir = path.dirname(configPath());
+    const auditFile = path.join(cfgDir, 'index-failures.jsonl');
+    if (fs.existsSync(auditFile)) {
+      const raw = fs.readFileSync(auditFile, 'utf8');
+      const lines = raw.split('\n').filter(Boolean);
+      const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+      let recent = 0;
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+          if (entry?.ts && new Date(entry.ts).getTime() >= cutoff) recent++;
+        } catch { /* skip malformed */ }
+      }
+      indexInfo = { failuresLast24h: recent, totalFailures: lines.length };
+      if (recent > 0) {
+        issues.push(`${recent} index write failure(s) in the last 24h — run \`lazyclaw index rebuild\` to recover.`);
+      }
+    } else {
+      indexInfo = { failuresLast24h: 0, totalFailures: 0 };
+    }
+  } catch (e) {
+    indexInfo = { error: e?.message || String(e) };
+  }
   // Workflow state health — informational counters that show whether
   // the user has any failed or stuck workflow runs to attend to. We
   // don't push these to `issues` (a stuck workflow doesn't break the
@@ -901,6 +959,8 @@ async function cmdDoctor() {
     issues,
     knownProviders: Object.keys(_registryMod.PROVIDERS),
     workflows,
+    git: gitInfo,
+    index: indexInfo,
     timestamp: new Date().toISOString(),
   };
   console.log(JSON.stringify(out, null, 2));
@@ -1299,7 +1359,7 @@ const HELP_DETAILS = {
   browse: 'Usage: lazyclaw browse <url> [--max-bytes <N>] [--timeout-ms <N>] [--user-agent <ua>] [--meta]\n  Fetches the URL and emits Markdown on stdout. Pipes cleanly into `agent`:\n      lazyclaw browse https://example.com/docs | lazyclaw agent -\n  Strips <script>/<style>/<svg>/comments, prefers <main>/<article>, falls back to <body>.\n  --max-bytes caps the body read (default 2 MB) so a misconfigured upstream can\'t OOM the process.\n  --meta prints { url, title, bytes, truncated } as JSON to stderr alongside the markdown on stdout.',
   cron: 'Usage: lazyclaw cron <list | add <name> "<cron-spec>" -- <cmd> ... | remove <name> | show <name> | sync | run <name>>\n  Schedule recurring agent runs. macOS uses launchd (~/Library/LaunchAgents/com.lazyclaw.<name>.plist); Linux / WSL uses the user crontab.\n  Cron spec is the standard 5-field form (minute hour dom month dow). Supports *, range a-b, list a,b,c, step */N.\n  add: pass the command after `--`. Typical use:\n      lazyclaw cron add daily-summary "0 9 * * 1-5" -- lazyclaw agent "Summarise today\'s TODOs"\n  list / show: read from cfg.cron[name] (config is the source of truth).\n  sync: re-installs every job in cfg.cron into the system scheduler — handy after a reinstall.\n  run: one-shot in-process execution of the named job; the OS scheduler does the same thing on its trigger.\n  Logs: ~/.lazyclaw/logs/cron-<name>.{out,err}.log (macOS launchd path).',
   setup: 'Usage: lazyclaw setup [--skip-test]\n  OpenClaw-style multi-step first-run wizard. Walks through:\n    1. Provider + model + api-key (delegates to onboard --pick)\n    2. Optional workspace init  (AGENTS.md / SOUL.md / TOOLS.md)\n    3. Optional skill bundle install from GitHub\n    4. Optional outbound webhook (Slack / Discord)\n    5. Reachability test against the picked provider\n  Each optional step takes Enter or "skip" to bypass. Re-runnable safely.\n  Also fires automatically on first run when `lazyclaw` is invoked with no config.',
-  dashboard: 'Usage: lazyclaw dashboard [--port <N>] [--no-open]\n  Launches the lazyclaw-only web UI on http://127.0.0.1:<port> (default 19600) and opens it in the default browser.\n  Wraps `lazyclaw daemon` + a static HTML; no Python / lazyclaude dashboard required.\n  Tabs: Chat · Sessions · Skills · Workspace · Providers · Status. Each tab calls existing daemon endpoints.\n  --no-open keeps the browser closed (handy for SSH / headless / dev). The bound URL is always printed to stdout.',
+  dashboard: 'Usage: lazyclaw dashboard [--port <N>] [--no-open]\n  Launches the lazyclaw-only web UI on http://127.0.0.1:<port> (default 19600) and opens it in the default browser.\n  Wraps `lazyclaw daemon` + a static HTML; no Python / lazyclaude dashboard required.\n  See web/dashboard.html for the current tab set (v5: Chat / Sessions / Workflows / Skills / Providers / Rates / Metrics / Doctor / Config / Status / Agents / Teams / Tasks / Trainer / Recall / Sandbox / Channels).\n  --no-open keeps the browser closed (handy for SSH / headless / dev). The bound URL is always printed to stdout.',
   orchestrator: 'Usage: lazyclaw orchestrator <status | set-planner <provider[:model]> | workers add <spec> | workers remove <spec> | workers set <spec,spec,...> | workers clear | set-max-subtasks <N> | clear>\n  Read/write cfg.orchestrator without editing config.json by hand.\n  status               — print {planner, workers, maxSubtasks} as JSON; lists registered providers for reference.\n  set-planner          — replace the planner spec ("provider" or "provider:model"). "orchestrator" itself is rejected (self-recursion).\n  workers add          — append a worker (idempotent — duplicates skipped).\n  workers remove       — drop a worker by exact match. Idempotent.\n  workers set          — replace the whole list (comma-separated specs).\n  workers clear        — empty the workers list.\n  set-max-subtasks <N> — cap subtasks per request, clamped 1..10 (default 5).\n  clear                — delete the cfg.orchestrator block entirely.\n  Pair with: `lazyclaw config set provider orchestrator` to route chats through it.',
 };
 
@@ -1694,6 +1754,7 @@ function _printChatBanner(activeProvName, activeModel, version) {
   process.stdout.write(lines.join('\n') + '\n');
 }
 
+
 // Interactive provider/model picker. Used on first run (no config) or
 // when the user passes --pick. Falls back to plain stdin reads when
 // stdout isn't a TTY (CI/script callers should pass --non-interactive
@@ -2469,9 +2530,113 @@ async function cmdChat(flags = {}) {
         skills: skillGroups,
       };
       void renderSplashToString; // surfaced for tests; runtime uses <Splash/>
+
+      // C7 — minimal chat-session state for the ink path so runTurn can
+      // talk to the provider (the legacy readline path below sets up the
+      // same shape — kept duplicated here intentionally so the ink branch
+      // remains self-contained and the legacy path stays byte-identical).
+      // Slash commands aren't wired into the ink REPL yet (v5.1 follow-up);
+      // until then, system-prompt composition / --session resume happen
+      // identically to the legacy path.
+      let _inkSandboxSpec = null;
+      if (flags.sandbox) {
+        const sb = await import('./sandbox.mjs');
+        try { _inkSandboxSpec = sb.parseSandboxSpec(flags.sandbox, flags); }
+        catch (err) { console.error(`error: ${err.message}`); process.exit(2); }
+      }
+      let _inkSessionId = flags.session || null;
+      const _inkCfgDir = path.dirname(configPath());
+      let _inkMessages = _inkSessionId
+        ? sessionsMod.loadTurns(_inkSessionId, _inkCfgDir).map((t) => ({ role: t.role, content: t.content }))
+        : [];
+      if (_inkMessages.length > 0) {
+        const cfgChat = cfg.chat || {};
+        const winTurns = Number(cfgChat.windowTurns) || CHAT_WINDOW_TURNS;
+        const winTokens = Number(cfgChat.windowTokens) || CHAT_WINDOW_TOKEN_BUDGET;
+        const { messages: trimmed } = _applyChatWindow(_inkMessages, { turns: winTurns, tokens: winTokens });
+        _inkMessages = trimmed;
+      }
+      // System prompt composition — mirrors the legacy path's sysParts logic.
+      const _inkSkillNames = (flags.skill ? String(flags.skill) : (Array.isArray(cfg.skills) ? cfg.skills.join(',') : ''))
+        .split(',').map((s) => s.trim()).filter(Boolean);
+      const _inkWorkspaceName = flags.workspace || cfg.workspace || '';
+      const _inkSysParts = [];
+      try {
+        const { composePromptStack } = await import('./mas/prompt_stack.mjs');
+        const stacked = composePromptStack({
+          cfgDir: _inkCfgDir,
+          agent: { name: 'chat', role: '' },
+          workspace: _inkWorkspaceName,
+        });
+        if (stacked && stacked.trim()) _inkSysParts.push(stacked);
+      } catch { /* never block chat start on stack composition */ }
+      if (_inkWorkspaceName && !_inkMessages.some((m) => m.role === 'system')) {
+        try {
+          const ws = await import('./workspace.mjs');
+          const wsPrompt = ws.composeWorkspacePrompt(_inkCfgDir, _inkWorkspaceName);
+          if (wsPrompt) _inkSysParts.push(wsPrompt);
+        } catch (err) { console.error(`workspace error: ${err.message}`); process.exit(2); }
+      }
+      if (_inkSkillNames.length > 0 && !_inkMessages.some((m) => m.role === 'system')) {
+        try {
+          const sys = skillsMod.composeSystemPrompt(_inkSkillNames, _inkCfgDir);
+          if (sys) _inkSysParts.push(sys);
+        } catch (err) { console.error(`skill error: ${err.message}`); process.exit(2); }
+      }
+      if (_inkSysParts.length && !_inkMessages.some((m) => m.role === 'system')) {
+        const merged = _inkSysParts.join('\n\n---\n\n');
+        _inkMessages.unshift({ role: 'system', content: merged });
+        if (_inkSessionId) sessionsMod.appendTurn(_inkSessionId, 'system', merged, _inkCfgDir);
+      }
+      let _inkRunningUsage = null;
+      const _inkAccumulateUsage = (u) => {
+        if (!u) return;
+        if (!_inkRunningUsage) _inkRunningUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0, turnsWithUsage: 0 };
+        _inkRunningUsage.inputTokens  += Number(u.inputTokens) || 0;
+        _inkRunningUsage.outputTokens += Number(u.outputTokens) || 0;
+        _inkRunningUsage.totalTokens  += Number(u.totalTokens) || ((Number(u.inputTokens) || 0) + (Number(u.outputTokens) || 0));
+        _inkRunningUsage.turnsWithUsage += 1;
+      };
+      const _inkChatStartedAt = Date.now();
+      const _inkSyntheticChatSessionId = `chat-${process.pid}-${_inkChatStartedAt}`;
+      const _inkPersistTurn = (role, content) => {
+        if (_inkSessionId) {
+          sessionsMod.appendTurn(_inkSessionId, role, content, _inkCfgDir);
+          return;
+        }
+        try {
+          import('./memory.mjs').then((m) => {
+            try { m.appendRecent(_inkSyntheticChatSessionId, role, content, _inkCfgDir); }
+            catch { /* swallow */ }
+          }).catch(() => {});
+        } catch { /* swallow */ }
+      };
+      const _inkCtx = {
+        cfg,
+        cfgDir: _inkCfgDir,
+        sandboxSpec: _inkSandboxSpec,
+        syntheticChatSessionId: _inkSyntheticChatSessionId,
+        getMessages: () => _inkMessages,
+        getProv: () => prov,
+        getActiveProvName: () => activeProvName,
+        getActiveModel: () => activeModel,
+        getSessionId: () => _inkSessionId,
+        persistTurn: _inkPersistTurn,
+        accumulateUsage: _inkAccumulateUsage,
+        resolveAuthKey: (providerName) => _resolveAuthKey(cfg, providerName),
+      };
+      // v5.0.10: write streamed chunks straight to process.stdout. Ink
+      // owns the screen, so interleaved stdout writes can produce some
+      // visual jank — accepted trade for unblocking the chat loop. v5.1
+      // TODO: route through a ref'd scrollback <Static/> region in
+      // ReplApp so Ink owns all output.
+      const _inkRunTurn = _chatRunTurnFactory({
+        ctx: _inkCtx,
+        writeFn: (chunk) => process.stdout.write(chunk),
+      });
       const ink = render(/* @__PURE__ */ React.createElement(ReplApp, {
         splashProps,
-        runTurn: async (_text, _signal) => { void _text; void _signal; },
+        runTurn: _inkRunTurn,
       }));
       await ink.waitUntilExit();
       return;
@@ -2529,6 +2694,24 @@ async function cmdChat(flags = {}) {
     ? sessionsMod.loadTurns(sessionId, cfgDir).map(t => ({ role: t.role, content: t.content }))
     : [];
 
+  // M6 — apply sliding window at session start. Long-running sessions
+  // (50+ turns) used to ship every prior turn to the provider every
+  // request; we now keep at most CHAT_WINDOW_TURNS turns (default 20)
+  // plus the system message. Operators can override via env. The
+  // per-session log on disk is untouched — only the in-memory prompt
+  // window is trimmed. We log to stderr once at session start so the
+  // user knows context was dropped.
+  if (messages.length > 0) {
+    const cfgChat = cfg.chat || {};
+    const winTurns = Number(cfgChat.windowTurns) || CHAT_WINDOW_TURNS;
+    const winTokens = Number(cfgChat.windowTokens) || CHAT_WINDOW_TOKEN_BUDGET;
+    const { messages: trimmed, dropped } = _applyChatWindow(messages, { turns: winTurns, tokens: winTokens });
+    if (dropped > 0) {
+      process.stderr.write(`[chat] sliding window: dropped ${dropped} older turn(s), ${trimmed.length} kept\n`);
+    }
+    messages = trimmed;
+  }
+
   // --skill (comma-separated names) composes into a system message at the
   // head of the conversation. Same shape as `agent --skill`. Defaults from
   // config.skills array when --skill not passed. We only inject if no
@@ -2542,6 +2725,21 @@ async function cmdChat(flags = {}) {
   // a faithful preview.
   const workspaceName = flags.workspace || cfg.workspace || '';
   const sysParts = [];
+  // v5 (canonical decision C5) — prepend the 8-layer composePromptStack
+  // output. Falls back silently to no-op when the configDir has none of
+  // the source files present (fresh install) so chat-start stays
+  // byte-identical to the v4 shape until a user authors USER.md or a
+  // personality. Wrapped in try/catch — chat start must never break on
+  // a stack composition error.
+  try {
+    const { composePromptStack } = await import('./mas/prompt_stack.mjs');
+    const stacked = composePromptStack({
+      cfgDir,
+      agent: { name: 'chat', role: '' },
+      workspace: workspaceName,
+    });
+    if (stacked && stacked.trim()) sysParts.push(stacked);
+  } catch { /* never block chat start on stack composition */ }
   if (workspaceName && !messages.some(m => m.role === 'system')) {
     try {
       const ws = await import('./workspace.mjs');
@@ -2582,11 +2780,56 @@ async function cmdChat(flags = {}) {
     runningUsage.totalTokens  += Number(u.totalTokens) || ((Number(u.inputTokens) || 0) + (Number(u.outputTokens) || 0));
     runningUsage.turnsWithUsage += 1;
   };
+  // v5 Group A (M2): always-on synthetic session id so an unsessioned
+  // chat still populates memory/recent.jsonl. Without this, the nudge
+  // loop never saw repeated prompts in chat sessions that didn't pass
+  // --session, and `nudge.suggest_skill` clusters silently lost ~95%
+  // of their evidence. The `chat-<pid>-<startTs>` prefix keeps the
+  // synthetic id distinguishable from real session ids on disk.
+  const chatStartedAt = Date.now();
+  const _syntheticChatSessionId = `chat-${process.pid}-${chatStartedAt}`;
   const persistTurn = (role, content) => {
-    if (!sessionId) return;
-    sessionsMod.appendTurn(sessionId, role, content, cfgDir);
+    if (sessionId) {
+      sessionsMod.appendTurn(sessionId, role, content, cfgDir);
+      return;
+    }
+    // No --session: don't touch sessions/<id>.jsonl, but DO append to
+    // memory/recent.jsonl directly so the nudge loop can cluster on
+    // unsessioned chats. Best-effort — a broken memory module must not
+    // break a chat turn.
+    try {
+      import('./memory.mjs').then((m) => {
+        try { m.appendRecent(_syntheticChatSessionId, role, content, cfgDir); }
+        catch { /* swallow */ }
+      }).catch(() => {});
+    } catch { /* swallow */ }
   };
 
+  // C7 — shared runTurn closure for the legacy path. The same factory
+  // backs the ink path above; both call sites get one set of bugs.
+  // Getters close over the *current* binding of sessionId, prov,
+  // activeProvName, activeModel — so a mid-session /provider switch
+  // takes effect on the very next turn.
+  const _legacyCtx = {
+    cfg,
+    cfgDir,
+    sandboxSpec,
+    syntheticChatSessionId: _syntheticChatSessionId,
+    getMessages: () => messages,
+    getProv: () => prov,
+    getActiveProvName: () => activeProvName,
+    getActiveModel: () => activeModel,
+    getSessionId: () => sessionId,
+    persistTurn,
+    accumulateUsage,
+    resolveAuthKey: (providerName) => _resolveAuthKey(cfg, providerName),
+    onCharsSent: (n) => { charsSent += n; },
+  };
+  const runTurn = _chatRunTurnFactory({
+    ctx: _legacyCtx,
+    writeFn: (chunk) => process.stdout.write(chunk),
+  });
+
   const handleSlash = async (line) => {
     const cmd = line.split(/\s+/)[0];
     switch (cmd) {
@@ -3172,6 +3415,35 @@ async function cmdChat(flags = {}) {
         return true;
       }
       case '/exit': {
+        // v5 Group A (C4): fire one updateUserModel call before exit so
+        // the Honcho-style USER.md captures the durable facts surfaced
+        // in this session. Wrapped in a 3-second timeout so a slow
+        // trainer never makes /exit hang. Best-effort: failure logs are
+        // suppressed so we don't disturb the clean shutdown.
+        try {
+          const turns = sessionId
+            ? sessionsMod.loadTurns(sessionId, cfgDir)
+            : messages.map((t) => ({ role: t.role, content: t.content }));
+          if (turns && turns.length) {
+            const trainer = (typeof _registryMod?.resolveTrainer === 'function')
+              ? _registryMod.resolveTrainer(cfg)
+              : { provider: activeProvName, model: activeModel };
+            const userModelPromise = import('./mas/user_modeler.mjs').then((m) =>
+              m.updateUserModel({
+                sessionTurns: turns,
+                provider: trainer.provider,
+                model: trainer.model,
+                apiKey: _resolveAuthKey(cfg, trainer.provider),
+                baseUrl: _resolveBaseUrl(trainer.provider),
+                configDir: cfgDir,
+              }),
+            ).catch(() => null);
+            await Promise.race([
+              userModelPromise,
+              new Promise((resolve) => setTimeout(resolve, 3000)),
+            ]);
+          }
+        } catch { /* /exit must never hang or throw */ }
         return 'EXIT';
       }
       default:
@@ -3189,10 +3461,6 @@ async function cmdChat(flags = {}) {
       if (useTerminal) rl.prompt();
       continue;
     }
-    messages.push({ role: 'user', content: text });
-    charsSent += text.length;
-    persistTurn('user', text);
-    let acc = '';
     // Per-turn AbortController. Ctrl+C during a stream aborts THIS turn
     // and returns to the prompt instead of killing the process. Outside
     // a stream, Ctrl+C still terminates (we restore the default handler
@@ -3210,55 +3478,12 @@ async function cmdChat(flags = {}) {
     // gaps between CJK characters (visible in user-reported screen
     // captures of Korean replies).
     if (useTerminal) _ghost.suspend();
-    // Buffered writer — coalesce single-character streaming chunks
-    // into ~30 ms windows. Two reasons:
-    //   1. Korean / Japanese / Chinese tokens often arrive as one
-    //      character per chunk. Each individual `process.stdout.write`
-    //      can race against terminal redraw on a wide-cell character,
-    //      producing the same "visible space between every character"
-    //      symptom the suspend above also addresses.
-    //   2. Far fewer syscalls. A 200-char Korean reply was ~200
-    //      separate writes; this collapses to ~7-10.
-    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(messages, {
-        apiKey: _resolveAuthKey(cfg, activeProvName),
-        model: activeModel,
-        sandbox: sandboxSpec,
-        signal: turnAc.signal,
-        onUsage: accumulateUsage,
-      })) {
-        _writeChunk(chunk);
-        acc += chunk;
-      }
-      // Drain anything still buffered before the trailing newline so
-      // the prompt lands on its own line cleanly.
-      if (_writeTimer) clearTimeout(_writeTimer);
-      _flush();
-      process.stdout.write('\n');
-      messages.push({ role: 'assistant', content: acc });
-      persistTurn('assistant', acc);
-    } catch (err) {
-      // Drain pending buffer so partial reply stays on screen even
-      // when the stream errors mid-flight.
-      if (_writeTimer) clearTimeout(_writeTimer);
-      _flush();
-      // ABORT errors are user-initiated; partial assistant output is
-      // discarded (we don't append a half-reply to the message history
-      // because the next turn would treat it as a complete reply and
-      // give odd context to the model).
-      if (err?.code !== 'ABORT' && !turnAc.signal.aborted) {
-        process.stdout.write(`error: ${err?.message || String(err)}\n`);
-      }
+      // C7 — single source of truth for the streaming + persist +
+      // post-task learning loop. The factory handles the user-msg push,
+      // 30 ms buffered writer (CJK-safe), assistant-msg push,
+      // persistTurn for both turns, and the post-task learning hook.
+      await runTurn(text, turnAc.signal);
     } finally {
       process.off('SIGINT', onSigint);
       if (useTerminal) _ghost.resume();