lazyclaw 3.99.28 → 4.2.1

package/scripts/loop-worker.mjs

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+// Detached worker for `lazyclaw loop --detach`.
+//
+// Invoked by the parent CLI with the same provider/model the parent
+// resolved, plus a loop id pointing at the state directory the parent
+// pre-created. Streams nothing to stdout — we are headless. Every
+// iteration's outcome lands in iterations.log, and the final disposition
+// lands in result.json + meta.status. SIGTERM flips status to `killed`
+// and unwinds cleanly so a follow-up SIGKILL is rarely needed.
+//
+// Argv contract (all required except --until / --session-existing):
+//   --loop-id <id>
+//   --prompt <text>
+//   --max <N>
+//   --provider <name>
+//   --until <regex>
+//   --session-existing <id>      reuse the named chat session
+//   --cfg-dir <path>             override LAZYCLAW_CONFIG_DIR
+//   --model <name>               provider-specific model name
+//
+// LC_FAIL_AT_ITER=<N> is honored as a test hook: exits with code 7 just
+// before iteration N's provider call. Used by phase 2 spec to assert
+// the `failed` meta status path.
+
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(HERE, '..');
+
+function parseArgs(argv) {
+  const out = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const t = argv[i];
+    if (t.startsWith('--')) {
+      const key = t.slice(2);
+      const v = argv[i + 1];
+      if (v === undefined || v.startsWith('--')) {
+        out[key] = true;
+      } else {
+        out[key] = v;
+        i++;
+      }
+    } else {
+      out._.push(t);
+    }
+  }
+  return out;
+}
+
+const args = parseArgs(process.argv.slice(2));
+const loopId = args['loop-id'];
+if (!loopId) {
+  process.stderr.write('loop-worker: --loop-id required\n');
+  process.exit(2);
+}
+
+if (args['cfg-dir']) {
+  process.env.LAZYCLAW_CONFIG_DIR = args['cfg-dir'];
+}
+
+const loops = await import(path.join(REPO_ROOT, 'loops.mjs'));
+const sessions = await import(path.join(REPO_ROOT, 'sessions.mjs'));
+const loopEngine = await import(path.join(REPO_ROOT, 'loop-engine.mjs'));
+const registryUrl = path.join(REPO_ROOT, 'providers', 'registry.mjs');
+const { PROVIDERS } = await import(registryUrl);
+
+const cfgDir = process.env.LAZYCLAW_CONFIG_DIR || loops.defaultConfigDir();
+const sessionId = args['session-existing'] || `loop:${loopId}`;
+
+const provName = args.provider || 'mock';
+const prov = PROVIDERS[provName];
+if (!prov) {
+  loops.patchMeta(loopId, { status: 'failed', finishedAt: new Date().toISOString() }, cfgDir);
+  loops.writeResult(loopId, { error: `unknown provider: ${provName}` }, cfgDir);
+  process.exit(2);
+}
+
+const until = args.until ? loopEngine.compileUntil(args.until) : null;
+const max = Number(args.max) || loopEngine.LOOP_MAX_DEFAULT;
+
+// Initial meta — pid was filled by parent. We update startedAt here so
+// the timestamp reflects when the worker actually started executing, not
+// when the parent forked us.
+loops.patchMeta(loopId, { status: 'running', startedAt: new Date().toISOString() }, cfgDir);
+
+const ac = new AbortController();
+function onTerm(sig) {
+  ac.abort();
+  loops.patchMeta(loopId, { status: 'killed', finishedAt: new Date().toISOString(), signal: sig }, cfgDir);
+  loops.writeResult(loopId, { stoppedBy: 'kill', signal: sig }, cfgDir);
+  // Give the in-flight stream a moment to unwind before we exit.
+  setTimeout(() => process.exit(143), 50);
+}
+process.on('SIGTERM', () => onTerm('SIGTERM'));
+process.on('SIGINT', () => onTerm('SIGINT'));
+
+const failAtIter = Number(process.env.LC_FAIL_AT_ITER) || 0;
+let iterCounter = 0;
+
+async function sendOnce(messages, signal) {
+  iterCounter++;
+  if (failAtIter && iterCounter === failAtIter) {
+    process.exit(7);
+  }
+  let acc = '';
+  for await (const chunk of prov.sendMessage(messages, {
+    apiKey: process.env.LAZYCLAW_API_KEY || '',
+    model: args.model,
+    signal,
+  })) {
+    acc += chunk;
+  }
+  return acc;
+}
+
+const messages = [];
+// Hydrate prior turns if reusing an existing session — the engine appends
+// every successful pair, so resume semantics line up with `/loop` in REPL.
+if (sessionId && sessions.sessionPath) {
+  try {
+    const prior = sessions.loadTurns(sessionId, cfgDir);
+    for (const t of prior) messages.push({ role: t.role, content: t.content });
+  } catch { /* fresh session */ }
+}
+
+const persist = (role, content) => {
+  try { sessions.appendTurn(sessionId, role, content, cfgDir); }
+  catch { /* surface via result.json on failure */ }
+};
+
+const onIteration = ({ i, max: m, reply }) => {
+  loops.appendIteration(loopId, {
+    iteration: i,
+    of: m,
+    bytes: reply.length,
+    preview: reply.slice(0, 200),
+  }, cfgDir);
+};
+
+try {
+  const result = await loopEngine.runLoop({
+    prompt: args.prompt || '',
+    max,
+    until,
+    messages,
+    sendOnce,
+    persist,
+    onIteration,
+    signal: ac.signal,
+  });
+  const finalStatus = result.stoppedBy === 'abort' ? 'killed' : 'completed';
+  loops.patchMeta(loopId, { status: finalStatus, finishedAt: new Date().toISOString() }, cfgDir);
+  loops.writeResult(loopId, result, cfgDir);
+  process.exit(0);
+} catch (err) {
+  loops.patchMeta(loopId, { status: 'failed', finishedAt: new Date().toISOString() }, cfgDir);
+  loops.writeResult(loopId, { error: err?.message || String(err), stack: err?.stack }, cfgDir);
+  process.exit(1);
+}

package/sessions.mjs

@@ -17,6 +17,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import { appendRecent as _memoryAppendRecent } from './memory.mjs';
 
 const SESSIONS_DIRNAME = 'sessions';
 
@@ -74,6 +75,10 @@ export function appendTurn(id, role, content, configDir = defaultConfigDir()) {
   fs.mkdirSync(path.dirname(p), { recursive: true });
   const line = JSON.stringify({ role, content: String(content ?? ''), ts: Date.now() }) + '\n';
   fs.appendFileSync(p, line);
+  // Write-through to the memory recency log. Best-effort; failures
+  // never propagate up — a missing or broken memory store must not
+  // break the session-write path.
+  _memoryAppendRecent(id, role, content, configDir);
 }
 
 export function clearSession(id, configDir = defaultConfigDir()) {

package/tasks.mjs

@@ -0,0 +1,220 @@
+// Persistent task registry for `/task` REPL command and `lazyclaw task`
+// subcommand. Backs the Phase 11 piece of docs/multi-agent.md.
+//
+// One file per task under <configDir>/tasks/<id>.json. Tasks are the
+// unit of work: a title, a description, an owning team, a lead, and a
+// (channel, threadTs) pair pointing at the Slack thread that hosts the
+// conversation. The `turns` array grows over time as agents take turns
+// in the thread; Phase 11 only seeds it with the kickoff turn, Phases
+// 13+ extend it.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import crypto from 'node:crypto';
+import { getTeam } from './teams.mjs';
+
+const TASKS_DIRNAME = 'tasks';
+export const VALID_STATUSES = ['pending', 'running', 'done', 'failed', 'abandoned'];
+
+export class TaskError extends Error {
+  constructor(message, code) {
+    super(message);
+    this.name = 'TaskError';
+    this.code = code || 'TASK_ERR';
+  }
+}
+
+export function defaultConfigDir() {
+  return process.env.LAZYCLAW_CONFIG_DIR || path.join(os.homedir(), '.lazyclaw');
+}
+
+export function tasksDir(configDir = defaultConfigDir()) {
+  return path.join(configDir, TASKS_DIRNAME);
+}
+
+export function taskPath(id, configDir = defaultConfigDir()) {
+  if (!isValidTaskId(id)) throw new TaskError(`bad task id "${id}"`, 'TASK_BAD_ID');
+  return path.join(tasksDir(configDir), `${id}.json`);
+}
+
+// Task IDs are short, sortable, and filename-safe: t_<yyyymmdd>_<rand6>.
+// Time-prefix makes a `ls`-sorted directory chronologically ordered,
+// which is the natural order for a "recent tasks" dashboard view.
+const ID_RE = /^t_\d{8}_[a-z0-9]{6}$/;
+
+export function isValidTaskId(id) {
+  return typeof id === 'string' && ID_RE.test(id);
+}
+
+export function newTaskId(now = new Date()) {
+  const yyyy = now.getUTCFullYear();
+  const mm = String(now.getUTCMonth() + 1).padStart(2, '0');
+  const dd = String(now.getUTCDate()).padStart(2, '0');
+  const rand = crypto.randomBytes(4).toString('hex').slice(0, 6);
+  return `t_${yyyy}${mm}${dd}_${rand}`;
+}
+
+function defaultShape(id, now) {
+  return {
+    version: 1,
+    id,
+    title: '',
+    description: '',
+    team: '',
+    lead: '',
+    status: 'pending',
+    slackChannel: '',
+    slackThreadTs: '',
+    createdAt: now.toISOString(),
+    updatedAt: now.toISOString(),
+    turns: [],
+  };
+}
+
+function writeAtomic(filePath, obj) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  const tmp = filePath + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify(obj, null, 2));
+  fs.renameSync(tmp, filePath);
+}
+
+// Register a task. `team` (name) must already exist in the registry,
+// and `lead` (agent name) must belong to that team. We do not check
+// slackChannel here — the CLI does that at start time so we can fail
+// fast before posting to Slack.
+export function registerTask({ id, title, description = '', team, lead, slackChannel = '', slackThreadTs = '', status = 'pending', turns = [] } = {}, configDir = defaultConfigDir()) {
+  if (!id) id = newTaskId();
+  if (!isValidTaskId(id)) throw new TaskError(`bad task id "${id}"`, 'TASK_BAD_ID');
+  if (!title || !String(title).trim()) {
+    throw new TaskError('title is required', 'TASK_NO_TITLE');
+  }
+  const t = getTeam(team, configDir);
+  if (!t) throw new TaskError(`team "${team}" is not registered`, 'TASK_NO_TEAM');
+  const chosenLead = lead || t.lead;
+  if (!t.agents.includes(chosenLead)) {
+    throw new TaskError(`lead "${chosenLead}" is not in team "${team}" (agents=[${t.agents.join(', ')}])`, 'TASK_BAD_LEAD');
+  }
+  if (!VALID_STATUSES.includes(status)) {
+    throw new TaskError(`bad status "${status}" — one of ${VALID_STATUSES.join(', ')}`, 'TASK_BAD_STATUS');
+  }
+  const p = taskPath(id, configDir);
+  if (fs.existsSync(p)) {
+    throw new TaskError(`task "${id}" already exists`, 'TASK_EXISTS');
+  }
+  const now = new Date();
+  const data = {
+    ...defaultShape(id, now),
+    title: String(title),
+    description: String(description || ''),
+    team,
+    lead: chosenLead,
+    slackChannel: String(slackChannel || ''),
+    slackThreadTs: String(slackThreadTs || ''),
+    status,
+    turns: Array.isArray(turns) ? turns : [],
+  };
+  writeAtomic(p, data);
+  return data;
+}
+
+export function getTask(id, configDir = defaultConfigDir()) {
+  let p;
+  try { p = taskPath(id, configDir); }
+  catch { return null; }
+  if (!fs.existsSync(p)) return null;
+  try { return JSON.parse(fs.readFileSync(p, 'utf8')); }
+  catch { return null; }
+}
+
+export function listTasks(configDir = defaultConfigDir()) {
+  const dir = tasksDir(configDir);
+  if (!fs.existsSync(dir)) return [];
+  const out = [];
+  for (const f of fs.readdirSync(dir)) {
+    if (!f.endsWith('.json')) continue;
+    const id = f.slice(0, -5);
+    const t = getTask(id, configDir);
+    if (t) out.push(t);
+  }
+  out.sort((a, b) => String(b.createdAt).localeCompare(String(a.createdAt)));
+  return out;
+}
+
+export function patchTask(id, patch, configDir = defaultConfigDir()) {
+  const t = getTask(id, configDir);
+  if (!t) throw new TaskError(`no task "${id}"`, 'TASK_NO_TASK');
+  const next = { ...t, ...patch, updatedAt: new Date().toISOString() };
+  if (patch.status !== undefined && !VALID_STATUSES.includes(patch.status)) {
+    throw new TaskError(`bad status "${patch.status}" — one of ${VALID_STATUSES.join(', ')}`, 'TASK_BAD_STATUS');
+  }
+  writeAtomic(taskPath(id, configDir), next);
+  return next;
+}
+
+export function appendTurn(id, turn, configDir = defaultConfigDir()) {
+  const t = getTask(id, configDir);
+  if (!t) throw new TaskError(`no task "${id}"`, 'TASK_NO_TASK');
+  const turns = Array.isArray(t.turns) ? [...t.turns, turn] : [turn];
+  return patchTask(id, { turns }, configDir);
+}
+
+export function removeTask(id, configDir = defaultConfigDir()) {
+  const p = taskPath(id, configDir);
+  if (!fs.existsSync(p)) throw new TaskError(`no task "${id}"`, 'TASK_NO_TASK');
+  fs.unlinkSync(p);
+  return { id, removed: true };
+}
+
+// Render the task's turns into a single string suitable for handing
+// to a human reader. Three formats:
+//   'text' (default) — "[Who]\ntext\n\n[Who]\ntext\n..." plain
+//   'md'             — markdown with H3 per turn, fenced code blocks
+//                      for tool calls when present
+//   'json'           — the raw task record (no projection)
+export function formatTranscript(task, format = 'text') {
+  if (!task || typeof task !== 'object') return '';
+  if (format === 'json') return JSON.stringify(task, null, 2);
+  const head = (format === 'md')
+    ? [
+        `# Task \`${task.id}\` — ${task.title || '(untitled)'}`,
+        task.description ? `\n${task.description}\n` : '',
+        `**Team**: ${task.team}  ·  **Lead**: ${task.lead}  ·  **Status**: ${task.status}`,
+        '',
+        '---',
+        '',
+      ].join('\n')
+    : `Task ${task.id}: ${task.title || '(untitled)'}\n` +
+      `Team: ${task.team} · Lead: ${task.lead} · Status: ${task.status}\n` +
+      '-'.repeat(60) + '\n';
+  const body = (Array.isArray(task.turns) ? task.turns : []).map((t) => {
+    const who = t.agent === 'user' ? 'User' : t.agent === 'system' ? 'System' : t.agent;
+    if (format === 'md') {
+      const parts = [`### ${who}`, ''];
+      if (t.text) parts.push(t.text, '');
+      if (Array.isArray(t.toolCalls) && t.toolCalls.length) {
+        for (const tc of t.toolCalls) {
+          parts.push('```json');
+          parts.push(JSON.stringify({ tool: tc.name, input: tc.input, ok: tc.ok }, null, 2));
+          parts.push('```');
+        }
+        parts.push('');
+      }
+      return parts.join('\n');
+    }
+    return `[${who}]\n${t.text || ''}`;
+  }).join(format === 'md' ? '\n' : '\n\n');
+  return head + body + '\n';
+}
+
+// Build the kickoff message Slack will see as the thread root. Stays
+// template-based for Phase 11 — Phase 13 will replace this with the
+// lead agent's actual first LLM turn.
+export function buildKickoffMessage({ id, title, description, leadDisplayName, teamDisplayName }) {
+  const parts = [];
+  parts.push(`*Task* \`${id}\`: ${title}`);
+  if (description && description.trim()) parts.push(description.trim());
+  parts.push(`assigned to *${leadDisplayName}* (team: ${teamDisplayName})`);
+  return parts.join('\n');
+}

package/teams.mjs

@@ -0,0 +1,199 @@
+// Persistent team registry for `/team` REPL command and `lazyclaw team`
+// subcommand. Backs the Phase 10 piece of docs/multi-agent.md.
+//
+// Storage under <configDir>/teams/<name>.json. A team is a named set of
+// agents that share a Slack channel and a default lead. Both `agents`
+// and `lead` are validated against the agent registry at write time so
+// the on-disk record is always consistent (no dangling refs).
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { ensureValidName as cronEnsureValidName } from './cron.mjs';
+import { getAgent } from './agents.mjs';
+
+const TEAMS_DIRNAME = 'teams';
+
+export class TeamError extends Error {
+  constructor(message, code) {
+    super(message);
+    this.name = 'TeamError';
+    this.code = code || 'TEAM_ERR';
+  }
+}
+
+export function defaultConfigDir() {
+  return process.env.LAZYCLAW_CONFIG_DIR || path.join(os.homedir(), '.lazyclaw');
+}
+
+export function teamsDir(configDir = defaultConfigDir()) {
+  return path.join(configDir, TEAMS_DIRNAME);
+}
+
+export function teamPath(name, configDir = defaultConfigDir()) {
+  ensureValidName(name);
+  return path.join(teamsDir(configDir), `${name}.json`);
+}
+
+export function ensureValidName(name) {
+  try { cronEnsureValidName(name); }
+  catch (e) { throw new TeamError(e.message, 'TEAM_BAD_NAME'); }
+}
+
+function validateAgentRefs(agents, lead, configDir) {
+  if (!Array.isArray(agents) || agents.length === 0) {
+    throw new TeamError('agents must be a non-empty array', 'TEAM_NO_AGENTS');
+  }
+  for (const a of agents) {
+    if (!getAgent(a, configDir)) {
+      throw new TeamError(`agent "${a}" is not registered — run 'lazyclaw agent add ${a}' first`, 'TEAM_BAD_AGENT');
+    }
+  }
+  if (lead && !agents.includes(lead)) {
+    throw new TeamError(`lead "${lead}" must be one of the team's agents [${agents.join(', ')}]`, 'TEAM_BAD_LEAD');
+  }
+}
+
+function titleCase(s) {
+  return String(s).split(/[-_]/).map(p => p.charAt(0).toUpperCase() + p.slice(1)).join(' ');
+}
+
+function defaultShape(name) {
+  return {
+    version: 1,
+    name,
+    displayName: titleCase(name),
+    agents: [],
+    lead: null,
+    slackChannel: '',
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  };
+}
+
+function writeAtomic(filePath, obj) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  const tmp = filePath + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify(obj, null, 2));
+  fs.renameSync(tmp, filePath);
+}
+
+export function registerTeam({ name, displayName, agents = [], lead = null, slackChannel = '' } = {}, configDir = defaultConfigDir()) {
+  ensureValidName(name);
+  const p = teamPath(name, configDir);
+  if (fs.existsSync(p)) {
+    throw new TeamError(`team "${name}" already exists`, 'TEAM_EXISTS');
+  }
+  const cleanAgents = [...new Set(agents)];
+  // lead defaults to the first agent if the caller didn't pick one — spec §3.2
+  // says "default lead", so we materialise it on write rather than leaving null.
+  const cleanLead = lead || cleanAgents[0] || null;
+  validateAgentRefs(cleanAgents, cleanLead, configDir);
+  const data = {
+    ...defaultShape(name),
+    displayName: displayName || titleCase(name),
+    agents: cleanAgents,
+    lead: cleanLead,
+    slackChannel: String(slackChannel || ''),
+  };
+  writeAtomic(p, data);
+  return data;
+}
+
+export function getTeam(name, configDir = defaultConfigDir()) {
+  let p;
+  try { p = teamPath(name, configDir); }
+  catch { return null; }
+  if (!fs.existsSync(p)) return null;
+  try { return JSON.parse(fs.readFileSync(p, 'utf8')); }
+  catch { return null; }
+}
+
+export function listTeams(configDir = defaultConfigDir()) {
+  const dir = teamsDir(configDir);
+  if (!fs.existsSync(dir)) return [];
+  const out = [];
+  for (const f of fs.readdirSync(dir)) {
+    if (!f.endsWith('.json')) continue;
+    const name = f.slice(0, -5);
+    const t = getTeam(name, configDir);
+    if (t) out.push(t);
+  }
+  out.sort((a, b) => String(a.name).localeCompare(String(b.name)));
+  return out;
+}
+
+export function patchTeam(name, patch, configDir = defaultConfigDir()) {
+  const t = getTeam(name, configDir);
+  if (!t) throw new TeamError(`no team "${name}"`, 'TEAM_NO_TEAM');
+  const next = { ...t, ...patch, updatedAt: new Date().toISOString() };
+  // Renormalise agents/lead pair when either changes so we never persist
+  // an inconsistent (lead not in agents) record.
+  if (patch.agents !== undefined) next.agents = [...new Set(patch.agents)];
+  validateAgentRefs(next.agents, next.lead, configDir);
+  writeAtomic(teamPath(name, configDir), next);
+  return next;
+}
+
+export function removeTeam(name, configDir = defaultConfigDir()) {
+  const p = teamPath(name, configDir);
+  if (!fs.existsSync(p)) {
+    throw new TeamError(`no team "${name}"`, 'TEAM_NO_TEAM');
+  }
+  fs.unlinkSync(p);
+  return { name, removed: true };
+}
+
+// Resolve a user-supplied channel string into a Slack channel id by
+// calling conversations.list. Strategy:
+//  - Already-looks-like-an-id ("C…" or "G…", uppercase + digits): pass through
+//  - "#name" or bare name: best-effort lookup; on failure, return the
+//    input unchanged so the team record still saves (the user can fix
+//    later from the dashboard, and chat.postMessage tolerates "#name").
+//
+// `botToken` and `apiBase` are read from the caller — env access stays
+// out of this module so it's testable.
+export async function resolveSlackChannel(input, { botToken, apiBase = 'https://slack.com/api', logger = () => {} } = {}) {
+  if (!input) return '';
+  const raw = String(input).trim();
+  if (!raw) return '';
+  // ID heuristic: starts with uppercase letter, only alphanumerics, ≥9 chars.
+  if (/^[CGD][A-Z0-9]{8,}$/.test(raw)) return raw;
+  if (!botToken) {
+    logger(`[team] no SLACK_BOT_TOKEN — keeping channel literal "${raw}"\n`);
+    return raw;
+  }
+  const target = raw.startsWith('#') ? raw.slice(1) : raw;
+  const url = `${apiBase.replace(/\/$/, '')}/conversations.list?limit=1000&types=public_channel,private_channel`;
+  try {
+    const res = await fetch(url, {
+      headers: { 'Authorization': `Bearer ${botToken}` },
+    });
+    if (!res.ok) {
+      logger(`[team] conversations.list HTTP ${res.status} — keeping "${raw}"\n`);
+      return raw;
+    }
+    const json = await res.json().catch(() => ({}));
+    if (!json.ok) {
+      logger(`[team] conversations.list error "${json.error}" — keeping "${raw}"\n`);
+      return raw;
+    }
+    const hit = (json.channels || []).find((c) => c && c.name === target);
+    if (!hit) {
+      logger(`[team] no channel "#${target}" in workspace — keeping literal\n`);
+      return raw;
+    }
+    return hit.id;
+  } catch (err) {
+    logger(`[team] conversations.list failed: ${err?.message || err} — keeping "${raw}"\n`);
+    return raw;
+  }
+}
+
+export function parseListFlag(raw) {
+  if (raw === undefined || raw === null) return null;
+  const s = String(raw).trim();
+  if (s === '') return [];
+  return s.split(',').map(x => x.trim()).filter(Boolean);
+}