lazyclaw 6.4.0 → 6.6.0

package/agents.mjs

@@ -90,6 +90,16 @@ function defaultShape(name) {
     tools: [...DEFAULT_TOOLS],
     tags: [],
     iconEmoji: '',
+    // Explicit Team Live sprite choice: an integer 1..20 picks one of the 20
+    // built-in pixel-art avatars (web/avatars/NN.png); null lets the dashboard
+    // keep inferring one from the agent's name/role/tags. (dashboard.js
+    // avatarIndexFor already honours rec.avatar — this is the registry side.)
+    avatar: null,
+    // Optional custom character image: a ready-to-use <img src> — either a
+    // remote http(s) URL or a daemon-served '/agent-avatars/<file>' path for a
+    // photo the user supplied (copied under <configDir>/agent-avatars/). null =
+    // none. Takes precedence over `avatar` and the keyword inference.
+    avatarImage: null,
     // Optional parent agent (hierarchy). '' = top-level. A team's org tree is
     // derived from members' manager links (see teams.teamTree). Validated to
     // reference a registered agent and to never form a cycle.
@@ -124,6 +134,18 @@ function writeAtomic(filePath, obj) {
 const VALID_MEMORY_WRITE = ['auto', 'manual', 'off'];
 const VALID_SKILL_WRITE = ['auto', 'manual', 'off'];
 
+// Normalise an explicit avatar choice. null/''/undefined → null (keep the
+// dashboard's keyword inference). A value that parses to an integer 1..20 picks
+// that built-in sprite. Anything else (0, 21, fractional, non-numeric) throws.
+function validateAvatar(v) {
+  if (v === undefined || v === null || v === '') return null;
+  const n = typeof v === 'number' ? v : Number(String(v).trim());
+  if (!Number.isInteger(n) || n < 1 || n > 20) {
+    throw new AgentError('avatar must be an integer 1..20 (or null to clear)', 'AGENT_BAD_AVATAR');
+  }
+  return n;
+}
+
 // Validate a proposed `manager` (parent agent) for `name`: it must reference a
 // registered agent, may not be the agent itself, and may not close a cycle
 // (i.e. `name` must not already be an ancestor of the proposed manager).
@@ -151,7 +173,7 @@ function validateManager(name, manager, configDir) {
   return mgr;
 }
 
-export function registerAgent({ name, displayName, role = '', provider = 'claude-cli', model = '', tools, tags = [], iconEmoji = '', memoryWrite, memoryMaxChars, skillWrite, manager } = {}, configDir = defaultConfigDir()) {
+export function registerAgent({ name, displayName, role = '', provider = 'claude-cli', model = '', tools, tags = [], iconEmoji = '', avatar, memoryWrite, memoryMaxChars, skillWrite, manager } = {}, configDir = defaultConfigDir()) {
   ensureValidName(name);
   const p = agentPath(name, configDir);
   if (fs.existsSync(p)) {
@@ -175,6 +197,7 @@ export function registerAgent({ name, displayName, role = '', provider = 'claude
     tools: toolsClean,
     tags: Array.isArray(tags) ? tags : [],
     iconEmoji: String(iconEmoji || ''),
+    avatar: validateAvatar(avatar),
     memoryWrite: mw,
     memoryMaxChars: Number.isFinite(+memoryMaxChars) && +memoryMaxChars > 0 ? +memoryMaxChars : 12 * 1024,
     skillWrite: sw,
@@ -220,6 +243,12 @@ export function patchAgent(name, patch, configDir = defaultConfigDir()) {
   if (patch.skillWrite !== undefined && !VALID_SKILL_WRITE.includes(patch.skillWrite)) {
     throw new AgentError(`skillWrite must be one of ${VALID_SKILL_WRITE.join(', ')}`, 'AGENT_BAD_SKILL_WRITE');
   }
+  if (patch.avatar !== undefined) {
+    next.avatar = validateAvatar(patch.avatar);
+  }
+  if (patch.avatarImage !== undefined) {
+    next.avatarImage = (patch.avatarImage == null || patch.avatarImage === '') ? null : String(patch.avatarImage);
+  }
   if (patch.manager !== undefined) {
     next.manager = validateManager(name, patch.manager, configDir);
   }
@@ -227,6 +256,44 @@ export function patchAgent(name, patch, configDir = defaultConfigDir()) {
   return next;
 }
 
+// Supported custom-avatar image types → their served content-type. svg is
+// deliberately excluded (inline-script XSS risk in an <img>/object context).
+export const AVATAR_IMAGE_TYPES = {
+  '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif', '.webp': 'image/webp',
+};
+
+// Point an agent at a custom character image. `src` is either a remote http(s)
+// URL (stored verbatim) or a path to a local image file (copied into
+// <configDir>/agent-avatars/<name><ext> and stored as a daemon-served
+// '/agent-avatars/<name><ext>' path). Returns the patched record. The image
+// takes precedence over the numeric sprite + keyword inference in the dashboard.
+export function setAgentAvatarImage(name, src, configDir = defaultConfigDir()) {
+  if (!getAgent(name, configDir)) throw new AgentError(`no agent "${name}"`, 'AGENT_NO_AGENT');
+  const s = String(src ?? '').trim();
+  if (!s) throw new AgentError('avatar image source required (a file path or http(s) URL)', 'AGENT_BAD_AVATAR_IMAGE');
+  if (/^https?:\/\//i.test(s)) {
+    return patchAgent(name, { avatarImage: s }, configDir);
+  }
+  const ext = path.extname(s).toLowerCase();
+  if (!AVATAR_IMAGE_TYPES[ext]) {
+    throw new AgentError(`unsupported image type "${ext || '(none)'}" — use png/jpg/jpeg/gif/webp or an http(s) URL`, 'AGENT_BAD_AVATAR_IMAGE');
+  }
+  if (!fs.existsSync(s) || !fs.statSync(s).isFile()) {
+    throw new AgentError(`no such image file: ${s}`, 'AGENT_BAD_AVATAR_IMAGE');
+  }
+  const destDir = path.join(configDir, 'agent-avatars');
+  fs.mkdirSync(destDir, { recursive: true });
+  // Drop any previously stored image for this agent (it may have a different
+  // extension) so a re-point doesn't leave a stale file shadowing the new one.
+  for (const e of Object.keys(AVATAR_IMAGE_TYPES)) {
+    const old = path.join(destDir, `${name}${e}`);
+    if (fs.existsSync(old)) fs.unlinkSync(old);
+  }
+  fs.copyFileSync(s, path.join(destDir, `${name}${ext}`));
+  return patchAgent(name, { avatarImage: `/agent-avatars/${name}${ext}` }, configDir);
+}
+
 export function removeAgent(name, configDir = defaultConfigDir()) {
   const p = agentPath(name, configDir);
   if (!fs.existsSync(p)) {

package/commands/agents.mjs

@@ -1,7 +1,6 @@
 // Multi-agent commands: cmdAgent (one-shot run), cmdTask, cmdTeam, and the
 // agent registry (cmdAgentRegistry), extracted from cli.mjs (Phase D3).
 import path from 'node:path';
-import fs from 'node:fs';
 import { configPath, readConfig, _resolveAuthKey, _resolveBaseUrl } from '../lib/config.mjs';
 import { ensureRegistry, getRegistry } from '../lib/registry_boot.mjs';
 import { loadDotenvIfAny as _loadDotenvShared } from '../dotenv_min.mjs';
@@ -474,199 +473,9 @@ export async function cmdTeam(sub, positional, flags = {}) {
   }
 }
 
-export 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 "..."] [--manager <agent>] [--tools bash,read,write,grep,skill_view] [--tags a,b] [--skill-write auto|manual|off]'); 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) || [],
-          skillWrite: flags['skill-write'],
-          manager: flags.manager,
-        }, 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 ...] [--skill-write auto|manual|off] [--memory-write auto|manual|off]'); 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 (flags['skill-write'] !== undefined)  patch.skillWrite = String(flags['skill-write']);
-      if (flags['memory-write'] !== undefined) patch.memoryWrite = String(flags['memory-write']);
-      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 = _resolveBaseUrl(a.provider);
-      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;
-    }
-    case 'skill-synth': {
-      const aname = positional[0];
-      const taskId = flags.task || positional[1];
-      if (!aname || !taskId) {
-        console.error('Usage: lazyclaw agent skill-synth <name> --task <id> [--dry-run]');
-        process.exit(2);
-      }
-      const tasksMod = await import('../tasks.mjs');
-      const synthMod = await import('../mas/skill_synth.mjs');
-      const skillsMod = await import('../skills.mjs');
-      const a = agentsMod.getAgent(aname, cfgDir);
-      if (!a) { console.error(`agent skill-synth: no agent "${aname}"`); process.exit(2); }
-      const task = tasksMod.getTask(taskId, cfgDir);
-      if (!task) { console.error(`agent skill-synth: no task "${taskId}"`); process.exit(2); }
-      try { _loadDotenvIfAny(cfgDir); } catch { /* best-effort */ }
-      const cfg = readConfig();
-      const apiKey = _resolveAuthKey(cfg, a.provider);
-      const baseUrl = _resolveBaseUrl(a.provider);
-      try {
-        const result = await synthMod.synthesizeSkill({ agent: a, task, apiKey, baseUrl });
-        if (!result) {
-          process.stderr.write('skill synthesis produced nothing worth saving\n');
-          return;
-        }
-        if (!flags['dry-run']) {
-          // installSynthesized reserves a collision-free name (never
-          // clobbers a human-authored skill) and version-bumps when it
-          // improves its own prior skill.
-          const installed = synthMod.installSynthesized(
-            { name: result.name, description: result.description, body: result.body, sourceTask: task.id },
-            cfgDir,
-          );
-          emitJson({ skill: installed.skill, description: result.description, version: installed.version, path: installed.path });
-        } else {
-          process.stdout.write(result.doc + (result.doc.endsWith('\n') ? '' : '\n'));
-        }
-      } catch (err) {
-        console.error(`agent skill-synth: ${err?.message || err}`);
-        process.exit(2);
-      }
-      return;
-    }
-    default:
-      console.error('Usage: lazyclaw agent <add|list|show|edit|remove|memory|reflect|skill-synth> ...');
-      process.exit(2);
-  }
-}
+// cmdAgentRegistry lives in a sibling module to keep this file under the
+// file-size gate. Re-exported here so cli.mjs's named import is unchanged.
+export { cmdAgentRegistry } from './agents_registry.mjs';
 
 // Best-effort .env loader for ~/.lazyclaw/.env. Only sets keys that are
 // not already present in process.env (so a shell-level export wins).

package/commands/agents_registry.mjs

@@ -0,0 +1,227 @@
+// Agent registry command (cmdAgentRegistry): the agent
+// add/list/show/edit/remove/memory/reflect/skill-synth handler. Extracted
+// from commands/agents.mjs as a sibling module for the file-size gate.
+import path from 'node:path';
+import fs from 'node:fs';
+import { configPath, readConfig, _resolveAuthKey, _resolveBaseUrl } from '../lib/config.mjs';
+import { loadDotenvIfAny } from '../dotenv_min.mjs';
+
+// Thin .env loader wrapper kept local so the module stays self-contained
+// (importing the wrapper back from agents.mjs would create a cycle).
+function _loadDotenvIfAny(cfgDir) { return loadDotenvIfAny(cfgDir); }
+
+export 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 "..."] [--manager <agent>] [--tools bash,read,write,grep,skill_view] [--tags a,b] [--skill-write auto|manual|off]'); 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) || [],
+          avatar: flags.avatar,
+          skillWrite: flags['skill-write'],
+          manager: flags.manager,
+        }, 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 ...] [--skill-write auto|manual|off] [--memory-write auto|manual|off]'); 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 (flags['skill-write'] !== undefined)  patch.skillWrite = String(flags['skill-write']);
+      if (flags['memory-write'] !== undefined) patch.memoryWrite = String(flags['memory-write']);
+      if (flags.avatar !== undefined)          patch.avatar = /^(none|clear|off)$/i.test(String(flags.avatar)) ? null : flags.avatar;
+      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 'set-avatar': {
+      const val = positional[1];
+      if (!name || val === undefined) {
+        console.error('Usage: lazyclaw agent set-avatar <name> <1-20 | none | <image-file> | http(s)://url>\n  1-20      pick a built-in pixel-art sprite\n  none      keep the role-inferred default\n  file/url  use a custom character photo');
+        process.exit(2);
+      }
+      const v = String(val).trim();
+      try {
+        if (/^(none|clear|off)$/i.test(v)) {
+          emitJson(agentsMod.patchAgent(name, { avatar: null, avatarImage: null }, cfgDir));
+        } else if (/^\d+$/.test(v)) {
+          // a built-in sprite index — clear any custom image so it shows through
+          emitJson(agentsMod.patchAgent(name, { avatar: v, avatarImage: null }, cfgDir));
+        } else {
+          // a local image file or a remote URL
+          emitJson(agentsMod.setAgentAvatarImage(name, val, cfgDir));
+        }
+      } catch (err) { console.error(`agent set-avatar: ${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 = _resolveBaseUrl(a.provider);
+      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;
+    }
+    case 'skill-synth': {
+      const aname = positional[0];
+      const taskId = flags.task || positional[1];
+      if (!aname || !taskId) {
+        console.error('Usage: lazyclaw agent skill-synth <name> --task <id> [--dry-run]');
+        process.exit(2);
+      }
+      const tasksMod = await import('../tasks.mjs');
+      const synthMod = await import('../mas/skill_synth.mjs');
+      const skillsMod = await import('../skills.mjs');
+      const a = agentsMod.getAgent(aname, cfgDir);
+      if (!a) { console.error(`agent skill-synth: no agent "${aname}"`); process.exit(2); }
+      const task = tasksMod.getTask(taskId, cfgDir);
+      if (!task) { console.error(`agent skill-synth: no task "${taskId}"`); process.exit(2); }
+      try { _loadDotenvIfAny(cfgDir); } catch { /* best-effort */ }
+      const cfg = readConfig();
+      const apiKey = _resolveAuthKey(cfg, a.provider);
+      const baseUrl = _resolveBaseUrl(a.provider);
+      try {
+        const result = await synthMod.synthesizeSkill({ agent: a, task, apiKey, baseUrl });
+        if (!result) {
+          process.stderr.write('skill synthesis produced nothing worth saving\n');
+          return;
+        }
+        if (!flags['dry-run']) {
+          // installSynthesized reserves a collision-free name (never
+          // clobbers a human-authored skill) and version-bumps when it
+          // improves its own prior skill.
+          const installed = synthMod.installSynthesized(
+            { name: result.name, description: result.description, body: result.body, sourceTask: task.id },
+            cfgDir,
+          );
+          emitJson({ skill: installed.skill, description: result.description, version: installed.version, path: installed.path });
+        } else {
+          process.stdout.write(result.doc + (result.doc.endsWith('\n') ? '' : '\n'));
+        }
+      } catch (err) {
+        console.error(`agent skill-synth: ${err?.message || err}`);
+        process.exit(2);
+      }
+      return;
+    }
+    default:
+      console.error('Usage: lazyclaw agent <add|list|show|edit|remove|memory|reflect|skill-synth> ...');
+      process.exit(2);
+  }
+}

package/commands/automation.mjs

@@ -1,6 +1,7 @@
 // Automation commands: cron schedules, detached loop workers, and goals,
-// extracted from cli.mjs (Phase D3). Owns the _killLog/KILL_ESCALATE_MS
-// loop-kill escalation state.
+// extracted from cli.mjs (Phase D3). The `loops` subcommands and their
+// _killLog/KILL_ESCALATE_MS escalation state live in ./automation_loops.mjs
+// (re-exported below) to keep this file under the size gate.
 import path from 'node:path';
 import { configPath, readConfig, writeConfig, _resolveAuthKey } from '../lib/config.mjs';
 import { ensureRegistry, getRegistry } from '../lib/registry_boot.mjs';
@@ -266,93 +267,11 @@ export async function cmdLoop(prompt, flags = {}) {
   }
 }
 
-// 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;
-
-export 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);
-  }
-}
+// `lazyclaw loops <list|show|kill|tail>` and its private _killLog/
+// KILL_ESCALATE_MS escalation state live in a sibling module to keep this
+// file under the size gate. Re-exported so cli.mjs's named import keeps
+// resolving against ./commands/automation.mjs.
+export { cmdLoops } from './automation_loops.mjs';
 
 // Install (or refresh) the system scheduler entry that fires
 // `lazyclaw goal tick <name>` on a schedule. Writes to cfg.cron and to