lazyclaw 3.99.27 → 4.2.0

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);
+}

package/web/dashboard.html

@@ -324,6 +324,9 @@
     <button data-tab="doctor">Doctor</button>
     <button data-tab="config">Config</button>
     <button data-tab="status">Status</button>
+    <button data-tab="agents">Agents</button>
+    <button data-tab="teams">Teams</button>
+    <button data-tab="tasks">Tasks</button>
   </nav>
 
   <main>
@@ -429,6 +432,35 @@
         <pre id="config-raw"></pre>
       </details>
     </section>
+
+    <section id="tab-agents">
+      <h2>Agents</h2>
+      <div class="toolbar">
+        <button class="btn" onclick="openAgentModal()">+ New agent</button>
+        <button class="btn btn-secondary" onclick="LOADERS.agents()">Refresh</button>
+        <span class="dim" id="agents-meta"></span>
+      </div>
+      <div id="agents-list"><div class="empty">Loading…</div></div>
+    </section>
+
+    <section id="tab-teams">
+      <h2>Teams</h2>
+      <div class="toolbar">
+        <button class="btn" onclick="openTeamModal()">+ New team</button>
+        <button class="btn btn-secondary" onclick="LOADERS.teams()">Refresh</button>
+        <span class="dim" id="teams-meta"></span>
+      </div>
+      <div id="teams-list"><div class="empty">Loading…</div></div>
+    </section>
+
+    <section id="tab-tasks">
+      <h2>Tasks</h2>
+      <div class="toolbar">
+        <button class="btn btn-secondary" onclick="LOADERS.tasks()">Refresh</button>
+        <span class="dim" id="tasks-meta">Tasks are created via <code>lazyclaw task start</code>.</span>
+      </div>
+      <div id="tasks-list"><div class="empty">Loading…</div></div>
+    </section>
   </main>
 
   <footer>
@@ -1351,6 +1383,140 @@
       }
     }
 
+    // ── Multi-agent loaders (Phase 15) ────────────────────────────
+    // Keep these minimal — list view + prompt-driven create. Phase
+    // 15.1+ can swap the prompts for inline forms once the data model
+    // settles. The point of v0.1 is parity with the CLI, not polish.
+
+    function escapeHtml(s) {
+      return String(s).replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c]));
+    }
+
+    LOADERS.agents = async function loadAgents() {
+      const root = document.getElementById('agents-list');
+      try {
+        const arr = await api('/agents');
+        document.getElementById('agents-meta').textContent = `${arr.length} agent(s)`;
+        if (arr.length === 0) { root.innerHTML = '<div class="empty">No agents yet — click + New agent to create one.</div>'; return; }
+        root.innerHTML = '<table><thead><tr><th>name</th><th>provider/model</th><th>tools</th><th>role (excerpt)</th><th></th></tr></thead><tbody>'
+          + arr.map((a) => {
+              const provLine = a.model ? `${escapeHtml(a.provider)}/${escapeHtml(a.model)}` : escapeHtml(a.provider);
+              const role = a.role ? (a.role.slice(0, 60) + (a.role.length > 60 ? '…' : '')) : '<span class="dim">(none)</span>';
+              return `<tr>
+                <td><strong>${escapeHtml(a.name)}</strong><br><span class="dim">${escapeHtml(a.displayName || '')}</span></td>
+                <td>${provLine}</td>
+                <td>${(a.tools || []).map((t) => `<code>${escapeHtml(t)}</code>`).join(' ')}</td>
+                <td>${escapeHtml(role)}</td>
+                <td><button class="btn btn-secondary" onclick="deleteAgent('${encodeURIComponent(a.name)}')">Delete</button></td>
+              </tr>`;
+            }).join('')
+          + '</tbody></table>';
+      } catch (e) {
+        root.innerHTML = `<div class="empty">Error: ${escapeHtml(e.message)}</div>`;
+      }
+    };
+
+    async function openAgentModal() {
+      const name = (prompt('Agent name (e.g. planner, backend, frontend):') || '').trim();
+      if (!name) return;
+      const role = prompt('Role / system prompt (optional):') || '';
+      const provider = (prompt('Provider (anthropic / openai / gemini / claude-cli):', 'anthropic') || 'anthropic').trim();
+      const model = (prompt('Model id (blank = provider default):') || '').trim();
+      const toolsRaw = (prompt('Tools (comma-separated):', 'bash,read,write,grep') || '').trim();
+      const tools = toolsRaw ? toolsRaw.split(',').map((s) => s.trim()).filter(Boolean) : undefined;
+      try {
+        await api('/agents', { method: 'POST', body: JSON.stringify({ name, role, provider, model, tools }) });
+        LOADERS.agents();
+      } catch (e) {
+        alert('Create failed: ' + e.message);
+      }
+    }
+
+    async function deleteAgent(encName) {
+      const name = decodeURIComponent(encName);
+      if (!confirm(`Delete agent "${name}"?`)) return;
+      try { await api(`/agents/${encName}`, { method: 'DELETE' }); LOADERS.agents(); }
+      catch (e) { alert('Delete failed: ' + e.message); }
+    }
+
+    LOADERS.teams = async function loadTeams() {
+      const root = document.getElementById('teams-list');
+      try {
+        const arr = await api('/teams');
+        document.getElementById('teams-meta').textContent = `${arr.length} team(s)`;
+        if (arr.length === 0) { root.innerHTML = '<div class="empty">No teams yet — click + New team to create one.</div>'; return; }
+        root.innerHTML = '<table><thead><tr><th>name</th><th>lead</th><th>agents</th><th>slack channel</th><th></th></tr></thead><tbody>'
+          + arr.map((t) => `<tr>
+              <td><strong>${escapeHtml(t.name)}</strong><br><span class="dim">${escapeHtml(t.displayName || '')}</span></td>
+              <td>${escapeHtml(t.lead || '')}</td>
+              <td>${(t.agents || []).map((a) => escapeHtml(a)).join(', ')}</td>
+              <td>${t.slackChannel ? `<code>${escapeHtml(t.slackChannel)}</code>` : '<span class="dim">(none)</span>'}</td>
+              <td><button class="btn btn-secondary" onclick="deleteTeam('${encodeURIComponent(t.name)}')">Delete</button></td>
+            </tr>`).join('')
+          + '</tbody></table>';
+      } catch (e) {
+        root.innerHTML = `<div class="empty">Error: ${escapeHtml(e.message)}</div>`;
+      }
+    };
+
+    async function openTeamModal() {
+      const name = (prompt('Team name (e.g. shop, growth):') || '').trim();
+      if (!name) return;
+      const agentsRaw = (prompt('Agents (comma-separated names):') || '').trim();
+      if (!agentsRaw) return;
+      const agents = agentsRaw.split(',').map((s) => s.trim()).filter(Boolean);
+      const lead = (prompt(`Lead (one of ${agents.join(', ')}):`, agents[0]) || agents[0]).trim();
+      const slackChannel = (prompt('Slack channel (C… id or #name, optional):') || '').trim();
+      try {
+        await api('/teams', { method: 'POST', body: JSON.stringify({ name, agents, lead, slackChannel }) });
+        LOADERS.teams();
+      } catch (e) {
+        alert('Create failed: ' + e.message);
+      }
+    }
+
+    async function deleteTeam(encName) {
+      const name = decodeURIComponent(encName);
+      if (!confirm(`Delete team "${name}"?`)) return;
+      try { await api(`/teams/${encName}`, { method: 'DELETE' }); LOADERS.teams(); }
+      catch (e) { alert('Delete failed: ' + e.message); }
+    }
+
+    LOADERS.tasks = async function loadTasks() {
+      const root = document.getElementById('tasks-list');
+      try {
+        const arr = await api('/tasks');
+        document.getElementById('tasks-meta').textContent = `${arr.length} task(s) (newest first)`;
+        if (arr.length === 0) { root.innerHTML = '<div class="empty">No tasks yet. Run <code>lazyclaw task start --team X --title "..."</code>.</div>'; return; }
+        root.innerHTML = '<table><thead><tr><th>id</th><th>title</th><th>team</th><th>lead</th><th>status</th><th>turns</th><th>opened</th><th></th></tr></thead><tbody>'
+          + arr.map((t) => `<tr>
+              <td><code>${escapeHtml(t.id)}</code></td>
+              <td>${escapeHtml(t.title)}</td>
+              <td>${escapeHtml(t.team)}</td>
+              <td>${escapeHtml(t.lead)}</td>
+              <td><span class="status status-${escapeHtml(t.status)}">${escapeHtml(t.status)}</span></td>
+              <td>${Array.isArray(t.turns) ? t.turns.length : 0}</td>
+              <td><span class="dim">${escapeHtml((t.createdAt || '').slice(0, 19))}</span></td>
+              <td>
+                ${t.status === 'running' || t.status === 'pending'
+                  ? `<button class="btn btn-secondary" onclick="closeTask('${encodeURIComponent(t.id)}','done')">Mark done</button>
+                     <button class="btn btn-secondary" onclick="closeTask('${encodeURIComponent(t.id)}','abandon')">Abandon</button>`
+                  : ''}
+              </td>
+            </tr>`).join('')
+          + '</tbody></table>';
+      } catch (e) {
+        root.innerHTML = `<div class="empty">Error: ${escapeHtml(e.message)}</div>`;
+      }
+    };
+
+    async function closeTask(encId, action) {
+      const id = decodeURIComponent(encId);
+      if (!confirm(`${action === 'done' ? 'Mark done' : 'Abandon'} task ${id}?`)) return;
+      try { await api(`/tasks/${encId}/${action}`, { method: 'POST' }); LOADERS.tasks(); }
+      catch (e) { alert(`${action} failed: ` + e.message); }
+    }
+
     // First load = chat tab.
     LOADERS.chat();