lazyclaw 5.4.4 → 6.0.1

package/dotenv_min.mjs

@@ -0,0 +1,23 @@
+// dotenv_min.mjs — minimal .env loader shared by the CLI and the Ink slash
+// dispatcher. Loads <cfgDir>/.env into process.env (without overwriting
+// already-set vars) so Slack / provider tokens are available. Extracted from
+// cli.mjs `_loadDotenvIfAny` so the /task Slack-close flow can reuse it.
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+export 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 };
+}

package/first_run.mjs

@@ -0,0 +1,15 @@
+// first_run.mjs — decide what onboarding the chat entrypoint runs.
+//
+//   'setup' — genuine fresh install (no provider, interactive): run the full
+//             5-step guided setup (provider+model, workspace, skills) instead
+//             of only the provider picker the Ink path used to run.
+//   'pick'  — explicit `chat --pick`: just re-pick provider/model.
+//   'none'  — provider already configured, or non-interactive (automation).
+//
+// Pure so it unit-tests without a TTY.
+export function firstRunMode({ hasProvider, flagPick, isTTY }) {
+  if (!isTTY) return 'none';
+  if (flagPick) return 'pick';
+  if (!hasProvider) return 'setup';
+  return 'none';
+}

package/goals_cron.mjs

@@ -0,0 +1,37 @@
+// goals_cron.mjs — attach/detach a cron schedule to a goal.
+//
+// Extracted from cli.mjs (_attachGoalCron / _detachGoalCron) so the Ink
+// /goal slash can actually schedule (and unschedule) a goal instead of just
+// recording the cron string and telling the user to re-run from the CLI.
+// Dependency-injected on readConfig / writeConfig and the cron module so the
+// core unit-tests with a fake cron and no real launchd/crontab writes.
+// `LAZYCLAW_SKIP_CRON_INSTALL` skips the backend install (config still written).
+
+export async function attachGoalCron({ readConfig, writeConfig, cron, name, schedule }) {
+  cron.parseCronSpec(schedule); // validate before touching 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 };
+}
+
+export async function detachGoalCron({ readConfig, writeConfig, cron, name }) {
+  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;
+}

package/lib/args.mjs

@@ -0,0 +1,216 @@
+// CLI argument parsing + shell-completion generation, extracted from cli.mjs.
+// Pure leaf module: no imports, no side effects — just the subcommand inventory
+// and the parseArgs/completion functions that main() and `lazyclaw completion`
+// share.
+
+// Subcommand inventory used by `lazyclaw completion`. Single source of
+// truth so adding a subcommand updates the completion script too. The
+// dispatcher in main() is the runtime authority; this list mirrors it.
+export const SUBCOMMANDS = [
+  'run', 'resume', 'inspect', 'clear', 'validate', 'graph',
+  'config', 'chat', 'agent',
+  'doctor', 'status', 'onboard',
+  'sessions', 'skills', 'providers',
+  'daemon', 'version', 'completion', 'help',
+  'export', 'import',
+  'rates',
+  // v5.0 — sandbox 6-backend (Phase D)
+  'sandbox',
+  // OpenClaw-parity subsurfaces (v3.93–v3.98)
+  'auth', 'pairing', 'nodes', 'message', 'workspace', 'browse', 'cron',
+  // v3.99.6 — multi-step setup wizard + lazyclaw-only dashboard
+  '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.3.0 — Telegram long-poll listener (zero-install mobile control)
+  'telegram',
+  // v4.3.0 — Matrix /sync long-poll listener
+  'matrix',
+  // v5.0 — channels plugin loader (Phase F)
+  'channels',
+  // v4.1.0 — multi-agent slack system (Phase 9+)
+  'agent', 'team', 'task',
+  // v5.0 Phase G — persona compose + cross-tool import (spec §9, §10)
+  'personality', 'migrate', 'hermes', 'openclaw',
+  // v5.0.6 — arrow-key launcher menu (was the no-arg default in v5.0.5-)
+  'menu',
+  // v5.0 Phase H1 — trajectory exporter (spec §2.7)
+  'trajectories',
+];
+
+export const SUBCOMMAND_SUBS = {
+  config:    ['get', 'set', 'list', 'delete', 'unset', 'path', 'edit', 'validate'],
+  sessions:  ['list', 'show', 'clear', 'export', 'search'],
+  skills:    ['list', 'show', 'install', 'remove', 'search', 'curate', 'classify'],
+  providers: ['list', 'info', 'test', 'add', 'remove', 'models'],
+  rates:     ['list', 'set', 'delete', 'shape', 'validate', 'copy'],
+  sandbox:   ['list', 'test', 'add', 'use'],
+  completion: ['bash', 'zsh'],
+  auth:      ['list', 'add', 'remove', 'use', 'rotate'],
+  pairing:   ['list', 'add', 'remove'],
+  nodes:     ['list', 'register', 'remove', 'pending', 'approve', 'revoke', 'devices'],
+  message:   ['list', 'add', 'remove', 'send'],
+  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'],
+  telegram:  ['listen'],
+  matrix:    ['listen'],
+  agent:     ['add', 'list', 'show', 'edit', 'remove'],
+  team:      ['add', 'list', 'show', 'edit', 'remove'],
+  task:      ['start', 'list', 'show', 'abandon', 'done', 'remove'],
+  trajectories: ['export'],
+};
+
+// Flags whose presence is the signal — they don't consume the next arg
+// even when one is available. Without this allow-list,
+// `lazyclaw run --parallel demo wf.mjs` would set `flags.parallel='demo'`
+// and silently lose the session id; the user would only see a
+// "missing positional" error after the dispatcher rejected it.
+export const BOOLEAN_FLAGS = new Set([
+  'parallel',
+  'parallel-persistent',
+  'once',
+  'non-interactive',
+  'include-secrets',
+  'include-sessions',
+  'overwrite-skills',
+  'no-overwrite-config',
+  'import-sessions',
+  'show-thinking',
+  'usage',
+  'cost',
+  'response-cache',
+  'help',         // also handled as a subcommand alias
+  'version',
+  'summary',      // inspect: trim per-node detail
+  'regex',        // sessions search: treat query as a regex
+  'lr',           // graph: emit Mermaid `graph LR` (left-right)
+  'force',        // rates copy: overwrite existing destination
+  'aggregate',    // inspect (list mode): per-node stats across sessions
+  'all',          // providers test: run all providers in parallel
+  '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
+]);
+
+export function parseArgs(argv) {
+  const out = { positional: [], flags: {} };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    // POSIX `--`: everything after is positional verbatim. Used by
+    // `cron add <name> "<spec>" -- <cmd> [args...]` so a recurring
+    // command with --flag of its own doesn't get parsed as our flag.
+    if (a === '--') {
+      for (let j = i + 1; j < argv.length; j++) out.positional.push(argv[j]);
+      break;
+    }
+    if (a.startsWith('--')) {
+      const eq = a.indexOf('=');
+      if (eq >= 0) {
+        out.flags[a.slice(2, eq)] = a.slice(eq + 1);
+      } else {
+        const name = a.slice(2);
+        if (BOOLEAN_FLAGS.has(name)) {
+          // Known boolean — never consumes the next arg.
+          out.flags[name] = true;
+          continue;
+        }
+        const next = argv[i + 1];
+        if (next === undefined || next.startsWith('--')) {
+          // Unknown flag at end-of-args or before another --flag: still boolean.
+          out.flags[name] = true;
+        } else {
+          out.flags[name] = next;
+          i += 1;
+        }
+      }
+    } else out.positional.push(a);
+  }
+  return out;
+}
+
+export function bashCompletion() {
+  // Standard bash COMPREPLY pattern. We split COMP_WORDS into:
+  //   [0] = lazyclaw, [1] = subcommand, [2+] = subcommand args.
+  // Two-level completion: word index 1 → top subcommands; index 2 → the
+  // sub-subcommand list (if defined for that subcommand). Beyond index 2
+  // we don't try to enumerate dynamic items (session ids etc.) — that
+  // would require running the CLI on every <Tab>, which is too slow.
+  const subs = SUBCOMMANDS.join(' ');
+  const subSubsCases = Object.entries(SUBCOMMAND_SUBS)
+    .map(([name, list]) => `      ${name})\n        COMPREPLY=( $(compgen -W "${list.join(' ')}" -- "$cur") )\n        ;;`)
+    .join('\n');
+  return `# lazyclaw bash completion. Source from your shell:
+#   eval "$(node /path/to/cli.mjs completion bash)"
+_lazyclaw_completion() {
+  local cur prev words cword
+  _init_completion 2>/dev/null || {
+    cur="\${COMP_WORDS[COMP_CWORD]}"
+    prev="\${COMP_WORDS[COMP_CWORD-1]}"
+    cword=$COMP_CWORD
+  }
+  if [ "$cword" -eq 1 ]; then
+    COMPREPLY=( $(compgen -W "${subs}" -- "$cur") )
+    return 0
+  fi
+  if [ "$cword" -eq 2 ]; then
+    case "\${COMP_WORDS[1]}" in
+${subSubsCases}
+    esac
+    return 0
+  fi
+  return 0
+}
+complete -F _lazyclaw_completion lazyclaw
+`;
+}
+
+export function zshCompletion() {
+  // _arguments-style. We list subcommands then dispatch on the first
+  // positional via a single `_describe`. Sub-subcommands handled by a
+  // case inside the function. Same coverage rationale as bash.
+  const subs = SUBCOMMANDS.map(s => `    '${s}'`).join('\n');
+  const subSubsCases = Object.entries(SUBCOMMAND_SUBS)
+    .map(([name, list]) => `      (${name}) _values 'sub' ${list.map(v => `'${v}'`).join(' ')} ;;`)
+    .join('\n');
+  return `#compdef lazyclaw
+# lazyclaw zsh completion. Add to fpath, or eval inline:
+#   eval "$(node /path/to/cli.mjs completion zsh)"
+_lazyclaw() {
+  local subs=(
+${subs}
+  )
+  if (( CURRENT == 2 )); then
+    _values 'subcommand' \${subs[@]}
+    return
+  fi
+  if (( CURRENT == 3 )); then
+    case \${words[2]} in
+${subSubsCases}
+    esac
+    return
+  fi
+}
+compdef _lazyclaw lazyclaw
+_lazyclaw "$@"
+`;
+}
+
+// Subcommand-classifier sets for the multi-agent surfaces. cli.mjs uses
+// AGENT_REG_SUBS to decide whether a bare `agent <sub>` routes to the agent
+// registry vs a one-shot agent run. TEAM_SUBS/TASK_SUBS mirror their command's
+// subcommands for the same disambiguation pattern.
+export const AGENT_REG_SUBS = new Set(['add', 'list', 'show', 'edit', 'remove', 'rm', 'delete', 'memory', 'reflect', 'skill-synth']);
+export const TEAM_SUBS = new Set(['add', 'list', 'show', 'edit', 'remove', 'rm', 'delete']);
+export const TASK_SUBS = new Set(['start', 'tick', 'list', 'show', 'abandon', 'done', 'transcript', 'remove', 'rm', 'delete']);

package/lib/config.mjs

@@ -0,0 +1,113 @@
+// Shared config + key/url resolution helpers, extracted from cli.mjs so the
+// per-domain command modules (commands/*.mjs) can import them without pulling
+// in the whole entrypoint. Leaf module: depends only on node builtins and the
+// owner-only secure writer — never on the provider registry (the registry
+// dependency is injected via setRegistryEnvResolver to keep this a leaf and
+// avoid a config<->registry_boot import cycle).
+import path from 'node:path';
+import fs from 'node:fs';
+import os from 'node:os';
+// Owner-only (0600/0700) atomic writer for config.json — it holds plaintext
+// API keys / auth profiles and must not be group/other readable.
+import { writeJsonSecure, tightenIfLoose } from '../secure_write.mjs';
+
+export function configPath() {
+  const override = process.env.LAZYCLAW_CONFIG_DIR;
+  const dir = override ? override : path.join(os.homedir(), '.lazyclaw');
+  return path.join(dir, 'config.json');
+}
+
+export function readConfig() {
+  const p = configPath();
+  if (!fs.existsSync(p)) return {};
+  // Migrate already-deployed world/group-readable config.json (plaintext keys)
+  // to 0600 the first time we touch it. Best-effort, idempotent.
+  tightenIfLoose(p);
+  try { return JSON.parse(fs.readFileSync(p, 'utf8')); }
+  catch { return {}; }
+}
+
+export function writeConfig(cfg) {
+  // 0600 file in a 0700 dir, atomically — config.json stores plaintext API
+  // keys / auth profiles, so it must be owner-only on disk.
+  writeJsonSecure(configPath(), cfg);
+}
+
+// Injected built-in OpenAI-compat env-var resolver. registry_boot wires this
+// to registry.resolveBuiltinEnvKey on ensureRegistry() so _resolveAuthKey can
+// fall back to provider env vars without importing the registry (no cycle).
+let _envResolver = null;
+export function setRegistryEnvResolver(fn) { _envResolver = fn; }
+
+// Synchronous, dependency-free resolver for the api-key the
+// chat / agent flow sends. Mirrors config_features.resolveApiKey
+// without forcing the dynamic import on every hot-path call.
+//   1. cfg.authProfiles[provider] active label, if set
+//   2. first profile in the array
+//   3. customProviders[<provider>].apiKey (custom OpenAI-compat entries)
+//   4. PROVIDER_INFO[<provider>].envKey / altEnvKeys env var (built-in
+//      OpenAI-compat: nim → NVIDIA_API_KEY, openrouter → OPENROUTER_API_KEY, …)
+//   5. legacy single `cfg["api-key"]` (pre-v3.93 configs)
+export function _resolveAuthKey(cfg, provider) {
+  const arr = (cfg.authProfiles || {})[provider] || [];
+  const active = (cfg.authActiveProfile || {})[provider];
+  const hit = arr.find((p) => p && p.label === active) || arr[0];
+  if (hit?.key) return hit.key;
+  const custom = Array.isArray(cfg.customProviders)
+    ? cfg.customProviders.find((p) => p && p.name === provider)
+    : null;
+  if (custom?.apiKey) return custom.apiKey;
+  // Built-in OpenAI-compat env var fallback. Skipped silently when the
+  // registry module isn't loaded yet (every chat / agent path calls
+  // ensureRegistry() before _resolveAuthKey, so this is just defence-in-depth).
+  if (typeof _envResolver === 'function') {
+    const envHit = _envResolver(provider);
+    if (envHit) return envHit;
+  }
+  return cfg['api-key'] || '';
+}
+
+// Per-provider base-URL override (used by tests + private gateways).
+// Single source of truth — the reflect / skill-synth / task-tick paths
+// all resolve through here so a new provider's env var lands in one spot.
+export function _resolveBaseUrl(provider) {
+  return {
+    anthropic: process.env.LAZYCLAW_ANTHROPIC_BASE_URL,
+    openai:    process.env.LAZYCLAW_OPENAI_BASE_URL,
+    gemini:    process.env.LAZYCLAW_GEMINI_BASE_URL,
+  }[provider] || undefined;
+}
+
+export function readVersionFromRepo() {
+  // Two source-of-truth lookups, in order:
+  //   1. The npm-published package's own package.json (sits next to the
+  //      entrypoint once installed via `npm i -g lazyclaw`).
+  //   2. The monorepo's VERSION file at the repo root (one or two
+  //      levels up depending on how the file is symlinked / copied).
+  // Either one wins on first hit. Falls back to '0.0.0' so the CLI
+  // never crashes on a stripped-down install. The candidate list is a
+  // superset spanning both the repo-root entrypoint and this lib/ module
+  // location so resolution is identical regardless of where it runs from.
+  const here = path.dirname(new URL(import.meta.url).pathname);
+  const candidates = [
+    { kind: 'pkg',     path: path.resolve(here, './package.json') },
+    { kind: 'pkg',     path: path.resolve(here, '../package.json') },
+    { kind: 'pkg',     path: path.resolve(here, '../../package.json') },
+    { kind: 'version', path: path.resolve(here, '../../VERSION') },
+    { kind: 'version', path: path.resolve(here, '../../../VERSION') },
+    { kind: 'version', path: path.resolve(here, '../../../../VERSION') },
+  ];
+  for (const c of candidates) {
+    try {
+      const raw = fs.readFileSync(c.path, 'utf8').trim();
+      if (!raw) continue;
+      if (c.kind === 'pkg') {
+        const v = JSON.parse(raw).version;
+        if (v) return v;
+      } else {
+        return raw;
+      }
+    } catch { /* keep trying */ }
+  }
+  return '0.0.0';
+}

package/lib/registry_boot.mjs

@@ -0,0 +1,55 @@
+// Provider-registry bootstrap, extracted from cli.mjs so every command module
+// (commands/*.mjs) shares one lazily-loaded registry instance instead of each
+// re-importing and re-registering. One-directional dependency: registry_boot
+// -> config (never the reverse), so this stays cycle-free.
+import { readConfig, _resolveAuthKey, setRegistryEnvResolver } from './config.mjs';
+
+let _registryMod = null;
+
+// Throwing accessor — use when the caller has already awaited ensureRegistry()
+// and a null registry would be a programmer error.
+export function requireRegistry() {
+  if (!_registryMod) {
+    throw new Error('registry module not pre-loaded — call ensureRegistry() first');
+  }
+  return _registryMod;
+}
+
+// Nullable accessor — returns the loaded registry module or null. Mirrors the
+// old bare `_registryMod` read semantics for sites that tolerate "not loaded".
+export function getRegistry() {
+  return _registryMod;
+}
+
+export async function ensureRegistry() {
+  if (!_registryMod) {
+    _registryMod = await import('../providers/registry.mjs');
+    // Wire config._resolveAuthKey's built-in env-var fallback to the registry
+    // without config importing the registry (keeps config a leaf module).
+    if (typeof _registryMod.resolveBuiltinEnvKey === 'function') {
+      setRegistryEnvResolver((p) => _registryMod.resolveBuiltinEnvKey(p));
+    }
+  }
+  // Re-run registration on every call so config changes within the same
+  // process (e.g. setup wizard adding a custom endpoint mid-session) take
+  // effect for the next chat / agent / picker invocation. registerCustom-
+  // Providers is idempotent — re-registering the same name is a no-op.
+  try {
+    if (typeof _registryMod.registerCustomProviders === 'function') {
+      _registryMod.registerCustomProviders(readConfig());
+    }
+  } catch { /* never let a malformed cfg.customProviders block startup */ }
+  // Wire the orchestrator's live cfg + auth-key resolver. We do this on
+  // every ensureRegistry() call (cheap — just replaces the closure) so a
+  // mid-session config edit (custom provider added, env var exported)
+  // takes effect on the next orchestrator turn without a restart.
+  try {
+    if (typeof _registryMod.registerOrchestrator === 'function') {
+      _registryMod.registerOrchestrator({
+        cfgGetter: readConfig,
+        keyResolver: _resolveAuthKey,
+      });
+    }
+  } catch { /* defensive */ }
+  return _registryMod;
+}

package/mas/agent_turn.mjs

@@ -94,6 +94,7 @@ export async function runAgentTurn({
   maxIterations = DEFAULT_MAX_ITERATIONS,
   signal,
   approve,
+  security,
   // v5 (Group A — C3): trajectoryRef is OPT-OUT, not opt-in. A caller
   // that doesn't pass one but DOES pass a configDir gets a
   // default-stamped record so every production agent turn lands in
@@ -218,7 +219,7 @@ export async function runAgentTurn({
       try {
         result = await runTool({
           agent, tool: call.name, args: call.input,
-          taskId, configDir, cwd, approve,
+          taskId, configDir, cwd, approve, security,
         });
         if (result && result.ok === false) ok = false;
       } catch (err) {

package/mas/index_db.mjs

@@ -85,6 +85,16 @@ function prepareStatements(db) {
     insertMemory: db.prepare(
       `INSERT INTO fts_memories(content, topic, kind)
        VALUES (?, ?, ?)`),
+    // Upsert-by-natural-key deletes (skills/trajectories/memories only —
+    // these get re-indexed for the same key on every save/put, so a bare
+    // INSERT would accumulate duplicate FTS rows that skew bm25 and eat the
+    // recall k-budget). Sessions are NOT deduped this way: each turn has a
+    // unique (session_id,turn_idx) in normal flow, and a per-turn full-table
+    // DELETE would reintroduce O(n^2) on the hot write path; session dedup is
+    // handled by reindexAll rebuilding from scratch.
+    deleteSkill: db.prepare(`DELETE FROM fts_skills WHERE skill_name = ?`),
+    deleteTrajectory: db.prepare(`DELETE FROM fts_trajectories WHERE trajectory_id = ?`),
+    deleteMemory: db.prepare(`DELETE FROM fts_memories WHERE topic = ? AND kind = ?`),
     queries: {
       sessions: db.prepare(
         `SELECT 'sessions' AS scope, bm25(fts_sessions) AS bm25,
@@ -160,6 +170,7 @@ export function indexSessionTurn(row, configDir = defaultConfigDir()) {
 export function indexSkill(row, configDir = defaultConfigDir()) {
   try {
     const s = _stmts(configDir);
+    s.deleteSkill.run(String(row.skill_name || ''));   // upsert by skill_name
     s.insertSkill.run(
       redactSecrets(String(row.content || '')),
       String(row.skill_name || ''), String(row.trained_by || ''),
@@ -175,6 +186,7 @@ export function indexSkill(row, configDir = defaultConfigDir()) {
 export function indexTrajectory(row, configDir = defaultConfigDir()) {
   try {
     const s = _stmts(configDir);
+    s.deleteTrajectory.run(String(row.trajectory_id || ''));   // upsert by trajectory_id
     s.insertTrajectory.run(
       redactSecrets(String(row.content || '')),
       String(row.trajectory_id || ''), String(row.agent || ''),
@@ -190,6 +202,7 @@ export function indexTrajectory(row, configDir = defaultConfigDir()) {
 export function indexMemory(row, configDir = defaultConfigDir()) {
   try {
     const s = _stmts(configDir);
+    s.deleteMemory.run(String(row.topic || ''), String(row.kind || ''));   // upsert by (topic,kind)
     s.insertMemory.run(
       redactSecrets(String(row.content || '')),
       String(row.topic || ''), String(row.kind || ''),
@@ -287,6 +300,9 @@ export function integrityCheck(configDir = defaultConfigDir()) {
   return { ok: r === 'ok', result: r };
 }
 
+// Destructive primitive: drop the db (+ WAL sidecars) and recreate the empty
+// schema. Callers that want a *populated* index must use reindexAll — a bare
+// rebuild leaves recall returning zero hits.
 export function rebuild(configDir = defaultConfigDir()) {
   closeIndex(configDir);
   const p = dbPath(configDir);
@@ -300,3 +316,69 @@ export function rebuild(configDir = defaultConfigDir()) {
   }
   openIndex(configDir);
 }
+
+// Minimal frontmatter splitter (trained_by / group are the only keys reindex
+// needs); avoids importing skills.mjs and risking an import cycle.
+function _miniFrontmatter(raw) {
+  const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(String(raw || ''));
+  if (!m) return { meta: {}, body: String(raw || '') };
+  const meta = {};
+  for (const line of m[1].split('\n')) {
+    const i = line.indexOf(':');
+    if (i > 0) meta[line.slice(0, i).trim()] = line.slice(i + 1).trim();
+  }
+  return { meta, body: m[2] };
+}
+
+// Rebuild AND repopulate the FTS index from the on-disk source of truth
+// (sessions JSONL, flat skill .md, memory core/episodic). This is what
+// `index rebuild` / doctor recovery must call — a bare rebuild() zeroes recall.
+// Shared by scripts/migrate-v5 and the daemon POST /index/rebuild route.
+export function reindexAll(configDir = defaultConfigDir()) {
+  rebuild(configDir);
+  // Sessions — flat <configDir>/sessions/<id>.jsonl, one turn per line.
+  const sessDir = path.join(configDir, 'sessions');
+  if (fs.existsSync(sessDir)) {
+    for (const f of fs.readdirSync(sessDir)) {
+      if (!f.endsWith('.jsonl')) continue;
+      const id = f.slice(0, -'.jsonl'.length);
+      let idx = 0;
+      const raw = fs.readFileSync(path.join(sessDir, f), 'utf8');
+      for (const line of raw.split('\n')) {
+        if (!line) continue;
+        try {
+          const o = JSON.parse(line);
+          indexSessionTurn({ session_id: id, turn_idx: idx++, role: o.role || 'user', ts: o.ts || 0, content: o.content || '' }, configDir);
+        } catch { /* skip malformed line */ }
+      }
+    }
+  }
+  // Skills — canonical flat <configDir>/skills/<name>.md (skip the .archive dir).
+  const skillsDir = path.join(configDir, 'skills');
+  if (fs.existsSync(skillsDir)) {
+    for (const f of fs.readdirSync(skillsDir)) {
+      if (!f.endsWith('.md')) continue;
+      const name = f.slice(0, -'.md'.length);
+      const { meta, body } = _miniFrontmatter(fs.readFileSync(path.join(skillsDir, f), 'utf8'));
+      indexSkill({
+        skill_name: name,
+        trained_by: meta.trained_by || 'legacy',
+        group_name: meta.group || (name.includes('-') ? name.split('-')[0] : 'legacy'),
+        content: body,
+      }, configDir);
+    }
+  }
+  // Memory — core.md + episodic/*.md.
+  const memDir = path.join(configDir, 'memory');
+  if (fs.existsSync(memDir)) {
+    const core = path.join(memDir, 'core.md');
+    if (fs.existsSync(core)) indexMemory({ topic: 'core', kind: 'core', content: fs.readFileSync(core, 'utf8') }, configDir);
+    const epi = path.join(memDir, 'episodic');
+    if (fs.existsSync(epi)) {
+      for (const f of fs.readdirSync(epi)) {
+        if (!f.endsWith('.md')) continue;
+        indexMemory({ topic: f.slice(0, -'.md'.length), kind: 'episodic', content: fs.readFileSync(path.join(epi, f), 'utf8') }, configDir);
+      }
+    }
+  }
+}

package/mas/learning.mjs

@@ -34,6 +34,7 @@ import * as userModeler from './user_modeler.mjs';
 import * as confidence from './confidence.mjs';
 import * as skills from '../skills.mjs';
 import { resolveTrainer } from '../providers/registry.mjs';
+import { hasClaudeCliSession } from '../providers/claude_cli_detect.mjs';
 
 export const TRIGGERS = Object.freeze([
   'post-task',
@@ -330,9 +331,24 @@ export async function _runPeriodicCuration(_ctx, logger) {
 
 // ── helpers ──────────────────────────────────────────────────────────
 
+let _trainerNoticed = false;
+
 function _safeResolveTrainer(cfg, agent) {
   try {
-    return resolveTrainer(cfg || { provider: agent?.provider, model: agent?.model });
+    const c = cfg || { provider: agent?.provider, model: agent?.model };
+    // Use real claude-cli session detection in production (the resolver's own
+    // default stub only checked an env var that `claude login` never sets).
+    const resolved = resolveTrainer(c, { detectClaudeCli: hasClaudeCliSession });
+    // Honesty: if the user asked for trainer.provider:'auto' but no claude-cli
+    // session was found, the learning loop bills the chat provider — say so once
+    // so the "$0 on Claude Pro" promise never fails silently.
+    if (!_trainerNoticed && c && c.trainer && c.trainer.provider === 'auto' && resolved.provider !== 'claude-cli') {
+      _trainerNoticed = true;
+      try {
+        process.stderr.write(`[trainer] no claude-cli session detected → learning will use "${resolved.provider || 'the chat provider'}" (billed per token). Run 'claude login', or set trainer.provider explicitly, to control cost.\n`);
+      } catch { /* stderr closed */ }
+    }
+    return resolved;
   } catch {
     return { provider: agent?.provider || '', model: agent?.model || '' };
   }